Non-PEP440 versions shouldn't prevent prerelease versions in empty specifier

Author: notatallshaw

src/packaging/specifiers.py

@@ -994,14 +994,22 @@ def filter(
 
         # Finally if prereleases is None, apply PEP 440 logic:
         # exclude prereleases unless there are no final releases that matched.
-        filtered: list[UnparsedVersionVar] = []
+        filtered_items: list[UnparsedVersionVar] = []
         found_prereleases: list[UnparsedVersionVar] = []
+        found_final_release = False
 
         for item in iterable:
             parsed_version = _coerce_version(item)
-            if parsed_version is not None and parsed_version.is_prerelease:
+            # Arbitrary strings are always included as it is not
+            # possible to determine if they are prereleases,
+            # and they have already passed all specifiers.
+            if parsed_version is None:
+                filtered_items.append(item)
+                found_prereleases.append(item)
+            elif parsed_version.is_prerelease:
                 found_prereleases.append(item)
             else:
-                filtered.append(item)
+                filtered_items.append(item)
+                found_final_release = True
 
-        return iter(filtered if filtered else found_prereleases)
+        return iter(filtered_items if found_final_release else found_prereleases)

tests/test_specifiers.py

@@ -688,13 +688,7 @@ def test_specifiers_prereleases(
             # Test != with invalid versions (should not pass as versions are not valid)
             ("!=1.0", None, None, ["invalid", "foobar"], []),
             ("!=1.0", None, None, ["1.0", "invalid", "2.0"], ["2.0"]),
-            (
-                "!=2.0.*",
-                None,
-                None,
-                ["invalid", "foobar", "2.0"],
-                []
-            ),
+            ("!=2.0.*", None, None, ["invalid", "foobar", "2.0"], []),
             ("!=2.0.*", None, None, ["1.0", "invalid", "2.0.0"], ["1.0"]),
             # Test that !== ignores prereleases parameter for non-PEP 440 versions
             ("!=1.0", None, True, ["invalid", "foobar"], []),
@@ -803,15 +797,34 @@ def test_empty_specifier(self, version):
         assert spec.contains(parse(version))
 
     @pytest.mark.parametrize(
-        "prereleases",
-        [None, False, True],
+        ("prereleases", "versions", "expected"),
+        [
+            # single arbitrary string
+            (None, ["foobar"], ["foobar"]),
+            (False, ["foobar"], ["foobar"]),
+            (True, ["foobar"], ["foobar"]),
+            # arbitrary string with a stable version present
+            (None, ["foobar", "1.0"], ["foobar", "1.0"]),
+            (False, ["foobar", "1.0"], ["foobar", "1.0"]),
+            (True, ["foobar", "1.0"], ["foobar", "1.0"]),
+            # arbitrary string with a prerelease only
+            (None, ["foobar", "1.0a1"], ["foobar", "1.0a1"]),
+            (False, ["foobar", "1.0a1"], ["foobar"]),
+            (True, ["foobar", "1.0a1"], ["foobar", "1.0a1"]),
+        ],
     )
-    def test_empty_specifier_arbitrary_string(self, prereleases):
+    def test_empty_specifier_arbitrary_string(self, prereleases, versions, expected):
         """Test empty SpecifierSet accepts arbitrary strings."""
 
         spec = SpecifierSet("", prereleases=prereleases)
+
+        # basic behavior preserved
         assert spec.contains("foobar")
 
+        # check filter behavior (no override of prereleases passed to filter)
+        kwargs = {}
+        assert list(spec.filter(versions, **kwargs)) == expected
+
     def test_create_from_specifiers(self):
         spec_strs = [">=1.0", "!=1.1", "!=1.2", "<2.0"]
         specs = [Specifier(s) for s in spec_strs]