From 121e1347c95389d3534955056d752838dc76d244 Mon Sep 17 00:00:00 2001
From: Lukas Drews <drews.lukas@yahoo.com>
Date: Thu, 11 Apr 2024 22:08:05 +0200
Subject: [PATCH] black formatting for tests

---
 tests/test_LocalClassifierPerLevel.py      | 105 +++++--
 tests/test_LocalClassifierPerNode.py       | 168 ++++++++---
 tests/test_LocalClassifierPerParentNode.py | 123 ++++++--
 tests/test_ProbabilityCombiner.py          | 204 ++++++++++---
 tests/test_calibration.py                  | 336 +++++++++++++++------
 tests/test_metrics.py                      |  93 ++++--
 6 files changed, 756 insertions(+), 273 deletions(-)

diff --git a/tests/test_LocalClassifierPerLevel.py b/tests/test_LocalClassifierPerLevel.py
index 6286a06d..880fc904 100644
--- a/tests/test_LocalClassifierPerLevel.py
+++ b/tests/test_LocalClassifierPerLevel.py
@@ -21,7 +21,9 @@ def test_sklearn_compatible_estimator(estimator, check):
 
 @pytest.fixture
 def digraph_logistic_regression():
-    digraph = LocalClassifierPerLevel(local_classifier=LogisticRegression(), calibration_method="ivap")
+    digraph = LocalClassifierPerLevel(
+        local_classifier=LogisticRegression(), calibration_method="ivap"
+    )
     digraph.hierarchy_ = nx.DiGraph([("a", "b"), ("a", "c")])
     digraph.y_ = np.array([["a", "b"], ["a", "c"]])
     digraph.X_ = np.array([[1, 2], [3, 4]])
@@ -46,14 +48,12 @@ def test_initialize_local_classifiers(digraph_logistic_regression):
             LogisticRegression,
         )
 
+
 def test_initialize_local_calibrators(digraph_logistic_regression):
     digraph_logistic_regression._initialize_local_classifiers()
     digraph_logistic_regression._initialize_local_calibrators()
     for calibrator in digraph_logistic_regression.local_calibrators_:
-        assert isinstance(
-            calibrator,
-            _Calibrator
-        )
+        assert isinstance(calibrator, _Calibrator)
 
 
 def test_fit_digraph(digraph_logistic_regression):
@@ -71,6 +71,7 @@ def test_fit_digraph(digraph_logistic_regression):
             pytest.fail(repr(e))
     assert 1
 
+
 def test_calibrate_digraph(digraph_logistic_regression):
     classifiers = [
         LogisticRegression(),
@@ -80,7 +81,10 @@ def test_calibrate_digraph(digraph_logistic_regression):
     digraph_logistic_regression.local_classifiers_ = classifiers
     digraph_logistic_regression._fit_digraph(local_mode=True)
 
-    calibrators = [_Calibrator(classifier) for classifier in digraph_logistic_regression.local_classifiers_]
+    calibrators = [
+        _Calibrator(classifier)
+        for classifier in digraph_logistic_regression.local_classifiers_
+    ]
     digraph_logistic_regression.local_calibrators_ = calibrators
     digraph_logistic_regression._calibrate_digraph(local_mode=True)
 
@@ -91,7 +95,6 @@ def test_calibrate_digraph(digraph_logistic_regression):
     assert 1
 
 
-
 def test_fit_digraph_joblib_multiprocessing(digraph_logistic_regression):
     classifiers = [
         LogisticRegression(),
@@ -108,6 +111,7 @@ def test_fit_digraph_joblib_multiprocessing(digraph_logistic_regression):
             pytest.fail(repr(e))
     assert 1
 
+
 def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     classifiers = [
         LogisticRegression(),
@@ -117,7 +121,10 @@ def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     digraph_logistic_regression.local_classifiers_ = classifiers
     digraph_logistic_regression._fit_digraph(local_mode=True, use_joblib=True)
 
-    calibrators = [_Calibrator(classifier) for classifier in digraph_logistic_regression.local_classifiers_]
+    calibrators = [
+        _Calibrator(classifier)
+        for classifier in digraph_logistic_regression.local_classifiers_
+    ]
     digraph_logistic_regression.local_calibrators_ = calibrators
     digraph_logistic_regression._calibrate_digraph(local_mode=True, use_joblib=True)
 
@@ -128,15 +135,15 @@ def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     assert 1
 
 
-
 @pytest.fixture
 def fitted_logistic_regression():
     digraph = LocalClassifierPerLevel(
         local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner=None)
-    
+        probability_combiner=None,
+    )
+
     digraph.separator_ = "::HiClass::Separator::"
     digraph.hierarchy_ = nx.DiGraph(
         [("r", "1"), ("r", "2"), ("1", "1.1"), ("1", "1.2"), ("2", "2.1"), ("2", "2.2")]
@@ -148,16 +155,38 @@ def fitted_logistic_regression():
 
     # for predict_proba
     tmp_labels = digraph._disambiguate(make_leveled(digraph.y_))
-    digraph.max_level_dimensions_ = np.array([len(np.unique(tmp_labels[:, level])) for level in range(tmp_labels.shape[1])])
-    digraph.global_classes_ = [np.unique(tmp_labels[:, level]).astype("str") for level in range(tmp_labels.shape[1])]
-    digraph.global_class_to_index_mapping_ = [{digraph.global_classes_[level][index]: index for index in range(len(digraph.global_classes_[level]))} for level in range(tmp_labels.shape[1])]
+    digraph.max_level_dimensions_ = np.array(
+        [len(np.unique(tmp_labels[:, level])) for level in range(tmp_labels.shape[1])]
+    )
+    digraph.global_classes_ = [
+        np.unique(tmp_labels[:, level]).astype("str")
+        for level in range(tmp_labels.shape[1])
+    ]
+    digraph.global_class_to_index_mapping_ = [
+        {
+            digraph.global_classes_[level][index]: index
+            for index in range(len(digraph.global_classes_[level]))
+        }
+        for level in range(tmp_labels.shape[1])
+    ]
 
     classes_ = [digraph.global_classes_[0]]
     for level in range(1, digraph.max_levels_):
-        classes_.append(np.sort(np.unique([label.split(digraph.separator_)[level] for label in digraph.global_classes_[level]])))
+        classes_.append(
+            np.sort(
+                np.unique(
+                    [
+                        label.split(digraph.separator_)[level]
+                        for label in digraph.global_classes_[level]
+                    ]
+                )
+            )
+        )
     digraph.classes_ = classes_
-    digraph.class_to_index_mapping_ = [{local_labels[index]: index for index in range(len(local_labels))} for local_labels in classes_]
-
+    digraph.class_to_index_mapping_ = [
+        {local_labels[index]: index for index in range(len(local_labels))}
+        for local_labels in classes_
+    ]
 
     digraph.dtype_ = "<U3"
     digraph.root_ = "r"
@@ -194,17 +223,28 @@ def test_predict_proba(fitted_logistic_regression):
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
 
 
 def test_predict_proba_sparse(fitted_logistic_regression):
-    proba = fitted_logistic_regression.predict_proba(csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]]))
+    proba = fitted_logistic_regression.predict_proba(
+        csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]])
+    )
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_fit_predict():
     lcpl = LocalClassifierPerLevel(local_classifier=LogisticRegression())
@@ -223,13 +263,15 @@ def test_fit_predict():
     predictions = lcpl.predict(x)
     assert_array_equal(y, predictions)
 
+
 def test_fit_calibrate_predict_proba():
     lcpl = LocalClassifierPerLevel(
-        local_classifier=LogisticRegression(), 
+        local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner="geometric")
-    
+        probability_combiner="geometric",
+    )
+
     x = np.array([[1, 2], [3, 4]])
     y = np.array([["a", "b"], ["b", "c"]])
     ground_truth = np.array(
@@ -250,15 +292,20 @@ def test_fit_calibrate_predict_proba():
     assert len(proba) == 2
     assert proba[0].shape == (2, 2)
     assert proba[1].shape == (2, 2)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_fit_calibrate_predict_predict_proba_bert():
     classifier = LocalClassifierPerLevel(
-        local_classifier=LogisticRegression(), 
+        local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner="geometric" 
+        probability_combiner="geometric",
     )
 
     classifier.logger_ = logging.getLogger("HC")
diff --git a/tests/test_LocalClassifierPerNode.py b/tests/test_LocalClassifierPerNode.py
index 533802c6..2bcdf45c 100644
--- a/tests/test_LocalClassifierPerNode.py
+++ b/tests/test_LocalClassifierPerNode.py
@@ -49,7 +49,9 @@ def digraph_with_unknown_policy():
 
 def test_initialize_unknown_binary_policy(digraph_with_unknown_policy):
     with pytest.raises(KeyError):
-        digraph_with_unknown_policy.binary_policy_ = digraph_with_unknown_policy._initialize_binary_policy()
+        digraph_with_unknown_policy.binary_policy_ = (
+            digraph_with_unknown_policy._initialize_binary_policy()
+        )
         digraph_with_unknown_policy._initialize_binary_policy()
 
 
@@ -69,7 +71,9 @@ def test_initialize_object_binary_policy(digraph_with_object_policy):
 
 @pytest.fixture
 def digraph_logistic_regression():
-    digraph = LocalClassifierPerNode(local_classifier=LogisticRegression(), calibration_method="ivap")
+    digraph = LocalClassifierPerNode(
+        local_classifier=LogisticRegression(), calibration_method="ivap"
+    )
     digraph.hierarchy_ = nx.DiGraph([("a", "b"), ("a", "c")])
     digraph.y_ = np.array([["a", "b"], ["a", "c"]])
     digraph.X_ = np.array([[1, 2], [3, 4]])
@@ -98,6 +102,7 @@ def test_initialize_local_classifiers(digraph_logistic_regression):
                     LogisticRegression,
                 )
 
+
 def test_initialize_local_calibrators(digraph_logistic_regression):
     digraph_logistic_regression._initialize_local_classifiers()
     digraph_logistic_regression._initialize_local_calibrators()
@@ -135,6 +140,7 @@ def test_fit_digraph(digraph_logistic_regression):
             pytest.fail(repr(e))
     assert 1
 
+
 def test_calibrate_digraph(digraph_logistic_regression):
     classifiers = {
         "b": {"classifier": LogisticRegression()},
@@ -145,12 +151,20 @@ def test_calibrate_digraph(digraph_logistic_regression):
     digraph_logistic_regression._fit_digraph(local_mode=True)
 
     calibrators = {
-        "b": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["b"]["classifier"])},
-        "c": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["c"]["classifier"])}
+        "b": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["b"]["classifier"]
+            )
+        },
+        "c": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["c"]["classifier"]
+            )
+        },
     }
     nx.set_node_attributes(digraph_logistic_regression.hierarchy_, calibrators)
     digraph_logistic_regression._calibrate_digraph(local_mode=True)
-    
+
     with pytest.raises(KeyError):
         check_is_fitted(digraph_logistic_regression.hierarchy_.nodes["a"]["calibrator"])
     for node in ["b", "c"]:
@@ -182,6 +196,7 @@ def test_fit_digraph_joblib_multiprocessing(digraph_logistic_regression):
             pytest.fail(repr(e))
     assert 1
 
+
 def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     classifiers = {
         "b": {"classifier": LogisticRegression()},
@@ -192,8 +207,16 @@ def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     digraph_logistic_regression._fit_digraph(local_mode=True, use_joblib=True)
 
     calibrators = {
-        "b": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["b"]["classifier"])},
-        "c": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["c"]["classifier"])}
+        "b": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["b"]["classifier"]
+            )
+        },
+        "c": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["c"]["classifier"]
+            )
+        },
     }
     nx.set_node_attributes(digraph_logistic_regression.hierarchy_, calibrators)
     digraph_logistic_regression._calibrate_digraph(local_mode=True, use_joblib=True)
@@ -228,27 +251,26 @@ def fitted_logistic_regression():
         local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner="geometric")
-    
+        probability_combiner="geometric",
+    )
+
     digraph.separator_ = "::HiClass::Separator::"
-    #digraph.hierarchy_ = nx.DiGraph(
+    # digraph.hierarchy_ = nx.DiGraph(
     #    [("r", "1"), ("r", "2"), ("1", "1.1"), ("1", "1.2"), ("2", "2.1"), ("2", "2.2")]
-    #)
+    # )
 
     digraph.hierarchy_ = nx.DiGraph(
-        [("r", "1"), 
-         ("r", "2"), 
-         ("1", "1"+digraph.separator_+"1.1"),
-         ("1", "1"+digraph.separator_+"1.2"), 
-         ("2", "2"+digraph.separator_+"2.1"), 
-         ("2", "2"+digraph.separator_+"2.2")]
+        [
+            ("r", "1"),
+            ("r", "2"),
+            ("1", "1" + digraph.separator_ + "1.1"),
+            ("1", "1" + digraph.separator_ + "1.2"),
+            ("2", "2" + digraph.separator_ + "2.1"),
+            ("2", "2" + digraph.separator_ + "2.2"),
+        ]
     )
-    digraph.y_ = np.array([
-        ["1", "1.1"], 
-        ["1", "1.2"], 
-        ["2", "2.1"], 
-        ["2", "2.2"]])
-    
+    digraph.y_ = np.array([["1", "1.1"], ["1", "1.2"], ["2", "2.1"], ["2", "2.2"]])
+
     digraph.X_ = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
     digraph.logger_ = logging.getLogger("LCPN")
     digraph.max_levels_ = 2
@@ -257,25 +279,59 @@ def fitted_logistic_regression():
 
     # for predict_proba
     tmp_labels = digraph._disambiguate(make_leveled(digraph.y_))
-    #digraph.y_ = tmp_labels
-    digraph.max_level_dimensions_ = np.array([len(np.unique(tmp_labels[:, level])) for level in range(tmp_labels.shape[1])])
-    digraph.global_classes_ = [np.unique(tmp_labels[:, level]).astype("str") for level in range(tmp_labels.shape[1])]
-    digraph.global_class_to_index_mapping_ = [{digraph.global_classes_[level][index]: index for index in range(len(digraph.global_classes_[level]))} for level in range(tmp_labels.shape[1])]
+    # digraph.y_ = tmp_labels
+    digraph.max_level_dimensions_ = np.array(
+        [len(np.unique(tmp_labels[:, level])) for level in range(tmp_labels.shape[1])]
+    )
+    digraph.global_classes_ = [
+        np.unique(tmp_labels[:, level]).astype("str")
+        for level in range(tmp_labels.shape[1])
+    ]
+    digraph.global_class_to_index_mapping_ = [
+        {
+            digraph.global_classes_[level][index]: index
+            for index in range(len(digraph.global_classes_[level]))
+        }
+        for level in range(tmp_labels.shape[1])
+    ]
 
     classes_ = [digraph.global_classes_[0]]
     for level in range(1, digraph.max_levels_):
-        classes_.append(np.sort(np.unique([label.split(digraph.separator_)[level] for label in digraph.global_classes_[level]])))
+        classes_.append(
+            np.sort(
+                np.unique(
+                    [
+                        label.split(digraph.separator_)[level]
+                        for label in digraph.global_classes_[level]
+                    ]
+                )
+            )
+        )
     digraph.classes_ = classes_
-    digraph.class_to_index_mapping_ = [{local_labels[index]: index for index in range(len(local_labels))} for local_labels in classes_]
+    digraph.class_to_index_mapping_ = [
+        {local_labels[index]: index for index in range(len(local_labels))}
+        for local_labels in classes_
+    ]
 
-    classifiers = {key: {"classifier": LogisticRegression()} for key in np.hstack([digraph.global_classes_[0], digraph.global_classes_[1]])}
+    classifiers = {
+        key: {"classifier": LogisticRegression()}
+        for key in np.hstack([digraph.global_classes_[0], digraph.global_classes_[1]])
+    }
 
     classifiers["1"]["classifier"].fit(digraph.X_, [1, 1, 0, 0])
-    classifiers["1"+digraph.separator_+"1.1"]["classifier"].fit(digraph.X_, [1, 0, 0, 0])
-    classifiers["1"+digraph.separator_+"1.2"]["classifier"].fit(digraph.X_, [0, 1, 0, 0])
+    classifiers["1" + digraph.separator_ + "1.1"]["classifier"].fit(
+        digraph.X_, [1, 0, 0, 0]
+    )
+    classifiers["1" + digraph.separator_ + "1.2"]["classifier"].fit(
+        digraph.X_, [0, 1, 0, 0]
+    )
     classifiers["2"]["classifier"].fit(digraph.X_, [0, 0, 1, 1])
-    classifiers["2"+digraph.separator_+"2.1"]["classifier"].fit(digraph.X_, [0, 0, 1, 0])
-    classifiers["2"+digraph.separator_+"2.2"]["classifier"].fit(digraph.X_, [0, 0, 0, 1])
+    classifiers["2" + digraph.separator_ + "2.1"]["classifier"].fit(
+        digraph.X_, [0, 0, 1, 0]
+    )
+    classifiers["2" + digraph.separator_ + "2.2"]["classifier"].fit(
+        digraph.X_, [0, 0, 0, 1]
+    )
     nx.set_node_attributes(digraph.hierarchy_, classifiers)
     return digraph
 
@@ -293,21 +349,33 @@ def test_predict_sparse(fitted_logistic_regression):
     )
     assert_array_equal(ground_truth, prediction)
 
+
 def test_predict_proba(fitted_logistic_regression):
     proba = fitted_logistic_regression.predict_proba([[7, 8], [5, 6], [3, 4], [1, 2]])
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_predict_proba_sparse(fitted_logistic_regression):
-    proba = fitted_logistic_regression.predict_proba(csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]]))
+    proba = fitted_logistic_regression.predict_proba(
+        csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]])
+    )
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
 
 
 def test_fit_predict():
@@ -318,8 +386,13 @@ def test_fit_predict():
     predictions = lcpn.predict(x)
     assert_array_equal(y, predictions)
 
+
 def test_fit_calibrate_predict_proba():
-    lcpn = LocalClassifierPerNode(local_classifier=LogisticRegression(), calibration_method="ivap", return_all_probabilities=True)
+    lcpn = LocalClassifierPerNode(
+        local_classifier=LogisticRegression(),
+        calibration_method="ivap",
+        return_all_probabilities=True,
+    )
     x = np.array([[1, 2], [3, 4]])
     y = np.array([["a", "b"], ["b", "c"]])
     lcpn.fit(x, y)
@@ -331,15 +404,20 @@ def test_fit_calibrate_predict_proba():
     assert len(proba) == 2
     assert proba[0].shape == (2, 2)
     assert proba[1].shape == (2, 2)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_fit_calibrate_predict_predict_proba_bert():
     classifier = LocalClassifierPerNode(
-        local_classifier=LogisticRegression(), 
+        local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner="geometric" 
+        probability_combiner="geometric",
     )
 
     classifier.logger_ = logging.getLogger("HC")
@@ -350,4 +428,4 @@ def test_fit_calibrate_predict_predict_proba_bert():
     classifier.fit(x, y, sample_weight)
     classifier.calibrate(x, y)
     classifier.predict(x)
-    classifier.predict_proba(x)
\ No newline at end of file
+    classifier.predict_proba(x)
diff --git a/tests/test_LocalClassifierPerParentNode.py b/tests/test_LocalClassifierPerParentNode.py
index 9480dbab..ad1a5469 100644
--- a/tests/test_LocalClassifierPerParentNode.py
+++ b/tests/test_LocalClassifierPerParentNode.py
@@ -22,7 +22,9 @@ def test_sklearn_compatible_estimator(estimator, check):
 
 @pytest.fixture
 def digraph_logistic_regression():
-    digraph = LocalClassifierPerParentNode(local_classifier=LogisticRegression(), calibration_method="ivap")
+    digraph = LocalClassifierPerParentNode(
+        local_classifier=LogisticRegression(), calibration_method="ivap"
+    )
     digraph.hierarchy_ = nx.DiGraph([("a", "b"), ("a", "c"), ("b", "d"), ("c", "f")])
     digraph.y_ = np.array([["a", "b"], ["a", "c"], ["b", "d"], ["c", "f"]])
     digraph.X_ = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
@@ -50,6 +52,7 @@ def test_initialize_local_classifiers(digraph_logistic_regression):
                     LogisticRegression,
                 )
 
+
 def test_initialize_local_calibrators(digraph_logistic_regression):
     digraph_logistic_regression._initialize_local_classifiers()
     digraph_logistic_regression._initialize_local_calibrators()
@@ -88,6 +91,7 @@ def test_fit_digraph(digraph_logistic_regression):
             )
     assert 1
 
+
 def test_calibrate_digraph(digraph_logistic_regression):
     classifiers = {
         "a": {"classifier": LogisticRegression()},
@@ -99,7 +103,11 @@ def test_calibrate_digraph(digraph_logistic_regression):
     digraph_logistic_regression._fit_digraph(local_mode=True)
 
     calibrators = {
-        "a": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["a"]["classifier"])},
+        "a": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["a"]["classifier"]
+            )
+        },
     }
     nx.set_node_attributes(digraph_logistic_regression.hierarchy_, calibrators)
     digraph_logistic_regression._calibrate_digraph(local_mode=True)
@@ -136,6 +144,7 @@ def test_fit_digraph_joblib_multiprocessing(digraph_logistic_regression):
             )
     assert 1
 
+
 def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     classifiers = {
         "a": {"classifier": LogisticRegression()},
@@ -147,7 +156,11 @@ def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
     digraph_logistic_regression._fit_digraph(local_mode=True, use_joblib=True)
 
     calibrators = {
-        "a": {"calibrator": _Calibrator(digraph_logistic_regression.hierarchy_.nodes["a"]["classifier"])},
+        "a": {
+            "calibrator": _Calibrator(
+                digraph_logistic_regression.hierarchy_.nodes["a"]["classifier"]
+            )
+        },
     }
     nx.set_node_attributes(digraph_logistic_regression.hierarchy_, calibrators)
     digraph_logistic_regression._calibrate_digraph(local_mode=True, use_joblib=True)
@@ -163,6 +176,7 @@ def test_calibrate_digraph_joblib_multiprocessing(digraph_logistic_regression):
             )
     assert 1
 
+
 @pytest.fixture
 def digraph_2d():
     classifier = LocalClassifierPerParentNode()
@@ -211,24 +225,24 @@ def test_get_successors(x_and_y_arrays):
 @pytest.fixture
 def fitted_logistic_regression():
     digraph = LocalClassifierPerParentNode(
-        local_classifier=LogisticRegression(), 
+        local_classifier=LogisticRegression(),
         calibration_method="ivap",
         probability_combiner="geometric",
-        return_all_probabilities=True)
-    
+        return_all_probabilities=True,
+    )
+
     digraph.separator_ = "::HiClass::Separator::"
     digraph.hierarchy_ = nx.DiGraph(
         [
             ("r", "1"),
             ("r", "2"),
-            ("1", "1"+digraph.separator_+"1.1"),
-            ("1", "1"+digraph.separator_+"1.2"),
-            ("2", "2"+digraph.separator_+"2.1"),
-            ("2", "2"+digraph.separator_+"2.2"),
+            ("1", "1" + digraph.separator_ + "1.1"),
+            ("1", "1" + digraph.separator_ + "1.2"),
+            ("2", "2" + digraph.separator_ + "2.1"),
+            ("2", "2" + digraph.separator_ + "2.2"),
         ]
     )
-    digraph.y_ = np.array([
-        ["1", "1.1"], ["1", "1.2"], ["2", "2.1"], ["2", "2.2"]])
+    digraph.y_ = np.array([["1", "1.1"], ["1", "1.2"], ["2", "2.1"], ["2", "2.2"]])
     digraph.X_ = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
     digraph.logger_ = logging.getLogger("LCPPN")
     digraph.max_levels_ = 2
@@ -238,15 +252,36 @@ def fitted_logistic_regression():
 
     # for predict_proba
     tmp_labels = digraph._disambiguate(make_leveled(digraph.y_))
-    #digraph.y_ = tmp_labels
-    digraph.global_classes_ = [np.unique(tmp_labels[:, level]).astype("str") for level in range(tmp_labels.shape[1])]
-    digraph.global_class_to_index_mapping_ = [{digraph.global_classes_[level][index]: index for index in range(len(digraph.global_classes_[level]))} for level in range(tmp_labels.shape[1])]
+    # digraph.y_ = tmp_labels
+    digraph.global_classes_ = [
+        np.unique(tmp_labels[:, level]).astype("str")
+        for level in range(tmp_labels.shape[1])
+    ]
+    digraph.global_class_to_index_mapping_ = [
+        {
+            digraph.global_classes_[level][index]: index
+            for index in range(len(digraph.global_classes_[level]))
+        }
+        for level in range(tmp_labels.shape[1])
+    ]
 
     classes_ = [digraph.global_classes_[0]]
     for level in range(1, digraph.max_levels_):
-        classes_.append(np.sort(np.unique([label.split(digraph.separator_)[level] for label in digraph.global_classes_[level]])))
+        classes_.append(
+            np.sort(
+                np.unique(
+                    [
+                        label.split(digraph.separator_)[level]
+                        for label in digraph.global_classes_[level]
+                    ]
+                )
+            )
+        )
     digraph.classes_ = classes_
-    digraph.class_to_index_mapping_ = [{local_labels[index]: index for index in range(len(local_labels))} for local_labels in classes_]
+    digraph.class_to_index_mapping_ = [
+        {local_labels[index]: index for index in range(len(local_labels))}
+        for local_labels in classes_
+    ]
 
     classifiers = {
         "r": {"classifier": LogisticRegression()},
@@ -254,8 +289,14 @@ def fitted_logistic_regression():
         "2": {"classifier": LogisticRegression()},
     }
     classifiers["r"]["classifier"].fit(digraph.X_, ["1", "1", "2", "2"])
-    classifiers["1"]["classifier"].fit(digraph.X_[:2], ["1"+digraph.separator_+"1.1", "1"+digraph.separator_+"1.2"])
-    classifiers["2"]["classifier"].fit(digraph.X_[2:], ["2"+digraph.separator_+"2.1", "2"+digraph.separator_+"2.2"])
+    classifiers["1"]["classifier"].fit(
+        digraph.X_[:2],
+        ["1" + digraph.separator_ + "1.1", "1" + digraph.separator_ + "1.2"],
+    )
+    classifiers["2"]["classifier"].fit(
+        digraph.X_[2:],
+        ["2" + digraph.separator_ + "2.1", "2" + digraph.separator_ + "2.2"],
+    )
     nx.set_node_attributes(digraph.hierarchy_, classifiers)
     return digraph
 
@@ -273,21 +314,33 @@ def test_predict_sparse(fitted_logistic_regression):
     )
     assert_array_equal(ground_truth, prediction)
 
+
 def test_predict_proba(fitted_logistic_regression):
     proba = fitted_logistic_regression.predict_proba([[7, 8], [5, 6], [3, 4], [1, 2]])
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_predict_proba_sparse(fitted_logistic_regression):
-    proba = fitted_logistic_regression.predict_proba(csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]]))
+    proba = fitted_logistic_regression.predict_proba(
+        csr_matrix([[7, 8], [5, 6], [3, 4], [1, 2]])
+    )
     assert len(proba) == 2
     assert proba[0].shape == (4, 2)
     assert proba[1].shape == (4, 4)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
 
 
 def test_fit_predict():
@@ -298,8 +351,13 @@ def test_fit_predict():
     predictions = lcppn.predict(x)
     assert_array_equal(y, predictions)
 
+
 def test_fit_calibrate_predict_proba():
-    lcppn = LocalClassifierPerParentNode(local_classifier=LogisticRegression(), calibration_method="ivap", return_all_probabilities=True)
+    lcppn = LocalClassifierPerParentNode(
+        local_classifier=LogisticRegression(),
+        calibration_method="ivap",
+        return_all_probabilities=True,
+    )
     x = np.array([[1, 2], [3, 4]])
     y = np.array([["a", "b"], ["b", "c"]])
     lcppn.fit(x, y)
@@ -310,15 +368,20 @@ def test_fit_calibrate_predict_proba():
     assert len(proba) == 2
     assert proba[0].shape == (2, 2)
     assert proba[1].shape == (2, 2)
-    assert_array_almost_equal(np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10)
-    assert_array_almost_equal(np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10)
+    assert_array_almost_equal(
+        np.sum(proba[0], axis=1), np.ones(len(proba[0])), decimal=10
+    )
+    assert_array_almost_equal(
+        np.sum(proba[1], axis=1), np.ones(len(proba[1])), decimal=10
+    )
+
 
 def test_fit_calibrate_predict_predict_proba_bert():
     classifier = LocalClassifierPerParentNode(
-        local_classifier=LogisticRegression(), 
+        local_classifier=LogisticRegression(),
         return_all_probabilities=True,
         calibration_method="ivap",
-        probability_combiner="geometric" 
+        probability_combiner="geometric",
     )
 
     classifier.logger_ = logging.getLogger("HC")
@@ -329,4 +392,4 @@ def test_fit_calibrate_predict_predict_proba_bert():
     classifier.fit(x, y, sample_weight)
     classifier.calibrate(x, y)
     classifier.predict(x)
-    classifier.predict_proba(x)
\ No newline at end of file
+    classifier.predict_proba(x)
diff --git a/tests/test_ProbabilityCombiner.py b/tests/test_ProbabilityCombiner.py
index db4c81b8..a9f21aa7 100644
--- a/tests/test_ProbabilityCombiner.py
+++ b/tests/test_ProbabilityCombiner.py
@@ -9,7 +9,11 @@
 from hiclass.HierarchicalClassifier import make_leveled
 
 from hiclass.HierarchicalClassifier import HierarchicalClassifier
-from hiclass.probability_combiner import MultiplyCombiner, ArithmeticMeanCombiner, GeometricMeanCombiner
+from hiclass.probability_combiner import (
+    MultiplyCombiner,
+    ArithmeticMeanCombiner,
+    GeometricMeanCombiner,
+)
 
 
 def _disambiguate(y, separator):
@@ -25,6 +29,7 @@ def _disambiguate(y, separator):
         return np.array(new_y)
     return y
 
+
 @pytest.fixture
 def one_sample_probs_with_hierarchy():
     hierarchy = nx.DiGraph()
@@ -35,27 +40,55 @@ def one_sample_probs_with_hierarchy():
 
     for i in range(3):
         # first level
-        first_level_node = f'node_{i}'
+        first_level_node = f"node_{i}"
         hierarchy.add_node(first_level_node)
         hierarchy.add_edge(root_node, first_level_node)
         for j in range(3):
             # second level
-            second_level_node = f'node_{i}:{j}'
-            second_level_label = _disambiguate(np.array([[first_level_node, second_level_node]]), separator)[0][1]
+            second_level_node = f"node_{i}:{j}"
+            second_level_label = _disambiguate(
+                np.array([[first_level_node, second_level_node]]), separator
+            )[0][1]
             hierarchy.add_node(second_level_label)
             hierarchy.add_edge(first_level_node, second_level_label)
             for k in range(2):
                 # third level
-                third_level_node = f'node_{i}:{j}:{k}'
-                third_level_label = _disambiguate(np.array([[first_level_node, second_level_node, third_level_node]]), separator)[0][2]
+                third_level_node = f"node_{i}:{j}:{k}"
+                third_level_label = _disambiguate(
+                    np.array([[first_level_node, second_level_node, third_level_node]]),
+                    separator,
+                )[0][2]
                 y_.append([first_level_node, second_level_node, third_level_node])
                 hierarchy.add_node(third_level_label)
                 hierarchy.add_edge(second_level_label, third_level_label)
 
     probs = [
-        np.array([[0.3, 0.5, 0.2]]), # level 0
-        np.array([[0.19, 0.10, 0.16, 0.14, 0.07, 0.08, 0.19, 0.03, 0.04]]), # level 1
-        np.array([[0.03, 0.17, 0.07, 0.01, 0.00, 0.06, 0.17, 0.02, 0.01, 0.07, 0.20, 0.01, 0.10, 0.00, 0.05, 0.02, 0.00, 0.01]]) # level 2
+        np.array([[0.3, 0.5, 0.2]]),  # level 0
+        np.array([[0.19, 0.10, 0.16, 0.14, 0.07, 0.08, 0.19, 0.03, 0.04]]),  # level 1
+        np.array(
+            [
+                [
+                    0.03,
+                    0.17,
+                    0.07,
+                    0.01,
+                    0.00,
+                    0.06,
+                    0.17,
+                    0.02,
+                    0.01,
+                    0.07,
+                    0.20,
+                    0.01,
+                    0.10,
+                    0.00,
+                    0.05,
+                    0.02,
+                    0.00,
+                    0.01,
+                ]
+            ]
+        ),  # level 2
     ]
     assert all([np.sum(probs[level], axis=1) == 1 for level in range(3)])
 
@@ -63,18 +96,36 @@ def one_sample_probs_with_hierarchy():
     y_ = make_leveled(y_)
     y_ = _disambiguate(y_, separator)
 
-    global_classes_ = [np.unique(y_[:, level]).astype("str") for level in range(y_.shape[1])]
+    global_classes_ = [
+        np.unique(y_[:, level]).astype("str") for level in range(y_.shape[1])
+    ]
 
     classes_ = [global_classes_[0]]
     for level in range(1, len(y_[1])):
-        classes_.append(np.sort(np.unique([label.split(separator)[level] for label in global_classes_[level]])))
-
-    class_to_index_mapping_ = [{local_labels[index]: index for index in range(len(local_labels))} for local_labels in classes_]
+        classes_.append(
+            np.sort(
+                np.unique(
+                    [label.split(separator)[level] for label in global_classes_[level]]
+                )
+            )
+        )
+
+    class_to_index_mapping_ = [
+        {local_labels[index]: index for index in range(len(local_labels))}
+        for local_labels in classes_
+    ]
 
     return hierarchy, probs, global_classes_, classes_, class_to_index_mapping_
 
+
 def test_multiply_combiner(one_sample_probs_with_hierarchy):
-    hierarchy, probs, global_classes, classes_, class_to_index_mapping_ = one_sample_probs_with_hierarchy
+    (
+        hierarchy,
+        probs,
+        global_classes,
+        classes_,
+        class_to_index_mapping_,
+    ) = one_sample_probs_with_hierarchy
     obj = HierarchicalClassifier()
     classifier = Mock(spec=obj)
     classifier._disambiguate = obj._disambiguate
@@ -82,7 +133,7 @@ def test_multiply_combiner(one_sample_probs_with_hierarchy):
     classifier.max_levels_ = len(global_classes)
     classifier.classes_ = classes_
     classifier.class_to_index_mapping_ = class_to_index_mapping_
-    
+
     classifier.hierarchy_ = hierarchy
     classifier.separator_ = "::HiClass::Separator::"
 
@@ -91,24 +142,43 @@ def test_multiply_combiner(one_sample_probs_with_hierarchy):
 
     # check combined probability of first node for both levels
     assert math.isclose(combined_probs[1][0][0], 0.0569, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][0], probs[0][0][0] * probs[1][0][0], abs_tol=1e-4)
-    
+    assert math.isclose(
+        combined_probs[1][0][0], probs[0][0][0] * probs[1][0][0], abs_tol=1e-4
+    )
+
     assert math.isclose(combined_probs[2][0][0], 0.0017, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][0], probs[0][0][0] * probs[1][0][0] * probs[2][0][0], abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][0],
+        probs[0][0][0] * probs[1][0][0] * probs[2][0][0],
+        abs_tol=1e-4,
+    )
 
     # check combined probability of last node for both levels
     assert math.isclose(combined_probs[1][0][-1], 0.008, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][-1], probs[0][0][-1] * probs[1][0][-1], abs_tol=1e-4)
-    
+    assert math.isclose(
+        combined_probs[1][0][-1], probs[0][0][-1] * probs[1][0][-1], abs_tol=1e-4
+    )
+
     assert math.isclose(combined_probs[2][0][-1], 8e-5, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][-1], probs[0][0][-1] * probs[1][0][-1] * probs[2][0][-1], abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][-1],
+        probs[0][0][-1] * probs[1][0][-1] * probs[2][0][-1],
+        abs_tol=1e-4,
+    )
+
 
 def test_arithmetic_mean_combiner(one_sample_probs_with_hierarchy):
-    hierarchy, probs, global_classes, classes_, class_to_index_mapping_ = one_sample_probs_with_hierarchy
+    (
+        hierarchy,
+        probs,
+        global_classes,
+        classes_,
+        class_to_index_mapping_,
+    ) = one_sample_probs_with_hierarchy
     obj = HierarchicalClassifier()
     classifier = Mock(spec=obj)
     classifier._disambiguate = obj._disambiguate
-    
+
     classifier.global_classes_ = global_classes
     classifier.max_levels_ = len(global_classes)
     classifier.classes_ = classes_
@@ -121,20 +191,39 @@ def test_arithmetic_mean_combiner(one_sample_probs_with_hierarchy):
 
     # check combined probability of first node for both levels
     assert math.isclose(combined_probs[1][0][0], 0.245, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][0], (probs[0][0][0] + probs[1][0][0]) / 2, abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[1][0][0], (probs[0][0][0] + probs[1][0][0]) / 2, abs_tol=1e-4
+    )
 
     assert math.isclose(combined_probs[2][0][0], 0.1733, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][0], (probs[0][0][0] + probs[1][0][0] + probs[2][0][0]) / 3, abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][0],
+        (probs[0][0][0] + probs[1][0][0] + probs[2][0][0]) / 3,
+        abs_tol=1e-4,
+    )
 
     # check combined probability of last node for both levels
     assert math.isclose(combined_probs[1][0][-1], 0.12, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][-1], (probs[0][0][-1] + probs[1][0][-1]) / 2, abs_tol=1e-4)
-    
+    assert math.isclose(
+        combined_probs[1][0][-1], (probs[0][0][-1] + probs[1][0][-1]) / 2, abs_tol=1e-4
+    )
+
     assert math.isclose(combined_probs[2][0][-1], 0.0833, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][-1], (probs[0][0][-1] + probs[1][0][-1] + probs[2][0][-1]) / 3, abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][-1],
+        (probs[0][0][-1] + probs[1][0][-1] + probs[2][0][-1]) / 3,
+        abs_tol=1e-4,
+    )
+
 
 def test_geometric_mean_combiner(one_sample_probs_with_hierarchy):
-    hierarchy, probs, global_classes, classes_, class_to_index_mapping_ = one_sample_probs_with_hierarchy
+    (
+        hierarchy,
+        probs,
+        global_classes,
+        classes_,
+        class_to_index_mapping_,
+    ) = one_sample_probs_with_hierarchy
     obj = HierarchicalClassifier()
     classifier = Mock(spec=obj)
     classifier._disambiguate = obj._disambiguate
@@ -151,20 +240,41 @@ def test_geometric_mean_combiner(one_sample_probs_with_hierarchy):
 
     # check combined probability of first node for both levels
     assert math.isclose(combined_probs[1][0][0], 0.2387, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][0], gmean([probs[0][0][0], probs[1][0][0]]), abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[1][0][0], gmean([probs[0][0][0], probs[1][0][0]]), abs_tol=1e-4
+    )
 
     assert math.isclose(combined_probs[2][0][0], 0.1195, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][0], gmean([probs[0][0][0], probs[1][0][0], probs[2][0][0]]), abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][0],
+        gmean([probs[0][0][0], probs[1][0][0], probs[2][0][0]]),
+        abs_tol=1e-4,
+    )
 
     # check combined probability of last node for both levels
     assert math.isclose(combined_probs[1][0][-1], 0.0894, abs_tol=1e-4)
-    assert math.isclose(combined_probs[1][0][-1], gmean([probs[0][0][-1], probs[1][0][-1]]), abs_tol=1e-4)
-    
+    assert math.isclose(
+        combined_probs[1][0][-1],
+        gmean([probs[0][0][-1], probs[1][0][-1]]),
+        abs_tol=1e-4,
+    )
+
     assert math.isclose(combined_probs[2][0][-1], 0.0430, abs_tol=1e-4)
-    assert math.isclose(combined_probs[2][0][-1], gmean([probs[0][0][-1], probs[1][0][-1], probs[2][0][-1]]), abs_tol=1e-4)
+    assert math.isclose(
+        combined_probs[2][0][-1],
+        gmean([probs[0][0][-1], probs[1][0][-1], probs[2][0][-1]]),
+        abs_tol=1e-4,
+    )
+
 
 def test_mean_combiner_with_normalization(one_sample_probs_with_hierarchy):
-    hierarchy, probs, global_classes, classes_, class_to_index_mapping_ = one_sample_probs_with_hierarchy
+    (
+        hierarchy,
+        probs,
+        global_classes,
+        classes_,
+        class_to_index_mapping_,
+    ) = one_sample_probs_with_hierarchy
     obj = HierarchicalClassifier()
     classifier = Mock(spec=obj)
     classifier._disambiguate = obj._disambiguate
@@ -176,7 +286,11 @@ def test_mean_combiner_with_normalization(one_sample_probs_with_hierarchy):
     classifier.class_to_index_mapping_ = class_to_index_mapping_
     classifier.hierarchy_ = hierarchy
 
-    combiners = [MultiplyCombiner(classifier), ArithmeticMeanCombiner(classifier), GeometricMeanCombiner(classifier)]
+    combiners = [
+        MultiplyCombiner(classifier),
+        ArithmeticMeanCombiner(classifier),
+        GeometricMeanCombiner(classifier),
+    ]
 
     for combiner in combiners:
         combined_probs = combiner.combine(probs)
@@ -185,6 +299,18 @@ def test_mean_combiner_with_normalization(one_sample_probs_with_hierarchy):
         assert combined_probs[0].shape == (1, 3)
         assert combined_probs[1].shape == (1, 9)
         assert combined_probs[2].shape == (1, 18)
-        assert_array_almost_equal(np.sum(combined_probs[0], axis=1), np.ones(len(combined_probs[0])), decimal=10)
-        assert_array_almost_equal(np.sum(combined_probs[1], axis=1), np.ones(len(combined_probs[1])), decimal=10)
-        assert_array_almost_equal(np.sum(combined_probs[2], axis=1), np.ones(len(combined_probs[2])), decimal=10)
+        assert_array_almost_equal(
+            np.sum(combined_probs[0], axis=1),
+            np.ones(len(combined_probs[0])),
+            decimal=10,
+        )
+        assert_array_almost_equal(
+            np.sum(combined_probs[1], axis=1),
+            np.ones(len(combined_probs[1])),
+            decimal=10,
+        )
+        assert_array_almost_equal(
+            np.sum(combined_probs[2], axis=1),
+            np.ones(len(combined_probs[2])),
+            decimal=10,
+        )
diff --git a/tests/test_calibration.py b/tests/test_calibration.py
index 0ef04f70..2f655c86 100644
--- a/tests/test_calibration.py
+++ b/tests/test_calibration.py
@@ -5,65 +5,88 @@
 from sklearn.linear_model import LogisticRegression
 from sklearn.exceptions import NotFittedError
 
-from hiclass._calibration.VennAbersCalibrator import _InductiveVennAbersCalibrator, _CrossVennAbersCalibrator
+from hiclass._calibration.VennAbersCalibrator import (
+    _InductiveVennAbersCalibrator,
+    _CrossVennAbersCalibrator,
+)
 from hiclass._calibration.PlattScaling import _PlattScaling
 from hiclass._calibration.IsotonicRegression import _IsotonicRegression
 from hiclass._calibration.BetaCalibrator import _BetaCalibrator
 from hiclass._calibration.Calibrator import _Calibrator
 
+
 @pytest.fixture
 def binary_calibration_data():
-    prob = np.array([[0.37, 0.63],
-                     [0.39, 0.61],
-                     [0.42, 0.58],
-                     [0.51, 0.49],
-                     [0.51, 0.49],
-                     [0.45, 0.55],
-                     [0.48, 0.52],
-                     [0.60, 0.40],
-                     [0.54, 0.46],
-                     [0.57, 0.43],
-                     [0.57, 0.43],
-                     [0.62, 0.38]]) 
-    
+    prob = np.array(
+        [
+            [0.37, 0.63],
+            [0.39, 0.61],
+            [0.42, 0.58],
+            [0.51, 0.49],
+            [0.51, 0.49],
+            [0.45, 0.55],
+            [0.48, 0.52],
+            [0.60, 0.40],
+            [0.54, 0.46],
+            [0.57, 0.43],
+            [0.57, 0.43],
+            [0.62, 0.38],
+        ]
+    )
+
     assert_array_equal(np.sum(prob, axis=1), np.ones(len(prob)))
 
     ground_truth_labels = np.array([1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0])
     return prob, ground_truth_labels
 
+
 @pytest.fixture
 def binary_test_scores():
-    X = np.array([[0.22, 0.78],
-                  [0.48, 0.52],
-                  [0.66, 0.34],
-                  [0.01, 0.99],
-                  [0.77, 0.23],
-                  [0.50, 0.50],
-                  [1.00, 0.00]])
-    
+    X = np.array(
+        [
+            [0.22, 0.78],
+            [0.48, 0.52],
+            [0.66, 0.34],
+            [0.01, 0.99],
+            [0.77, 0.23],
+            [0.50, 0.50],
+            [1.00, 0.00],
+        ]
+    )
+
     assert_array_equal(np.sum(X, axis=1), np.ones(len(X)))
     return X
 
+
 @pytest.fixture
 def binary_cal_X():
-    X = np.array([[1, 2], 
-                  [3, 4], 
-                  [5, 6], 
-                  [7, 8], 
-                  [1, 2], 
-                  [3, 4], 
-                  [5, 6], 
-                  [7, 8], 
-                  [1, 2], 
-                  [3, 4], 
-                  [5, 6], 
-                  [7, 8]])
+    X = np.array(
+        [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+            [7, 8],
+            [1, 2],
+            [3, 4],
+            [5, 6],
+            [7, 8],
+            [1, 2],
+            [3, 4],
+            [5, 6],
+            [7, 8],
+        ]
+    )
     return X
 
+
 @pytest.fixture
 def binary_mock_estimator(binary_calibration_data, binary_test_scores):
     # return calibration scores or test scores depending on input size
-    side_effect = lambda X: binary_calibration_data[0] if len(X) == len(binary_calibration_data[0]) else binary_test_scores
+    side_effect = (
+        lambda X: binary_calibration_data[0]
+        if len(X) == len(binary_calibration_data[0])
+        else binary_test_scores
+    )
 
     lr = LogisticRegression()
     binary_estimator = Mock(spec=lr)
@@ -72,49 +95,63 @@ def binary_mock_estimator(binary_calibration_data, binary_test_scores):
     binary_estimator.get_params.return_value = lr.get_params()
     return binary_estimator
 
+
 @pytest.fixture
 def multiclass_calibration_data():
-    prob = np.array([[0.12, 0.24, 0.64],
-                     [0.44, 0.22, 0.34],
-                     [0.30, 0.40, 0.30],
-                     [0.11, 0.33, 0.56],
-                     [0.44, 0.22, 0.34],
-                     [0.66, 0.33, 0.01],
-                     [0.14, 0.66, 0.20],
-                     [0.44, 0.12, 0.44],
-                     [0.64, 0.24, 0.12],
-                     [0.20, 0.77, 0.03]
-    ])
+    prob = np.array(
+        [
+            [0.12, 0.24, 0.64],
+            [0.44, 0.22, 0.34],
+            [0.30, 0.40, 0.30],
+            [0.11, 0.33, 0.56],
+            [0.44, 0.22, 0.34],
+            [0.66, 0.33, 0.01],
+            [0.14, 0.66, 0.20],
+            [0.44, 0.12, 0.44],
+            [0.64, 0.24, 0.12],
+            [0.20, 0.77, 0.03],
+        ]
+    )
 
     assert_array_equal(np.sum(prob, axis=1), np.ones(len(prob)))
 
     ground_truth_labels = np.array([2, 0, 1, 2, 0, 0, 1, 0, 0, 1])
     return prob, ground_truth_labels
 
+
 @pytest.fixture
 def multiclass_test_scores():
-    X = np.array([[0.23, 0.47, 0.30],
-                  [0.44, 0.21, 0.35],
-                  [0.22, 0.22, 0.56],
-                  [0.25, 0.50, 0.25],
-                  [0.01, 0.72, 0.27],
-                  [0.12, 0.35, 0.53],
-                  [0.30, 0.23, 0.47]
-    ])
-    
+    X = np.array(
+        [
+            [0.23, 0.47, 0.30],
+            [0.44, 0.21, 0.35],
+            [0.22, 0.22, 0.56],
+            [0.25, 0.50, 0.25],
+            [0.01, 0.72, 0.27],
+            [0.12, 0.35, 0.53],
+            [0.30, 0.23, 0.47],
+        ]
+    )
+
     assert_array_equal(np.sum(X, axis=1), np.ones(len(X)))
     return X
 
+
 @pytest.fixture
 def multiclass_mock_estimator(multiclass_calibration_data, multiclass_test_scores):
     # return calibration scores or test scores depending on input size
-    side_effect = lambda X: multiclass_calibration_data[0] if len(X) == len(multiclass_calibration_data[0]) else multiclass_test_scores
+    side_effect = (
+        lambda X: multiclass_calibration_data[0]
+        if len(X) == len(multiclass_calibration_data[0])
+        else multiclass_test_scores
+    )
 
     multiclass_estimator = Mock(spec=LogisticRegression)
     multiclass_estimator.predict_proba.side_effect = side_effect
     multiclass_estimator.classes_ = np.array([0, 1, 2])
     return multiclass_estimator
 
+
 def test_inductive_venn_abers_calibrator(binary_calibration_data, binary_test_scores):
     scores, ground_truth_labels = binary_calibration_data
     test_scores = binary_test_scores
@@ -124,22 +161,76 @@ def test_inductive_venn_abers_calibrator(binary_calibration_data, binary_test_sc
     intervalls = calibrator.predict_intervall(test_scores[:, 1])
     proba = calibrator.predict_proba(test_scores[:, 1])
 
-    assert_array_almost_equal(calibrator._F1, np.array([0, 0.33333333, 0.375, 0.375, 0.4, 0.5, 0.5, 0.66666666, 0.66666666, 1.0, 1.0]))
-    assert_array_almost_equal(calibrator._F0, np.array([0, 0, 0.2, 0.2, 0.2, 0.25, 0.25, 0.33333333, 0.33333333, 0.5, 0.66666666]))
-    assert_array_almost_equal(intervalls, np.array([[0.66666666, 1.0], [0.25, 0.66666666], [0, 0.33333333], [0.66666666, 1.0], [0, 0.33333333], [0.25, 0.5], [0,0.33333333]]))
-    assert_array_almost_equal(proba, np.array([0.74999999, 0.47058823, 0.24999999, 0.74999999, 0.24999999, 0.4, 0.24999999]))
-
-def test_cross_venn_abers_calibrator(binary_calibration_data, binary_test_scores, binary_cal_X):
+    assert_array_almost_equal(
+        calibrator._F1,
+        np.array(
+            [
+                0,
+                0.33333333,
+                0.375,
+                0.375,
+                0.4,
+                0.5,
+                0.5,
+                0.66666666,
+                0.66666666,
+                1.0,
+                1.0,
+            ]
+        ),
+    )
+    assert_array_almost_equal(
+        calibrator._F0,
+        np.array(
+            [0, 0, 0.2, 0.2, 0.2, 0.25, 0.25, 0.33333333, 0.33333333, 0.5, 0.66666666]
+        ),
+    )
+    assert_array_almost_equal(
+        intervalls,
+        np.array(
+            [
+                [0.66666666, 1.0],
+                [0.25, 0.66666666],
+                [0, 0.33333333],
+                [0.66666666, 1.0],
+                [0, 0.33333333],
+                [0.25, 0.5],
+                [0, 0.33333333],
+            ]
+        ),
+    )
+    assert_array_almost_equal(
+        proba,
+        np.array(
+            [
+                0.74999999,
+                0.47058823,
+                0.24999999,
+                0.74999999,
+                0.24999999,
+                0.4,
+                0.24999999,
+            ]
+        ),
+    )
+
+
+def test_cross_venn_abers_calibrator(
+    binary_calibration_data, binary_test_scores, binary_cal_X
+):
     cal_scores, y_cal = binary_calibration_data
     test_scores = binary_test_scores
 
     calibrator = _CrossVennAbersCalibrator(LogisticRegression(), n_folds=5)
     calibrator.fit(y_cal, cal_scores, X=binary_cal_X)
     proba = calibrator.predict_proba(test_scores[:, 1])
-    expected = np.array([0.602499, 0.51438, 0.397501, 0.602499, 0.346239, 0.51438, 0.328119])
+    expected = np.array(
+        [0.602499, 0.51438, 0.397501, 0.602499, 0.346239, 0.51438, 0.328119]
+    )
     assert len(calibrator.ivaps) == 5
     assert_array_almost_equal(proba, expected)
 
+
 def test_platt_scaling(binary_calibration_data, binary_test_scores):
     cal_scores, cal_labels = binary_calibration_data
     calibrator = _PlattScaling()
@@ -147,16 +238,33 @@ def test_platt_scaling(binary_calibration_data, binary_test_scores):
     proba = calibrator.predict_proba(binary_test_scores[:, 1])
 
     assert proba.shape == (len(binary_test_scores),)
-    assert_array_almost_equal(proba, np.array([0.8827398, 0.46130191, 0.15976229, 0.97756289, 0.07045925, 0.42011212, 0.01095897]))
+    assert_array_almost_equal(
+        proba,
+        np.array(
+            [
+                0.8827398,
+                0.46130191,
+                0.15976229,
+                0.97756289,
+                0.07045925,
+                0.42011212,
+                0.01095897,
+            ]
+        ),
+    )
+
 
 def test_isotonic_regression(binary_calibration_data, binary_test_scores):
     cal_scores, cal_labels = binary_calibration_data
     calibrator = _IsotonicRegression()
     calibrator.fit(cal_labels, cal_scores[:, 1])
     proba = calibrator.predict_proba(binary_test_scores[:, 1])
-    
+
     assert proba.shape == (len(binary_test_scores),)
-    assert_array_almost_equal(proba, np.array([1.0, 0.33333333, 0.0, 1.0, 0.0, 0.33333333, 0.0]))
+    assert_array_almost_equal(
+        proba, np.array([1.0, 0.33333333, 0.0, 1.0, 0.0, 0.33333333, 0.0])
+    )
+
 
 def test_beta_calibration(binary_calibration_data, binary_test_scores):
     cal_scores, cal_labels = binary_calibration_data
@@ -165,22 +273,32 @@ def test_beta_calibration(binary_calibration_data, binary_test_scores):
     proba = calibrator.predict_proba(binary_test_scores[:, 1])
 
     assert proba.shape == (len(binary_test_scores),)
-    assert_array_almost_equal(proba, np.array([0.526125, 0.423743, 0.363907, 0.785855, 0.323201, 0.417089, 0.0]))
+    assert_array_almost_equal(
+        proba,
+        np.array([0.526125, 0.423743, 0.363907, 0.785855, 0.323201, 0.417089, 0.0]),
+    )
+
 
 def test_illegal_calibration_method_raises_error(binary_mock_estimator):
     with pytest.raises(ValueError, match="abc is not a valid calibration method."):
         _Calibrator(binary_mock_estimator, method="abc")
 
+
 def test_not_fitted_calibrator_throws_error(binary_test_scores, binary_mock_estimator):
-    for calibrator in [_PlattScaling(), 
-                       _IsotonicRegression(),
-                       _BetaCalibrator(),
-                       _InductiveVennAbersCalibrator(), 
-                       _CrossVennAbersCalibrator(binary_mock_estimator)]:
-            with pytest.raises(NotFittedError):
-                calibrator.predict_proba(binary_test_scores)
-
-def test_valid_calibration(binary_calibration_data, binary_test_scores, binary_cal_X, binary_mock_estimator):
+    for calibrator in [
+        _PlattScaling(),
+        _IsotonicRegression(),
+        _BetaCalibrator(),
+        _InductiveVennAbersCalibrator(),
+        _CrossVennAbersCalibrator(binary_mock_estimator),
+    ]:
+        with pytest.raises(NotFittedError):
+            calibrator.predict_proba(binary_test_scores)
+
+
+def test_valid_calibration(
+    binary_calibration_data, binary_test_scores, binary_cal_X, binary_mock_estimator
+):
     _, y_cal = binary_calibration_data
 
     for method in _Calibrator.available_methods:
@@ -191,9 +309,12 @@ def test_valid_calibration(binary_calibration_data, binary_test_scores, binary_c
         calibrator.fit(X=binary_cal_X, y=y_cal)
         proba = calibrator.predict_proba(binary_test_scores)
 
-        assert proba.shape == (len(binary_test_scores),2)
+        assert proba.shape == (len(binary_test_scores), 2)
 
-def test_multiclass_calibration(multiclass_calibration_data, multiclass_test_scores, multiclass_mock_estimator):
+
+def test_multiclass_calibration(
+    multiclass_calibration_data, multiclass_test_scores, multiclass_mock_estimator
+):
     scores, y_cal = multiclass_calibration_data
 
     calibrator = _Calibrator(multiclass_mock_estimator, method="ivap")
@@ -204,40 +325,57 @@ def test_multiclass_calibration(multiclass_calibration_data, multiclass_test_sco
     assert proba.shape == multiclass_test_scores.shape
     assert_array_almost_equal(np.sum(proba, axis=1), np.ones(len(proba)))
 
-    expected = np.array([[0.27777778, 0.55555556, 0.16666667],
-                         [0.52173913, 0.13043478, 0.34782609],
-                         [0.33333333, 0.16666667, 0.5       ],
-                         [0.28571429, 0.57142857, 0.14285714],
-                         [0.13483146, 0.70786517, 0.15730337],
-                         [0.16666667, 0.41666667, 0.41666667],
-                         [0.42857143, 0.14285714, 0.42857143]])
-    
+    expected = np.array(
+        [
+            [0.27777778, 0.55555556, 0.16666667],
+            [0.52173913, 0.13043478, 0.34782609],
+            [0.33333333, 0.16666667, 0.5],
+            [0.28571429, 0.57142857, 0.14285714],
+            [0.13483146, 0.70786517, 0.15730337],
+            [0.16666667, 0.41666667, 0.41666667],
+            [0.42857143, 0.14285714, 0.42857143],
+        ]
+    )
+
     assert_array_almost_equal(proba, expected)
 
-def test_multiclass_probability_merge(multiclass_mock_estimator, multiclass_calibration_data, multiclass_test_scores):
+
+def test_multiclass_probability_merge(
+    multiclass_mock_estimator, multiclass_calibration_data, multiclass_test_scores
+):
     calibrator = _Calibrator(estimator=multiclass_mock_estimator, method="ivap")
     X_cal, y_cal = multiclass_calibration_data
     calibrator.fit(X_cal, y_cal)
 
     calibrator_1 = Mock(spec=_PlattScaling)
-    calibrator_1.predict_proba.return_value = np.array([0.40, 0.60, 0.20, 0.80, 0.75, 0.25, 0.85])
-    
+    calibrator_1.predict_proba.return_value = np.array(
+        [0.40, 0.60, 0.20, 0.80, 0.75, 0.25, 0.85]
+    )
+
     calibrator_2 = Mock(spec=_PlattScaling)
-    calibrator_2.predict_proba.return_value = np.array([0.30, 0.70, 0.35, 0.65, 0.30, 0.70, 0.20])
+    calibrator_2.predict_proba.return_value = np.array(
+        [0.30, 0.70, 0.35, 0.65, 0.30, 0.70, 0.20]
+    )
 
     calibrator_3 = Mock(spec=_PlattScaling)
-    calibrator_3.predict_proba.return_value = np.array([0.55, 0.45, 0.10, 0.90, 0.45, 0.55, 0.40])
+    calibrator_3.predict_proba.return_value = np.array(
+        [0.55, 0.45, 0.10, 0.90, 0.45, 0.55, 0.40]
+    )
 
     calibrator.calibrators = [calibrator_1, calibrator_2, calibrator_3]
     proba = calibrator.predict_proba(multiclass_test_scores)
 
-    expected = np.array([[0.32, 0.24, 0.44],
-                         [0.34, 0.40, 0.26],
-                         [0.31, 0.54, 0.15],
-                         [0.34, 0.28, 0.38],
-                         [0.5,  0.20, 0.30],
-                         [0.17, 0.46, 0.37],
-                         [0.59, 0.14, 0.27]])
-    
+    expected = np.array(
+        [
+            [0.32, 0.24, 0.44],
+            [0.34, 0.40, 0.26],
+            [0.31, 0.54, 0.15],
+            [0.34, 0.28, 0.38],
+            [0.5, 0.20, 0.30],
+            [0.17, 0.46, 0.37],
+            [0.59, 0.14, 0.27],
+        ]
+    )
+
     assert_array_equal(np.sum(expected, axis=1), np.ones(len(expected)))
     assert_array_almost_equal(proba, expected, decimal=2)
diff --git a/tests/test_metrics.py b/tests/test_metrics.py
index 785adbb3..75b5dba9 100644
--- a/tests/test_metrics.py
+++ b/tests/test_metrics.py
@@ -7,10 +7,10 @@
 
 from hiclass.HierarchicalClassifier import HierarchicalClassifier
 from hiclass.metrics import (
-    precision, 
-    recall, 
-    f1, 
-    _multiclass_brier_score, 
+    precision,
+    recall,
+    f1,
+    _multiclass_brier_score,
     _log_loss,
     _expected_calibration_error,
     _static_calibration_error,
@@ -19,7 +19,7 @@
     log_loss,
     expected_calibration_error,
     static_calibration_error,
-    adaptive_calibration_error
+    adaptive_calibration_error,
 )
 
 
@@ -356,16 +356,22 @@ def test_empty_levels_2d_list_2():
 
 @pytest.fixture
 def uncertainty_data():
-    prob = [np.array([[0.88, 0.06, 0.06],
-                     [0.22, 0.48, 0.30],
-                     [0.33, 0.33, 0.34],
-                     [0.49, 0.40, 0.11],
-                     [0.23, 0.03, 0.74],
-                     [0.21, 0.67, 0.12],
-                     [0.34, 0.34, 0.32],
-                     [0.02, 0.77, 0.21],
-                     [0.44, 0.42, 0.14],
-                     [0.85, 0.13, 0.02]])]
+    prob = [
+        np.array(
+            [
+                [0.88, 0.06, 0.06],
+                [0.22, 0.48, 0.30],
+                [0.33, 0.33, 0.34],
+                [0.49, 0.40, 0.11],
+                [0.23, 0.03, 0.74],
+                [0.21, 0.67, 0.12],
+                [0.34, 0.34, 0.32],
+                [0.02, 0.77, 0.21],
+                [0.44, 0.42, 0.14],
+                [0.85, 0.13, 0.02],
+            ]
+        )
+    ]
 
     assert_array_equal(np.sum(prob[0], axis=1), np.ones(len(prob[0])))
 
@@ -374,15 +380,13 @@ def uncertainty_data():
 
     return prob, y_pred, y_true
 
+
 @pytest.fixture
 def uncertainty_data_multi_level():
-    prob = [np.array([[0.88, 0.06, 0.06],
-                     [0.22, 0.48, 0.30],
-                     [0.33, 0.33, 0.34]]),
-
-            np.array([[0.88, 0.06, 0.06],
-                     [0.22, 0.48, 0.30],
-                     [0.33, 0.33, 0.34]])]
+    prob = [
+        np.array([[0.88, 0.06, 0.06], [0.22, 0.48, 0.30], [0.33, 0.33, 0.34]]),
+        np.array([[0.88, 0.06, 0.06], [0.22, 0.48, 0.30], [0.33, 0.33, 0.34]]),
+    ]
 
     assert_array_equal(np.sum(prob[0], axis=1), np.ones(len(prob[0])))
 
@@ -391,6 +395,7 @@ def uncertainty_data_multi_level():
 
     return prob, y_pred, y_true
 
+
 def test_local_brier_score(uncertainty_data):
     prob, _, y_true = uncertainty_data
     obj = HierarchicalClassifier()
@@ -398,10 +403,11 @@ def test_local_brier_score(uncertainty_data):
     classifier._disambiguate = obj._disambiguate
     classifier.classes_ = [[0, 1, 2]]
     classifier.separator_ = "::HiClass::Separator::"
-    
+
     brier_score = _multiclass_brier_score(classifier, y_true, prob[0], level=0)
     assert math.isclose(brier_score, 0.34852, abs_tol=1e-4)
 
+
 def test_brier_score_multi_level(uncertainty_data_multi_level):
     prob, _, y_true = uncertainty_data_multi_level
     obj = HierarchicalClassifier()
@@ -417,6 +423,7 @@ def test_brier_score_multi_level(uncertainty_data_multi_level):
     assert math.isclose(brier_score_per_level[0], 0.48793, abs_tol=1e-4)
     assert math.isclose(brier_score_per_level[1], 0.48793, abs_tol=1e-4)
 
+
 def test_brier_score_single_level(uncertainty_data_multi_level):
     prob, _, y_true = uncertainty_data_multi_level
     prob = prob[1]
@@ -443,6 +450,7 @@ def test_local_log_loss(uncertainty_data):
     log_loss = _log_loss(classifier, y_true, prob[0], level=0)
     assert math.isclose(log_loss, 0.61790, abs_tol=1e-4)
 
+
 def test_log_loss_multi_level(uncertainty_data_multi_level):
     prob, _, y_true = uncertainty_data_multi_level
     obj = HierarchicalClassifier()
@@ -458,6 +466,7 @@ def test_log_loss_multi_level(uncertainty_data_multi_level):
     assert math.isclose(log_loss_per_level[0], 0.81348, abs_tol=1e-4)
     assert math.isclose(log_loss_per_level[1], 0.81348, abs_tol=1e-4)
 
+
 def test_log_loss_single_level(uncertainty_data_multi_level):
     prob, _, y_true = uncertainty_data_multi_level
     prob = prob[1]
@@ -472,6 +481,7 @@ def test_log_loss_single_level(uncertainty_data_multi_level):
     assert math.isclose(log_loss_1, 0.48793, abs_tol=1e-4)
     assert math.isclose(log_loss_2, 0.48793, abs_tol=1e-4)
 
+
 def test_local_expected_calibration_error(uncertainty_data):
     prob, y_pred, y_true = uncertainty_data
     obj = HierarchicalClassifier()
@@ -480,9 +490,12 @@ def test_local_expected_calibration_error(uncertainty_data):
     classifier.classes_ = [[0, 1, 2]]
     classifier.separator_ = "::HiClass::Separator::"
 
-    ece = _expected_calibration_error(classifier, y_true, prob[0], y_pred, level=0, n_bins=3)
+    ece = _expected_calibration_error(
+        classifier, y_true, prob[0], y_pred, level=0, n_bins=3
+    )
     assert math.isclose(ece, 0.118, abs_tol=1e-4)
 
+
 def test_expected_calibration_error_multi_level(uncertainty_data_multi_level):
     prob, y_pred, y_true = uncertainty_data_multi_level
     obj = HierarchicalClassifier()
@@ -490,14 +503,19 @@ def test_expected_calibration_error_multi_level(uncertainty_data_multi_level):
     classifier._disambiguate = obj._disambiguate
     classifier.classes_ = [[0, 1, 2], [3, 4, 5]]
     classifier.separator_ = "::HiClass::Separator::"
-    ece_avg = expected_calibration_error(classifier, y_true, prob, y_pred, agg="average")
+    ece_avg = expected_calibration_error(
+        classifier, y_true, prob, y_pred, agg="average"
+    )
     ece_sum = expected_calibration_error(classifier, y_true, prob, y_pred, agg="sum")
-    ece_per_level = expected_calibration_error(classifier, y_true, prob, y_pred, agg=None)
+    ece_per_level = expected_calibration_error(
+        classifier, y_true, prob, y_pred, agg=None
+    )
     assert math.isclose(ece_avg, 0.31333, abs_tol=1e-4)
     assert math.isclose(ece_sum, 0.62666, abs_tol=1e-4)
     assert math.isclose(ece_per_level[0], 0.31333, abs_tol=1e-4)
     assert math.isclose(ece_per_level[1], 0.31333, abs_tol=1e-4)
 
+
 def test_expected_calibration_error_single_level(uncertainty_data_multi_level):
     prob, y_pred, y_true = uncertainty_data_multi_level
     prob = prob[1]
@@ -511,6 +529,7 @@ def test_expected_calibration_error_single_level(uncertainty_data_multi_level):
     assert math.isclose(ece_1, 0.31333, abs_tol=1e-4)
     assert math.isclose(ece_2, 0.31333, abs_tol=1e-4)
 
+
 def test_local_static_calibration_error(uncertainty_data):
     prob, y_pred, y_true = uncertainty_data
     obj = HierarchicalClassifier()
@@ -519,9 +538,12 @@ def test_local_static_calibration_error(uncertainty_data):
     classifier.classes_ = [[0, 1, 2]]
     classifier.separator_ = "::HiClass::Separator::"
 
-    sce = _static_calibration_error(classifier, y_true, prob[0], y_pred, level=0, n_bins=3)
+    sce = _static_calibration_error(
+        classifier, y_true, prob[0], y_pred, level=0, n_bins=3
+    )
     assert math.isclose(sce, 0.3889, abs_tol=1e-3)
 
+
 def test_static_calibration_error_multi_level(uncertainty_data_multi_level):
     prob, y_pred, y_true = uncertainty_data_multi_level
     obj = HierarchicalClassifier()
@@ -552,6 +574,7 @@ def test_static_calibration_error_single_level(uncertainty_data_multi_level):
     assert math.isclose(sce_1, 0.44444, abs_tol=1e-4)
     assert math.isclose(sce_2, 0.44444, abs_tol=1e-4)
 
+
 def test_local_adaptive_calibration_error(uncertainty_data):
     prob, y_pred, y_true = uncertainty_data
     obj = HierarchicalClassifier()
@@ -560,9 +583,12 @@ def test_local_adaptive_calibration_error(uncertainty_data):
     classifier.classes_ = [[0, 1, 2]]
     classifier.separator_ = "::HiClass::Separator::"
 
-    ace = _adaptive_calibration_error(classifier, y_true, prob[0], y_pred, level=0, n_ranges=3)
+    ace = _adaptive_calibration_error(
+        classifier, y_true, prob[0], y_pred, level=0, n_ranges=3
+    )
     assert math.isclose(ace, 0.44, abs_tol=1e-3)
 
+
 def test_adaptive_calibration_error_multi_level(uncertainty_data_multi_level):
     prob, y_pred, y_true = uncertainty_data_multi_level
     obj = HierarchicalClassifier()
@@ -571,14 +597,19 @@ def test_adaptive_calibration_error_multi_level(uncertainty_data_multi_level):
     classifier.classes_ = [[0, 1, 2], [3, 4, 5]]
     classifier.separator_ = "::HiClass::Separator::"
 
-    ace_avg = adaptive_calibration_error(classifier, y_true, prob, y_pred, agg="average")
+    ace_avg = adaptive_calibration_error(
+        classifier, y_true, prob, y_pred, agg="average"
+    )
     ace_sum = adaptive_calibration_error(classifier, y_true, prob, y_pred, agg="sum")
-    ace_per_level = adaptive_calibration_error(classifier, y_true, prob, y_pred, agg=None)
+    ace_per_level = adaptive_calibration_error(
+        classifier, y_true, prob, y_pred, agg=None
+    )
     assert math.isclose(ace_avg, 0.13333, abs_tol=1e-4)
     assert math.isclose(ace_sum, 0.26666, abs_tol=1e-4)
     assert math.isclose(ace_per_level[0], 0.13333, abs_tol=1e-4)
     assert math.isclose(ace_per_level[1], 0.13333, abs_tol=1e-4)
 
+
 def test_adaptive_calibration_error_single_level(uncertainty_data_multi_level):
     prob, y_pred, y_true = uncertainty_data_multi_level
     prob = prob[1]
@@ -591,4 +622,4 @@ def test_adaptive_calibration_error_single_level(uncertainty_data_multi_level):
     ace_1 = adaptive_calibration_error(classifier, y_true, prob, y_pred, level=1)
     ace_2 = adaptive_calibration_error(classifier, y_true, [prob], y_pred, level=1)
     assert math.isclose(ace_1, 0.13333, abs_tol=1e-4)
-    assert math.isclose(ace_2, 0.13333, abs_tol=1e-4)
\ No newline at end of file
+    assert math.isclose(ace_2, 0.13333, abs_tol=1e-4)