Use black.

34 files changed, 1406 insertions, 554 deletions

diff --git a/test/ec/perf_formula.py b/test/ec/perf_formula.py
index 9e651ae..2cc4513 100755
--- a/test/ec/perf_formula.py
+++ b/test/ec/perf_formula.py
@@ -9,9 +9,20 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=5000)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
@@ -19,22 +30,36 @@ def main(profiler, mod, operations, directory):
         coords = p256.curve.coordinate_model
         add = coords.formulas["add-2016-rcb"]
         dbl = coords.formulas["dbl-2016-rcb"]
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit doubling formula executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit doubling formula executions..."
+        )
         one_point = p256.generator
-        with Profiler(profiler, directory, f"formula_dbl2016rcb_p256_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_dbl2016rcb_p256_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 one_point = dbl(p256.curve.prime, one_point, **p256.curve.parameters)[0]
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit addition formula executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit addition formula executions..."
+        )
         other_point = p256.generator
-        with Profiler(profiler, directory, f"formula_add2016rcb_p256_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_add2016rcb_p256_{operations}_{mod}"
+        ):
             for _ in range(operations):
-                one_point = add(p256.curve.prime, one_point, other_point, **p256.curve.parameters)[0]
+                one_point = add(
+                    p256.curve.prime, one_point, other_point, **p256.curve.parameters
+                )[0]
         ed25519 = get_params("other", "Ed25519", "extended")
         ecoords = ed25519.curve.coordinate_model
         dblg = ecoords.formulas["mdbl-2008-hwcd"]
-        click.echo(f"Profiling {operations} {ed25519.curve.prime.bit_length()}-bit doubling formula executions (with assumption)...")
+        click.echo(
+            f"Profiling {operations} {ed25519.curve.prime.bit_length()}-bit doubling formula executions (with assumption)..."
+        )
         eone_point = ed25519.generator
-        with Profiler(profiler, directory, f"formula_mdbl2008hwcd_ed25519_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_mdbl2008hwcd_ed25519_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 dblg(ed25519.curve.prime, eone_point, **ed25519.curve.parameters)
 
diff --git a/test/ec/perf_mod.py b/test/ec/perf_mod.py
index 37cf41b..49fe9a7 100755
--- a/test/ec/perf_mod.py
+++ b/test/ec/perf_mod.py
@@ -8,20 +8,33 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=100000)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
-        n = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
+        n = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
         a = Mod(0x11111111111111111111111111111111, n)
-        b = Mod(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, n)
+        b = Mod(0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB, n)
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular inverse...")
         with Profiler(profiler, directory, f"mod_256b_inverse_{operations}_{mod}"):
             for _ in range(operations):
                 a.inverse()
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit modular square root...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit modular square root..."
+        )
         with Profiler(profiler, directory, f"mod_256b_sqrt_{operations}_{mod}"):
             for _ in range(operations):
                 a.sqrt()
@@ -30,16 +43,20 @@ def main(profiler, mod, operations, directory):
         with Profiler(profiler, directory, f"mod_256b_multiply_{operations}_{mod}"):
             for _ in range(operations):
                 c = c * b
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit constant modular multiply...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit constant modular multiply..."
+        )
         c = a
-        with Profiler(profiler, directory, f"mod_256b_constmultiply_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"mod_256b_constmultiply_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 c = c * 48006
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular square...")
         c = a
         with Profiler(profiler, directory, f"mod_256b_square_{operations}_{mod}"):
             for _ in range(operations):
-                c = c**2
+                c = c ** 2
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular add...")
         c = a
         with Profiler(profiler, directory, f"mod_256b_add_{operations}_{mod}"):
@@ -50,7 +67,9 @@ def main(profiler, mod, operations, directory):
         with Profiler(profiler, directory, f"mod_256b_subtract_{operations}_{mod}"):
             for _ in range(operations):
                 c = c - b
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit modular quadratic residue checks...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit modular quadratic residue checks..."
+        )
         with Profiler(profiler, directory, f"mod_256b_isresidue_{operations}_{mod}"):
             for _ in range(operations):
                 a.is_residue()
diff --git a/test/ec/perf_mult.py b/test/ec/perf_mult.py
index 2ec82b0..36f004b 100755
--- a/test/ec/perf_mult.py
+++ b/test/ec/perf_mult.py
@@ -10,9 +10,20 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=50)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
@@ -21,12 +32,16 @@ def main(profiler, mod, operations, directory):
         add = coords.formulas["add-2016-rcb"]
         dbl = coords.formulas["dbl-2016-rcb"]
         mult = LTRMultiplier(add, dbl)
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit scalar multiplication executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit scalar multiplication executions..."
+        )
         one_point = p256.generator
         with Profiler(profiler, directory, f"mult_ltr_rcb_p256_{operations}_{mod}"):
             for _ in range(operations):
                 mult.init(p256, one_point)
-                one_point = mult.multiply(0x71a55e0c1abb3a0e069419e0f837bc195f1b9545e69fc51e53c4d48d7fea3b1a)
+                one_point = mult.multiply(
+                    0x71A55E0C1ABB3A0E069419E0F837BC195F1B9545E69FC51E53C4D48D7FEA3B1A
+                )
         # ed25519 = get_params("other", "Ed25519", "extended")
         # ecoords = ed25519.curve.coordinate_model
         # dblg = ecoords.formulas["mdbl-2008-hwcd"]
diff --git a/test/ec/test_configuration.py b/test/ec/test_configuration.py
index 9c8e361..7603321 100644
--- a/test/ec/test_configuration.py
+++ b/test/ec/test_configuration.py
@@ -1,14 +1,20 @@
 from unittest import TestCase
 
-from pyecsca.ec.configuration import (all_configurations, HashType, RandomMod, Multiplication,
-                                      Squaring, Reduction, Inversion)
+from pyecsca.ec.configuration import (
+    all_configurations,
+    HashType,
+    RandomMod,
+    Multiplication,
+    Squaring,
+    Reduction,
+    Inversion,
+)
 from pyecsca.ec.model import ShortWeierstrassModel
 from pyecsca.ec.mult import LTRMultiplier
 from .utils import slow
 
 
 class ConfigurationTests(TestCase):
-
     def base_independents(self):
         return {
             "hash_type": HashType.SHA1,
@@ -16,7 +22,7 @@ class ConfigurationTests(TestCase):
             "mult": Multiplication.BASE,
             "sqr": Squaring.BASE,
             "red": Reduction.BASE,
-            "inv": Inversion.GCD
+            "inv": Inversion.GCD,
         }
 
     @slow
@@ -29,15 +35,23 @@ class ConfigurationTests(TestCase):
     def test_weierstrass_projective(self):
         model = ShortWeierstrassModel()
         coords = model.coordinates["projective"]
-        configs = list(all_configurations(model=model, coords=coords, **self.base_independents()))
+        configs = list(
+            all_configurations(model=model, coords=coords, **self.base_independents())
+        )
         self.assertEqual(len(configs), 1960)
 
     def test_mult_class(self):
         model = ShortWeierstrassModel()
         coords = model.coordinates["projective"]
         scalarmult = LTRMultiplier
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 560)
 
     def test_one(self):
@@ -50,16 +64,37 @@ class ConfigurationTests(TestCase):
             "scl": None,
             "always": True,
             "complete": False,
-            "short_circuit": True
+            "short_circuit": True,
         }
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
-        scalarmult = LTRMultiplier(coords.formulas["add-1998-cmo"], coords.formulas["dbl-1998-cmo"],
-                                   None, True, False, True)
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        scalarmult = LTRMultiplier(
+            coords.formulas["add-1998-cmo"],
+            coords.formulas["dbl-1998-cmo"],
+            None,
+            True,
+            False,
+            True,
+        )
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
-        configs = list(all_configurations(model=model, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model, scalarmult=scalarmult, **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
diff --git a/test/ec/test_context.py b/test/ec/test_context.py
index 603369d..04dbc7d 100644
--- a/test/ec/test_context.py
+++ b/test/ec/test_context.py
@@ -1,7 +1,15 @@
 from unittest import TestCase
 
-from pyecsca.ec.context import (local, DefaultContext, NullContext, getcontext,
-                                setcontext, resetcontext, Tree, PathContext)
+from pyecsca.ec.context import (
+    local,
+    DefaultContext,
+    NullContext,
+    getcontext,
+    setcontext,
+    resetcontext,
+    Tree,
+    PathContext,
+)
 from pyecsca.ec.key_generation import KeygenAction, KeyGeneration
 from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import RandomModAction
@@ -9,7 +17,6 @@ from pyecsca.ec.mult import LTRMultiplier, ScalarMultiplicationAction
 
 
 class TreeTests(TestCase):
-
     def test_walk_by_key(self):
         tree = Tree()
         tree["a"] = Tree()
@@ -46,14 +53,16 @@ class TreeTests(TestCase):
 
 
 class ContextTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.base = self.secp128r1.generator
         self.coords = self.secp128r1.curve.coordinate_model
-        self.mult = LTRMultiplier(self.coords.formulas["add-1998-cmo"],
-                                  self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"],
-                                  always=True)
+        self.mult = LTRMultiplier(
+            self.coords.formulas["add-1998-cmo"],
+            self.coords.formulas["dbl-1998-cmo"],
+            self.coords.formulas["z"],
+            always=True,
+        )
         self.mult.init(self.secp128r1, self.base)
 
     def test_null(self):
diff --git a/test/ec/test_curve.py b/test/ec/test_curve.py
index c358c68..345d3de 100644
--- a/test/ec/test_curve.py
+++ b/test/ec/test_curve.py
@@ -19,55 +19,89 @@ class CurveTests(TestCase):
 
     def test_init(self):
         with self.assertRaises(ValueError):
-            EllipticCurve(MontgomeryModel(), self.secp128r1.curve.coordinate_model, 1,
-                          InfinityPoint(self.secp128r1.curve.coordinate_model), parameters={})
+            EllipticCurve(
+                MontgomeryModel(),
+                self.secp128r1.curve.coordinate_model,
+                1,
+                InfinityPoint(self.secp128r1.curve.coordinate_model),
+                parameters={},
+            )
 
         with self.assertRaises(ValueError):
-            EllipticCurve(self.secp128r1.curve.model, self.secp128r1.curve.coordinate_model, 15,
-                          InfinityPoint(self.secp128r1.curve.coordinate_model), parameters={"c": 0})
+            EllipticCurve(
+                self.secp128r1.curve.model,
+                self.secp128r1.curve.coordinate_model,
+                15,
+                InfinityPoint(self.secp128r1.curve.coordinate_model),
+                parameters={"c": 0},
+            )
 
         with self.assertRaises(ValueError):
-            EllipticCurve(self.secp128r1.curve.model, self.secp128r1.curve.coordinate_model, 15,
-                          InfinityPoint(self.secp128r1.curve.coordinate_model),
-                          parameters={"a": Mod(1, 5), "b": Mod(2, 5)})
+            EllipticCurve(
+                self.secp128r1.curve.model,
+                self.secp128r1.curve.coordinate_model,
+                15,
+                InfinityPoint(self.secp128r1.curve.coordinate_model),
+                parameters={"a": Mod(1, 5), "b": Mod(2, 5)},
+            )
 
     def test_is_neutral(self):
-        self.assertTrue(self.secp128r1.curve.is_neutral(InfinityPoint(self.secp128r1.curve.coordinate_model)))
+        self.assertTrue(
+            self.secp128r1.curve.is_neutral(
+                InfinityPoint(self.secp128r1.curve.coordinate_model)
+            )
+        )
 
     def test_is_on_curve(self):
         self.assertTrue(self.secp128r1.curve.is_on_curve(self.secp128r1.curve.neutral))
-        pt = Point(self.secp128r1.curve.coordinate_model,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
-                   Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.secp128r1.curve.coordinate_model,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         self.assertTrue(self.secp128r1.curve.is_on_curve(pt))
         self.assertTrue(self.secp128r1.curve.is_on_curve(pt.to_affine()))
-        other = Point(self.secp128r1.curve.coordinate_model,
-                      X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                      Y=Mod(0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, self.secp128r1.curve.prime),
-                      Z=Mod(1, self.secp128r1.curve.prime))
+        other = Point(
+            self.secp128r1.curve.coordinate_model,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         self.assertFalse(self.secp128r1.curve.is_on_curve(other))
         self.assertFalse(self.secp128r1.curve.is_on_curve(self.curve25519.generator))
 
     def test_affine_add(self):
-        pt = Point(AffineCoordinateModel(self.secp128r1.curve.model),
-                   x=Mod(0xeb916224eda4fb356421773573297c15, self.secp128r1.curve.prime),
-                   y=Mod(0xbcdaf32a2c08fd4271228fef35070848, self.secp128r1.curve.prime))
+        pt = Point(
+            AffineCoordinateModel(self.secp128r1.curve.model),
+            x=Mod(0xEB916224EDA4FB356421773573297C15, self.secp128r1.curve.prime),
+            y=Mod(0xBCDAF32A2C08FD4271228FEF35070848, self.secp128r1.curve.prime),
+        )
         self.assertIsNotNone(self.secp128r1.curve.affine_add(self.affine_base, pt))
 
         added = self.secp128r1.curve.affine_add(self.affine_base, self.affine_base)
         doubled = self.secp128r1.curve.affine_double(self.affine_base)
         self.assertEqual(added, doubled)
-        self.assertEqual(self.secp128r1.curve.affine_add(self.secp128r1.curve.neutral, pt), pt)
-        self.assertEqual(self.secp128r1.curve.affine_add(pt, self.secp128r1.curve.neutral), pt)
+        self.assertEqual(
+            self.secp128r1.curve.affine_add(self.secp128r1.curve.neutral, pt), pt
+        )
+        self.assertEqual(
+            self.secp128r1.curve.affine_add(pt, self.secp128r1.curve.neutral), pt
+        )
 
     def test_affine_double(self):
         self.assertIsNotNone(self.secp128r1.curve.affine_double(self.affine_base))
-        self.assertEqual(self.secp128r1.curve.affine_double(self.secp128r1.curve.neutral), self.secp128r1.curve.neutral)
+        self.assertEqual(
+            self.secp128r1.curve.affine_double(self.secp128r1.curve.neutral),
+            self.secp128r1.curve.neutral,
+        )
 
     def test_affine_negate(self):
         self.assertIsNotNone(self.secp128r1.curve.affine_negate(self.affine_base))
-        self.assertEqual(self.secp128r1.curve.affine_negate(self.secp128r1.curve.neutral), self.secp128r1.curve.neutral)
+        self.assertEqual(
+            self.secp128r1.curve.affine_negate(self.secp128r1.curve.neutral),
+            self.secp128r1.curve.neutral,
+        )
         with self.assertRaises(ValueError):
             self.secp128r1.curve.affine_negate(self.base)
         with self.assertRaises(ValueError):
@@ -79,8 +113,13 @@ class CurveTests(TestCase):
         expected = self.secp128r1.curve.affine_double(expected)
         expected = self.secp128r1.curve.affine_add(expected, self.affine_base)
         expected = self.secp128r1.curve.affine_double(expected)
-        self.assertEqual(self.secp128r1.curve.affine_multiply(self.affine_base, 10), expected)
-        self.assertEqual(self.secp128r1.curve.affine_multiply(self.secp128r1.curve.neutral, 10), self.secp128r1.curve.neutral)
+        self.assertEqual(
+            self.secp128r1.curve.affine_multiply(self.affine_base, 10), expected
+        )
+        self.assertEqual(
+            self.secp128r1.curve.affine_multiply(self.secp128r1.curve.neutral, 10),
+            self.secp128r1.curve.neutral,
+        )
         with self.assertRaises(ValueError):
             self.secp128r1.curve.affine_multiply(self.base, 10)
         with self.assertRaises(ValueError):
@@ -129,7 +168,9 @@ class CurveTests(TestCase):
         with self.assertRaises(ValueError):
             affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b"))
         with self.assertRaises(ValueError):
-            affine_curve.decode_point(unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b"))
+            affine_curve.decode_point(
+                unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b")
+            )
         with self.assertRaises(ValueError):
             affine_curve.decode_point(unhexlify("7a161ff7528b899b2d0c28607ca52c5b86"))
         with self.assertRaises(ValueError):
diff --git a/test/ec/test_formula.py b/test/ec/test_formula.py
index ec585ad..ffae4c4 100644
--- a/test/ec/test_formula.py
+++ b/test/ec/test_formula.py
@@ -10,20 +10,25 @@ from pyecsca.ec.point import Point
 
 
 class FormulaTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mdbl = self.secp128r1.curve.coordinate_model.formulas["mdbl-2007-bl"]
         self.jac_secp128r1 = get_params("secg", "secp128r1", "jacobian")
-        self.jac_dbl = self.jac_secp128r1.curve.coordinate_model.formulas["dbl-1998-hnm"]
+        self.jac_dbl = self.jac_secp128r1.curve.coordinate_model.formulas[
+            "dbl-1998-hnm"
+        ]
 
     def test_wrong_call(self):
         with self.assertRaises(ValueError):
             self.add(self.secp128r1.curve.prime)
         with self.assertRaises(ValueError):
-            self.add(self.secp128r1.curve.prime, self.secp128r1.generator.to_affine(), self.secp128r1.generator.to_affine())
+            self.add(
+                self.secp128r1.curve.prime,
+                self.secp128r1.generator.to_affine(),
+                self.secp128r1.generator.to_affine(),
+            )
 
     def test_indices(self):
         self.assertEqual(self.add.input_index, 1)
@@ -47,33 +52,56 @@ class FormulaTests(TestCase):
         self.assertEqual(self.add.num_addsubs, 10)
 
     def test_assumptions(self):
-        res = self.mdbl(self.secp128r1.curve.prime, self.secp128r1.generator, **self.secp128r1.curve.parameters)
+        res = self.mdbl(
+            self.secp128r1.curve.prime,
+            self.secp128r1.generator,
+            **self.secp128r1.curve.parameters
+        )
         self.assertIsNotNone(res)
 
-        coords = {name: value * 5 for name, value in self.secp128r1.generator.coords.items()}
+        coords = {
+            name: value * 5 for name, value in self.secp128r1.generator.coords.items()
+        }
         other = Point(self.secp128r1.generator.coordinate_model, **coords)
         with self.assertRaises(UnsatisfiedAssumptionError):
-            self.mdbl(self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters)
+            self.mdbl(
+                self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters
+            )
         with TemporaryConfig() as cfg:
             cfg.ec.unsatisfied_formula_assumption_action = "ignore"
-            pt = self.mdbl(self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters)
+            pt = self.mdbl(
+                self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters
+            )
             self.assertIsNotNone(pt)
 
     def test_parameters(self):
-        res = self.jac_dbl(self.secp128r1.curve.prime, self.jac_secp128r1.generator, **self.jac_secp128r1.curve.parameters)
+        res = self.jac_dbl(
+            self.secp128r1.curve.prime,
+            self.jac_secp128r1.generator,
+            **self.jac_secp128r1.curve.parameters
+        )
         self.assertIsNotNone(res)
 
     def test_symbolic(self):
         p = self.secp128r1.curve.prime
         k = FF(p)
         coords = self.secp128r1.curve.coordinate_model
-        sympy_params = {key: SymbolicMod(k(int(value)), p) for key, value in self.secp128r1.curve.parameters.items()}
-        symbolic_point = Point(coords, **{key: SymbolicMod(symbols(key), p) for key in coords.variables})
+        sympy_params = {
+            key: SymbolicMod(k(int(value)), p)
+            for key, value in self.secp128r1.curve.parameters.items()
+        }
+        symbolic_point = Point(
+            coords, **{key: SymbolicMod(symbols(key), p) for key in coords.variables}
+        )
         symbolic_double = self.dbl(p, symbolic_point, **sympy_params)[0]
-        generator_double = self.dbl(p, self.secp128r1.generator, **self.secp128r1.curve.parameters)[0]
+        generator_double = self.dbl(
+            p, self.secp128r1.generator, **self.secp128r1.curve.parameters
+        )[0]
         for outer_var in coords.variables:
             symbolic_val = getattr(symbolic_double, outer_var).x
             generator_val = getattr(generator_double, outer_var).x
             for inner_var in coords.variables:
-                symbolic_val = symbolic_val.subs(inner_var, k(getattr(self.secp128r1.generator, inner_var).x))
+                symbolic_val = symbolic_val.subs(
+                    inner_var, k(getattr(self.secp128r1.generator, inner_var).x)
+                )
             self.assertEqual(Mod(int(symbolic_val), p), Mod(generator_val, p))
diff --git a/test/ec/test_key_agreement.py b/test/ec/test_key_agreement.py
index cbdb1c8..240c174 100644
--- a/test/ec/test_key_agreement.py
+++ b/test/ec/test_key_agreement.py
@@ -3,33 +3,40 @@ from unittest import TestCase
 from parameterized import parameterized
 
 from pyecsca.ec.params import get_params
-from pyecsca.ec.key_agreement import (ECDH_NONE, ECDH_SHA1, ECDH_SHA224, ECDH_SHA256, ECDH_SHA384,
-                                      ECDH_SHA512)
+from pyecsca.ec.key_agreement import (
+    ECDH_NONE,
+    ECDH_SHA1,
+    ECDH_SHA224,
+    ECDH_SHA256,
+    ECDH_SHA384,
+    ECDH_SHA512,
+)
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.mult import LTRMultiplier
 
 
 class KeyAgreementTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mult = LTRMultiplier(self.add, self.dbl)
-        self.priv_a = Mod(0xdeadbeef, self.secp128r1.order)
+        self.priv_a = Mod(0xDEADBEEF, self.secp128r1.order)
         self.mult.init(self.secp128r1, self.secp128r1.generator)
         self.pub_a = self.mult.multiply(int(self.priv_a))
-        self.priv_b = Mod(0xcafebabe, self.secp128r1.order)
+        self.priv_b = Mod(0xCAFEBABE, self.secp128r1.order)
         self.pub_b = self.mult.multiply(int(self.priv_b))
 
-    @parameterized.expand([
-        ("NONE", ECDH_NONE),
-        ("SHA1", ECDH_SHA1),
-        ("SHA224", ECDH_SHA224),
-        ("SHA256", ECDH_SHA256),
-        ("SHA384", ECDH_SHA384),
-        ("SHA512", ECDH_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("NONE", ECDH_NONE),
+            ("SHA1", ECDH_SHA1),
+            ("SHA224", ECDH_SHA224),
+            ("SHA256", ECDH_SHA256),
+            ("SHA384", ECDH_SHA384),
+            ("SHA512", ECDH_SHA512),
+        ]
+    )
     def test_all(self, name, algo):
         result_ab = algo(self.mult, self.secp128r1, self.pub_a, self.priv_b).perform()
         result_ba = algo(self.mult, self.secp128r1, self.pub_b, self.priv_a).perform()
diff --git a/test/ec/test_key_generation.py b/test/ec/test_key_generation.py
index f0d926c..7eb26f0 100644
--- a/test/ec/test_key_generation.py
+++ b/test/ec/test_key_generation.py
@@ -6,7 +6,6 @@ from pyecsca.ec.mult import LTRMultiplier
 
 
 class KeyGenerationTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
diff --git a/test/ec/test_mod.py b/test/ec/test_mod.py
index a21ef06..2c45447 100644
--- a/test/ec/test_mod.py
+++ b/test/ec/test_mod.py
@@ -1,13 +1,27 @@
 from sympy import FF, symbols
 from unittest import TestCase
 
-from pyecsca.ec.mod import Mod, gcd, extgcd, Undefined, miller_rabin, has_gmp, RawMod, SymbolicMod, jacobi
-from pyecsca.ec.error import NonInvertibleError, NonResidueError, NonInvertibleWarning, NonResidueWarning
+from pyecsca.ec.mod import (
+    Mod,
+    gcd,
+    extgcd,
+    Undefined,
+    miller_rabin,
+    has_gmp,
+    RawMod,
+    SymbolicMod,
+    jacobi,
+)
+from pyecsca.ec.error import (
+    NonInvertibleError,
+    NonResidueError,
+    NonInvertibleWarning,
+    NonResidueWarning,
+)
 from pyecsca.misc.cfg import getconfig, TemporaryConfig
 
 
 class ModTests(TestCase):
-
     def test_gcd(self):
         self.assertEqual(gcd(15, 20), 5)
         self.assertEqual(extgcd(15, 0), (1, 0, 15))
@@ -15,20 +29,33 @@ class ModTests(TestCase):
 
     def test_jacobi(self):
         self.assertEqual(jacobi(5, 1153486465415345646578465454655646543248656451), 1)
-        self.assertEqual(jacobi(564786456646845, 46874698564153465453246546545456849797895547657), -1)
-        self.assertEqual(jacobi(564786456646845, 46874698564153465453246546545456849797895), 0)
+        self.assertEqual(
+            jacobi(564786456646845, 46874698564153465453246546545456849797895547657), -1
+        )
+        self.assertEqual(
+            jacobi(564786456646845, 46874698564153465453246546545456849797895), 0
+        )
 
     def test_miller_rabin(self):
         self.assertTrue(miller_rabin(2))
         self.assertTrue(miller_rabin(3))
         self.assertTrue(miller_rabin(5))
         self.assertFalse(miller_rabin(8))
-        self.assertTrue(miller_rabin(0xe807561107ccf8fa82af74fd492543a918ca2e9c13750233a9))
-        self.assertFalse(miller_rabin(0x6f6889deb08da211927370810f026eb4c17b17755f72ea005))
+        self.assertTrue(
+            miller_rabin(0xE807561107CCF8FA82AF74FD492543A918CA2E9C13750233A9)
+        )
+        self.assertFalse(
+            miller_rabin(0x6F6889DEB08DA211927370810F026EB4C17B17755F72EA005)
+        )
 
     def test_inverse(self):
-        p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
-        self.assertEqual(Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).inverse(), Mod(0x1cb2e5274bba085c4ca88eede75ae77949e7a410c80368376e97ab22eb590f9d, p))
+        p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
+        self.assertEqual(
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).inverse(),
+            Mod(0x1CB2E5274BBA085C4CA88EEDE75AE77949E7A410C80368376E97AB22EB590F9D, p),
+        )
         with self.assertRaises(NonInvertibleError):
             Mod(0, p).inverse()
         with self.assertRaises(NonInvertibleError):
@@ -50,22 +77,42 @@ class ModTests(TestCase):
         self.assertTrue(Mod(1, 2).is_residue())
 
     def test_sqrt(self):
-        p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
-        self.assertIn(Mod(0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc, p).sqrt(), (0x9add512515b70d9ec471151c1dec46625cd18b37bde7ca7fb2c8b31d7033599d, 0x6522aed9ea48f2623b8eeae3e213b99da32e74c9421835804d374ce28fcca662))
+        p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
+        self.assertIn(
+            Mod(
+                0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC, p
+            ).sqrt(),
+            (
+                0x9ADD512515B70D9EC471151C1DEC46625CD18B37BDE7CA7FB2C8B31D7033599D,
+                0x6522AED9EA48F2623B8EEAE3E213B99DA32E74C9421835804D374CE28FCCA662,
+            ),
+        )
         with self.assertRaises(NonResidueError):
-            Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).sqrt()
         getconfig().ec.non_residue_action = "warning"
         with self.assertRaises(NonResidueWarning):
-            Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).sqrt()
         getconfig().ec.non_residue_action = "ignore"
-        Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+        Mod(
+            0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+        ).sqrt()
         with TemporaryConfig() as cfg:
             cfg.ec.non_residue_action = "warning"
             with self.assertRaises(NonResidueWarning):
-                Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+                Mod(
+                    0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1,
+                    p,
+                ).sqrt()
         self.assertEqual(Mod(0, p).sqrt(), Mod(0, p))
-        q = 0x75d44fee9a71841ae8403c0c251fbad
-        self.assertIn(Mod(0x591e0db18cf1bd81a11b2985a821eb3, q).sqrt(), (0x113b41a1a2b73f636e73be3f9a3716e, 0x64990e4cf7ba44b779cc7dcc8ae8a3f))
+        q = 0x75D44FEE9A71841AE8403C0C251FBAD
+        self.assertIn(
+            Mod(0x591E0DB18CF1BD81A11B2985A821EB3, q).sqrt(),
+            (0x113B41A1A2B73F636E73BE3F9A3716E, 0x64990E4CF7BA44B779CC7DCC8AE8A3F),
+        )
         getconfig().ec.non_residue_action = "error"
 
     def test_eq(self):
@@ -77,9 +124,9 @@ class ModTests(TestCase):
 
     def test_pow(self):
         a = Mod(5, 7)
-        self.assertEqual(a**(-1), a.inverse())
-        self.assertEqual(a**0, Mod(1, 7))
-        self.assertEqual(a**(-2), a.inverse()**2)
+        self.assertEqual(a ** (-1), a.inverse())
+        self.assertEqual(a ** 0, Mod(1, 7))
+        self.assertEqual(a ** (-2), a.inverse() ** 2)
 
     def test_wrong_mod(self):
         a = Mod(5, 7)
@@ -91,7 +138,7 @@ class ModTests(TestCase):
         a = Mod(5, 7)
         c = Mod(4, 11)
         with self.assertRaises(TypeError):
-            a**c
+            a ** c
 
     def test_other(self):
         a = Mod(5, 7)
@@ -116,7 +163,15 @@ class ModTests(TestCase):
     def test_undefined(self):
         u = Undefined()
         for k, meth in u.__class__.__dict__.items():
-            if k in ("__module__", "__new__", "__init__", "__doc__", "__hash__", "__abstractmethods__", "_abc_impl"):
+            if k in (
+                "__module__",
+                "__new__",
+                "__init__",
+                "__doc__",
+                "__hash__",
+                "__abstractmethods__",
+                "_abc_impl",
+            ):
                 continue
             args = [5 for _ in range(meth.__code__.co_argcount - 1)]
             if k == "__repr__":
diff --git a/test/ec/test_model.py b/test/ec/test_model.py
index b9d4383..d1c03c3 100644
--- a/test/ec/test_model.py
+++ b/test/ec/test_model.py
@@ -1,11 +1,14 @@
 from unittest import TestCase
 
-from pyecsca.ec.model import (ShortWeierstrassModel, MontgomeryModel, EdwardsModel,
-                              TwistedEdwardsModel)
+from pyecsca.ec.model import (
+    ShortWeierstrassModel,
+    MontgomeryModel,
+    EdwardsModel,
+    TwistedEdwardsModel,
+)
 
 
 class CurveModelTests(TestCase):
-
     def test_load(self):
         self.assertGreater(len(ShortWeierstrassModel().coordinates), 0)
         self.assertGreater(len(MontgomeryModel().coordinates), 0)
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index 19db2b2..5200520 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -3,16 +3,21 @@ from unittest import TestCase
 from parameterized import parameterized
 
 from pyecsca.ec.params import get_params
-from pyecsca.ec.mult import (LTRMultiplier, RTLMultiplier, LadderMultiplier, BinaryNAFMultiplier,
-                             WindowNAFMultiplier, SimpleLadderMultiplier,
-                             DifferentialLadderMultiplier,
-                             CoronMultiplier)
+from pyecsca.ec.mult import (
+    LTRMultiplier,
+    RTLMultiplier,
+    LadderMultiplier,
+    BinaryNAFMultiplier,
+    WindowNAFMultiplier,
+    SimpleLadderMultiplier,
+    DifferentialLadderMultiplier,
+    CoronMultiplier,
+)
 from pyecsca.ec.point import InfinityPoint
 from .utils import cartesian
 
 
 class ScalarMultiplierTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.base = self.secp128r1.generator
@@ -31,9 +36,13 @@ class ScalarMultiplierTests(TestCase):
         else:
             assert one.equals(other)
 
-    def do_basic_test(self, mult_class, params, base, add, dbl, scale, neg=None, **kwargs):
-        mult = mult_class(*self.get_formulas(params.curve.coordinate_model, add, dbl, neg, scale),
-                          **kwargs)
+    def do_basic_test(
+        self, mult_class, params, base, add, dbl, scale, neg=None, **kwargs
+    ):
+        mult = mult_class(
+            *self.get_formulas(params.curve.coordinate_model, add, dbl, neg, scale),
+            **kwargs
+        )
         mult.init(params, base)
         res = mult.multiply(314)
         other = mult.multiply(157)
@@ -44,71 +53,120 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(InfinityPoint(params.curve.coordinate_model), mult.multiply(0))
         return res
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_rtl(self, name, add, dbl, scale):
         self.do_basic_test(RTLMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_ltr(self, name, add, dbl, scale):
-        a = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale)
-        b = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               always=True)
-        c = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               complete=False)
-        d = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               always=True,
-                               complete=False)
+        a = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale
+        )
+        b = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, always=True
+        )
+        c = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, complete=False
+        )
+        d = self.do_basic_test(
+            LTRMultiplier,
+            self.secp128r1,
+            self.base,
+            add,
+            dbl,
+            scale,
+            always=True,
+            complete=False,
+        )
         self.assertPointEquality(a, b, scale)
         self.assertPointEquality(b, c, scale)
         self.assertPointEquality(c, d, scale)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_coron(self, name, add, dbl, scale):
         self.do_basic_test(CoronMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     def test_ladder(self):
-        a = self.do_basic_test(LadderMultiplier, self.curve25519, self.base25519, "ladd-1987-m",
-                               "dbl-1987-m", "scale")
-        b = self.do_basic_test(LadderMultiplier, self.curve25519, self.base25519, "ladd-1987-m",
-                               "dbl-1987-m", "scale", complete=False)
+        a = self.do_basic_test(
+            LadderMultiplier,
+            self.curve25519,
+            self.base25519,
+            "ladd-1987-m",
+            "dbl-1987-m",
+            "scale",
+        )
+        b = self.do_basic_test(
+            LadderMultiplier,
+            self.curve25519,
+            self.base25519,
+            "ladd-1987-m",
+            "dbl-1987-m",
+            "scale",
+            complete=False,
+        )
         self.assertPointEquality(a, b, True)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_simple_ladder(self, name, add, dbl, scale):
-        self.do_basic_test(SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale)
+        self.do_basic_test(
+            SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale
+        )
 
-    @parameterized.expand([
-        ("15", 15, True),
-        ("15", 15, False),
-        ("2355498743", 2355498743, True),
-        ("2355498743", 2355498743, False),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746, True),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746, False)
-    ])
+    @parameterized.expand(
+        [
+            ("15", 15, True),
+            ("15", 15, False),
+            ("2355498743", 2355498743, True),
+            ("2355498743", 2355498743, False),
+            (
+                "325385790209017329644351321912443757746",
+                325385790209017329644351321912443757746,
+                True,
+            ),
+            (
+                "325385790209017329644351321912443757746",
+                325385790209017329644351321912443757746,
+                False,
+            ),
+        ]
+    )
     def test_ladder_differential(self, name, num, complete):
-        ladder = LadderMultiplier(self.coords25519.formulas["ladd-1987-m"],
-                                  self.coords25519.formulas["dbl-1987-m"],
-                                  self.coords25519.formulas["scale"], complete=complete)
-        differential = DifferentialLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
-                                                    self.coords25519.formulas["dbl-1987-m"],
-                                                    self.coords25519.formulas["scale"],
-                                                    complete=complete)
+        ladder = LadderMultiplier(
+            self.coords25519.formulas["ladd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+            complete=complete,
+        )
+        differential = DifferentialLadderMultiplier(
+            self.coords25519.formulas["dadd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+            complete=complete,
+        )
         ladder.init(self.curve25519, self.base25519)
         res_ladder = ladder.multiply(num)
         differential.init(self.curve25519, self.base25519)
@@ -116,22 +174,28 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_ladder, res_differential)
         self.assertEqual(InfinityPoint(self.coords25519), differential.multiply(0))
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None),
+        ]
+    )
     def test_binary_naf(self, name, add, dbl, neg, scale):
-        self.do_basic_test(BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg)
+        self.do_basic_test(
+            BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg
+        )
 
-    @parameterized.expand([
-        ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
-        ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None),
-        ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None),
-        ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"),
-        ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None),
-        ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None),
-    ])
+    @parameterized.expand(
+        [
+            ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
+            ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None),
+            ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None),
+            ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"),
+            ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None),
+            ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None),
+        ]
+    )
     def test_window_naf(self, name, add, dbl, neg, width, scale):
         formulas = self.get_formulas(self.coords, add, dbl, neg, scale)
         mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:])
@@ -144,41 +208,59 @@ class ScalarMultiplierTests(TestCase):
         mult.init(self.secp128r1, self.base)
         self.assertEqual(InfinityPoint(self.coords), mult.multiply(0))
 
-        mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:],
-                                   precompute_negation=True)
+        mult = WindowNAFMultiplier(
+            *formulas[:3], width, *formulas[3:], precompute_negation=True
+        )
         mult.init(self.secp128r1, self.base)
         res_precompute = mult.multiply(157 * 789)
         self.assertPointEquality(res_precompute, res, scale)
 
-    @parameterized.expand(cartesian([
-        ("10", 10),
-        ("2355498743", 2355498743),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746)
-    ], [
-        ("add-1998-cmo", "dbl-1998-cmo"),
-        ("add-2016-rcb", "dbl-2016-rcb")
-    ]))
+    @parameterized.expand(
+        cartesian(
+            [
+                ("10", 10),
+                ("2355498743", 2355498743),
+                (
+                    "325385790209017329644351321912443757746",
+                    325385790209017329644351321912443757746,
+                ),
+            ],
+            [("add-1998-cmo", "dbl-1998-cmo"), ("add-2016-rcb", "dbl-2016-rcb")],
+        )
+    )
     def test_basic_multipliers(self, name, num, add, dbl):
-        ltr = LTRMultiplier(self.coords.formulas[add],
-                            self.coords.formulas[dbl], self.coords.formulas["z"])
+        ltr = LTRMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             ltr.multiply(1)
         ltr.init(self.secp128r1, self.base)
         res_ltr = ltr.multiply(num)
-        rtl = RTLMultiplier(self.coords.formulas[add],
-                            self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+        rtl = RTLMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas["dbl-1998-cmo"],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             rtl.multiply(1)
         rtl.init(self.secp128r1, self.base)
         res_rtl = rtl.multiply(num)
         self.assertEqual(res_ltr, res_rtl)
 
-        ltr_always = LTRMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl], self.coords.formulas["z"],
-                                   always=True)
-        rtl_always = RTLMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl], self.coords.formulas["z"],
-                                   always=True)
+        ltr_always = LTRMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+            always=True,
+        )
+        rtl_always = RTLMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+            always=True,
+        )
         ltr_always.init(self.secp128r1, self.base)
         rtl_always.init(self.secp128r1, self.base)
         res_ltr_always = ltr_always.multiply(num)
@@ -186,36 +268,47 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_ltr, res_ltr_always)
         self.assertEqual(res_rtl, res_rtl_always)
 
-        bnaf = BinaryNAFMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl],
-                                   self.coords.formulas["neg"], self.coords.formulas["z"])
+        bnaf = BinaryNAFMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["neg"],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             bnaf.multiply(1)
         bnaf.init(self.secp128r1, self.base)
         res_bnaf = bnaf.multiply(num)
         self.assertEqual(res_bnaf, res_ltr)
 
-        wnaf = WindowNAFMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl],
-                                   self.coords.formulas["neg"], 3, self.coords.formulas["z"])
+        wnaf = WindowNAFMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["neg"],
+            3,
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             wnaf.multiply(1)
         wnaf.init(self.secp128r1, self.base)
         res_wnaf = wnaf.multiply(num)
         self.assertEqual(res_wnaf, res_ltr)
 
-        ladder = SimpleLadderMultiplier(self.coords.formulas[add],
-                                        self.coords.formulas[dbl],
-                                        self.coords.formulas["z"])
+        ladder = SimpleLadderMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             ladder.multiply(1)
         ladder.init(self.secp128r1, self.base)
         res_ladder = ladder.multiply(num)
         self.assertEqual(res_ladder, res_ltr)
 
-        coron = CoronMultiplier(self.coords.formulas[add],
-                                self.coords.formulas[dbl],
-                                self.coords.formulas["z"])
+        coron = CoronMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             coron.multiply(1)
         coron.init(self.secp128r1, self.base)
@@ -223,12 +316,17 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_coron, res_ltr)
 
     def test_init_fail(self):
-        mult = DifferentialLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
-                                            self.coords25519.formulas["dbl-1987-m"],
-                                            self.coords25519.formulas["scale"])
+        mult = DifferentialLadderMultiplier(
+            self.coords25519.formulas["dadd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+        )
         with self.assertRaises(ValueError):
             mult.init(self.secp128r1, self.base)
 
         with self.assertRaises(ValueError):
-            LadderMultiplier(self.coords25519.formulas["ladd-1987-m"],
-                             scl=self.coords25519.formulas["scale"], complete=False)
+            LadderMultiplier(
+                self.coords25519.formulas["ladd-1987-m"],
+                scl=self.coords25519.formulas["scale"],
+                complete=False,
+            )
diff --git a/test/ec/test_naf.py b/test/ec/test_naf.py
index c87c03f..bdc176a 100644
--- a/test/ec/test_naf.py
+++ b/test/ec/test_naf.py
@@ -4,7 +4,6 @@ from pyecsca.ec.naf import naf, wnaf
 
 
 class NafTests(TestCase):
-
     def test_nafs(self):
         i = 0b1100110101001101011011
         self.assertListEqual(naf(i), wnaf(i, 2))
diff --git a/test/ec/test_op.py b/test/ec/test_op.py
index 019e0e8..c09914f 100644
--- a/test/ec/test_op.py
+++ b/test/ec/test_op.py
@@ -10,28 +10,31 @@ from pyecsca.ec.op import CodeOp, OpType
 
 
 class OpTests(TestCase):
-
-    @parameterized.expand([
-        ("add", "x = a+b", "x = a+b", OpType.Add),
-        ("sub", "x = a-b", "x = a-b", OpType.Sub),
-        ("mul", "y = a*b", "y = a*b", OpType.Mult),
-        ("div", "z = a/b", "z = a/b", OpType.Div),
-        ("inv", "z = 1/b", "z = 1/b", OpType.Inv),
-        ("pow", "b = a**d", "b = a^d", OpType.Pow),
-        ("sqr", "b = a**2", "b = a^2", OpType.Sqr),
-        ("id1", "b = 7", "b = 7", OpType.Id),
-        ("id2", "b = a", "b = a", OpType.Id),
-    ])
+    @parameterized.expand(
+        [
+            ("add", "x = a+b", "x = a+b", OpType.Add),
+            ("sub", "x = a-b", "x = a-b", OpType.Sub),
+            ("mul", "y = a*b", "y = a*b", OpType.Mult),
+            ("div", "z = a/b", "z = a/b", OpType.Div),
+            ("inv", "z = 1/b", "z = 1/b", OpType.Inv),
+            ("pow", "b = a**d", "b = a^d", OpType.Pow),
+            ("sqr", "b = a**2", "b = a^2", OpType.Sqr),
+            ("id1", "b = 7", "b = 7", OpType.Id),
+            ("id2", "b = a", "b = a", OpType.Id),
+        ]
+    )
     def test_str(self, name, module, result, op_type):
         code = parse(module, mode="exec")
         op = CodeOp(code)
         self.assertEqual(str(op), result)
         self.assertEqual(op.operator, op_type)
 
-    @parameterized.expand([
-        ("add", "x = a+b", {"a": Mod(5, 21), "b": Mod(7, 21)}, Mod(12, 21)),
-        ("sub", "x = a-b", {"a": Mod(7, 21), "b": Mod(5, 21)}, Mod(2, 21))
-    ])
+    @parameterized.expand(
+        [
+            ("add", "x = a+b", {"a": Mod(5, 21), "b": Mod(7, 21)}, Mod(12, 21)),
+            ("sub", "x = a-b", {"a": Mod(7, 21), "b": Mod(5, 21)}, Mod(2, 21)),
+        ]
+    )
     def test_call(self, name, module, locals, result):
         code = parse(module, mode="exec")
         op = CodeOp(code)
@@ -40,7 +43,6 @@ class OpTests(TestCase):
 
 
 class OpResultTests(TestCase):
-
     def test_str(self):
         for op, char in zip((ast.Add(), ast.Sub(), ast.Mult(), ast.Div()), "+-*/"):
             res = OpResult("X1", Mod(0, 5), op, Mod(2, 5), Mod(3, 5))
diff --git a/test/ec/test_params.py b/test/ec/test_params.py
index eb70342..b2a57b6 100644
--- a/test/ec/test_params.py
+++ b/test/ec/test_params.py
@@ -21,15 +21,17 @@ class DomainParameterTests(TestCase):
     def test_str(self):
         self.assertEqual(str(self.secp128r1), "DomainParameters(secg/secp128r1)")
 
-    @parameterized.expand([
-        ("secg/secp128r1", "projective"),
-        ("secg/secp256r1", "projective"),
-        ("secg/secp521r1", "projective"),
-        ("other/Curve25519", "xz"),
-        ("other/Ed25519", "projective"),
-        ("other/Ed448", "projective"),
-        ("other/E-222", "projective")
-    ])
+    @parameterized.expand(
+        [
+            ("secg/secp128r1", "projective"),
+            ("secg/secp256r1", "projective"),
+            ("secg/secp521r1", "projective"),
+            ("other/Curve25519", "xz"),
+            ("other/Ed25519", "projective"),
+            ("other/Ed448", "projective"),
+            ("other/E-222", "projective"),
+        ]
+    )
     def test_get_params(self, name, coords):
         params = get_params(*name.split("/"), coords)
         try:
@@ -37,10 +39,15 @@ class DomainParameterTests(TestCase):
         except NotImplementedError:
             pass
 
-    @parameterized.expand([
-        ("anssi", "projective"),
-        ("brainpool", lambda name: "projective" if name.endswith("r1") else "jacobian")
-    ])
+    @parameterized.expand(
+        [
+            ("anssi", "projective"),
+            (
+                "brainpool",
+                lambda name: "projective" if name.endswith("r1") else "jacobian",
+            ),
+        ]
+    )
     def test_get_category(self, name, coords):
         get_category(name, coords)
 
@@ -55,11 +62,13 @@ class DomainParameterTests(TestCase):
         category = load_category("test/data/curves.json", "yz")
         self.assertEqual(len(category), 1)
 
-    @parameterized.expand([
-        ("no_category/some", "else"),
-        ("secg/no_curve", "else"),
-        ("secg/secp128r1", "some")
-    ])
+    @parameterized.expand(
+        [
+            ("no_category/some", "else"),
+            ("secg/no_curve", "else"),
+            ("secg/secp128r1", "some"),
+        ]
+    )
     def test_unknown(self, name, coords):
         with self.assertRaises(ValueError):
             get_params(*name.split("/"), coords)
diff --git a/test/ec/test_point.py b/test/ec/test_point.py
index 9bff800..51907ec 100644
--- a/test/ec/test_point.py
+++ b/test/ec/test_point.py
@@ -19,10 +19,12 @@ class PointTests(TestCase):
             Point(self.coords)
 
     def test_to_affine(self):
-        pt = Point(self.coords,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
-                   Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         affine = pt.to_affine()
 
         self.assertIsInstance(affine.coordinate_model, AffineCoordinateModel)
@@ -35,7 +37,11 @@ class PointTests(TestCase):
         self.assertIsInstance(affine, InfinityPoint)
 
     def test_to_model(self):
-        affine = Point(self.affine, x=Mod(0xabcd, self.secp128r1.curve.prime), y=Mod(0xef, self.secp128r1.curve.prime))
+        affine = Point(
+            self.affine,
+            x=Mod(0xABCD, self.secp128r1.curve.prime),
+            y=Mod(0xEF, self.secp128r1.curve.prime),
+        )
         projective_model = self.coords
         other = affine.to_model(projective_model, self.secp128r1.curve)
 
@@ -53,26 +59,34 @@ class PointTests(TestCase):
             self.base.to_model(self.coords, self.secp128r1.curve)
 
     def test_to_from_affine(self):
-        pt = Point(self.coords,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
-                   Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         other = pt.to_affine().to_model(self.coords, self.secp128r1.curve)
         self.assertEqual(pt, other)
 
     def test_equals(self):
-        pt = Point(self.coords,
-                   X=Mod(0x4, self.secp128r1.curve.prime),
-                   Y=Mod(0x6, self.secp128r1.curve.prime),
-                   Z=Mod(2, self.secp128r1.curve.prime))
-        other = Point(self.coords,
-                      X=Mod(0x2, self.secp128r1.curve.prime),
-                      Y=Mod(0x3, self.secp128r1.curve.prime),
-                      Z=Mod(1, self.secp128r1.curve.prime))
-        third = Point(self.coords,
-                      X=Mod(0x5, self.secp128r1.curve.prime),
-                      Y=Mod(0x3, self.secp128r1.curve.prime),
-                      Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x4, self.secp128r1.curve.prime),
+            Y=Mod(0x6, self.secp128r1.curve.prime),
+            Z=Mod(2, self.secp128r1.curve.prime),
+        )
+        other = Point(
+            self.coords,
+            X=Mod(0x2, self.secp128r1.curve.prime),
+            Y=Mod(0x3, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
+        third = Point(
+            self.coords,
+            X=Mod(0x5, self.secp128r1.curve.prime),
+            Y=Mod(0x3, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         self.assertTrue(pt.equals(other))
         self.assertNotEqual(pt, other)
         self.assertFalse(pt.equals(2))
@@ -94,17 +108,26 @@ class PointTests(TestCase):
         self.assertFalse(pt.equals_scaled(infty_one))
 
         mont = MontgomeryModel()
-        different = Point(mont.coordinates["xz"],
-                          X=Mod(0x64daccd2656420216545e5f65221eb,
-                                0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),
-                          Z=Mod(1, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa))
+        different = Point(
+            mont.coordinates["xz"],
+            X=Mod(
+                0x64DACCD2656420216545E5F65221EB,
+                0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,
+            ),
+            Z=Mod(1, 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA),
+        )
         self.assertFalse(pt.equals(different))
         self.assertNotEqual(pt, different)
 
     def test_bytes(self):
-        pt = Point(self.coords,
-                   X=Mod(0x4, self.secp128r1.curve.prime),
-                   Y=Mod(0x6, self.secp128r1.curve.prime),
-                   Z=Mod(2, self.secp128r1.curve.prime))
-        self.assertEqual(bytes(pt), b"\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02")
+        pt = Point(
+            self.coords,
+            X=Mod(0x4, self.secp128r1.curve.prime),
+            Y=Mod(0x6, self.secp128r1.curve.prime),
+            Z=Mod(2, self.secp128r1.curve.prime),
+        )
+        self.assertEqual(
+            bytes(pt),
+            b"\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02",
+        )
         self.assertEqual(bytes(InfinityPoint(self.coords)), b"\x00")
diff --git a/test/ec/test_regress.py b/test/ec/test_regress.py
index ef593fc..e02cc8e 100644
--- a/test/ec/test_regress.py
+++ b/test/ec/test_regress.py
@@ -10,7 +10,6 @@ from pyecsca.ec.point import Point
 
 
 class RegressionTests(TestCase):
-
     def test_issue_7(self):
         secp128r1 = get_params("secg", "secp128r1", "projective")
         base = secp128r1.generator
@@ -18,7 +17,9 @@ class RegressionTests(TestCase):
         add = coords.formulas["add-1998-cmo"]
         dbl = coords.formulas["dbl-1998-cmo"]
         scl = coords.formulas["z"]
-        mult = LTRMultiplier(add, dbl, scl, always=False, complete=False, short_circuit=True)
+        mult = LTRMultiplier(
+            add, dbl, scl, always=False, complete=False, short_circuit=True
+        )
         mult.init(secp128r1, base)
         pt = mult.multiply(13613624287328732)
         self.assertIsInstance(pt.coords["X"], Mod)
@@ -44,7 +45,9 @@ class RegressionTests(TestCase):
         coords = model.coordinates["xz"]
         p = 19
         neutral = Point(coords, X=Mod(1, p), Z=Mod(0, p))
-        curve = EllipticCurve(model, coords, p, neutral, {"a": Mod(8, p), "b": Mod(1, p)})
+        curve = EllipticCurve(
+            model, coords, p, neutral, {"a": Mod(8, p), "b": Mod(1, p)}
+        )
         base = Point(coords, X=Mod(12, p), Z=Mod(1, p))
         formula = coords.formulas["dbl-1987-m-2"]
         res = formula(p, base, **curve.parameters)[0]
@@ -60,13 +63,13 @@ class RegressionTests(TestCase):
         model = EdwardsModel()
         coords = model.coordinates["yz"]
         coords_sqr = model.coordinates["yzsquared"]
-        p = 0x1d
+        p = 0x1D
         c = Mod(1, p)
-        d = Mod(0x1c, p)
+        d = Mod(0x1C, p)
         r = d.sqrt()
         neutral = Point(coords, Y=c * r, Z=Mod(1, p))
         curve = EllipticCurve(model, coords, p, neutral, {"c": c, "d": d, "r": r})
         neutral_affine = Point(AffineCoordinateModel(model), x=Mod(0, p), y=c)
         self.assertEqual(neutral, neutral_affine.to_model(coords, curve))
-        neutral_sqr = Point(coords_sqr, Y=c**2 * r, Z=Mod(1, p))
+        neutral_sqr = Point(coords_sqr, Y=c ** 2 * r, Z=Mod(1, p))
         self.assertEqual(neutral_sqr, neutral_affine.to_model(coords_sqr, curve))
diff --git a/test/ec/test_signature.py b/test/ec/test_signature.py
index 8d4a439..f6ab302 100644
--- a/test/ec/test_signature.py
+++ b/test/ec/test_signature.py
@@ -5,29 +5,38 @@ from parameterized import parameterized
 from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.mult import LTRMultiplier
-from pyecsca.ec.signature import (Signature, SignatureResult, ECDSA_NONE, ECDSA_SHA1, ECDSA_SHA224,
-                                  ECDSA_SHA256, ECDSA_SHA384, ECDSA_SHA512)
+from pyecsca.ec.signature import (
+    Signature,
+    SignatureResult,
+    ECDSA_NONE,
+    ECDSA_SHA1,
+    ECDSA_SHA224,
+    ECDSA_SHA256,
+    ECDSA_SHA384,
+    ECDSA_SHA512,
+)
 
 
 class SignatureTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mult = LTRMultiplier(self.add, self.dbl)
-        self.msg = 0xcafebabe.to_bytes(4, byteorder="big")
-        self.priv = Mod(0xdeadbeef, self.secp128r1.order)
+        self.msg = 0xCAFEBABE .to_bytes(4, byteorder="big")
+        self.priv = Mod(0xDEADBEEF, self.secp128r1.order)
         self.mult.init(self.secp128r1, self.secp128r1.generator)
         self.pub = self.mult.multiply(self.priv.x)
 
-    @parameterized.expand([
-        ("SHA1", ECDSA_SHA1),
-        ("SHA224", ECDSA_SHA224),
-        ("SHA256", ECDSA_SHA256),
-        ("SHA384", ECDSA_SHA384),
-        ("SHA512", ECDSA_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("SHA1", ECDSA_SHA1),
+            ("SHA224", ECDSA_SHA224),
+            ("SHA256", ECDSA_SHA256),
+            ("SHA384", ECDSA_SHA384),
+            ("SHA512", ECDSA_SHA512),
+        ]
+    )
     def test_all(self, name, algo):
         signer = algo(self.mult, self.secp128r1, privkey=self.priv)
         self.assertTrue(signer.can_sign)
@@ -36,13 +45,17 @@ class SignatureTests(TestCase):
         self.assertTrue(verifier.can_verify)
         self.assertTrue(verifier.verify_data(sig, self.msg))
 
-        none = ECDSA_NONE(self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv)
+        none = ECDSA_NONE(
+            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
+        )
         digest = signer.hash_algo(self.msg).digest()
         sig = none.sign_hash(digest)
         self.assertTrue(none.verify_hash(sig, digest))
 
     def test_cannot(self):
-        ok = ECDSA_NONE(self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv)
+        ok = ECDSA_NONE(
+            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
+        )
         data = b"aaaa"
         sig = ok.sign_data(data)
 
@@ -60,23 +73,25 @@ class SignatureTests(TestCase):
         with self.assertRaises(ValueError):
             Signature(self.mult, self.secp128r1)
 
-    @parameterized.expand([
-        ("SHA1", ECDSA_SHA1),
-        ("SHA224", ECDSA_SHA224),
-        ("SHA256", ECDSA_SHA256),
-        ("SHA384", ECDSA_SHA384),
-        ("SHA512", ECDSA_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("SHA1", ECDSA_SHA1),
+            ("SHA224", ECDSA_SHA224),
+            ("SHA256", ECDSA_SHA256),
+            ("SHA384", ECDSA_SHA384),
+            ("SHA512", ECDSA_SHA512),
+        ]
+    )
     def test_fixed_nonce(self, name, algo):
         signer = algo(self.mult, self.secp128r1, privkey=self.priv)
-        sig_one = signer.sign_data(self.msg, nonce=0xabcdef)
-        sig_other = signer.sign_data(self.msg, nonce=0xabcdef)
+        sig_one = signer.sign_data(self.msg, nonce=0xABCDEF)
+        sig_other = signer.sign_data(self.msg, nonce=0xABCDEF)
         verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
         self.assertTrue(verifier.verify_data(sig_one, self.msg))
         self.assertTrue(verifier.verify_data(sig_other, self.msg))
         self.assertEqual(sig_one, sig_other)
 
     def test_der(self):
-        sig = SignatureResult(0xaaaaa, 0xbbbbb)
+        sig = SignatureResult(0xAAAAA, 0xBBBBB)
         self.assertEqual(sig, SignatureResult.from_DER(sig.to_DER()))
         self.assertNotEqual(sig, "abc")
diff --git a/test/ec/test_transformations.py b/test/ec/test_transformations.py
index 951fbb8..b15f868 100644
--- a/test/ec/test_transformations.py
+++ b/test/ec/test_transformations.py
@@ -5,7 +5,6 @@ from pyecsca.ec.transformations import M2SW, M2TE, TE2M, SW2M, SW2TE
 
 
 class TransformationTests(TestCase):
-
     def test_montgomery(self):
         curve25519 = get_params("other", "Curve25519", "affine")
         sw = M2SW(curve25519)
diff --git a/test/ec/utils.py b/test/ec/utils.py
index 6429ac9..84c568d 100644
--- a/test/ec/utils.py
+++ b/test/ec/utils.py
@@ -46,12 +46,21 @@ class Profiler(object):
             raise ValueError
         if self._output_directory is None or self._benchmark_name is None:
             return
-        git_commit = run(["git", "rev-parse", "--short", "HEAD"], stdout=PIPE, stderr=DEVNULL).stdout.strip().decode()
-        git_dirty = run(["git", "diff", "--quiet"], stdout=DEVNULL, stderr=DEVNULL).returncode != 0
+        git_commit = (
+            run(["git", "rev-parse", "--short", "HEAD"], stdout=PIPE, stderr=DEVNULL)
+            .stdout.strip()
+            .decode()
+        )
+        git_dirty = (
+            run(["git", "diff", "--quiet"], stdout=DEVNULL, stderr=DEVNULL).returncode
+            != 0
+        )
         version = git_commit + ("-dirty" if git_dirty else "")
         output_path = Path(self._output_directory) / (self._benchmark_name + ".csv")
         with output_path.open("a") as f:
-            f.write(f"{version},{'.'.join(map(str, sys.version_info[:3]))},{self.get_time()}\n")
+            f.write(
+                f"{version},{'.'.join(map(str, sys.version_info[:3]))},{self.get_time()}\n"
+            )
 
     def output(self):
         if self._state != "out":
diff --git a/test/sca/test_align.py b/test/sca/test_align.py
index 2630b24..607b297 100644
--- a/test/sca/test_align.py
+++ b/test/sca/test_align.py
@@ -1,28 +1,49 @@
 import numpy as np
-from pyecsca.sca import align_correlation, align_peaks, align_sad, align_dtw_scale,\
-    align_dtw, Trace, InspectorTraceSet
+from pyecsca.sca import (
+    align_correlation,
+    align_peaks,
+    align_sad,
+    align_dtw_scale,
+    align_dtw,
+    Trace,
+    InspectorTraceSet,
+)
 from .utils import Plottable, slow
 
 
 class AlignTests(Plottable):
-
     def test_align(self):
-        first_arr = np.array([10, 64, 120, 64, 10, 10, 10, 10, 10], dtype=np.dtype("i1"))
+        first_arr = np.array(
+            [10, 64, 120, 64, 10, 10, 10, 10, 10], dtype=np.dtype("i1")
+        )
         second_arr = np.array([10, 10, 10, 10, 50, 80, 50, 20], dtype=np.dtype("i1"))
         third_arr = np.array([70, 30, 42, 35, 28, 21, 15, 10, 5], dtype=np.dtype("i1"))
         a = Trace(first_arr)
         b = Trace(second_arr)
         c = Trace(third_arr)
-        result, offsets = align_correlation(a, b, c, reference_offset=1, reference_length=3, max_offset=4, min_correlation=0.65)
+        result, offsets = align_correlation(
+            a,
+            b,
+            c,
+            reference_offset=1,
+            reference_length=3,
+            max_offset=4,
+            min_correlation=0.65,
+        )
         self.assertIsNotNone(result)
         self.assertEqual(len(result), 2)
         np.testing.assert_equal(result[0].samples, first_arr)
-        np.testing.assert_equal(result[1].samples, np.array([10, 50, 80, 50, 20, 0, 0, 0], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result[1].samples,
+            np.array([10, 50, 80, 50, 20, 0, 0, 0], dtype=np.dtype("i1")),
+        )
 
     @slow
     def test_large_align(self):
         example = InspectorTraceSet.read("test/data/example.trs")
-        result, offsets = align_correlation(*example, reference_offset=100000, reference_length=20000, max_offset=15000)
+        result, offsets = align_correlation(
+            *example, reference_offset=100000, reference_length=20000, max_offset=15000
+        )
         self.assertIsNotNone(result)
 
     @slow
@@ -32,25 +53,46 @@ class AlignTests(Plottable):
         self.assertIsNotNone(result)
 
     def test_peak_align(self):
-        first_arr = np.array([10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10], dtype=np.dtype("i1"))
-        second_arr = np.array([10, 10, 10, 10, 90, 40, 50, 20, 10, 17, 16, 10], dtype=np.dtype("i1"))
+        first_arr = np.array(
+            [10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10], dtype=np.dtype("i1")
+        )
+        second_arr = np.array(
+            [10, 10, 10, 10, 90, 40, 50, 20, 10, 17, 16, 10], dtype=np.dtype("i1")
+        )
         a = Trace(first_arr)
         b = Trace(second_arr)
-        result, offsets = align_peaks(a, b, reference_offset=2, reference_length=5, max_offset=3)
+        result, offsets = align_peaks(
+            a, b, reference_offset=2, reference_length=5, max_offset=3
+        )
         self.assertEqual(np.argmax(result[0].samples), np.argmax(result[1].samples))
 
     def test_sad_align(self):
-        first_arr = np.array([10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10], dtype=np.dtype("i1"))
-        second_arr = np.array([10, 10, 90, 40, 50, 20, 10, 17, 16, 10, 10], dtype=np.dtype("i1"))
+        first_arr = np.array(
+            [10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10], dtype=np.dtype("i1")
+        )
+        second_arr = np.array(
+            [10, 10, 90, 40, 50, 20, 10, 17, 16, 10, 10], dtype=np.dtype("i1")
+        )
         a = Trace(first_arr)
         b = Trace(second_arr)
-        result, offsets = align_sad(a, b, reference_offset=2, reference_length=5, max_offset=3)
+        result, offsets = align_sad(
+            a, b, reference_offset=2, reference_length=5, max_offset=3
+        )
         self.assertEqual(len(result), 2)
 
     def test_dtw_align_scale(self):
-        first_arr = np.array([10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10, 8, 10, 12, 10, 13, 9], dtype=np.dtype("f2"))
-        second_arr = np.array([10, 10, 60, 40, 90, 20, 10, 17, 16, 10, 10, 10, 10, 10, 17, 12, 10], dtype=np.dtype("f2"))
-        third_arr = np.array([10, 30, 20, 21, 15, 8, 10, 37, 21, 77, 20, 28, 25, 10, 9, 10, 15, 9, 10], dtype=np.dtype("f2"))
+        first_arr = np.array(
+            [10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10, 8, 10, 12, 10, 13, 9],
+            dtype=np.dtype("f2"),
+        )
+        second_arr = np.array(
+            [10, 10, 60, 40, 90, 20, 10, 17, 16, 10, 10, 10, 10, 10, 17, 12, 10],
+            dtype=np.dtype("f2"),
+        )
+        third_arr = np.array(
+            [10, 30, 20, 21, 15, 8, 10, 37, 21, 77, 20, 28, 25, 10, 9, 10, 15, 9, 10],
+            dtype=np.dtype("f2"),
+        )
         a = Trace(first_arr)
         b = Trace(second_arr)
         c = Trace(third_arr)
@@ -62,14 +104,27 @@ class AlignTests(Plottable):
 
         result_other = align_dtw_scale(a, b, c, fast=False)
 
-        self.assertEqual(np.argmax(result_other[0].samples), np.argmax(result_other[1].samples))
-        self.assertEqual(np.argmax(result_other[1].samples), np.argmax(result_other[2].samples))
+        self.assertEqual(
+            np.argmax(result_other[0].samples), np.argmax(result_other[1].samples)
+        )
+        self.assertEqual(
+            np.argmax(result_other[1].samples), np.argmax(result_other[2].samples)
+        )
         self.plot(*result_other)
 
     def test_dtw_align(self):
-        first_arr = np.array([10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10, 8, 10, 12, 10, 13, 9], dtype=np.dtype("i1"))
-        second_arr = np.array([10, 10, 60, 40, 90, 20, 10, 17, 16, 10, 10, 10, 10, 10, 17, 12, 10], dtype=np.dtype("i1"))
-        third_arr = np.array([10, 30, 20, 21, 15, 8, 10, 47, 21, 77, 20, 28, 25, 10, 9, 10, 15, 9, 10], dtype=np.dtype("i1"))
+        first_arr = np.array(
+            [10, 64, 14, 120, 15, 30, 10, 15, 20, 15, 15, 10, 10, 8, 10, 12, 10, 13, 9],
+            dtype=np.dtype("i1"),
+        )
+        second_arr = np.array(
+            [10, 10, 60, 40, 90, 20, 10, 17, 16, 10, 10, 10, 10, 10, 17, 12, 10],
+            dtype=np.dtype("i1"),
+        )
+        third_arr = np.array(
+            [10, 30, 20, 21, 15, 8, 10, 47, 21, 77, 20, 28, 25, 10, 9, 10, 15, 9, 10],
+            dtype=np.dtype("i1"),
+        )
         a = Trace(first_arr)
         b = Trace(second_arr)
         c = Trace(third_arr)
@@ -81,6 +136,10 @@ class AlignTests(Plottable):
 
         result_other = align_dtw(a, b, c, fast=False)
 
-        self.assertEqual(np.argmax(result_other[0].samples), np.argmax(result_other[1].samples))
-        self.assertEqual(np.argmax(result_other[1].samples), np.argmax(result_other[2].samples))
+        self.assertEqual(
+            np.argmax(result_other[0].samples), np.argmax(result_other[1].samples)
+        )
+        self.assertEqual(
+            np.argmax(result_other[1].samples), np.argmax(result_other[2].samples)
+        )
         self.plot(*result_other)
diff --git a/test/sca/test_combine.py b/test/sca/test_combine.py
index 51f7f02..953b4bf 100644
--- a/test/sca/test_combine.py
+++ b/test/sca/test_combine.py
@@ -1,11 +1,20 @@
 from unittest import TestCase
 
 import numpy as np
-from pyecsca.sca import Trace, CombinedTrace, average, conditional_average, standard_deviation, variance, average_and_variance, add, subtract
+from pyecsca.sca import (
+    Trace,
+    CombinedTrace,
+    average,
+    conditional_average,
+    standard_deviation,
+    variance,
+    average_and_variance,
+    add,
+    subtract,
+)
 
 
 class CombineTests(TestCase):
-
     def setUp(self):
         self.a = Trace(np.array([20, 80], dtype=np.dtype("i1")), {"data": b"\xff"})
         self.b = Trace(np.array([30, 42], dtype=np.dtype("i1")), {"data": b"\xff"})
@@ -21,8 +30,12 @@ class CombineTests(TestCase):
         self.assertEqual(result.samples[1], 61)
 
     def test_conditional_average(self):
-        result = conditional_average(self.a, self.b, self.c,
-                                     condition=lambda trace: trace.meta["data"] == b"\xff")
+        result = conditional_average(
+            self.a,
+            self.b,
+            self.c,
+            condition=lambda trace: trace.meta["data"] == b"\xff",
+        )
         self.assertIsInstance(result, CombinedTrace)
         self.assertEqual(len(result.samples), 2)
         self.assertEqual(result.samples[0], 25)
diff --git a/test/sca/test_edit.py b/test/sca/test_edit.py
index f701d83..282e62e 100644
--- a/test/sca/test_edit.py
+++ b/test/sca/test_edit.py
@@ -6,18 +6,21 @@ from pyecsca.sca import Trace, trim, reverse, pad
 
 
 class EditTests(TestCase):
-
     def setUp(self):
         self._trace = Trace(np.array([10, 20, 30, 40, 50], dtype=np.dtype("i1")))
 
     def test_trim(self):
         result = trim(self._trace, 2)
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples, np.array([30, 40, 50], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result.samples, np.array([30, 40, 50], dtype=np.dtype("i1"))
+        )
 
         result = trim(self._trace, end=3)
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples, np.array([10, 20, 30], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result.samples, np.array([10, 20, 30], dtype=np.dtype("i1"))
+        )
 
         with self.assertRaises(ValueError):
             trim(self._trace, 5, 1)
@@ -25,16 +28,21 @@ class EditTests(TestCase):
     def test_reverse(self):
         result = reverse(self._trace)
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples,
-                                np.array([50, 40, 30, 20, 10], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result.samples, np.array([50, 40, 30, 20, 10], dtype=np.dtype("i1"))
+        )
 
     def test_pad(self):
         result = pad(self._trace, 2)
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples,
-                                np.array([0, 0, 10, 20, 30, 40, 50, 0, 0], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result.samples,
+            np.array([0, 0, 10, 20, 30, 40, 50, 0, 0], dtype=np.dtype("i1")),
+        )
 
         result = pad(self._trace, (1, 3))
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples,
-                                np.array([0, 10, 20, 30, 40, 50, 0, 0, 0], dtype=np.dtype("i1")))
+        np.testing.assert_equal(
+            result.samples,
+            np.array([0, 10, 20, 30, 40, 50, 0, 0, 0], dtype=np.dtype("i1")),
+        )
diff --git a/test/sca/test_filter.py b/test/sca/test_filter.py
index 1c9e9ca..9d63ea3 100644
--- a/test/sca/test_filter.py
+++ b/test/sca/test_filter.py
@@ -1,16 +1,25 @@
 from unittest import TestCase
 
 import numpy as np
-from pyecsca.sca import Trace, filter_lowpass, filter_highpass, filter_bandpass, filter_bandstop
+from pyecsca.sca import (
+    Trace,
+    filter_lowpass,
+    filter_highpass,
+    filter_bandpass,
+    filter_bandstop,
+)
 from .utils import Plottable
 
 
 class FilterTests(Plottable):
-
     def setUp(self):
         self._trace = Trace(
-            np.array([5, 12, 15, 13, 15, 11, 7, 2, -4, -8, -10, -8, -13, -9, -11, -8, -5],
-                     dtype=np.dtype("i1")), None)
+            np.array(
+                [5, 12, 15, 13, 15, 11, 7, 2, -4, -8, -10, -8, -13, -9, -11, -8, -5],
+                dtype=np.dtype("i1"),
+            ),
+            None,
+        )
 
     def test_lowpass(self):
         result = filter_lowpass(self._trace, 100, 20)
diff --git a/test/sca/test_match.py b/test/sca/test_match.py
index cd0b780..9ba81a3 100644
--- a/test/sca/test_match.py
+++ b/test/sca/test_match.py
@@ -7,22 +7,68 @@ from .utils import Plottable
 
 
 class MatchingTests(Plottable):
-
     def test_simple_match(self):
-        pattern = Trace(np.array([1, 15, 12, -10, 0, 13, 17, -1, 0], dtype=np.dtype("i1")), None)
-        base = Trace(np.array(
+        pattern = Trace(
+            np.array([1, 15, 12, -10, 0, 13, 17, -1, 0], dtype=np.dtype("i1")), None
+        )
+        base = Trace(
+            np.array(
                 [0, 1, 3, 1, 2, -2, -3, 1, 15, 12, -10, 0, 13, 17, -1, 0, 3, 1],
-                dtype=np.dtype("i1")), None)
+                dtype=np.dtype("i1"),
+            ),
+            None,
+        )
         filtered = match_part(base, 7, 9)
         self.assertListEqual(filtered, [7])
         self.plot(base=base, pattern=pad(pattern, (filtered[0], 0)))
 
     def test_multiple_match(self):
-        pattern = Trace(np.array([1, 15, 12, -10, 0, 13, 17, -1, 0], dtype=np.dtype("i1")), None)
-        base = Trace(np.array(
-                [0, 1, 3, 1, 2, -2, -3, 1, 18, 10, -5, 0, 13, 17, -1, 0, 3, 1, 2, 5, 13, 8, -8, 1,
-                 11, 15, 0, 1, 5, 2, 4],
-                dtype=np.dtype("i1")), None)
+        pattern = Trace(
+            np.array([1, 15, 12, -10, 0, 13, 17, -1, 0], dtype=np.dtype("i1")), None
+        )
+        base = Trace(
+            np.array(
+                [
+                    0,
+                    1,
+                    3,
+                    1,
+                    2,
+                    -2,
+                    -3,
+                    1,
+                    18,
+                    10,
+                    -5,
+                    0,
+                    13,
+                    17,
+                    -1,
+                    0,
+                    3,
+                    1,
+                    2,
+                    5,
+                    13,
+                    8,
+                    -8,
+                    1,
+                    11,
+                    15,
+                    0,
+                    1,
+                    5,
+                    2,
+                    4,
+                ],
+                dtype=np.dtype("i1"),
+            ),
+            None,
+        )
         filtered = match_pattern(base, pattern, 0.9)
         self.assertListEqual(filtered, [7, 19])
-        self.plot(base=base, pattern1=pad(pattern, (filtered[0], 0)), pattern2=pad(pattern, (filtered[1], 0)))
+        self.plot(
+            base=base,
+            pattern1=pad(pattern, (filtered[0], 0)),
+            pattern2=pad(pattern, (filtered[1], 0)),
+        )
diff --git a/test/sca/test_plot.py b/test/sca/test_plot.py
index 2cd6b11..7d2cec0 100644
--- a/test/sca/test_plot.py
+++ b/test/sca/test_plot.py
@@ -4,13 +4,17 @@ import numpy as np
 import holoviews as hv
 import matplotlib as mpl
 from pyecsca.sca.trace import Trace
-from pyecsca.sca.trace.plot import (plot_trace, save_figure, save_figure_png, save_figure_svg,
-                                    plot_traces)
+from pyecsca.sca.trace.plot import (
+    plot_trace,
+    save_figure,
+    save_figure_png,
+    save_figure_svg,
+    plot_traces,
+)
 from .utils import Plottable
 
 
 class PlotTests(Plottable):
-
     def setUp(self) -> None:
         self.trace1 = Trace(np.array([6, 7, 3, -2, 5, 1], dtype=np.dtype("i1")))
         self.trace2 = Trace(np.array([2, 3, 7, 0, -1, 0], dtype=np.dtype("i1")))
diff --git a/test/sca/test_process.py b/test/sca/test_process.py
index 4525d01..fda8575 100644
--- a/test/sca/test_process.py
+++ b/test/sca/test_process.py
@@ -1,11 +1,20 @@
 from unittest import TestCase
 
 import numpy as np
-from pyecsca.sca import Trace, absolute, invert, threshold, rolling_mean, offset, recenter, normalize, normalize_wl
+from pyecsca.sca import (
+    Trace,
+    absolute,
+    invert,
+    threshold,
+    rolling_mean,
+    offset,
+    recenter,
+    normalize,
+    normalize_wl,
+)
 
 
 class ProcessTests(TestCase):
-
     def setUp(self):
         self._trace = Trace(np.array([30, -60, 145, 247], dtype=np.dtype("i2")), None)
 
@@ -36,7 +45,9 @@ class ProcessTests(TestCase):
     def test_offset(self):
         result = offset(self._trace, 5)
         self.assertIsNotNone(result)
-        np.testing.assert_equal(result.samples, np.array([35, -55, 150, 252], dtype=np.dtype("i2")))
+        np.testing.assert_equal(
+            result.samples, np.array([35, -55, 150, 252], dtype=np.dtype("i2"))
+        )
 
     def test_recenter(self):
         self.assertIsNotNone(recenter(self._trace))
diff --git a/test/sca/test_rpa.py b/test/sca/test_rpa.py
index 0c96e86..ac8392e 100644
--- a/test/sca/test_rpa.py
+++ b/test/sca/test_rpa.py
@@ -3,14 +3,18 @@ from unittest import TestCase
 from parameterized import parameterized
 
 from pyecsca.ec.context import local
-from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, \
-    DifferentialLadderMultiplier
+from pyecsca.ec.mult import (
+    LTRMultiplier,
+    BinaryNAFMultiplier,
+    WindowNAFMultiplier,
+    LadderMultiplier,
+    DifferentialLadderMultiplier,
+)
 from pyecsca.ec.params import get_params
 from pyecsca.sca.re.rpa import MultipleContext
 
 
 class MultipleContextTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.base = self.secp128r1.generator
@@ -20,14 +24,26 @@ class MultipleContextTests(TestCase):
         self.neg = self.coords.formulas["neg"]
         self.scale = self.coords.formulas["z"]
 
-    @parameterized.expand([
-        ("10", 10),
-        ("2355498743", 2355498743),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746),
-        ("13613624287328732", 13613624287328732)
-    ])
+    @parameterized.expand(
+        [
+            ("10", 10),
+            ("2355498743", 2355498743),
+            (
+                "325385790209017329644351321912443757746",
+                325385790209017329644351321912443757746,
+            ),
+            ("13613624287328732", 13613624287328732),
+        ]
+    )
     def test_basic(self, name, scalar):
-        mult = LTRMultiplier(self.add, self.dbl, self.scale, always=False, complete=False, short_circuit=True)
+        mult = LTRMultiplier(
+            self.add,
+            self.dbl,
+            self.scale,
+            always=False,
+            complete=False,
+            short_circuit=True,
+        )
         with local(MultipleContext()) as ctx:
             mult.init(self.secp128r1, self.base)
             mult.multiply(scalar)
diff --git a/test/sca/test_sampling.py b/test/sca/test_sampling.py
index 6108c17..4a54b4d 100644
--- a/test/sca/test_sampling.py
+++ b/test/sca/test_sampling.py
@@ -1,12 +1,18 @@
 from unittest import TestCase
 
 import numpy as np
-from pyecsca.sca import Trace, downsample_average, downsample_pick, downsample_decimate, downsample_max, downsample_min
+from pyecsca.sca import (
+    Trace,
+    downsample_average,
+    downsample_pick,
+    downsample_decimate,
+    downsample_max,
+    downsample_min,
+)
 from .utils import Plottable
 
 
 class SamplingTests(Plottable):
-
     def setUp(self):
         self._trace = Trace(np.array([20, 40, 50, 50, 10], dtype=np.dtype("i1")))
 
@@ -27,29 +33,136 @@ class SamplingTests(Plottable):
         self.assertEqual(result.samples[1], 50)
 
     def test_downsample_max(self):
-        trace = Trace(np.array([20, 30, 55, 18, 15, 10, 35, 24, 21, 15, 10, 8, -10, -5,
-                                -8, -12, -15, -18, -34, -21, -17, -10, -5, -12, -6, -2,
-                                4, 8, 21, 28], dtype=np.dtype("i1")))
+        trace = Trace(
+            np.array(
+                [
+                    20,
+                    30,
+                    55,
+                    18,
+                    15,
+                    10,
+                    35,
+                    24,
+                    21,
+                    15,
+                    10,
+                    8,
+                    -10,
+                    -5,
+                    -8,
+                    -12,
+                    -15,
+                    -18,
+                    -34,
+                    -21,
+                    -17,
+                    -10,
+                    -5,
+                    -12,
+                    -6,
+                    -2,
+                    4,
+                    8,
+                    21,
+                    28,
+                ],
+                dtype=np.dtype("i1"),
+            )
+        )
         result = downsample_max(trace, 2)
         self.assertIsNotNone(result)
         self.assertIsInstance(result, Trace)
         self.assertEqual(len(result.samples), 15)
-        self.assertEqual(list(result), [30, 55, 15, 35, 21, 10, -5, -8, -15, -21, -10, -5, -2, 8, 28])
+        self.assertEqual(
+            list(result), [30, 55, 15, 35, 21, 10, -5, -8, -15, -21, -10, -5, -2, 8, 28]
+        )
 
     def test_downsample_min(self):
-        trace = Trace(np.array([20, 30, 55, 18, 15, 10, 35, 24, 21, 15, 10, 8, -10, -5,
-                                -8, -12, -15, -18, -34, -21, -17, -10, -5, -12, -6, -2,
-                                4, 8, 21, 28], dtype=np.dtype("i1")))
+        trace = Trace(
+            np.array(
+                [
+                    20,
+                    30,
+                    55,
+                    18,
+                    15,
+                    10,
+                    35,
+                    24,
+                    21,
+                    15,
+                    10,
+                    8,
+                    -10,
+                    -5,
+                    -8,
+                    -12,
+                    -15,
+                    -18,
+                    -34,
+                    -21,
+                    -17,
+                    -10,
+                    -5,
+                    -12,
+                    -6,
+                    -2,
+                    4,
+                    8,
+                    21,
+                    28,
+                ],
+                dtype=np.dtype("i1"),
+            )
+        )
         result = downsample_min(trace, 2)
         self.assertIsNotNone(result)
         self.assertIsInstance(result, Trace)
         self.assertEqual(len(result.samples), 15)
-        self.assertEqual(list(result), [20, 18, 10, 24, 15, 8, -10, -12, -18, -34, -17, -12, -6, 4, 21])
+        self.assertEqual(
+            list(result),
+            [20, 18, 10, 24, 15, 8, -10, -12, -18, -34, -17, -12, -6, 4, 21],
+        )
 
     def test_downsample_decimate(self):
-        trace = Trace(np.array([20, 30, 55, 18, 15, 10, 35, 24, 21, 15, 10, 8, -10, -5,
-                                -8, -12, -15, -18, -34, -21, -17, -10, -5, -12, -6, -2,
-                                4, 8, 21, 28], dtype=np.dtype("i1")))
+        trace = Trace(
+            np.array(
+                [
+                    20,
+                    30,
+                    55,
+                    18,
+                    15,
+                    10,
+                    35,
+                    24,
+                    21,
+                    15,
+                    10,
+                    8,
+                    -10,
+                    -5,
+                    -8,
+                    -12,
+                    -15,
+                    -18,
+                    -34,
+                    -21,
+                    -17,
+                    -10,
+                    -5,
+                    -12,
+                    -6,
+                    -2,
+                    4,
+                    8,
+                    21,
+                    28,
+                ],
+                dtype=np.dtype("i1"),
+            )
+        )
         result = downsample_decimate(trace, 2)
         self.assertIsNotNone(result)
         self.assertIsInstance(result, Trace)
diff --git a/test/sca/test_target.py b/test/sca/test_target.py
index a0f4fec..4168152 100644
--- a/test/sca/test_target.py
+++ b/test/sca/test_target.py
@@ -12,10 +12,24 @@ from pyecsca.ec.mult import LTRMultiplier
 from pyecsca.ec.params import DomainParameters, get_params
 from pyecsca.ec.point import Point
 from pyecsca.ec.signature import SignatureResult, ECDSA_SHA1
-from pyecsca.sca.target import BinaryTarget, SimpleSerialTarget, SimpleSerialMessage, has_pyscard
-from pyecsca.sca.target.ectester import (KeyAgreementEnum, SignatureEnum, KeypairEnum, KeyBuildEnum,
-                                         KeyClassEnum, CurveEnum, ParameterEnum, RunModeEnum,
-                                         KeyEnum, TransformationEnum)
+from pyecsca.sca.target import (
+    BinaryTarget,
+    SimpleSerialTarget,
+    SimpleSerialMessage,
+    has_pyscard,
+)
+from pyecsca.sca.target.ectester import (
+    KeyAgreementEnum,
+    SignatureEnum,
+    KeypairEnum,
+    KeyBuildEnum,
+    KeyClassEnum,
+    CurveEnum,
+    ParameterEnum,
+    RunModeEnum,
+    KeyEnum,
+    TransformationEnum,
+)
 
 if has_pyscard:
     from pyecsca.sca.target.ectester import ECTesterTarget
@@ -28,7 +42,6 @@ class TestTarget(SimpleSerialTarget, BinaryTarget):
 
 
 class BinaryTargetTests(TestCase):
-
     def test_basic_target(self):
         target_path = join(dirname(realpath(__file__)), "..", "data", "target.py")
         target = TestTarget(["python", target_path])
@@ -67,6 +80,7 @@ class ECTesterTargetTests(TestCase):
         if not has_pyscard:
             return
         from smartcard.System import readers
+
         try:
             rs = readers()
         except BaseSCardException:
@@ -95,35 +109,64 @@ class ECTesterTargetTests(TestCase):
         self.assertTrue(ka_resp.success)
         sig_resp = self.target.allocate_sig(SignatureEnum.ALG_ECDSA_SHA)
         self.assertTrue(sig_resp.success)
-        key_resp = self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                                        KeyClassEnum.ALG_EC_FP)
+        key_resp = self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
         self.assertTrue(key_resp.success)
 
     def test_set(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        set_resp = self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1,
-                                   ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        set_resp = self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.assertTrue(set_resp.success)
 
     def test_set_explicit(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        values = ECTesterTarget.encode_parameters(ParameterEnum.DOMAIN_FP, self.secp256r1)
-        set_resp = self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.external,
-                                   ParameterEnum.DOMAIN_FP, values)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        values = ECTesterTarget.encode_parameters(
+            ParameterEnum.DOMAIN_FP, self.secp256r1
+        )
+        set_resp = self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL,
+            CurveEnum.external,
+            ParameterEnum.DOMAIN_FP,
+            values,
+        )
         self.assertTrue(set_resp.success)
 
     def test_generate(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         generate_resp = self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
         self.assertTrue(generate_resp.success)
 
     def test_clear(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
         clear_resp = self.target.clear(KeypairEnum.KEYPAIR_LOCAL)
         self.assertTrue(clear_resp.success)
 
@@ -138,184 +181,312 @@ class ECTesterTargetTests(TestCase):
     def test_dry_run(self):
         dry_run_resp = self.target.run_mode(RunModeEnum.MODE_DRY_RUN)
         self.assertTrue(dry_run_resp.success)
-        allocate_resp = self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR,
-                                             256,
-                                             KeyClassEnum.ALG_EC_FP)
+        allocate_resp = self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
         self.assertTrue(allocate_resp.success)
         dry_run_resp = self.target.run_mode(RunModeEnum.MODE_NORMAL)
         self.assertTrue(dry_run_resp.success)
 
     def test_export(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
-        export_public_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC,
-                                                ParameterEnum.W)
+        export_public_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC, ParameterEnum.W
+        )
         self.assertTrue(export_public_resp.success)
-        pubkey_bytes = export_public_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W)
+        pubkey_bytes = export_public_resp.get_param(
+            KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W
+        )
         pubkey = self.secp256r1.curve.decode_point(pubkey_bytes)
-        export_privkey_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE,
-                                                 ParameterEnum.S)
+        export_privkey_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE, ParameterEnum.S
+        )
         self.assertTrue(export_privkey_resp.success)
         privkey = int.from_bytes(
-                export_privkey_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S), "big")
-        self.assertEqual(pubkey,
-                         self.secp256r1.curve.affine_multiply(self.secp256r1.generator, privkey))
+            export_privkey_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S),
+            "big",
+        )
+        self.assertEqual(
+            pubkey,
+            self.secp256r1.curve.affine_multiply(self.secp256r1.generator, privkey),
+        )
 
     def test_export_curve(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
-        export_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC,
-                                         ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
+        export_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC, ParameterEnum.DOMAIN_FP
+        )
         self.assertTrue(export_resp.success)
 
     def test_transform(self):
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
-        export_privkey_resp1 = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE,
-                                                  ParameterEnum.S)
+        export_privkey_resp1 = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE, ParameterEnum.S
+        )
         privkey = int.from_bytes(
-                export_privkey_resp1.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S), "big")
-        transform_resp = self.target.transform(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE,
-                                               ParameterEnum.S, TransformationEnum.INCREMENT)
+            export_privkey_resp1.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S),
+            "big",
+        )
+        transform_resp = self.target.transform(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyEnum.PRIVATE,
+            ParameterEnum.S,
+            TransformationEnum.INCREMENT,
+        )
         self.assertTrue(transform_resp.success)
-        export_privkey_resp2 = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE,
-                                                  ParameterEnum.S)
+        export_privkey_resp2 = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE, ParameterEnum.S
+        )
         privkey_new = int.from_bytes(
-                export_privkey_resp2.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S), "big")
+            export_privkey_resp2.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S),
+            "big",
+        )
         self.assertEqual(privkey + 1, privkey_new)
 
     def test_ecdh(self):
         self.target.allocate_ka(KeyAgreementEnum.ALG_EC_SVDP_DH)
-        self.target.allocate(KeypairEnum.KEYPAIR_BOTH, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_BOTH, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_BOTH,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_BOTH, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_BOTH)
-        ecdh_resp = self.target.ecdh(KeypairEnum.KEYPAIR_LOCAL, KeypairEnum.KEYPAIR_REMOTE, True,
-                                     TransformationEnum.NONE, KeyAgreementEnum.ALG_EC_SVDP_DH)
+        ecdh_resp = self.target.ecdh(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeypairEnum.KEYPAIR_REMOTE,
+            True,
+            TransformationEnum.NONE,
+            KeyAgreementEnum.ALG_EC_SVDP_DH,
+        )
         self.assertTrue(ecdh_resp.success)
-        export_public_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC,
-                                                ParameterEnum.W)
-        pubkey_bytes = export_public_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W)
+        export_public_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC, ParameterEnum.W
+        )
+        pubkey_bytes = export_public_resp.get_param(
+            KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W
+        )
         pubkey = self.secp256r1.curve.decode_point(pubkey_bytes)
-        export_privkey_resp = self.target.export(KeypairEnum.KEYPAIR_REMOTE, KeyEnum.PRIVATE,
-                                                 ParameterEnum.S)
-        privkey = Mod(int.from_bytes(
-                export_privkey_resp.get_param(KeypairEnum.KEYPAIR_REMOTE, ParameterEnum.S), "big"),
-                self.secp256r1.curve.prime)
-        pubkey_projective = pubkey.to_model(self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve)
+        export_privkey_resp = self.target.export(
+            KeypairEnum.KEYPAIR_REMOTE, KeyEnum.PRIVATE, ParameterEnum.S
+        )
+        privkey = Mod(
+            int.from_bytes(
+                export_privkey_resp.get_param(
+                    KeypairEnum.KEYPAIR_REMOTE, ParameterEnum.S
+                ),
+                "big",
+            ),
+            self.secp256r1.curve.prime,
+        )
+        pubkey_projective = pubkey.to_model(
+            self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve
+        )
 
         mult = LTRMultiplier(
-                self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
-                self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"])
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"],
+        )
         ecdh = ECDH_SHA1(mult, self.secp256r1_projective, pubkey_projective, privkey)
         expected = ecdh.perform()
         self.assertEqual(ecdh_resp.secret, expected)
 
     def test_ecdh_raw(self):
         self.target.allocate_ka(KeyAgreementEnum.ALG_EC_SVDP_DH)
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
         mult = LTRMultiplier(
-                self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
-                self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"])
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"],
+        )
         keygen = KeyGeneration(copy(mult), self.secp256r1_projective)
         priv, pubkey_projective = keygen.generate()
 
-        ecdh_resp = self.target.ecdh_direct(KeypairEnum.KEYPAIR_LOCAL, True,
-                                            TransformationEnum.NONE,
-                                            KeyAgreementEnum.ALG_EC_SVDP_DH,
-                                            bytes(pubkey_projective.to_affine()))
+        ecdh_resp = self.target.ecdh_direct(
+            KeypairEnum.KEYPAIR_LOCAL,
+            True,
+            TransformationEnum.NONE,
+            KeyAgreementEnum.ALG_EC_SVDP_DH,
+            bytes(pubkey_projective.to_affine()),
+        )
         self.assertTrue(ecdh_resp.success)
-        export_privkey_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE,
-                                                 ParameterEnum.S)
-        privkey = Mod(int.from_bytes(
-                export_privkey_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S), "big"),
-                self.secp256r1.curve.prime)
+        export_privkey_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PRIVATE, ParameterEnum.S
+        )
+        privkey = Mod(
+            int.from_bytes(
+                export_privkey_resp.get_param(
+                    KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.S
+                ),
+                "big",
+            ),
+            self.secp256r1.curve.prime,
+        )
 
-        ecdh = ECDH_SHA1(copy(mult), self.secp256r1_projective, pubkey_projective, privkey)
+        ecdh = ECDH_SHA1(
+            copy(mult), self.secp256r1_projective, pubkey_projective, privkey
+        )
         expected = ecdh.perform()
         self.assertEqual(ecdh_resp.secret, expected)
 
     def test_ecdsa(self):
         self.target.allocate_sig(SignatureEnum.ALG_ECDSA_SHA)
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
         data = "Some text over here.".encode()
-        ecdsa_resp = self.target.ecdsa(KeypairEnum.KEYPAIR_LOCAL, True, SignatureEnum.ALG_ECDSA_SHA,
-                                       data)
+        ecdsa_resp = self.target.ecdsa(
+            KeypairEnum.KEYPAIR_LOCAL, True, SignatureEnum.ALG_ECDSA_SHA, data
+        )
         self.assertTrue(ecdsa_resp.success)
-        export_public_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC,
-                                                ParameterEnum.W)
-        pubkey_bytes = export_public_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W)
+        export_public_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC, ParameterEnum.W
+        )
+        pubkey_bytes = export_public_resp.get_param(
+            KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W
+        )
         pubkey = self.secp256r1.curve.decode_point(pubkey_bytes)
-        pubkey_projective = pubkey.to_model(self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve)
+        pubkey_projective = pubkey.to_model(
+            self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve
+        )
 
         sig = SignatureResult.from_DER(ecdsa_resp.signature)
         mult = LTRMultiplier(
-                self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
-                self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"])
-        ecdsa = ECDSA_SHA1(copy(mult), self.secp256r1_projective,
-                           self.secp256r1_projective.curve.coordinate_model.formulas[
-                               "add-2016-rcb"],
-                           pubkey_projective)
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"],
+        )
+        ecdsa = ECDSA_SHA1(
+            copy(mult),
+            self.secp256r1_projective,
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            pubkey_projective,
+        )
         self.assertTrue(ecdsa.verify_data(sig, data))
 
     def test_ecdsa_sign(self):
         self.target.allocate_sig(SignatureEnum.ALG_ECDSA_SHA)
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         self.target.generate(KeypairEnum.KEYPAIR_LOCAL)
         data = "Some text over here.".encode()
-        ecdsa_resp = self.target.ecdsa_sign(KeypairEnum.KEYPAIR_LOCAL, True,
-                                            SignatureEnum.ALG_ECDSA_SHA, data)
+        ecdsa_resp = self.target.ecdsa_sign(
+            KeypairEnum.KEYPAIR_LOCAL, True, SignatureEnum.ALG_ECDSA_SHA, data
+        )
         self.assertTrue(ecdsa_resp.success)
-        export_public_resp = self.target.export(KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC,
-                                                ParameterEnum.W)
-        pubkey_bytes = export_public_resp.get_param(KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W)
+        export_public_resp = self.target.export(
+            KeypairEnum.KEYPAIR_LOCAL, KeyEnum.PUBLIC, ParameterEnum.W
+        )
+        pubkey_bytes = export_public_resp.get_param(
+            KeypairEnum.KEYPAIR_LOCAL, ParameterEnum.W
+        )
         pubkey = self.secp256r1.curve.decode_point(pubkey_bytes)
-        pubkey_projective = pubkey.to_model(self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve)
+        pubkey_projective = pubkey.to_model(
+            self.secp256r1_projective.curve.coordinate_model, self.secp256r1.curve
+        )
 
         sig = SignatureResult.from_DER(ecdsa_resp.signature)
         mult = LTRMultiplier(
-                self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
-                self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"])
-        ecdsa = ECDSA_SHA1(copy(mult), self.secp256r1_projective,
-                           self.secp256r1_projective.curve.coordinate_model.formulas[
-                               "add-2016-rcb"],
-                           pubkey_projective)
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"],
+        )
+        ecdsa = ECDSA_SHA1(
+            copy(mult),
+            self.secp256r1_projective,
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            pubkey_projective,
+        )
         self.assertTrue(ecdsa.verify_data(sig, data))
 
     def test_ecdsa_verify(self):
         self.target.allocate_sig(SignatureEnum.ALG_ECDSA_SHA)
-        self.target.allocate(KeypairEnum.KEYPAIR_LOCAL, KeyBuildEnum.BUILD_KEYPAIR, 256,
-                             KeyClassEnum.ALG_EC_FP)
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP)
+        self.target.allocate(
+            KeypairEnum.KEYPAIR_LOCAL,
+            KeyBuildEnum.BUILD_KEYPAIR,
+            256,
+            KeyClassEnum.ALG_EC_FP,
+        )
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL, CurveEnum.secp256r1, ParameterEnum.DOMAIN_FP
+        )
         mult = LTRMultiplier(
-                self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
-                self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"])
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            self.secp256r1_projective.curve.coordinate_model.formulas["dbl-2016-rcb"],
+        )
         keygen = KeyGeneration(copy(mult), self.secp256r1_projective)
         priv, pubkey_projective = keygen.generate()
-        self.target.set(KeypairEnum.KEYPAIR_LOCAL, CurveEnum.external, ParameterEnum.W,
-                        ECTesterTarget.encode_parameters(ParameterEnum.W,
-                                                         pubkey_projective.to_affine()))
-        ecdsa = ECDSA_SHA1(copy(mult), self.secp256r1_projective,
-                           self.secp256r1_projective.curve.coordinate_model.formulas[
-                               "add-2016-rcb"],
-                           pubkey_projective,
-                           priv)
+        self.target.set(
+            KeypairEnum.KEYPAIR_LOCAL,
+            CurveEnum.external,
+            ParameterEnum.W,
+            ECTesterTarget.encode_parameters(
+                ParameterEnum.W, pubkey_projective.to_affine()
+            ),
+        )
+        ecdsa = ECDSA_SHA1(
+            copy(mult),
+            self.secp256r1_projective,
+            self.secp256r1_projective.curve.coordinate_model.formulas["add-2016-rcb"],
+            pubkey_projective,
+            priv,
+        )
         data = "Some text over here.".encode()
         sig = ecdsa.sign_data(data)
 
-        ecdsa_resp = self.target.ecdsa_verify(KeypairEnum.KEYPAIR_LOCAL,
-                                              SignatureEnum.ALG_ECDSA_SHA, sig.to_DER(), data)
+        ecdsa_resp = self.target.ecdsa_verify(
+            KeypairEnum.KEYPAIR_LOCAL, SignatureEnum.ALG_ECDSA_SHA, sig.to_DER(), data
+        )
         self.assertTrue(ecdsa_resp.success)
diff --git a/test/sca/test_test.py b/test/sca/test_test.py
index 5a20f70..7b4f346 100644
--- a/test/sca/test_test.py
+++ b/test/sca/test_test.py
@@ -6,7 +6,6 @@ from pyecsca.sca import Trace, welch_ttest, student_ttest, ks_test
 
 
 class TTestTests(TestCase):
-
     def setUp(self):
         self.a = Trace(np.array([20, 80], dtype=np.dtype("i1")))
         self.b = Trace(np.array([30, 42], dtype=np.dtype("i1")))
@@ -15,9 +14,15 @@ class TTestTests(TestCase):
 
     def test_welch_ttest(self):
         self.assertIsNotNone(welch_ttest([self.a, self.b], [self.c, self.d]))
-        a = Trace(np.array([19.8, 20.4, 19.6, 17.8, 18.5, 18.9, 18.3, 18.9, 19.5, 22.0]))
-        b = Trace(np.array([28.2, 26.6, 20.1, 23.3, 25.2, 22.1, 17.7, 27.6, 20.6, 13.7]))
-        c = Trace(np.array([20.2, 21.6, 27.1, 13.3, 24.2, 20.1, 11.7, 25.6, 26.6, 21.4]))
+        a = Trace(
+            np.array([19.8, 20.4, 19.6, 17.8, 18.5, 18.9, 18.3, 18.9, 19.5, 22.0])
+        )
+        b = Trace(
+            np.array([28.2, 26.6, 20.1, 23.3, 25.2, 22.1, 17.7, 27.6, 20.6, 13.7])
+        )
+        c = Trace(
+            np.array([20.2, 21.6, 27.1, 13.3, 24.2, 20.1, 11.7, 25.6, 26.6, 21.4])
+        )
 
         result = welch_ttest([a, b], [b, c], dof=True, p_value=True)
         self.assertIsNotNone(result)
@@ -28,7 +33,6 @@ class TTestTests(TestCase):
 
 
 class KolmogorovSmirnovTests(TestCase):
-
     def test_ks_test(self):
         self.assertIsNone(ks_test([], []))
 
diff --git a/test/sca/test_trace.py b/test/sca/test_trace.py
index 91b640d..93baa89 100644
--- a/test/sca/test_trace.py
+++ b/test/sca/test_trace.py
@@ -4,7 +4,6 @@ from pyecsca.sca import Trace
 
 
 class TraceTests(TestCase):
-
     def test_basic(self):
         trace = Trace(np.array([10, 15, 24], dtype=np.dtype("i1")))
         self.assertIsNotNone(trace)
diff --git a/test/sca/test_traceset.py b/test/sca/test_traceset.py
index 7adff41..515790e 100644
--- a/test/sca/test_traceset.py
+++ b/test/sca/test_traceset.py
@@ -6,17 +6,24 @@ from unittest import TestCase
 
 import numpy as np
 
-from pyecsca.sca import (TraceSet, InspectorTraceSet, ChipWhispererTraceSet, PickleTraceSet,
-                         HDF5TraceSet, Trace)
+from pyecsca.sca import (
+    TraceSet,
+    InspectorTraceSet,
+    ChipWhispererTraceSet,
+    PickleTraceSet,
+    HDF5TraceSet,
+    Trace,
+)
 
-EXAMPLE_TRACES = [Trace(np.array([20, 40, 50, 50, 10], dtype=np.dtype("i1")), {"something": 5}),
-                  Trace(np.array([1, 2, 3, 4, 5], dtype=np.dtype("i1"))),
-                  Trace(np.array([6, 7, 8, 9, 10], dtype=np.dtype("i1")))]
+EXAMPLE_TRACES = [
+    Trace(np.array([20, 40, 50, 50, 10], dtype=np.dtype("i1")), {"something": 5}),
+    Trace(np.array([1, 2, 3, 4, 5], dtype=np.dtype("i1"))),
+    Trace(np.array([6, 7, 8, 9, 10], dtype=np.dtype("i1"))),
+]
 EXAMPLE_KWARGS = {"num_traces": 3, "thingy": "abc"}
 
 
 class TraceSetTests(TestCase):
-
     def test_create(self):
         self.assertIsNotNone(TraceSet())
         self.assertIsNotNone(InspectorTraceSet())
@@ -26,7 +33,6 @@ class TraceSetTests(TestCase):
 
 
 class InspectorTraceSetTests(TestCase):
-
     def test_load_fname(self):
         result = InspectorTraceSet.read("test/data/example.trs")
         self.assertIsNotNone(result)
@@ -55,7 +61,6 @@ class InspectorTraceSetTests(TestCase):
 
 
 class ChipWhispererTraceSetTests(TestCase):
-
     def test_load_fname(self):
         result = ChipWhispererTraceSet.read("test/data/config_chipwhisperer_.cfg")
         self.assertIsNotNone(result)
@@ -63,7 +68,6 @@ class ChipWhispererTraceSetTests(TestCase):
 
 
 class PickleTraceSetTests(TestCase):
-
     def test_load_fname(self):
         result = PickleTraceSet.read("test/data/test.pickle")
         self.assertIsNotNone(result)
@@ -82,7 +86,6 @@ class PickleTraceSetTests(TestCase):
 
 
 class HDF5TraceSetTests(TestCase):
-
     def test_load_fname(self):
         result = HDF5TraceSet.read("test/data/test.h5")
         self.assertIsNotNone(result)
@@ -97,8 +100,12 @@ class HDF5TraceSetTests(TestCase):
             shutil.copy("test/data/test.h5", path)
             trace_set = HDF5TraceSet.inplace(path)
             self.assertIsNotNone(trace_set)
-            test_trace = Trace(np.array([6, 7], dtype=np.dtype("i1")), meta={"thing": "ring"})
-            other_trace = Trace(np.array([15, 7], dtype=np.dtype("i1")), meta={"a": "b"})
+            test_trace = Trace(
+                np.array([6, 7], dtype=np.dtype("i1")), meta={"thing": "ring"}
+            )
+            other_trace = Trace(
+                np.array([15, 7], dtype=np.dtype("i1")), meta={"a": "b"}
+            )
             trace_set.append(test_trace)
             self.assertEqual(len(trace_set), 4)
             trace_set.append(other_trace)
diff --git a/test/sca/utils.py b/test/sca/utils.py
index 0a996cd..b00015b 100644
--- a/test/sca/utils.py
+++ b/test/sca/utils.py
@@ -24,7 +24,6 @@ cases: Dict[str, int] = {}
 
 
 class Plottable(TestCase):
-
     def get_dir(self):
         if split(getcwd())[1] == "test":
             directory = "plots"