feat(find_updates): support ~=, !=, === constraint operators

Extend _get_constraint_version() to support additional constraint types:
compatible release (~=), not equal (!=), and arbitrary equality (===).

Changes:
- Update _get_constraint_version() to recognize ~=, !=, === operators
- Update function and command docstrings with new supported operators
- Add comprehensive unit tests for new constraint types
- Remove nonsensical test cases (==,<= and >=,> combinations)
- Remove version format tests that tested packaging library, not our logic
- Focus test suite on actual constraint parsing logic

The find-updates command now handles more constraint types from pip
constraints files, providing better coverage for dependency update
analysis.

Chat log: https://gist.github.com/dhellmann/79167f4bda606517d325f0ee7dbb0c9d

Co-authored-by: Claude 3.5 Sonnet (Anthropic AI Assistant)
Signed-off-by: Doug Hellmann <dhellmann@redhat.com>

Author: dhellmann

src/fromager/commands/find_updates.py

@@ -64,13 +64,16 @@ def find_updates(
     """Find available updates for packages with specific version constraints.
 
     This command reads a constraints file and for each package that has a
-    supported constraint (==, <, <=), it lists newer versions available.
+    supported constraint (==, <, <=, ~=, !=, ===), it lists newer versions available.
     Constraints with lower bounds (>=) are ignored as they don't pin to specific versions.
 
     The CONSTRAINTS_FILE should be a pip-style constraints file with entries like:
     - "package_name==1.0.0" (will look for versions > 1.0.0)
     - "package_name<2.0.0" (will look for versions >= 2.0.0)
     - "package_name<=1.5.0" (will look for versions > 1.5.0)
+    - "package_name~=1.4.0" (will look for versions outside compatible range)
+    - "package_name!=1.0.0" (will look for versions other than 1.0.0)
+    - "package_name===1.0.0" (will look for versions other than exactly 1.0.0)
     - "package_name>=1.0.0" (ignored - not a specific constraint)
 
     Distribution types:
@@ -159,14 +162,17 @@ def find_updates(
             output_file.close()
 
 
+CONSTRAINT_OPERATORS = ("==", "<", "<=", "~=", "!=", "===")
+
+
 def _get_constraint_version(constraint: Requirement) -> Version | None:
-    """Extract version from supported constraint types (==, <, <=), return None if not supported."""
+    """Extract version from supported constraint types (==, <, <=, ~=, !=, ===), return None if not supported."""
     if not constraint.specifier:
         return None
 
     # Look for supported constraint operators
     supported_specs = [
-        spec for spec in constraint.specifier if spec.operator in ("==", "<", "<=")
+        spec for spec in constraint.specifier if spec.operator in CONSTRAINT_OPERATORS
     ]
     if len(supported_specs) != 1:
         return None
@@ -240,12 +246,12 @@ def _find_newer_versions(
 
     # Get the constraint operator to determine what "update" means
     constraint_spec = next(
-        spec for spec in constraint.specifier if spec.operator in ("==", "<", "<=")
+        spec for spec in constraint.specifier if spec.operator in CONSTRAINT_OPERATORS
     )
-    if constraint_spec.operator == "==":
+    if constraint_spec.operator in ("==", "==="):
         # For equality constraints, find versions newer than the pinned version
         newer_versions = [v for v in all_versions if v > constraint_version]
-    elif constraint_spec.operator in ("<", "<="):
+    elif constraint_spec.operator in ("<", "<=", "~=", "!="):
         # For upper bound constraints, find versions that exceed the constraint
         # (these would be versions that violate the current constraint)
         newer_versions = [v for v in all_versions if v >= constraint_version]

tests/test_find_updates.py

@@ -0,0 +1,89 @@
+from packaging.requirements import Requirement
+from packaging.version import Version
+
+from fromager.commands.find_updates import _get_constraint_version
+
+
+class TestGetConstraintVersion:
+    """Test cases for _get_constraint_version function."""
+
+    def test_equality_constraint(self):
+        """Test that equality constraints return the correct version."""
+        req = Requirement("package==1.2.3")
+        result = _get_constraint_version(req)
+        assert result == Version("1.2.3")
+
+    def test_less_than_constraint(self):
+        """Test that less than constraints return the correct version."""
+        req = Requirement("package<2.0.0")
+        result = _get_constraint_version(req)
+        assert result == Version("2.0.0")
+
+    def test_less_than_or_equal_constraint(self):
+        """Test that less than or equal constraints return the correct version."""
+        req = Requirement("package<=1.5.0")
+        result = _get_constraint_version(req)
+        assert result == Version("1.5.0")
+
+    def test_greater_than_constraint_unsupported(self):
+        """Test that greater than constraints return None (unsupported)."""
+        req = Requirement("package>1.0.0")
+        result = _get_constraint_version(req)
+        assert result is None
+
+    def test_greater_than_or_equal_constraint_unsupported(self):
+        """Test that greater than or equal constraints return None (unsupported)."""
+        req = Requirement("package>=1.0.0")
+        result = _get_constraint_version(req)
+        assert result is None
+
+    def test_no_version_constraint(self):
+        """Test that requirements without version constraints return None."""
+        req = Requirement("package")
+        result = _get_constraint_version(req)
+        assert result is None
+
+    def test_multiple_constraints_with_one_supported(self):
+        """Test that multiple constraints with one supported constraint return the supported one."""
+        req = Requirement("package>=1.0.0,<2.0.0")
+        result = _get_constraint_version(req)
+        assert result == Version("2.0.0")
+
+    def test_constraint_with_markers(self):
+        """Test that constraints with environment markers still work correctly."""
+        req = Requirement("package==1.2.3; python_version >= '3.8'")
+        result = _get_constraint_version(req)
+        assert result == Version("1.2.3")
+
+    def test_tilde_equal_constraint_supported(self):
+        """Test that tilde equal constraints (~=) return the correct version."""
+        req = Requirement("package~=1.4.2")
+        result = _get_constraint_version(req)
+        assert result == Version("1.4.2")
+
+    def test_not_equal_constraint_supported(self):
+        """Test that not equal constraints (!=) return the correct version."""
+        req = Requirement("package!=1.0.0")
+        result = _get_constraint_version(req)
+        assert result == Version("1.0.0")
+
+    def test_arbitrary_equality_constraint_supported(self):
+        """Test that arbitrary equality constraints (===) return the correct version."""
+        req = Requirement("package===1.0.0")
+        result = _get_constraint_version(req)
+        assert result == Version("1.0.0")
+
+    def test_invalid_version_format(self):
+        """Test that invalid version formats return None."""
+        # We need to test the case where Version() construction fails
+        # Let's create a requirement and then mock the Version parsing
+        import unittest.mock
+
+        req = Requirement("package==1.0.0")
+
+        with unittest.mock.patch(
+            "fromager.commands.find_updates.Version"
+        ) as mock_version:
+            mock_version.side_effect = ValueError("Invalid version")
+            result = _get_constraint_version(req)
+            assert result is None