some more improvements

Author: gykovacs

mlscorecheck/aggregated/_check_aggregated_scores.py

@@ -27,10 +27,10 @@ def check_aggregated_scores(
     experiment: dict,
     scores: dict,
     eps,
-    solver_name: str = None,
-    timeout: int = None,
+    solver_name: str | None = None,
+    timeout: int | None = None,
     verbosity: int = 1,
-    numerical_tolerance: float = NUMERICAL_TOLERANCE
+    numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
     """
     Check aggregated scores
@@ -71,9 +71,7 @@ def check_aggregated_scores(
             "message": "no scores suitable for aggregated consistency checks",
         }
 
-    experiment = (
-        Experiment(**experiment) if isinstance(experiment, dict) else experiment
-    )
+    experiment = Experiment(**experiment) if isinstance(experiment, dict) else experiment
 
     if experiment.aggregation == "som" and any(
         evaluation.aggregation == "mos" for evaluation in experiment.evaluations
@@ -85,9 +83,7 @@ def check_aggregated_scores(
         )
 
     solver_name = (
-        PREFERRED_SOLVER
-        if solver_name is None or solver_name not in solvers
-        else solver_name
+        PREFERRED_SOLVER if solver_name is None or solver_name not in solvers else solver_name
     )
 
     solver = pl.getSolver(

mlscorecheck/aggregated/_dataset.py

@@ -1,6 +1,7 @@
 """
 This module implements an abstraction for a dataset
 """
+
 # disabling pylint false positives
 # pylint: disable=no-member
 
@@ -17,10 +18,10 @@ class Dataset:
 
     def __init__(
         self,
-        p: int = None,
-        n: int = None,
-        dataset_name: str = None,
-        identifier: str = None,
+        p: int | None = None,
+        n: int | None = None,
+        dataset_name: str | None = None,
+        identifier: str | None = None,
     ):
         """
         Constructor of a dataset

mlscorecheck/aggregated/_evaluation.py

@@ -22,7 +22,7 @@ def __init__(
         dataset: dict,
         folding: dict,
         aggregation: str,
-        fold_score_bounds: dict = None,
+        fold_score_bounds: dict | None = None,
     ):
         """
         Constructor of the object
@@ -70,7 +70,7 @@ def to_dict(self) -> dict:
             "aggregation": self.aggregation,
         }
 
-    def sample_figures(self, random_state=None, score_subset: list = None):
+    def sample_figures(self, random_state=None, score_subset: list | None = None):
         """
         Samples the figures in the evaluation
 
@@ -90,7 +90,7 @@ def sample_figures(self, random_state=None, score_subset: list = None):
         return self
 
     def calculate_scores(
-        self, rounding_decimals: int = None, score_subset: list = None
+        self, rounding_decimals: int | None = None, score_subset: list | None = None
     ) -> dict:
         """
         Calculates the scores
@@ -116,9 +116,7 @@ def calculate_scores(
             self.figures["tn"] = sum(fold.tn for fold in self.folds)
 
         if self.aggregation == "som":
-            self.scores = calculate_scores_for_lp(
-                self.figures, score_subset=score_subset
-            )
+            self.scores = calculate_scores_for_lp(self.figures, score_subset=score_subset)
         elif self.aggregation == "mos":
             self.scores = dict_mean([fold.scores for fold in self.folds])
 
@@ -128,7 +126,7 @@ def calculate_scores(
             else round_scores(self.scores, rounding_decimals)
         )
 
-    def init_lp(self, lp_problem: pl.LpProblem, scores: dict = None) -> pl.LpProblem:
+    def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.LpProblem:
         """
         Initializes a linear programming problem
 
@@ -180,7 +178,7 @@ def check_bounds(self, numerical_tolerance: float = NUMERICAL_TOLERANCE) -> dict
             dict: a summary of the test, with the boolean flag under ``bounds_flag``
                     indicating the overall results
         """
-        results = {"folds": []}
+        results: dict = {"folds": []}
         for fold in self.folds:
             tmp = {
                 "fold": fold.to_dict() | {"tp": fold.tp, "tn": fold.tn},

mlscorecheck/aggregated/_experiment.py

@@ -19,7 +19,7 @@ class Experiment:
     """
 
     def __init__(
-        self, evaluations: list, aggregation: str, dataset_score_bounds: dict = None
+        self, evaluations: list, aggregation: str, dataset_score_bounds: dict | None = None
     ):
         """
         Constructor of the experiment
@@ -61,7 +61,7 @@ def to_dict(self) -> dict:
             "aggregation": self.aggregation,
         }
 
-    def sample_figures(self, random_state=None, score_subset: list = None):
+    def sample_figures(self, random_state=None, score_subset: list | None = None):
         """
         Samples the ``tp`` and ``tn`` figures
 
@@ -81,7 +81,7 @@ def sample_figures(self, random_state=None, score_subset: list = None):
         return self
 
     def calculate_scores(
-        self, rounding_decimals: int = None, score_subset: list = None
+        self, rounding_decimals: int | None = None, score_subset: list | None = None
     ) -> dict:
         """
         Calculates the scores
@@ -93,12 +93,8 @@ def calculate_scores(
         Returns:
             dict(str,float): the scores
         """
-        score_subset = (
-            ["acc", "sens", "spec", "bacc"] if score_subset is None else score_subset
-        )
-        score_subset = [
-            score for score in score_subset if score in ["acc", "sens", "spec", "bacc"]
-        ]
+        score_subset = ["acc", "sens", "spec", "bacc"] if score_subset is None else score_subset
+        score_subset = [score for score in score_subset if score in ["acc", "sens", "spec", "bacc"]]
 
         for evaluation in self.evaluations:
             evaluation.calculate_scores(score_subset=score_subset)
@@ -111,29 +107,21 @@ def calculate_scores(
                 evaluation.figures["tn"] for evaluation in self.evaluations
             )
         else:
-            self.figures["tp"] = sum(
-                evaluation.figures["tp"] for evaluation in self.evaluations
-            )
-            self.figures["tn"] = sum(
-                evaluation.figures["tn"] for evaluation in self.evaluations
-            )
+            self.figures["tp"] = sum(evaluation.figures["tp"] for evaluation in self.evaluations)
+            self.figures["tn"] = sum(evaluation.figures["tn"] for evaluation in self.evaluations)
 
         if self.aggregation == "som":
-            self.scores = calculate_scores_for_lp(
-                self.figures, score_subset=score_subset
-            )
+            self.scores = calculate_scores_for_lp(self.figures, score_subset=score_subset)
         elif self.aggregation == "mos":
-            self.scores = dict_mean(
-                [evaluation.scores for evaluation in self.evaluations]
-            )
+            self.scores = dict_mean([evaluation.scores for evaluation in self.evaluations])
 
         return (
             self.scores
             if rounding_decimals is None
             else round_scores(self.scores, rounding_decimals)
         )
 
-    def init_lp(self, lp_problem: pl.LpProblem, scores: dict = None) -> pl.LpProblem:
+    def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.LpProblem:
         """
         Initializes a linear programming problem
 
@@ -191,7 +179,7 @@ def check_bounds(self, numerical_tolerance: float = NUMERICAL_TOLERANCE) -> dict
                     indicating the overall results
         """
 
-        results = {"evaluations": []}
+        results: dict = {"evaluations": []}
         for evaluation in self.evaluations:
             tmp = {
                 "folds": evaluation.check_bounds(numerical_tolerance),

mlscorecheck/aggregated/_fold.py

@@ -21,7 +21,7 @@ class Fold:
     Abstract representation of a fold
     """
 
-    def __init__(self, p: int, n: int, identifier: str = None):
+    def __init__(self, p: int, n: int, identifier: str | None = None):
         """
         Constructor of a fold
 
@@ -34,9 +34,9 @@ def __init__(self, p: int, n: int, identifier: str = None):
         self.n = n
         self.identifier = random_identifier(5) if identifier is None else identifier
 
-        self.tp = None
-        self.tn = None
-        self.scores = None
+        self.tp: int | None = None
+        self.tn: int | None = None
+        self.scores: dict | None = None
 
         self.variable_names = {
             "tp": f"tp_{self.identifier}".replace("-", "_"),
@@ -70,7 +70,7 @@ def sample_figures(self, random_state=None):
         return self
 
     def calculate_scores(
-        self, rounding_decimals: int = None, score_subset: list = None
+        self, rounding_decimals: int | None = None, score_subset: list | None = None
     ) -> dict:
         """
         Calculate the scores for the fold
@@ -117,7 +117,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):
+    def init_lp(self, scores: dict | None = None):
         """
         Initialize a linear programming problem by creating the variables for the fold
 

mlscorecheck/aggregated/_fold_enumeration.py

@@ -116,9 +116,7 @@ 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
+def determine_min_max_p(*, p, n, k_a, k_b, c_a, p_non_zero, n_non_zero):  # pylint: disable=too-many-locals
     """
     Determines the minimum and maximum number of positives that can appear in folds
     of type A
@@ -145,9 +143,7 @@ def determine_min_max_p(
     return min_p_a, max_p_a
 
 
-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
+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
     """
     Generates the fold partitioning
 
@@ -270,9 +266,9 @@ def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
         logger.info("spec and bacc not among the reported scores, n=0 folds are also considered")
 
     if evaluation["dataset"].get("dataset_name") is not None:
-        evaluation["dataset"][
-            "identifier"
-        ] = f'{evaluation["dataset"]["dataset_name"]}_{random_identifier(3)}'
+        evaluation["dataset"]["identifier"] = (
+            f"{evaluation['dataset']['dataset_name']}_{random_identifier(3)}"
+        )
     else:
         evaluation["dataset"]["identifier"] = random_identifier(6)
 
@@ -416,7 +412,6 @@ def multiclass_fold_partitioning_generator_kn(ns: list, cs: list):
             yield part
         else:
             for part_deep in multiclass_fold_partitioning_generator_kn(ns[1:], part[1]):
-
                 if ns[0] == ns[1] and part[0] > part_deep[0]:
                     continue
 

mlscorecheck/aggregated/_folding.py

@@ -16,10 +16,10 @@ class Folding:
 
     def __init__(
         self,
-        n_folds: int = None,
-        n_repeats: int = None,
-        folds: list = None,
-        strategy: str = None,
+        n_folds: int | None = None,
+        n_repeats: int | None = None,
+        folds: list | None = None,
+        strategy: str | None = None,
     ):
         """
         Constructor of the folding
@@ -34,7 +34,7 @@ def __init__(
             raise ValueError("specify either n_folds,n_repeats,strategy or folds")
         if (n_folds is None) and (n_repeats is None) and (folds is None):
             raise ValueError("specify either n_folds,strategy or folds")
-        if ((folds is None) and (strategy is None)) and (n_folds > 1):
+        if ((folds is None) and (strategy is None)) and (n_folds is not None and n_folds > 1):
             raise ValueError("specify strategy if folds are not set explicitly")
 
         self.n_folds = n_folds
@@ -79,9 +79,7 @@ def generate_folds(self, dataset: Dataset, aggregation: str) -> list:
 
             term_a = (dataset.p != p) and (p % dataset.p != 0)
             term_b = (dataset.n != n) and (n % dataset.n != 0)
-            term_c = (
-                dataset.p > 0 and dataset.n > 0 and (p // dataset.p != n // dataset.n)
-            )
+            term_c = dataset.p > 0 and dataset.n > 0 and (p // dataset.p != n // dataset.n)
 
             if term_a or term_b or term_c:
                 raise ValueError(

mlscorecheck/aggregated/_folding_utils.py

@@ -82,11 +82,11 @@ def _create_folds(
     p: int,
     n: int,
     *,
-    n_folds: int = None,
-    n_repeats: int = None,
-    folding: str = None,
-    score_bounds: dict = None,
-    identifier: str = None,
+    n_folds: int | None = None,
+    n_repeats: int | None = None,
+    folding: str | None = None,
+    score_bounds: dict | None = None,
+    identifier: str | None = None,
 ) -> list:
     """
     Given a dataset, adds folds to it
@@ -108,16 +108,17 @@ def _create_folds(
     """
 
     if n_folds == 1:
+        n_repeats = n_repeats or 1
         folds = [
-            {"p": p, "n": n, "identifier": f"{identifier}_0_r{idx}"}
-            for idx in range(n_repeats)
+            {"p": p, "n": n, "identifier": f"{identifier}_0_r{idx}"} for idx in range(n_repeats)
         ]
 
     elif folding is None:
-        folds = [
-            {"p": p * n_repeats, "n": n * n_repeats, "identifier": f"{identifier}_0"}
-        ]
+        n_repeats = n_repeats or 1
+        folds = [{"p": p * n_repeats, "n": n * n_repeats, "identifier": f"{identifier}_0"}]
     else:
+        n_folds = n_folds or 5
+        n_repeats = n_repeats or 1
         folds = determine_fold_configurations(p, n, n_folds, n_repeats, folding)
         n_fold = 0
         n_repeat = 0
@@ -148,9 +149,7 @@ def multiclass_stratified_folds(dataset: dict, n_folds: int) -> list:
     """
     folds = []
     labels = np.hstack([np.repeat(key, value) for key, value in dataset.items()])
-    for _, test in StratifiedKFold(n_splits=n_folds).split(
-        labels.reshape(-1, 1), labels, labels
-    ):
+    for _, test in StratifiedKFold(n_splits=n_folds).split(labels.reshape(-1, 1), labels, labels):
         folds.append(dict(enumerate(np.bincount(labels[test]))))
 
     return folds