mypy clean

Author: gykovacs

mlscorecheck/aggregated/_fold.py

@@ -97,7 +97,7 @@ def calculate_scores(
             else round_scores(self.scores, rounding_decimals)
         )
 
-    def set_initial_values(self, scores):
+    def set_initial_values(self, scores: dict) -> None:
         """
         Sets the initial values for the tp and tn variables
 

mlscorecheck/aggregated/_fold_enumeration.py

@@ -408,7 +408,10 @@ def multiclass_fold_partitioning_generator_22(
         yield {0: (c_00, n0 - c_00), 1: (c0 - c_00, n1 - c0 + c_00)}
 
 
-def multiclass_fold_partitioning_generator_2n(n0: int, n1: int, cs: list):
+from typing import Iterator
+
+
+def multiclass_fold_partitioning_generator_2n(n0: int, n1: int, cs: list) -> Iterator[dict]:
     """
     Generates the configurations for two folds of cardinalities n0 and n1 and a list
     of classes with sizes in cs
@@ -431,7 +434,7 @@ def multiclass_fold_partitioning_generator_2n(n0: int, n1: int, cs: list):
                 yield {0: (part[0][0], *(part_deep[0])), 1: (part[1][0], *(part_deep[1]))}
 
 
-def multiclass_fold_partitioning_generator_kn(ns: list, cs: list):
+def multiclass_fold_partitioning_generator_kn(ns: list, cs: list) -> Iterator[dict]:
     """
     Generates the configurations for a list of folds of sizes ns and a list
     of classes with sizes in cs

mlscorecheck/aggregated/_generate_problems.py

@@ -62,7 +62,7 @@ def generate_folding(
     max_folds: int = 10,
     max_repeats: int = 5,
     strategies: list | None = None,
-    random_state=None,
+    random_state: int | np.random.RandomState | None = None,
     no_folds: bool = False,
 ) -> dict:
     """
@@ -113,7 +113,7 @@ def generate_evaluation(  # pylint: disable=too-many-locals
     strategies: list | None = None,
     feasible_fold_score_bounds: bool | None = None,
     aggregation: str | None = None,
-    random_state=None,
+    random_state: int | np.random.RandomState | None = None,
     return_scores: bool = False,
     rounding_decimals: int | None = None,
     no_name: bool = False,
@@ -222,7 +222,7 @@ def generate_experiment(
     evaluation_params: dict | None = None,
     feasible_dataset_score_bounds: bool | None = None,
     aggregation: str | None = None,
-    random_state=None,
+    random_state: int | np.random.RandomState | None = None,
     return_scores: bool = False,
     rounding_decimals: int | None = None,
     score_subset: list | None = None,
@@ -332,8 +332,12 @@ def get_dataset_score_bounds(
 
 
 def generate_scores_for_testsets(
-    testsets, rounding_decimals=None, subset=None, random_state=None, aggregation="mos"
-):
+    testsets: list,
+    rounding_decimals: int | None = None,
+    subset: list | None = None,
+    random_state: int | np.random.RandomState | None = None,
+    aggregation: str = "mos"
+) -> dict:
     """
     Sample scores for testsets
 
@@ -375,18 +379,18 @@ def generate_scores_for_testsets(
 
 def generate_dataset_folding_multiclass(
     *,
-    random_state=None,
-    max_n_classes=5,
-    min_n_classes=3,
-    max_class_size=200,
-    min_class_size=10,
-    max_n_folds=5,
-    max_n_repeats=3,
-    average=None,
-    aggregation=None,
-    rounding_decimals=None,
-    subset=None,
-):
+    random_state: int | np.random.RandomState | None = None,
+    max_n_classes: int = 5,
+    min_n_classes: int = 3,
+    max_class_size: int = 200,
+    min_class_size: int = 10,
+    max_n_folds: int = 5,
+    max_n_repeats: int = 3,
+    average: str | None = None,
+    aggregation: str | None = None,
+    rounding_decimals: int | None = None,
+    subset: list | None = None,
+) -> tuple:
     """
     Generates a multiclass dataset and folding with scores
 

mlscorecheck/check/binary/_check_1_testset_no_kfold.py

@@ -15,7 +15,7 @@
 def check_1_testset_no_kfold(
     testset: dict,
     scores: dict,
-    eps: float,
+    eps: float | dict,
     *,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
     prefilter_by_pairs: bool = True,

mlscorecheck/check/binary/_check_n_datasets_mos_known_folds_mos.py

@@ -16,7 +16,7 @@
 def check_n_datasets_mos_known_folds_mos(
     evaluations: list,
     scores: dict,
-    eps: float,
+    eps: float | dict,
     dataset_score_bounds: dict | None = None,
     *,
     solver_name: str | None = None,

mlscorecheck/check/binary/_check_n_testsets_mos_no_kfold.py

@@ -14,7 +14,7 @@
 def check_n_testsets_mos_no_kfold(
     testsets: list,
     scores: dict,
-    eps: float,
+    eps: float | dict,
     *,
     testset_score_bounds: dict | None = None,
     solver_name: str | None = None,

mlscorecheck/check/binary/_check_n_testsets_som_no_kfold.py

@@ -14,7 +14,7 @@
 def check_n_testsets_som_no_kfold(
     testsets: list,
     scores: dict,
-    eps: float,
+    eps: float | dict,
     *,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
     prefilter_by_pairs: bool = True,

mlscorecheck/check/bundles/retina/_chasedb1.py

@@ -165,10 +165,10 @@ def check_chasedb1_vessel_aggregated_som(
 
 
 def check_chasedb1_vessel_aggregated(
-    imageset,
+    imageset: str | list,
     annotator: str,
     scores: dict,
-    eps,
+    eps: float | dict,
     *,
     score_bounds: dict | None = None,
     solver_name: str | None = None,
@@ -249,7 +249,7 @@ def check_chasedb1_vessel_image(
     image_identifier: str,
     annotator: str,
     scores: dict,
-    eps,
+    eps: float | dict,
     *,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:

mlscorecheck/check/bundles/retina/_diaretdb0.py

@@ -16,7 +16,7 @@
 ]
 
 
-def _prepare_configuration_diaretdb0(subset: str, batch, class_name: str | list) -> list:
+def _prepare_configuration_diaretdb0(subset: str, batch: str | list, class_name: str | list) -> list:
     """
     Prepare the testset specifications for a "one vs rest" setup
 
@@ -52,10 +52,10 @@ def _prepare_configuration_diaretdb0(subset: str, batch, class_name: str | list)
 
 def check_diaretdb0_class_som(
     subset: str,
-    batch,
-    class_name,
+    batch: str | list,
+    class_name: str | list,
     scores: dict,
-    eps,
+    eps: float | dict,
     *,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
@@ -130,10 +130,10 @@ def check_diaretdb0_class_som(
 
 def check_diaretdb0_class_mos(
     subset: str,
-    batch,
-    class_name,
+    batch: str | list,
+    class_name: str | list,
     scores: dict,
-    eps,
+    eps: float | dict,
     *,
     score_bounds: dict | None = None,
     solver_name: str | None = None,
@@ -212,10 +212,10 @@ def check_diaretdb0_class_mos(
 
 def check_diaretdb0_class(
     subset: str,
-    batch,
-    class_name,
+    batch: str | list,
+    class_name: str | list,
     scores: dict,
-    eps,
+    eps: float | dict,
     *,
     score_bounds: dict | None = None,
     solver_name: str | None = None,

mlscorecheck/check/bundles/retina/_diaretdb1.py

@@ -111,10 +111,10 @@ def _prepare_configuration_diaretdb1(
 def check_diaretdb1_class(
     *,
     subset: str,
-    class_name,
+    class_name: str,
     confidence: float,
     scores: dict,
-    eps,
+    eps: float | dict,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
     """
@@ -196,11 +196,11 @@ def check_diaretdb1_class(
 def check_diaretdb1_segmentation_image_assumption(
     *,
     image_identifier: str,
-    class_name,
+    class_name: str,
     assumption: str,
     confidence: float,
     scores: dict,
-    eps,
+    eps: float | dict,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
     """
@@ -275,10 +275,10 @@ def check_diaretdb1_segmentation_image_assumption(
 def check_diaretdb1_segmentation_image(
     *,
     image_identifier: str,
-    class_name,
+    class_name: str,
     confidence: float,
     scores: dict,
-    eps,
+    eps: float | dict,
     numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
     """
@@ -356,12 +356,12 @@ def check_diaretdb1_segmentation_image(
 def check_diaretdb1_segmentation_aggregated_assumption(
     *,
     subset: str,
-    class_name,
+    class_name: str,
     assumption: str,
     confidence: float,
     only_valid: bool,
     scores: dict,
-    eps,
+    eps: float | dict,
     score_bounds: dict | None = None,
     solver_name: str | None = None,
     timeout: int | None = None,
@@ -446,11 +446,11 @@ def check_diaretdb1_segmentation_aggregated_assumption(
 def check_diaretdb1_segmentation_aggregated(
     *,
     subset: str,
-    class_name,
+    class_name: str,
     confidence: float,
     only_valid: bool,
     scores: dict,
-    eps,
+    eps: float | dict,
     score_bounds: dict | None = None,
     solver_name: str | None = None,
     timeout: int | None = None,