refactor: final typing fixes, conforming to Type Checking = Standard in Pyright

Author: CPrescher

glassure/utility.py

@@ -34,7 +34,7 @@
     "calculate_weighting_factor",
 ]
 
-Composition = Dict[str, Union[int, float]]
+Composition = dict[str, float] | dict[str, int]
 
 
 def parse_str_to_composition(formula: str) -> Composition:
@@ -341,8 +341,10 @@ def calculate_wkm_effective_atomic_number(
     return float(np.mean(form_factor / effective_form_factor))
 
 
-def calculate_total_atomic_number(composition: Composition) -> float:
-    """
+def calculate_total_atomic_number(
+    composition: Composition | dict[str, float] | dict[str, int],
+) -> float:
+    r"""
     Calculates the total atomic number of a given composition.
     """
     return sum(
@@ -351,9 +353,11 @@ def calculate_total_atomic_number(composition: Composition) -> float:
 
 
 def calculate_effective_form_factor(
-    composition: Composition, q: np.ndarray, sf_source="hajdu"
+    composition: Composition,
+    q: np.ndarray,
+    sf_source="hajdu",
 ) -> np.ndarray:
-    """
+    r"""
     Calculates the effective form factor for a given composition, which is given by
 
     .. math::
@@ -389,7 +393,7 @@ def normalize_composition(composition: Composition) -> dict[str, float]:
     for key, val in composition.items():
         sum += val
 
-    result = copy(composition)
+    result: dict[str, float] = {key: float(val) for key, val in composition.items()}
 
     for key in result:
         result[key] /= sum

tests/test_pattern.py

@@ -146,7 +146,7 @@ def test_pydantic_nparray_with_list_input():
 
 def test_pydantic_nparray_from_json():
     input = {"x": [1, 2, 3]}
-    t = DummyModel(**input)
+    t = DummyModel(**input)  # type: ignore[arg-type]
     assert np.array_equal(t.x, np.array([1, 2, 3]))
 
 

tests/test_utility.py

@@ -142,7 +142,7 @@ def test_linear_extrapolation(self):
 
         x_linear = x1[x1 < 1]
         y_linear = y1[x1 < 1]
-        self.assertAlmostEqual(np.sum(y_linear - x_linear), 0)
+        self.assertAlmostEqual(float(np.sum(y_linear - x_linear)), 0)
 
     def test_linear_extrapolation_with_different_y(self):
         x = np.arange(1, 5.05, 0.05)
@@ -197,7 +197,7 @@ def test_extrapolate_to_zero_poly(self):
         y_expected = a * (x_extrapolate - c) + b * (x_extrapolate - c) ** 2
         y_expected[x_extrapolate < c] = 0
 
-        self.assertAlmostEqual(np.sum(y_extrapolate - y_expected), 0)
+        self.assertAlmostEqual(float(np.sum(y_extrapolate - y_expected)), 0.0)
 
         extrapolated_pattern = extrapolate_to_zero_poly(pattern, x_max, replace=True)
         x1, y1 = extrapolated_pattern.data
@@ -208,7 +208,7 @@ def test_extrapolate_to_zero_poly(self):
         y_expected = a * (x_extrapolate - c) + b * (x_extrapolate - c) ** 2
         y_expected[x_extrapolate < c] = 0
 
-        self.assertAlmostEqual(np.sum(y_extrapolate - y_expected), 0)
+        self.assertAlmostEqual(float(np.sum(y_extrapolate - y_expected)), 0)
 
     def test_extrapolate_to_zero_poly_with_different_y(self):
         x = np.arange(1, 5.05, 0.05)
@@ -290,9 +290,9 @@ def test_calculate_effective_form_factor(self):
         self.assertEqual(len(q), len(effective_form_factor))
 
         effective_form_factor = calculate_effective_form_factor(
-            composition, 0, sf_source="hajdu"
+            composition, np.array([0]), sf_source="hajdu"
         )
-        self.assertAlmostEqual(effective_form_factor, 1.0, places=3)
+        self.assertAlmostEqual(float(effective_form_factor[0]), 1.0, places=3)
 
     def test_calculate_wkm_form_factor(self):
         q = 0.0