some more cleaning

Author: gykovacs

mlscorecheck/aggregated/_check_aggregated_scores.py

@@ -23,10 +23,10 @@
 
 
 def check_aggregated_scores(
-    *,
     experiment: dict,
     scores: dict,
-    eps,
+    eps: float | dict,
+    *,
     solver_name: str | None = None,
     timeout: int | None = None,
     verbosity: int = 1,

mlscorecheck/aggregated/_dataset.py

@@ -56,7 +56,7 @@ def __init__(
         else:
             self.identifier = identifier
 
-    def resolve_pn(self):
+    def resolve_pn(self) -> None:
         """
         Resolves the ``p`` and ``n`` values from the name of the dataset
         """

mlscorecheck/aggregated/_evaluation.py

@@ -70,7 +70,11 @@ def to_dict(self) -> dict:
             "aggregation": self.aggregation,
         }
 
-    def sample_figures(self, random_state=None, score_subset: list | None = None):
+    def sample_figures(
+        self, 
+        random_state=None, 
+        score_subset: list | None = None
+    ) -> "Evaluation":
         """
         Samples the figures in the evaluation
 
@@ -156,7 +160,7 @@ def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.Lp
 
         return lp_problem
 
-    def populate(self, lp_problem: pl.LpProblem):
+    def populate(self, lp_problem: pl.LpProblem) -> "Evaluation":
         """
         Populates the evaluation with the figures in the solved linear programming problem
 

mlscorecheck/aggregated/_experiment.py

@@ -61,7 +61,11 @@ def to_dict(self) -> dict:
             "aggregation": self.aggregation,
         }
 
-    def sample_figures(self, random_state=None, score_subset: list | None = None):
+    def sample_figures(
+        self, 
+        random_state=None, 
+        score_subset: list | None = None
+    ) -> "Experiment":
         """
         Samples the ``tp`` and ``tn`` figures
 
@@ -162,7 +166,7 @@ def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.Lp
 
         return lp_problem
 
-    def populate(self, lp_problem):
+    def populate(self, lp_problem) -> "Experiment":
         """
         Populates the evaluation with the figures in the solved linear programming problem
 

mlscorecheck/aggregated/_fold.py

@@ -54,7 +54,7 @@ def to_dict(self) -> dict:
         """
         return {"p": self.p, "n": self.n, "identifier": self.identifier}
 
-    def sample_figures(self, random_state=None):
+    def sample_figures(self, random_state=None) -> "Fold":
         """
         Samples the ``tp`` and ``tn`` figures
 
@@ -119,7 +119,7 @@ def set_initial_values(self, scores):
         self.tp.setInitialValue(int(tp_init))
         self.tn.setInitialValue(int(tn_init))
 
-    def init_lp(self, scores: dict | None = None):
+    def init_lp(self, scores: dict | None = None) -> pl.LpProblem:
         """
         Initialize a linear programming problem by creating the variables for the fold
 

mlscorecheck/aggregated/_fold_enumeration.py

@@ -4,6 +4,7 @@
 
 import copy
 import itertools
+from typing import Generator
 
 import numpy as np
 
@@ -26,7 +27,7 @@
 ]
 
 
-def integer_partitioning_generator(n: int, m: int):  # pylint: disable=invalid-name
+def integer_partitioning_generator(n: int, m: int) -> Generator[list, None, None]:  # pylint: disable=invalid-name
     """
     Integer partitioning generator
 
@@ -75,7 +76,7 @@ def integer_partitioning_generator(n: int, m: int):  # pylint: disable=invalid-n
         x[m] = n - s[m - 1]
 
 
-def all_integer_partitioning_generator(n, k, non_zero, max_count):  # pylint: disable=invalid-name
+def all_integer_partitioning_generator(n: int, k: int, non_zero: bool, max_count: int) -> Generator[list, None, None]:  # pylint: disable=invalid-name
     """
     Generate all integer partitioning of n to k parts (including 0 parts)
 
@@ -99,7 +100,7 @@ def all_integer_partitioning_generator(n, k, non_zero, max_count):  # pylint: di
                     yield [0] * (k - m) + positives
 
 
-def not_enough_diverse_folds(p_values, n_values):
+def not_enough_diverse_folds(p_values: list, n_values: list) -> bool:
     """
     Checks if there are enough folds with positive and negative samples
 
@@ -117,8 +118,15 @@ def not_enough_diverse_folds(p_values, n_values):
 
 
 def determine_min_max_p(
-    *, p, n, k_a, k_b, c_a, p_non_zero, n_non_zero
-):  # pylint: disable=too-many-locals
+    *, 
+    p: int, 
+    n: int, 
+    k_a: int, 
+    k_b: int, 
+    c_a: int, 
+    p_non_zero: int, 
+    n_non_zero: int
+) -> tuple[int, int]:
     """
     Determines the minimum and maximum number of positives that can appear in folds
     of type A
@@ -146,8 +154,14 @@ def determine_min_max_p(
 
 
 def fold_partitioning_generator(
-    *, p, n, k, p_non_zero=True, n_non_zero=True, p_min=-1
-):  # pylint: disable=invalid-name,too-many-locals
+    *, 
+    p: int, 
+    n: int, 
+    k: int, 
+    p_non_zero: bool = True, 
+    n_non_zero: bool = True, 
+    p_min: int = -1
+) -> Generator[tuple[list, list], None, None]:
     """
     Generates the fold partitioning
 
@@ -240,7 +254,11 @@ def _check_specification_and_determine_p_n(dataset: dict, folding: dict) -> tupl
     return p, n
 
 
-def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
+def kfolds_generator(
+    evaluation: dict, 
+    available_scores: list, 
+    repeat_idx: int = 0
+) -> Generator[list[dict], None, None]:
     """
     Generates the fold configurations
 
@@ -299,7 +317,10 @@ def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
         ]
 
 
-def repeated_kfolds_generator(evaluation: dict, available_scores: list):
+def repeated_kfolds_generator(
+    evaluation: dict, 
+    available_scores: list
+) -> Generator[dict, None, None]:
     """
     Generates the evaluation variations
 
@@ -334,7 +355,10 @@ def repeated_kfolds_generator(evaluation: dict, available_scores: list):
             }
 
 
-def experiment_kfolds_generator(experiment: dict, available_scores: list):
+def experiment_kfolds_generator(
+    experiment: dict, 
+    available_scores: list
+) -> Generator[dict, None, None]:
     """
     Generates the experiment variations
 
@@ -360,7 +384,11 @@ def experiment_kfolds_generator(experiment: dict, available_scores: list):
         }
 
 
-def multiclass_fold_partitioning_generator_22(n0: int, n1: int, c0: int):
+def multiclass_fold_partitioning_generator_22(
+    n0: int, 
+    n1: int, 
+    c0: int
+) -> Generator[dict, None, None]:
     """
     Generates the configurations for two folds of cardinalities n0 and n1 and two
     classes of cardinalities c0 and n0 + n1 - c0

mlscorecheck/aggregated/_generate_problems.py

@@ -28,7 +28,10 @@
 
 
 def generate_dataset(
-    max_p: int = 500, max_n: int = 500, random_state=None, no_name: bool = False
+    max_p: int = 100,
+    max_n: int = 100,
+    *,
+    random_state=None,
 ) -> dict:
     """
     Generate a random dataset specification

mlscorecheck/aggregated/_linear_programming.py

@@ -2,6 +2,7 @@
 Some general purpose linear programming functionalities
 """
 
+from typing import Any
 import numpy as np
 import pulp as pl
 
@@ -54,7 +55,7 @@ def add_bounds(lp_problem: pl.LpProblem, variables: dict, bounds: dict, label: s
     return lp_problem
 
 
-def create_lp_target(obj, scores: dict, eps, lp_problem: pl.LpProblem) -> pl.LpProblem:
+def create_lp_target(obj: Any, scores: dict, eps: float | dict, lp_problem: pl.LpProblem) -> pl.LpProblem:
     """
     Add the target and the score conditions to the linear programming problem
 
@@ -78,7 +79,7 @@ def create_lp_target(obj, scores: dict, eps, lp_problem: pl.LpProblem) -> pl.LpP
     return lp_problem
 
 
-def solve(obj, scores: dict, eps, solver=None) -> pl.LpProblem:
+def solve(obj: Any, scores: dict, eps: float | dict, solver: Any = None) -> pl.LpProblem:
     """
     Solving a problem.
 

mlscorecheck/aggregated/_utils.py

@@ -12,7 +12,7 @@
 aggregated_scores = ["acc", "sens", "spec", "bacc"]
 
 
-def random_identifier(length: int):
+def random_identifier(length: int) -> str:
     """
     Generating a random identifier
 
@@ -55,8 +55,12 @@ def check_bounds(scores: dict, bounds: dict | None = None, tolerance: float = 1e
 
 
 def compare_scores(
-    scores0: dict, scores1: dict, eps, subset: list | None = None, tolerance: float = 1e-5
-):
+    scores0: dict, 
+    scores1: dict, 
+    eps: float | dict, 
+    subset: list | None = None, 
+    tolerance: float = 1e-5
+) -> bool:
     """
     Compares two sets of scores
 

mlscorecheck/check/binary/_check_1_dataset_kfold_som.py

@@ -1,5 +1,13 @@
 """
-This module implements the top level check function for
+This modudef check_1_dataset_kfold_som(
+    dataset: dict,
+    folding: dict,
+    scores: dict,
+    eps: float,
+    *,
+    numerical_tolerance: float = NUMERICAL_TOLERANCE,
+    prefilter_by_pairs: bool = True,
+) -> dict:ents the top level check function for
 scores calculated by the score-of-means aggregation
 in a kfold scenario on one single dataset.
 """