revert IDE changes

try again

clean up

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)

python/libipld/_libipld.cpython-313-darwin.so

@@ -17,7 +17,7 @@ fn cid_hash_to_pydict<'py>(py: Python<'py>, cid: &Cid) -> Bound<'py, PyDict> {
     dict_obj.set_item("code", hash.code()).unwrap();
     dict_obj.set_item("size", hash.size()).unwrap();
     dict_obj
-        .set_item("digest", PyBytes::new(py, hash.digest()))
+        .set_item("digest", PyBytes::new(py, &hash.digest()))
         .unwrap();
 
     dict_obj
@@ -74,7 +74,7 @@ fn sort_map_keys(keys: &Bound<PyList>, len: usize) -> Vec<(PyBackedStr, usize)>
         if s1.len() != s2.len() {
             s1.len().cmp(&s2.len())
         } else {
-            s1.cmp(s2)
+            s1.cmp(&s2)
         }
     });
 
@@ -212,7 +212,7 @@ fn decode_dag_cbor_to_pyobject<R: Read + Seek>(
 }
 
 fn encode_dag_cbor_from_pyobject<'py, W: Write>(
-    _py: Python<'py>,
+    py: Python<'py>,
     obj: &Bound<'py, PyAny>,
     w: &mut W,
 ) -> Result<()> {
@@ -259,7 +259,7 @@ fn encode_dag_cbor_from_pyobject<'py, W: Write>(
         encode::write_u64(w, MajorKind::Array, len as u64)?;
 
         for i in 0..len {
-            encode_dag_cbor_from_pyobject(_py, &l.get_item(i)?, w)?;
+            encode_dag_cbor_from_pyobject(py, &l.get_item(i)?, w)?;
         }
 
         Ok(())
@@ -275,7 +275,7 @@ fn encode_dag_cbor_from_pyobject<'py, W: Write>(
             encode::write_u64(w, MajorKind::TextString, key_buf.len() as u64)?;
             w.write_all(key_buf)?;
 
-            encode_dag_cbor_from_pyobject(_py, &values.get_item(i)?, w)?;
+            encode_dag_cbor_from_pyobject(py, &values.get_item(i)?, w)?;
         }
 
         Ok(())
@@ -293,7 +293,7 @@ fn encode_dag_cbor_from_pyobject<'py, W: Write>(
     } else if let Ok(b) = obj.downcast::<PyBytes>() {
         // FIXME (MarshalX): it's not efficient to try to parse it as CID
         let cid = Cid::try_from(b.as_bytes());
-        if cid.is_ok() {
+        if let Ok(_) = cid {
             let buf = b.as_bytes();
             let len = buf.len();
 
@@ -345,7 +345,7 @@ fn read_u64_leb128<R: Read>(r: &mut R) -> Result<u64> {
 
     loop {
         let mut buf = [0];
-        if r.read_exact(&mut buf).is_err() {
+        if let Err(_) = r.read_exact(&mut buf) {
             return Err(anyhow!("Unexpected EOF while reading ULEB128 number."));
         }
 
@@ -390,7 +390,7 @@ fn read_cid_from_bytes<R: Read>(r: &mut R) -> CidResult<Cid> {
 pub fn decode_car<'py>(py: Python<'py>, data: &[u8]) -> PyResult<(PyObject, Bound<'py, PyDict>)> {
     let buf = &mut BufReader::new(Cursor::new(data));
 
-    if read_u64_leb128(buf).is_err() {
+    if let Err(_) = read_u64_leb128(buf) {
         return Err(get_err(
             "Failed to read CAR header",
             "Invalid uvarint".to_string(),
@@ -436,7 +436,7 @@ pub fn decode_car<'py>(py: Python<'py>, data: &[u8]) -> PyResult<(PyObject, Boun
     let parsed_blocks = PyDict::new(py);
 
     loop {
-        if read_u64_leb128(buf).is_err() {
+        if let Err(_) = read_u64_leb128(buf) {
             // FIXME (MarshalX): we are not raising an error here because of possible EOF
             break;
         }
@@ -485,7 +485,7 @@ pub fn decode_dag_cbor(py: Python, data: &[u8]) -> PyResult<PyObject> {
 
         if let Some(py_err) = PyErr::take(py) {
             py_err.set_cause(py, Option::from(err));
-            // in case something set global interpreter's error,
+            // in case something set global interpreter’s error,
             // for example C FFI function, we should return it
             // the real case: RecursionError (set by Py_EnterRecursiveCall)
             Err(py_err)
@@ -507,10 +507,9 @@ pub fn encode_dag_cbor<'py>(
     if let Err(e) = buf.flush() {
         return Err(get_err("Failed to flush buffer", e.to_string()));
     }
-    Ok(PyBytes::new(py, buf.get_ref()))
+    Ok(PyBytes::new(py, &buf.get_ref()))
 }
 
-#[allow(clippy::extra_unused_lifetimes)]
 fn get_cid_from_py_any<'py>(data: &Bound<PyAny>) -> PyResult<Cid> {
     let cid: CidResult<Cid>;
     if let Ok(s) = data.downcast::<PyString>() {