revert IDE changes

try again

clean up

3rd times a charm

one more

Author: zzstoatzz

.gitignore

@@ -28,3 +28,6 @@ test.py
 __pycache__
 .benchmarks
 .pytest_cache
+
+# Build artifacts
+*.so

pyproject.toml

@@ -2,24 +2,13 @@
 name = "libipld"
 dynamic = ["version"]
 description = "Python binding to the Rust IPLD library"
-authors = [{ name = "Ilya (Marshal)", email = "ilya@marshal.dev" }]
+authors = [
+    {name = "Ilya (Marshal)", email = "ilya@marshal.dev"}
+]
 license = "MIT"
 repository = "https://github.com/MarshalX/python-libipld"
 readme = "README.md"
-keywords = [
-    "library",
-    "lib",
-    "ipld",
-    "cid",
-    "multibase",
-    "multihash",
-    "dag",
-    "cbor",
-    "json",
-    "pb",
-    "dag-cbor",
-    "dag-json",
-]
+keywords = ["library", "lib", "ipld", "cid", "multibase", "multihash", "dag", "cbor", "json", "pb", "dag-cbor", "dag-json"]
 requires-python = ">=3.8"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -53,9 +42,8 @@ dev = ["maturin", "pytest", "pytest-benchmark"]
 
 [tool.pytest.ini_options]
 addopts = [
-    '--benchmark-columns',
-    'min,mean,stddev,outliers,rounds,iterations',
-    '--benchmark-disable',                        # use --benchmark-enable
+    '--benchmark-columns', 'min,mean,stddev,outliers,rounds,iterations',
+    '--benchmark-disable',  # use --benchmark-enable
 ]
 
 [tool.maturin]

pytests/test_cid.py

@@ -2,37 +2,31 @@
 
 
 def test_cid_decode_multibase() -> None:
-    cid = libipld.decode_cid(
-        "bafyreig7jbijxpn4lfhvnvyuwf5u5jyhd7begxwyiqe7ingwxycjdqjjoa"
-    )
-    assert 1 == cid["version"]
-    assert 113 == cid["codec"]
-    assert 18 == cid["hash"]["code"]
-    assert 32 == cid["hash"]["size"]
-    assert cid["hash"]["size"] == len(cid["hash"]["digest"])
+    cid = libipld.decode_cid('bafyreig7jbijxpn4lfhvnvyuwf5u5jyhd7begxwyiqe7ingwxycjdqjjoa')
+    assert 1 == cid['version']
+    assert 113 == cid['codec']
+    assert 18 == cid['hash']['code']
+    assert 32 == cid['hash']['size']
+    assert cid['hash']['size'] == len(cid['hash']['digest'])
 
 
 def test_cid_decode_raw() -> None:
-    cid = libipld.decode_cid(
-        b"\x01q\x12 \xb6\x81\x1a\x1d\x7f\x8c\x17\x91\xdam\x1bO\x13m\xc0\xe2&y\xea\xfe\xaaX\xd6M~/\xaa\xd5\x89\x0e\x9d\x9c"
-    )
-    assert 1 == cid["version"]
-    assert 113 == cid["codec"]
-    assert 18 == cid["hash"]["code"]
-    assert 32 == cid["hash"]["size"]
-    assert cid["hash"]["size"] == len(cid["hash"]["digest"])
+    cid = libipld.decode_cid(b'\x01q\x12 \xb6\x81\x1a\x1d\x7f\x8c\x17\x91\xdam\x1bO\x13m\xc0\xe2&y\xea\xfe\xaaX\xd6M~/\xaa\xd5\x89\x0e\x9d\x9c')
+    assert 1 == cid['version']
+    assert 113 == cid['codec']
+    assert 18 == cid['hash']['code']
+    assert 32 == cid['hash']['size']
+    assert cid['hash']['size'] == len(cid['hash']['digest'])
 
 
 def test_cid_encode_multibase() -> None:
-    cid = "bafyreig7jbijxpn4lfhvnvyuwf5u5jyhd7begxwyiqe7ingwxycjdqjjoa"
+    cid = 'bafyreig7jbijxpn4lfhvnvyuwf5u5jyhd7begxwyiqe7ingwxycjdqjjoa'
     assert cid == libipld.encode_cid(cid)  # because it's already encoded
 
 
 def test_cid_encode_raw() -> None:
-    raw_cid = b"\x01q\x12 \xb6\x81\x1a\x1d\x7f\x8c\x17\x91\xdam\x1bO\x13m\xc0\xe2&y\xea\xfe\xaaX\xd6M~/\xaa\xd5\x89\x0e\x9d\x9c"
-    expected_cid_multibase = (
-        "bafyreifwqenb274mc6i5u3i3j4jw3qhcez46v7vkldle27rpvlkysdu5tq"
-    )
+    raw_cid = b'\x01q\x12 \xb6\x81\x1a\x1d\x7f\x8c\x17\x91\xdam\x1bO\x13m\xc0\xe2&y\xea\xfe\xaaX\xd6M~/\xaa\xd5\x89\x0e\x9d\x9c'
+    expected_cid_multibase = 'bafyreifwqenb274mc6i5u3i3j4jw3qhcez46v7vkldle27rpvlkysdu5tq'
 
     cid = libipld.decode_cid(raw_cid)
     cid_multibase = libipld.encode_cid(raw_cid)
@@ -44,4 +38,4 @@ def test_cid_encode_raw() -> None:
     assert cid == cid2
 
     # manual encoding for CID v1:
-    assert expected_cid_multibase == libipld.encode_multibase("b", raw_cid)
+    assert expected_cid_multibase == libipld.encode_multibase('b', raw_cid)

pytests/test_decode_car.py

@@ -2,27 +2,24 @@
 
 import libipld
 import pytest
-from pytest_benchmark.fixture import BenchmarkFixture
 
 from conftest import load_car_fixture
 
-_DID = os.environ.get(
-    "CAR_REPO_DID", "did:plc:w4es6sfh43zlht3bgrzi5qzq"
-)  # default is public bot in bsky.app
-_REPO_CAR_PATH = os.path.join(os.path.dirname(__file__), "..", "data", "repo.car")
+_DID = os.environ.get('CAR_REPO_DID', 'did:plc:w4es6sfh43zlht3bgrzi5qzq')  # default is public bot in bsky.app
+_REPO_CAR_PATH = os.path.join(os.path.dirname(__file__), '..', 'data', 'repo.car')
 
 
-@pytest.fixture(scope="session")
+@pytest.fixture(scope='session')
 def car() -> bytes:
     return load_car_fixture(_DID, _REPO_CAR_PATH)
 
 
-def test_decode_car(benchmark: BenchmarkFixture, car: bytes) -> None:
+def test_decode_car(benchmark, car) -> None:
     header, blocks = benchmark(libipld.decode_car, car)
 
-    assert 1 == header["version"]
-    assert isinstance(header["roots"], list)
-    assert 1 == len(header["roots"])
+    assert 1 == header['version']
+    assert isinstance(header['roots'], list)
+    assert 1 == len(header['roots'])
 
     assert isinstance(blocks, dict)
     assert all(isinstance(k, bytes) for k in blocks.keys())
@@ -33,71 +30,71 @@ def test_decode_car(benchmark: BenchmarkFixture, car: bytes) -> None:
 
 def test_decode_car_invalid_header_len() -> None:
     with pytest.raises(ValueError) as exc_info:
-        libipld.decode_car(b"")
+        libipld.decode_car(b'')
 
-    assert "Invalid uvarint" in str(exc_info.value)
+    assert 'Invalid uvarint' in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_type() -> None:
     with pytest.raises(TypeError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor("strInsteadOfObj")
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor('strInsteadOfObj')
         libipld.decode_car(header_len + header_obj)
 
     assert "cannot be converted to 'PyDict'" in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_version_key() -> None:
     with pytest.raises(ValueError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"blabla": "blabla"})
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'blabla': 'blabla'})
         libipld.decode_car(header_len + header_obj)
 
-    assert "Version is None" in str(exc_info.value)
+    assert 'Version is None' in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_version_value() -> None:
     with pytest.raises(ValueError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"version": 2})
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'version': 2})
         libipld.decode_car(header_len + header_obj)
 
-    assert "Version must be 1" in str(exc_info.value)
+    assert 'Version must be 1' in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_roots_key() -> None:
     with pytest.raises(ValueError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"version": 1})
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'version': 1})
         libipld.decode_car(header_len + header_obj)
 
-    assert "Roots is None" in str(exc_info.value)
+    assert 'Roots is None' in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_roots_value_type() -> None:
     with pytest.raises(TypeError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"version": 1, "roots": 123})
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'version': 1, 'roots': 123})
         libipld.decode_car(header_len + header_obj)
 
     assert "cannot be converted to 'PyList'" in str(exc_info.value)
 
 
 def test_decode_car_invalid_header_roots_value_empty_list() -> None:
     with pytest.raises(ValueError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"version": 1, "roots": []})
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'version': 1, 'roots': []})
         libipld.decode_car(header_len + header_obj)
 
-    assert "Roots is empty" in str(exc_info.value)
+    assert 'Roots is empty' in str(exc_info.value)
 
 
 def test_decode_car_invalid_block_cid() -> None:
     with pytest.raises(ValueError) as exc_info:
-        header_len = bytes.fromhex("33")  # 3
-        header_obj = libipld.encode_dag_cbor({"version": 1, "roots": ["blabla"]})
-        block1 = bytes.fromhex("33") + b"invalidSid"
+        header_len = bytes.fromhex('33')  # 3
+        header_obj = libipld.encode_dag_cbor({'version': 1, 'roots': ['blabla']})
+        block1 = bytes.fromhex('33') + b'invalidSid'
 
         libipld.decode_car(header_len + header_obj + block1)
 
-    assert "Failed to read CID of block" in str(exc_info.value)
+    assert 'Failed to read CID of block' in str(exc_info.value)