update: fmt with black

Author: olivmath

merkly/mtree.py

@@ -9,6 +9,7 @@ class Node(BaseModel):
     """
     # 🍃 Leaf of Tree
     """
+
     left: Optional[str]
     right: Optional[str]
 
@@ -20,12 +21,14 @@ def __repr__(self) -> str:
         else:
             return ""
 
-class MerkleTree():
+
+class MerkleTree:
     """
     # 🌳 Merkle Tree
     - You can passa raw data
     - They will hashed by `keccak-256`
     """
+
     def __init__(self, leafs: List[str]) -> None:
         """
         # Constructor
@@ -36,8 +39,8 @@ def __init__(self, leafs: List[str]) -> None:
         if not is_power_2(leafs.__len__()):
             # todo: custom error
             raise Exception(
-                "size of leafs should be power of 2\n" +
-                "like: 2, 4, 8, 16, 32, 64, 128..."
+                "size of leafs should be power of 2\n"
+                + "like: 2, 4, 8, 16, 32, 64, 128..."
             )
         # todo: to lazy initialize
         # todo: cache leafs
@@ -75,7 +78,6 @@ def root(self) -> str:
 
         return MerkleTree.merkle_root(self.leafs)[0]
 
-
     def proof(self, leaf: str) -> List[Node]:
         """
         # Get a proof of merkle tree
@@ -133,16 +135,10 @@ def merkle_root(leafs: list):
         if len(leafs) == 1:
             return leafs
 
-        return MerkleTree.merkle_root([
-            keccak(i + j) for i, j in slice_in_pairs(leafs)
-        ])
+        return MerkleTree.merkle_root([keccak(i + j) for i, j in slice_in_pairs(leafs)])
 
     @staticmethod
-    def merkle_proof(
-        leafs: List[str],
-        proof: List[str],
-        leaf: str
-    ) -> list:
+    def merkle_proof(leafs: List[str], proof: List[str], leaf: str) -> list:
         """
         # Make a proof
         - if the `leaf` index is less than half the size of the `leafs`
@@ -151,30 +147,22 @@ def merkle_proof(
         from merkly.utils.crypto import half
 
         if len(leafs) == 2:
-            proof.append(
-                Node(right=leafs[1])
-            )
-            proof.append(
-                Node(left=leafs[0])
-            )
+            proof.append(Node(right=leafs[1]))
+            proof.append(Node(left=leafs[0]))
             return proof
 
         try:
             index = leafs.index(leaf)
         except ValueError as err:
             raise ValueError(
-                f'leaf: {leaf} does not exist in the tree: {leafs}'
+                f"leaf: {leaf} does not exist in the tree: {leafs}"
             ) from err
 
         left, right = half(leafs)
 
         if index < len(leafs) / 2:
-            proof.append(
-                Node(right=MerkleTree.merkle_root(right)[0])
-            )
+            proof.append(Node(right=MerkleTree.merkle_root(right)[0]))
             return MerkleTree.merkle_proof(left, proof, leaf)
         else:
-            proof.append(
-                Node(left=MerkleTree.merkle_root(left)[0])
-            )
+            proof.append(Node(left=MerkleTree.merkle_root(left)[0]))
             return MerkleTree.merkle_proof(right, proof, leaf)

merkly/utils/crypto.py

@@ -26,9 +26,7 @@ def keccak(data: str) -> str:
     "541111248b45b7a8dc3f5579f630e74cb01456ea6ac067d3f4d793245a255155"
     ```
     """
-    return keccak_256(
-        data.encode()
-    ).hexdigest()
+    return keccak_256(data.encode()).hexdigest()
 
 
 def half(list_item: List[int]) -> Tuple[int, int]:
@@ -66,7 +64,4 @@ def slice_in_pairs(list_item: list):
     ```
     """
 
-    return [
-        list_item[i: i + 2]
-        for i in range(0, len(list_item), 2)
-    ]
+    return [list_item[i : i + 2] for i in range(0, len(list_item), 2)]

merkly/utils/math.py

@@ -2,6 +2,7 @@
 Math utils functions
 """
 
+
 def is_power_2(number: int) -> bool:
     """
     # Verify if `x: int` is power of 2
@@ -16,6 +17,6 @@ def is_power_2(number: int) -> bool:
     ```
     """
 
-    left: bool = (number & (number - 1) == 0)
+    left: bool = number & (number - 1) == 0
     right: bool = number != 0
     return left and right

pyproject.toml

@@ -22,6 +22,7 @@ pylint = "^2.14.5"
 pydantic = "^1.10.2"
 rich = "^12.6.0" # for beatfull print 
 pytest-watcher = "^0.2.3"
+black = "^23.3.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.1.2"

scripts/poetry.py

@@ -6,7 +6,7 @@ def w_t():
     """
     # running `poetry run w-t` for watch tests
     """
-    subprocess.run(["ptw", "test","-vvx"])
+    subprocess.run(["ptw", "test", "-vvx"])
 
 
 def lint():

test/test_merkle_tree.py

@@ -15,22 +15,21 @@ def test_simple_merkle_tree_constructor():
     tree = MerkleTree(leafs)
 
     assert tree.leafs == [
-        '3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb',
-        'b5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510',
-        '0b42b6393c1f53060fe3ddbfcd7aadcca894465a5a438f69c87d790b2299b9b2',
-        'f1918e8562236eb17adc8502332f4c9c82bc14e19bfc0aa10ab674ff75b3d2f3',
+        "3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb",
+        "b5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510",
+        "0b42b6393c1f53060fe3ddbfcd7aadcca894465a5a438f69c87d790b2299b9b2",
+        "f1918e8562236eb17adc8502332f4c9c82bc14e19bfc0aa10ab674ff75b3d2f3",
     ]
 
 
-
 @mark.parametrize(
     "leafs",
     [
         ["a", "b", "c", "d", "e", "f", "g"],
         ["a", "b", "c", "d", "e", "f"],
         ["a", "b", "c", "d", "e"],
-        ["a", "b", "c"]
-    ]
+        ["a", "b", "c"],
+    ],
 )
 def test_error_simple_merkle_tree_constructor(leafs: List[str]):
     """
@@ -45,20 +44,18 @@ def test_error_simple_merkle_tree_constructor(leafs: List[str]):
     [
         (
             ["a", "b", "c", "d", "e", "f", "g", "h"],
-            "2dfe93948ecb1a0903dbf034de56d6529e62679519a37ed3b5b3356ab27b7bb8"
+            "2dfe93948ecb1a0903dbf034de56d6529e62679519a37ed3b5b3356ab27b7bb8",
         ),
-        (   ["a", "b", "c", "d"],
-            "115cbb4775ed495f3d954dfa47164359a97762b40059d9502895def16eed609c"
+        (
+            ["a", "b", "c", "d"],
+            "115cbb4775ed495f3d954dfa47164359a97762b40059d9502895def16eed609c",
         ),
         (
             ["a", "b"],
-            "414e3a845393ef6d68973ddbf5bd85ff524443cf0e06a361624f3d51b879ec1c"
+            "414e3a845393ef6d68973ddbf5bd85ff524443cf0e06a361624f3d51b879ec1c",
         ),
-        (
-            ["a"],
-            "3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb"
-        )
-    ]
+        (["a"], "3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb"),
+    ],
 )
 def test_simple_merkle_root(leafs: List[str], root: str):
     """
@@ -78,24 +75,20 @@ def test_proof_simple_merkle():
     assert tree.proof("a") == [
         Node(left="3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb"),
         Node(right="b5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510"),
-        Node(right="64673cf40035df6d3a0d0143cc8426de49b9a93b9ad2d330cb4f0bc390a86d20")
+        Node(right="64673cf40035df6d3a0d0143cc8426de49b9a93b9ad2d330cb4f0bc390a86d20"),
     ]
 
 
 @mark.parametrize(
     "leaf",
-    [
-        "a", "b", "c", "d", "e", "f", "g", "h",
-        "1", "2", "3", "4", "5", "6", "7", "8"
-    ]
+    ["a", "b", "c", "d", "e", "f", "g", "h", "1", "2", "3", "4", "5", "6", "7", "8"],
 )
 def test_verify_simple_merkle(leaf: str):
     """
     Instantiated a simple Merkle Tree
     """
-    tree = MerkleTree([
-        "a", "b", "c", "d", "e", "f", "g", "h",
-        "1", "2", "3", "4", "5", "6", "7", "8"
-    ])
+    tree = MerkleTree(
+        ["a", "b", "c", "d", "e", "f", "g", "h", "1", "2", "3", "4", "5", "6", "7", "8"]
+    )
 
     assert tree.verify(tree.proof(leaf))

test/utils/test_crypto.py

@@ -6,18 +6,23 @@
 @mark.parametrize(
     "data, expect",
     [
-        ("string very long",
-         "2b91b0c651a9e25f0c3ca0278fe4ce8d5fae980731bc48f92fa192886d4dc4b6"),
-        ("ethereum", "541111248b45b7a8dc3f5579f630e74cb01456ea6ac067d3f4d793245a255155"),
+        (
+            "string very long",
+            "2b91b0c651a9e25f0c3ca0278fe4ce8d5fae980731bc48f92fa192886d4dc4b6",
+        ),
+        (
+            "ethereum",
+            "541111248b45b7a8dc3f5579f630e74cb01456ea6ac067d3f4d793245a255155",
+        ),
         ("bitcoin", "7dee6e1aa550de37364ec77e03e62ea56bf42037b8297280de9d844d88444e4d"),
         ("merkle", "326fe0d8a70ab934a7bf9d1323c6d87ee37bbe70079f82e72203b1e07c0c185c"),
         ("cars", "0ee92a51567d02169526115460f55ddef86e734b94b947896e82d4532671fdf2"),
         ("tree", "b2510336c6497719adadc7ade198c988520f3349445f074dc729df0f3c2b12ad"),
         ("a", "3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb"),
         ("b", "b5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510"),
         ("x", "7521d1cadbcfa91eec65aa16715b94ffc1c9654ba57ea2ef1a2127bca1127a83"),
-        ("y", "83847cf31c36389df832d0d4d3df7cf28f211e3f83173e5c157bab31573d61f3")
-    ]
+        ("y", "83847cf31c36389df832d0d4d3df7cf28f211e3f83173e5c157bab31573d61f3"),
+    ],
 )
 def test_of_keccak(data: str, expect: bool):
     assert expect == keccak(data)
@@ -35,8 +40,8 @@ def test_of_keccak(data: str, expect: bool):
         ([i for i in range(1002)], 501),
         ([i for i in range(2040)], 1020),
         ([i for i in range(5008)], 2504),
-        ([i for i in range(10010)], 5005)
-    ]
+        ([i for i in range(10010)], 5005),
+    ],
 )
 def test_slice_in_pairs(full: List[int], half: int):
     assert half == len(slice_in_pairs(full))

test/utils/test_math.py

@@ -2,24 +2,21 @@
 from merkly.utils.math import is_power_2
 from pytest import mark
 
+
 @mark.parametrize(
-  "number, expect",
-  [
-    (3, False),
-    (13, False),
-    (345, False),
-    (3098, False),
-    (31234, False),
-    (2, True),
-    (4, True),
-    (64, True),
-    (4096, True),
-    (65536, True)
-  ]
+    "number, expect",
+    [
+        (3, False),
+        (13, False),
+        (345, False),
+        (3098, False),
+        (31234, False),
+        (2, True),
+        (4, True),
+        (64, True),
+        (4096, True),
+        (65536, True),
+    ],
 )
 def test_of_is_power_2(number: int, expect: bool):
-  assert expect == is_power_2(number)
-
-
-
-
+    assert expect == is_power_2(number)