Fix linters

Signed-off-by: Jorge J. Perez <jjperez@ekumenlabs.com>

Author: Blast545

pallet_patcher/solver.py

@@ -1,10 +1,14 @@
+# Copyright 2025 Open Source Robotics Foundation, Inc.
+# Licensed under the Apache License, Version 2.0
+
 from packaging.version import Version
 from packaging.specifiers import SpecifierSet
 
+
 # I heavily relied on AI to help with this one.
-# I added each case by iterating on the ones that throw me errors while debugging
-# We can add tests to make sure it handles most common Rust cases
-# (or at least the ones used right now
+# I added each case by iterating on the ones that throw me errors while
+# debugging. We can add tests to make sure it handles most common Rust
+# cases (or at least the ones used right now
 def _parse_rust_specifier(spec_str: str) -> SpecifierSet:
     clean_spec = spec_str.strip()
 
@@ -46,7 +50,7 @@ def _parse_rust_specifier(spec_str: str) -> SpecifierSet:
             if major == 0:
                 # Case B.1: Single digit (^0) -> Allow 0.x.x
                 if len(parts) == 1:
-                     return SpecifierSet(f">={clean_spec},<1.0.0")
+                    return SpecifierSet(f">={clean_spec},<1.0.0")
 
                 minor = int(parts[1])
 
@@ -65,7 +69,7 @@ def _parse_rust_specifier(spec_str: str) -> SpecifierSet:
                     return SpecifierSet(f">={clean_spec},<0.1.0")
 
         except ValueError:
-            pass # Fallback to standard handling if parsing fails
+            pass  # Fallback to standard handling if parsing fails
 
     # Fallback for standard Python specifiers (>=1.2, etc.)
     return SpecifierSet(clean_spec)
@@ -82,15 +86,15 @@ def solve_dependency(version_specifier, available_versions):
     :param available_versions: List of versions available.
     :type available_versions: str
 
-    :returns: matched version string, or None if available versions don't match the spec
+    :returns: matched version string, or None if available ver don't match
     :rtype: dict
     """
     spec = _parse_rust_specifier(version_specifier)
 
     # We sort them first to prioritize higher versions for the packages
     sorted_versions = sorted(
-        available_versions, 
-        key=lambda x: [int(part) for part in x.split('.')], 
+        available_versions,
+        key=lambda x: [int(part) for part in x.split('.')],
         reverse=True
     )
 
@@ -101,4 +105,4 @@ def solve_dependency(version_specifier, available_versions):
         if v in spec:
             return str(v)
 
-    return None
+    return None

test/test_solver.py

@@ -1,8 +1,12 @@
+# Copyright 2025 Open Source Robotics Foundation, Inc.
+# Licensed under the Apache License, Version 2.0
+
 import pytest
 from pallet_patcher.solver import _parse_rust_specifier, solve_dependency
 
+
 # Test code generated with LLM help
-@pytest.mark.parametrize("rust_input, expected_matches, expected_non_matches", [
+@pytest.mark.parametrize("input, expected_matches, expected_non_matches", [
     # 1. Explicit Equals (=)
     ("=1.2.3", ["1.2.3"], ["1.2.4", "1.2.2"]),
 
@@ -38,20 +42,22 @@
     ("^0.0", ["0.0.0", "0.0.5"], ["0.1.0"]),
     ("0.0", ["0.0.1"], ["0.1.0"]),
 ])
-def test_rust_specifier_logic(rust_input, expected_matches, expected_non_matches):
+def test_rust_specifier_logic(input, expected_matches, expected_non_matches):
     """
     Tests that the converted Python SpecifierSet correctly matches
     and excludes the versions dictated by Rust SemVer logic.
     """
-    spec_set = _parse_rust_specifier(rust_input)
+    spec_set = _parse_rust_specifier(input)
 
     for version in expected_matches:
         assert version in spec_set, \
-            f"Rust spec '{rust_input}' should MATCH {version}, but Python spec {spec_set} did not."
+            f"""Rust spec '{input}' should MATCH {version},
+                but Python spec {spec_set} did not."""
 
     for version in expected_non_matches:
         assert version not in spec_set, \
-            f"Rust spec '{rust_input}' should NOT match {version}, but Python spec {spec_set} did."
+            f"""Rust spec '{input}' should NOT match {version},
+                but Python spec {spec_set} did."""
 
 
 @pytest.mark.parametrize("input_str, expected_str_repr", [
@@ -62,34 +68,36 @@ def test_rust_specifier_logic(rust_input, expected_matches, expected_non_matches
 ])
 def test_standard_python_fallback(input_str, expected_str_repr):
     """
-    Tests that standard Python specifiers or other strings 
+    Tests that standard Python specifiers or other strings
     are passed through to SpecifierSet mostly unchanged.
     """
     spec = _parse_rust_specifier(input_str)
-    # Note: SpecifierSet normalization might change string spacing, 
+    # Note: SpecifierSet normalization might change string spacing,
     # but the logic checks if it parses without crashing.
     assert str(spec) == expected_str_repr or not input_str
 
+
 def test_invalid_version_strings():
     """
-    Ensure the function handles malformed strings gracefully 
-    (falling back to SpecifierSet which might raise its own error or handle it).
+    Ensure the function handles malformed strings gracefully
+    (falling back to SpecifierSet wich might raise or handle it).
     """
     # This falls through to "Bare" logic, fails try/except, hits fallback
-    # SpecifierSet("invalid") is technically valid in packaging but matches nothing usually
-    # or raises InvalidSpecifier depending on version. 
+    # SpecifierSet("invalid") is technically valid in packaging but matches
+    # nothing or raises InvalidSpecifier depending on version.
     # Here we just want to ensure your code doesn't crash internally.
     try:
         _parse_rust_specifier("invalid_string_with_char")
     except Exception as e:
-        # It is acceptable if SpecifierSet raises, but your parsing logic shouldn't
+        # It is acceptable if SpecifierSet raises, but your parsing logic
+        # shouldn't
         assert "Invalid specifier" in str(e) or isinstance(e, ValueError)
 
 
 @pytest.mark.parametrize("spec, available, expected", [
     # 1. Basic Caret Priority
     # ^1.2.0 allows >=1.2.0, <2.0.0.
-    # It should pick 1.9.9 (highest), ignore 2.0.0 (too high) and 1.1.0 (too low).
+    # It should pick 1.9.9 (highest), ignore 2.0.0 (high) and 1.1.0 (low).
     ("^1.2.0", ["1.1.0", "1.2.0", "1.2.5", "1.9.9", "2.0.0"], "1.9.9"),
 
     # 2. Basic Tilde Priority
@@ -98,7 +106,7 @@ def test_invalid_version_strings():
     ("~1.2.0", ["1.2.0", "1.2.5", "1.2.9", "1.3.0", "1.4.0"], "1.2.9"),
 
     # 3. Rust "0.x.y" Semantics (Major 0 breaking changes)
-    # ^0.2.0 allows >=0.2.0, <0.3.0. 
+    # ^0.2.0 allows >=0.2.0, <0.3.0.
     # Should ignore 0.3.0 even though it's higher.
     ("^0.2.0", ["0.1.9", "0.2.0", "0.2.5", "0.3.0"], "0.2.5"),
 
@@ -127,7 +135,8 @@ def test_solve_dependency_logic(spec, available, expected):
     """
     result = solve_dependency(spec, available)
     assert result == expected, \
-        f"For spec '{spec}' and versions {available}, expected '{expected}' but got '{result}'"
+        f"""For spec '{spec}' and versions {available}, expected '{expected}'
+          but got '{result}'"""
 
 
 def test_solve_dependency_sorting_correctness():
@@ -146,7 +155,7 @@ def test_solve_dependency_sorting_correctness():
 
 def test_solve_dependency_invalid_input_handling():
     """
-    Test how the function handles non-integer version strings 
+    Test how the function handles non-integer version strings
     given the lambda sorting logic provided.
     """
     # NOTE: The provided function uses `int(part)` which will crash on "beta".
@@ -159,4 +168,4 @@ def test_solve_dependency_invalid_input_handling():
         solve_dependency(spec, available)
 
     # Confirm it failed where we expected (in the sort lambda)
-    assert "invalid literal for int()" in str(excinfo.value)
+    assert "invalid literal for int()" in str(excinfo.value)