Linting and formatting to bring up to date with new use of Ruff

Author: TomHall2020

archeryutils/handicaps/handicap_scheme.py

@@ -53,7 +53,7 @@ def _pairwise(iterable):
         next(b, None)
         return zip(a, b)
 
-    itr.pairwise = _pairwise
+    setattr(itr, "pairwise", _pairwise)  # noqa: B010
 
 
 class HandicapScheme(ABC):
@@ -107,15 +107,17 @@ def __repr__(self) -> str:
 
     @overload
     @abstractmethod
-    def sigma_t(self, handicap: float, dist: float) -> float: ...
+    def sigma_t(self, handicap: float, dist: float) -> float:
+        ...
 
     @overload
     @abstractmethod
     def sigma_t(
         self,
         handicap: npt.NDArray[np.float64],
         dist: float,
-    ) -> npt.NDArray[np.float64]: ...
+    ) -> npt.NDArray[np.float64]:
+        ...
 
     @abstractmethod
     def sigma_t(self, handicap: FloatArray, dist: float) -> FloatArray:

archeryutils/handicaps/tests/test_handicaps.py

@@ -385,17 +385,13 @@ def test_different_target_faces(
         assert arrow_score_direct == pytest.approx(arrow_score_expected)
 
     def test_empty_spec(self):
-        """
-        Check expected score is zero when no target rings are defined.
-        """
+        """Check expected score is zero when no target rings are defined."""
         target = Target.from_spec({}, 10, 10)
         s_bar = hc.arrow_score(50, target, "AGB")
         assert s_bar == 0
 
     def test_unsorted_spec(self):
-        """
-        Check expected score is insensitive to order of input spec.
-        """
+        """Check expected score is insensitive to order of input spec."""
 
         def _target(spec):
             return Target.from_spec(spec, 10, 10)
@@ -408,7 +404,7 @@ def _target(spec):
 
     def test_decimal_ring_scores(self):
         """
-        Check expected score can be calculated for non integer ring scores
+        Check expected score can be calculated for non integer ring scores.
 
         Uses a target with integer ring scores at twice the value for comparison
         """
@@ -421,9 +417,7 @@ def test_decimal_ring_scores(self):
         assert s_bar_int == 2 * s_bar_dec
 
     def test_array_handicaps(self):
-        """
-        Check expected score can be calculated for an array of input handicap values
-        """
+        """Check expected score can be calculated for an array of handicap values."""
         handicaps = np.array([10, 20, 30, 40])
         target = Target.from_spec({0.1: 3, 0.2: 5}, 10, 10)
         s_bar = hc.arrow_score(handicaps, target, "AGB")
@@ -652,10 +646,7 @@ def test_rounded_round_score(
         )
 
     def test_calculation_custom_scoring(self):
-        """
-        Check that score can be calculated for a round with custom scoring
-        """
-
+        """Check that score can be calculated for a round with custom scoring."""
         assert hc.score_for_round(20.0, kings_900_rec, "AGB", None, True) == 896.0
 
 
@@ -913,8 +904,5 @@ def test_decimal(
         assert handicap == pytest.approx(handicap_expected)
 
     def test_calculation_custom_scoring(self):
-        """
-        Check that handicap can be calculated for a round with custom scoring
-        """
-
+        """Check that handicap can be calculated for a round with custom scoring."""
         assert hc.handicap_from_score(896, kings_900_rec, "AGB", int_prec=True) == 20

archeryutils/targets.py

@@ -126,7 +126,6 @@ def __init__(
         distance: Union[float, tuple[float, str]],
         indoor: bool = False,
     ) -> None:
-
         if scoring_system not in self.supported_systems:
             msg = (
                 f"""Invalid Target Face Type specified.\n"""
@@ -204,7 +203,7 @@ def from_spec(
 
         Examples
         --------
-        >>> #WA 18m compound triple spot
+        >>> # WA 18m compound triple spot
         >>> specs = {0.02: 10, 0.08: 9, 0.12: 8, 0.16: 7, 0.2: 6}
         >>> target = Target.from_spec(specs, 40, 18)
         """

archeryutils/tests/test_rounds.py

@@ -121,9 +121,7 @@ def test_properties(self) -> None:
         assert test_pass.native_diameter_unit == "cm"
 
     def test_custom_target(self) -> None:
-        """
-        Check that pass can be constructed from a custom target specification
-        """
+        """Check that pass can be constructed from a custom target specification."""
         target = Target.from_spec({0.1: 3, 0.5: 1}, 80, (50, "yard"))
         test_pass = Pass(30, target)
         assert test_pass.target.is_custom

archeryutils/tests/test_targets.py

@@ -1,5 +1,7 @@
 """Tests for Target class."""
 
+from typing import Final
+
 import pytest
 
 from archeryutils.targets import ScoringSystem, Target
@@ -251,9 +253,7 @@ def test_min_score_invalid_face_type(self) -> None:
         ],
     )
     def test_get_face_spec(self, scoring_system, diam) -> None:
-        """
-        Check that target returns correct face specifications from supported scoring systems.
-        """
+        """Check that target returns face specs from supported scoring systems."""
         expected_spec = {
             "5_zone": {0.244: 9, 0.488: 7, 0.732: 5, 0.976: 3, 1.22: 1},
             "10_zone": {
@@ -281,34 +281,25 @@ def test_get_face_spec(self, scoring_system, diam) -> None:
 
 
 class TestCustomScoringTarget:
-    """
-    Tests for Target class with custom scoring
-    """
+    """Tests for Target class with custom scoring."""
 
-    _11zone_spec = {0.02: 11, 0.04: 10, 0.8: 9, 0.12: 8, 0.16: 7, 0.2: 6}
+    _11zone_spec: Final = {0.02: 11, 0.04: 10, 0.8: 9, 0.12: 8, 0.16: 7, 0.2: 6}
 
     def test_constructor(self) -> None:
-        """
-        Can initialise Target with a custom scoring system and spec
-        """
-
+        """Can initialise Target with a custom scoring system and spec."""
         target = Target.from_spec({0.1: 3, 0.5: 1}, 80, (50, "yard"))
         assert target.distance == 50.0 * 0.9144
         assert target.diameter == 0.8
         assert target.scoring_system == "Custom"
         assert target.get_face_spec() == {0.1: 3, 0.5: 1}
 
     def test_face_spec_units(self) -> None:
-        """
-        Check custom Target can be constructed with alternative units.
-        """
+        """Check custom Target can be constructed with alternative units."""
         target = Target.from_spec(({10: 5, 20: 4, 30: 3}, "cm"), 50, 30)
         assert target.get_face_spec() == {0.1: 5, 0.2: 4, 0.3: 3}
 
     def test_invalid_face_spec_units(self) -> None:
-        """
-        Check custom Target cannot be constructed with unsupported units.
-        """
+        """Check custom Target cannot be constructed with unsupported units."""
         with pytest.raises(
             ValueError,
             # match=
@@ -333,23 +324,17 @@ def test_invalid_face_spec_units(self) -> None:
         ],
     )
     def test_equality(self, spec, args, result) -> None:
-        """
-        Check custom Target equality comparison is supported.
-        """
+        """Check custom Target equality comparison is supported."""
         target = Target.from_spec({0.2: 2, 0.4: 1}, 40, 20, indoor=True)
         comparison = target == Target.from_spec(spec, *args)
         assert comparison == result
 
     def test_max_score(self) -> None:
-        """
-        Check that Target with custom scoring system returns correct max score
-        """
+        """Check that Target with custom scoring system returns correct max score."""
         target = Target.from_spec(self._11zone_spec, 40, 18)
         assert target.max_score() == 11
 
     def test_min_score(self) -> None:
-        """
-        Check that Target with custom scoring system returns correct min score
-        """
+        """Check that Target with custom scoring system returns correct min score."""
         target = Target.from_spec(self._11zone_spec, 40, 18)
         assert target.min_score() == 6