zoocache 2026.1.20__tar.gz → 2026.2.5__tar.gz

{zoocache-2026.1.20 → zoocache-2026.2.5}/.gitignore

@@ -21,3 +21,7 @@ target/
 
 # LMDB files
 *.mdb
+
+
+# Docs files
+site/

zoocache-2026.2.5/.readthedocs.yaml

@@ -0,0 +1,14 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.10"
+    rust: "latest"
+  jobs:
+    install:
+      - pip install uv
+      - uv sync --group docs
+    build:
+      html:
+        - uv run mkdocs build -d $READTHEDOCS_OUTPUT/html

{zoocache-2026.1.20 → zoocache-2026.2.5}/Cargo.lock

@@ -963,7 +963,7 @@ dependencies = [
 
 [[package]]
 name = "zoocache"
-version = "2026.1.20"
+version = "2026.2.5"
 dependencies = [
  "dashmap",
  "lmdb",

{zoocache-2026.1.20 → zoocache-2026.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zoocache"
-version = "2026.1.20"
+version = "2026.2.5"
 edition = "2024"
 readme = "README.md"
 
@@ -23,3 +23,10 @@ lz4_flex = "0.11"
 pythonize = "0.27"
 serde_bytes = "0.11"
 serde-transcode = "1.1"
+
+[profile.release]
+codegen-units = 1
+lto = "fat"
+opt-level = 3
+strip = true
+panic = "abort"

{zoocache-2026.1.20 → zoocache-2026.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoocache
-Version: 2026.1.20
+Version: 2026.2.5
 Summary: Cache that invalidates when your data changes, not when a timer expires. Rust-powered semantic invalidation for Python.
 Author-email: Alberto Daniel Badia <alberto_badia@enlacepatagonia.com>
 License: MIT
@@ -18,11 +18,18 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 <p align="center">
   Zoocache is a high-performance caching library with a Rust core, designed for applications where data consistency and read performance are critical.
 </p>
+<div align="center" markdown="1">
+
+[**📖 Read the User Guide**](docs/user_guide.md)
+
+</div>
 <p align="center">
-  <a href="https://www.python.org/downloads/"><img alt="Python 3.10+" src="https://img.shields.io/badge/python-3.10+-blue.svg"></a>
-  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-green.svg"></a>
-  <img alt="PyPI" src="https://img.shields.io/pypi/v/zoocache">
-  <img alt="Downloads" src="https://img.shields.io/pypi/dm/zoocache">
+  <a href="https://www.python.org/downloads/"><img alt="Python 3.10+" src="https://img.shields.io/badge/python-3.10+-blue.svg?style=flat-square&logo=python"></a>
+  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-green.svg?style=flat-square"></a>
+  <a href="https://pypi.org/project/zoocache/"><img alt="PyPI" src="https://img.shields.io/pypi/v/zoocache?style=flat-square&logo=pypi&logoColor=white"></a>
+  <a href="https://pypi.org/project/zoocache/"><img alt="Downloads" src="https://img.shields.io/pepy/dt/zoocache?style=flat-square&color=blue"></a>
+  <a href="https://github.com/albertobadia/zoocache/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/albertobadia/zoocache/ci.yml?branch=main&style=flat-square&logo=github"></a>
+  <a href="https://zoocache.readthedocs.io/"><img alt="ReadTheDocs" src="https://img.shields.io/readthedocs/zoocache?style=flat-square&logo=readthedocs"></a>
 </p>
 
 ---
@@ -131,5 +138,5 @@ Explore the deep dives into Zoocache's architecture and features:
 
 ## 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/albertobadia/zoocache/blob/main/LICENSE) file for details.
 

{zoocache-2026.1.20 → zoocache-2026.2.5}/README.md

@@ -9,11 +9,18 @@
 <p align="center">
   Zoocache is a high-performance caching library with a Rust core, designed for applications where data consistency and read performance are critical.
 </p>
+<div align="center" markdown="1">
+
+[**📖 Read the User Guide**](docs/user_guide.md)
+
+</div>
 <p align="center">
-  <a href="https://www.python.org/downloads/"><img alt="Python 3.10+" src="https://img.shields.io/badge/python-3.10+-blue.svg"></a>
-  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-green.svg"></a>
-  <img alt="PyPI" src="https://img.shields.io/pypi/v/zoocache">
-  <img alt="Downloads" src="https://img.shields.io/pypi/dm/zoocache">
+  <a href="https://www.python.org/downloads/"><img alt="Python 3.10+" src="https://img.shields.io/badge/python-3.10+-blue.svg?style=flat-square&logo=python"></a>
+  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-green.svg?style=flat-square"></a>
+  <a href="https://pypi.org/project/zoocache/"><img alt="PyPI" src="https://img.shields.io/pypi/v/zoocache?style=flat-square&logo=pypi&logoColor=white"></a>
+  <a href="https://pypi.org/project/zoocache/"><img alt="Downloads" src="https://img.shields.io/pepy/dt/zoocache?style=flat-square&color=blue"></a>
+  <a href="https://github.com/albertobadia/zoocache/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/albertobadia/zoocache/ci.yml?branch=main&style=flat-square&logo=github"></a>
+  <a href="https://zoocache.readthedocs.io/"><img alt="ReadTheDocs" src="https://img.shields.io/readthedocs/zoocache?style=flat-square&logo=readthedocs"></a>
 </p>
 
 ---
@@ -122,4 +129,4 @@ Explore the deep dives into Zoocache's architecture and features:
 
 ## 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/albertobadia/zoocache/blob/main/LICENSE) file for details.

{zoocache-2026.1.20 → zoocache-2026.2.5}/docs/architecture.md

@@ -6,13 +6,13 @@ Zoocache is designed as a high-performance caching layer that bridge the gap bet
 
 The system is split into two main layers:
 
-### 1. The Plano de Control (Rust Core)
+### 1. The Control Plane (Rust Core)
 The Rust engine manages the complex logic of the cache:
 - **PrefixTrie**: A thread-safe, hierarchical structure that tracks versioning for dependency tags. Includes a **Global Version Counter** for $O(1)$ validation short-circuiting.
 - **Flight Manager**: Handles synchronization to prevent "thundering herd" scenarios for both Sync and Async functions.
 - **[Hybrid Logical Clocks (HLC)](consistency.md#hybrid-logical-clocks-hlc)**: Ensures causal consistency across distributed nodes by ratcheting timestamps based on wall clocks and logical counters.
 
-### 2. The Plano de Datos (Python Wrapper)
+### 2. The Data Plane (Python Wrapper)
 The Python layer provides the user-facing API:
 - **Decorators**: `@cacheable` intercepts function calls.
 - **Context Tracking**: `DepsTracker` uses `contextvars` to register dynamic dependencies during function execution.

zoocache-2026.2.5/docs/index.md

@@ -0,0 +1,9 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="assets/logo-light.svg">
+    <img alt="ZooCache Logo" src="assets/logo-light.svg" width="600">
+  </picture>
+</p>
+
+{% include-markdown "../README.md" start="</p>" %}

zoocache-2026.2.5/lint.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+
+cargo fmt
+cargo clippy --all-targets --all-features -- -D warnings
+uv run ruff check . --fix
+uv run ruff format .

zoocache-2026.2.5/mkdocs.yml

@@ -0,0 +1,64 @@
+site_name: ZooCache
+site_description: ZooCache is a high-performance caching library with a Rust core, designed for consistency and read performance.
+site_url: https://zoocache.readthedocs.io/
+
+theme:
+  name: material
+  logo: assets/logo-light.svg
+  favicon: assets/favicon.svg
+  features:
+    - navigation.indexes
+    - navigation.expand
+    - content.code.copy
+  palette:
+    # Light mode
+    - scheme: default
+      primary: orange
+      accent: amber
+      toggle:
+        icon: material/weather-night
+        name: Switch to dark mode
+    # Dark mode
+    - scheme: slate
+      primary: orange
+      accent: amber
+      toggle:
+        icon: material/weather-sunny
+        name: Switch to light mode
+
+plugins:
+  - search
+  - mkdocstrings
+  - include-markdown
+
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets:
+      base_path: ["."]
+  - pymdownx.superfences
+  - admonition
+  - pymdownx.details
+  - md_in_html
+
+nav:
+  - Home: index.md
+  - User Guide: user_guide.md
+  - Architecture: architecture.md
+  - Serialization: serialization.md
+  - Reliability: reliability.md
+  - Invalidation: invalidation.md
+  - Consistency: consistency.md
+  - Concurrency: concurrency.md
+  - Architectural Decisions:
+      - "ADR 0001: Prefix-Trie Invalidation": adr/0001-prefix-trie-invalidation.md
+      - "ADR 0002: Rust Core Python Wrapper": adr/0002-rust-core-python-wrapper.md
+      - "ADR 0003: HLC Distributed Consistency": adr/0003-hlc-distributed-consistency.md
+      - "ADR 0004: Serialization Strategy": adr/0004-serialization-strategy.md
+      - "ADR 0005: Singleflight Pattern": adr/0005-singleflight-pattern.md
+      - "ADR 0006: Trie Performance Optimizations": adr/0006-trie-performance-optimizations.md
+      - "ADR 0007: Zero-Bridge Serialization": adr/0007-zero-bridge-serialization.md
+      - "ADR 0008: Redis Bus Connection Pooling": adr/0008-redis-bus-connection-pooling.md

{zoocache-2026.1.20 → zoocache-2026.2.5}/pyproject.toml

@@ -29,4 +29,11 @@ dev = [
     "pytest-cov>=7.0.0",
     "ruff>=0.14.13",
     "maturin>=1.7",
+    "mkdocstrings>=1.0.1",
+]
+docs = [
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.1",
+    "mkdocstrings[python]>=0.24.0",
+    "mkdocs-include-markdown-plugin>=7.2.0",
 ]

{zoocache-2026.1.20 → zoocache-2026.2.5}/src/zoocache/core.py

@@ -12,7 +12,6 @@ _op_counter: int = 0
 
 
 def _reset() -> None:
-    """Internal use only: reset the global state for testing."""
     global _core, _config, _op_counter
     _core = None
     _config = {}
@@ -30,9 +29,7 @@ def configure(
 ) -> None:
     global _core, _config
     if _core is not None:
-        raise RuntimeError(
-            "zoocache already initialized, call configure() before any cache operation"
-        )
+        raise RuntimeError("zoocache already initialized")
     _config = {
         "storage_url": storage_url,
         "bus_url": bus_url,
@@ -47,7 +44,6 @@ def configure(
 def _get_core() -> Core:
     global _core
     if _core is None:
-        # Filter config for Rust Core.__init__
         core_args = {k: v for k, v in _config.items() if k != "prune_after"}
         _core = Core(**core_args)
     return _core
@@ -63,7 +59,6 @@ def _maybe_prune() -> None:
 
 
 def prune(max_age_secs: int = 3600) -> None:
-    """Manually trigger pruning of the PrefixTrie."""
     _get_core().prune(max_age_secs)
 
 
@@ -120,7 +115,6 @@ def cacheable(
             if fut is not None:
                 return await fut
 
-            # Fallback if flight was already finished before we could wait
             return await execute(key, args, kwargs)
 
         async def execute(key, args, kwargs):
@@ -154,5 +148,4 @@ def cacheable(
 
 
 def version() -> str:
-    """Return the version of the Rust core."""
     return _get_core().version()

{zoocache-2026.1.20 → zoocache-2026.2.5}/src/zoocache_core/bus/redis_pubsub.rs

@@ -1,7 +1,7 @@
+use r2d2::Pool;
 use redis::{Client, Commands};
 use std::sync::Arc;
 use std::thread;
-use r2d2::Pool;
 
 use super::InvalidateBus;
 
@@ -34,11 +34,14 @@ impl RedisPubSubBus {
             let mut backoff_ms = 100;
             loop {
                 let conn_res = pool.get();
-                
+
                 let mut conn = match conn_res {
                     Ok(c) => c,
                     Err(e) => {
-                        eprintln!("[zoocache] Bus listener connection failed: {}. Retrying in {}ms...", e, backoff_ms);
+                        eprintln!(
+                            "[zoocache] Bus listener connection failed: {}. Retrying in {}ms...",
+                            e, backoff_ms
+                        );
                         thread::sleep(std::time::Duration::from_millis(backoff_ms));
                         backoff_ms = (backoff_ms * 2).min(5000);
                         continue;
@@ -64,8 +67,7 @@ impl RedisPubSubBus {
                         callback(tag, ver);
                     }
                 }
-                
-                eprintln!("[zoocache] Bus connection lost. Reconnecting...");
+
                 thread::sleep(std::time::Duration::from_millis(100));
             }
         });

{zoocache-2026.1.20 → zoocache-2026.2.5}/src/zoocache_core/flight.rs

@@ -46,7 +46,11 @@ pub(crate) fn complete_flight(
 ) -> Option<Py<PyAny>> {
     if let Some((_, flight)) = flights.remove(key) {
         let mut state = flight.state.lock().unwrap();
-        state.0 = if is_error { FlightStatus::Error } else { FlightStatus::Done };
+        state.0 = if is_error {
+            FlightStatus::Error
+        } else {
+            FlightStatus::Done
+        };
         state.1 = value;
         flight.condvar.notify_all();
         return flight.py_future.lock().unwrap().take();
@@ -56,8 +60,22 @@ pub(crate) fn complete_flight(
 
 pub(crate) fn wait_for_flight(flight: &Flight) -> FlightStatus {
     let mut state = flight.state.lock().unwrap();
+    let timeout = std::time::Duration::from_secs(60);
+    let start = std::time::Instant::now();
+
     while state.0 == FlightStatus::Pending {
-        state = flight.condvar.wait(state).unwrap();
+        let elapsed = start.elapsed();
+        if elapsed >= timeout {
+            return FlightStatus::Error;
+        }
+        let (new_state, result) = flight
+            .condvar
+            .wait_timeout(state, timeout - elapsed)
+            .unwrap();
+        state = new_state;
+        if result.timed_out() {
+            return FlightStatus::Error;
+        }
     }
     state.0
 }

{zoocache-2026.1.20 → zoocache-2026.2.5}/src/zoocache_core/lib.rs

@@ -2,6 +2,7 @@ mod bus;
 mod flight;
 mod storage;
 mod trie;
+mod utils;
 
 use dashmap::DashMap;
 use pyo3::prelude::*;
@@ -11,12 +12,12 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use bus::{InvalidateBus, LocalBus, RedisPubSubBus};
-use flight::{complete_flight, try_enter_flight, wait_for_flight, Flight, FlightStatus};
-use storage::{CacheEntry, InMemoryStorage, LmdbStorage, RedisStorage, Storage};
-use trie::{build_dependency_snapshots, validate_dependencies, PrefixTrie};
+use flight::{Flight, FlightStatus, complete_flight, try_enter_flight, wait_for_flight};
 use std::sync::mpsc::{self, Sender};
 use std::thread;
 use std::time::{Duration, Instant};
+use storage::{CacheEntry, InMemoryStorage, LmdbStorage, RedisStorage, Storage};
+use trie::{PrefixTrie, build_dependency_snapshots, validate_dependencies};
 
 #[pyclass]
 struct Core {
@@ -35,23 +36,31 @@ struct Core {
 impl Core {
     #[new]
     #[pyo3(signature = (storage_url=None, bus_url=None, prefix=None, default_ttl=None, read_extend_ttl=true, max_entries=None))]
-    fn new(storage_url: Option<&str>, bus_url: Option<&str>, prefix: Option<&str>, default_ttl: Option<u64>, read_extend_ttl: bool, max_entries: Option<usize>) -> PyResult<Self> {
+    fn new(
+        storage_url: Option<&str>,
+        bus_url: Option<&str>,
+        prefix: Option<&str>,
+        default_ttl: Option<u64>,
+        read_extend_ttl: bool,
+        max_entries: Option<usize>,
+    ) -> PyResult<Self> {
         let storage: Arc<dyn Storage> = match storage_url {
-            Some(url) if url.starts_with("redis://") => Arc::new(
-                RedisStorage::new(url, prefix)
-                    .map_err(|e| PyErr::new::<pyo3::exceptions::PyConnectionError, _>(e.to_string()))?,
-            ),
+            Some(url) if url.starts_with("redis://") => {
+                Arc::new(RedisStorage::new(url, prefix).map_err(|e| {
+                    PyErr::new::<pyo3::exceptions::PyConnectionError, _>(e.to_string())
+                })?)
+            }
             Some(url) if url.starts_with("lmdb://") => {
                 let path = &url[7..];
-                Arc::new(
-                    LmdbStorage::new(path)
-                        .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?,
-                )
+                Arc::new(LmdbStorage::new(path).map_err(|e| {
+                    PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string())
+                })?)
             }
             Some(url) => {
-                return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
-                    format!("Unsupported storage scheme: {}", url),
-                ))
+                return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                    "Unsupported storage scheme: {}",
+                    url
+                )));
             }
             None => Arc::new(InMemoryStorage::new()),
         };
@@ -61,10 +70,10 @@ impl Core {
         let bus: Arc<dyn InvalidateBus> = match bus_url {
             Some(url) => {
                 let channel = prefix.map(|p| format!("{}:invalidate", p));
-                let r_bus = Arc::new(
-                    RedisPubSubBus::new(url, channel.as_deref())
-                        .map_err(|e| PyErr::new::<pyo3::exceptions::PyConnectionError, _>(e.to_string()))?,
-                );
+                let r_bus =
+                    Arc::new(RedisPubSubBus::new(url, channel.as_deref()).map_err(|e| {
+                        PyErr::new::<pyo3::exceptions::PyConnectionError, _>(e.to_string())
+                    })?);
 
                 let t_clone = trie.clone();
                 r_bus.start_listener(move |tag, ver| {
@@ -79,21 +88,25 @@ impl Core {
         if default_ttl.is_some() && read_extend_ttl {
             let (tx, rx) = mpsc::channel::<(String, u64)>();
             let storage_worker = Arc::clone(&storage);
-            
+
             thread::spawn(move || {
                 let mut last_touches: HashMap<String, Instant> = HashMap::new();
                 while let Ok((key, ttl)) = rx.recv() {
                     let now = Instant::now();
-                    if last_touches.get(&key).is_some_and(|&last| now.duration_since(last) < Duration::from_secs(60)) {
+                    if last_touches
+                        .get(&key)
+                        .is_some_and(|&last| now.duration_since(last) < Duration::from_secs(60))
+                    {
                         continue;
                     }
-                    
+
                     storage_worker.touch(&key, ttl);
                     last_touches.insert(key, now);
-                    
-                    // Periodic cleanup of last_touches to avoid memory leak
+
                     if last_touches.len() > 10000 {
-                         last_touches.retain(|_, &mut instant| now.duration_since(instant) < Duration::from_secs(300));
+                        last_touches.retain(|_, &mut instant| {
+                            now.duration_since(instant) < Duration::from_secs(300)
+                        });
                     }
                 }
             });
@@ -138,7 +151,11 @@ impl Core {
     }
 
     #[allow(clippy::type_complexity)]
-    fn get_or_entry_async(&self, py: Python, key: &str) -> PyResult<(Option<Py<PyAny>>, bool, Option<Py<PyAny>>)> {
+    fn get_or_entry_async(
+        &self,
+        py: Python,
+        key: &str,
+    ) -> PyResult<(Option<Py<PyAny>>, bool, Option<Py<PyAny>>)> {
         if let Some(res) = self.get(py, key)? {
             return Ok((Some(res), false, None));
         }
@@ -149,8 +166,12 @@ impl Core {
             return Ok((None, true, None));
         }
 
-        // Return the existing future if it exists
-        let fut = flight.py_future.lock().unwrap().as_ref().map(|f| f.clone_ref(py));
+        let fut = flight
+            .py_future
+            .lock()
+            .unwrap()
+            .as_ref()
+            .map(|f| f.clone_ref(py));
         Ok((None, false, fut))
     }
 
@@ -162,7 +183,13 @@ impl Core {
     }
 
     #[pyo3(signature = (key, is_error, value=None))]
-    fn finish_flight(&self, py: Python, key: &str, is_error: bool, value: Option<Py<PyAny>>) -> Option<Py<PyAny>> {
+    fn finish_flight(
+        &self,
+        py: Python,
+        key: &str,
+        is_error: bool,
+        value: Option<Py<PyAny>>,
+    ) -> Option<Py<PyAny>> {
         py.detach(|| complete_flight(&self.flights, key, is_error, value))
     }
 
@@ -177,7 +204,6 @@ impl Core {
 
         let global_version = self.trie.get_global_version();
 
-        // Short-circuit: O(1) validation if no invalidations occurred globally
         if entry.trie_version == global_version {
             return Ok(Some(entry.value.clone_ref(py)));
         }
@@ -189,8 +215,6 @@ impl Core {
             return Ok(None);
         }
 
-        // Lazy Update: Re-stamp the entry with the current global version
-        // so that the next hit can use the O(1) short-circuit.
         let current_global_version = self.trie.get_global_version();
         if entry.trie_version < current_global_version {
             let storage = Arc::clone(&self.storage);
@@ -203,7 +227,6 @@ impl Core {
             py.detach(move || storage.set(key_str, updated_entry, None));
         }
 
-        // TTI: Deferred refresh
         if let (Some(tx), Some(ttl)) = (&self.tti_tx, self.default_ttl) {
             let _ = tx.send((key.to_string(), ttl));
         }
@@ -212,7 +235,14 @@ impl Core {
     }
 
     #[pyo3(signature = (key, value, dependencies, ttl=None))]
-    fn set(&self, py: Python, key: String, value: Py<PyAny>, dependencies: Vec<String>, ttl: Option<u64>) {
+    fn set(
+        &self,
+        py: Python,
+        key: String,
+        value: Py<PyAny>,
+        dependencies: Vec<String>,
+        ttl: Option<u64>,
+    ) {
         let trie_version = self.trie.get_global_version();
         let snapshots = py.detach(|| build_dependency_snapshots(&self.trie, dependencies));
         let entry = Arc::new(CacheEntry {
@@ -222,10 +252,10 @@ impl Core {
         });
         let storage = Arc::clone(&self.storage);
         let final_ttl = ttl.or(self.default_ttl);
-        
+
         py.detach(|| {
             storage.set(key, entry, final_ttl);
-            
+
             if let Some(max) = self.max_entries {
                 let current = storage.len();
                 if current > max {
@@ -271,7 +301,7 @@ fn hash_key(_py: Python<'_>, obj: Bound<'_, PyAny>, prefix: Option<&str>) -> PyR
     let mut data = Vec::new();
     let mut serializer = rmp_serde::Serializer::new(&mut data);
     let mut depythonizer = pythonize::Depythonizer::from_object(&obj);
-    
+
     serde_transcode::transcode(&mut depythonizer, &mut serializer)
         .map_err(|e| PyErr::new::<pyo3::exceptions::PyTypeError, _>(e.to_string()))?;