dependency-cache 0.1.0__tar.gz → 0.1.1__tar.gz

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/.github/workflows/Test.yml

@@ -5,6 +5,7 @@ on:
     branches: [ "master" ]
   pull_request:
     branches: [ "master" ]
+    types: [ opened, synchronize, reopened, ready_for_review ]
 
 env:
   CARGO_TERM_COLOR: always
@@ -12,6 +13,7 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request' || github.event.pull_request.draft == false
 
     steps:
     - uses: actions/checkout@v4

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dependency_cache
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: matplotlib>=3.7.5
 Requires-Dist: networkx>=3.1
 License-File: LICENSE
-Summary: A caching system with a dependency graph for invalidation
+Summary: A caching system for object methods that utilises a dependency graph to track relationships and trigger invalidation
 Keywords: caching,dependency-graph,invalidation
 License: MIT
 Requires-Python: >=3.8
@@ -24,13 +24,21 @@ A library for managing the caching of an object's methods with cache invalidatio
 Instead of recomputing expensive, deeply nested calculations on every call, Dependency Cache stores the result and only invalidates (and recalculates) it when one of its dependencies actually changes.
 This project is written in rust, with [pyo3](https://github.com/PyO3/pyo3), and compiled using [maturin](https://github.com/PyO3/maturin).
 
+### Installation
+
+Install the latest stable version from [PyPI](https://pypi.org/project/dependency-cache/):
+
+```bash
+pip install dependency-cache
+```
+
 ### API Overview
 
 | Export | What it's for |
 |---|---|
 | `DependencyCacheBase` | Base class to inherit from. Gives your instance a cache and a dependency graph. |
-| `dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=False)` | A footgun-enabled :gun: decorator for a method where you **explicitly declare** direct dependencies. |
-| `automagically_dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=True)` | A decorator which **automagically infers** the direct dependencies with the option to override manually using `dependencies=`. |
+| `dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=False)` | A footgun-enabled decorator for a method where you **explicitly declare** all direct dependencies. |
+| `automagically_dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=True)` | A decorator which **automagically infers** the direct dependencies. Optionally override the defaults and inference using the `dependencies` parameter. |
 | `plot_dependency_graph(obj, **kwargs)` | Visualizes an instance's dependency graph, for inspection/debugging. |
 
 ### Setup

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/README.md

@@ -6,13 +6,21 @@ A library for managing the caching of an object's methods with cache invalidatio
 Instead of recomputing expensive, deeply nested calculations on every call, Dependency Cache stores the result and only invalidates (and recalculates) it when one of its dependencies actually changes.
 This project is written in rust, with [pyo3](https://github.com/PyO3/pyo3), and compiled using [maturin](https://github.com/PyO3/maturin).
 
+### Installation
+
+Install the latest stable version from [PyPI](https://pypi.org/project/dependency-cache/):
+
+```bash
+pip install dependency-cache
+```
+
 ### API Overview
 
 | Export | What it's for |
 |---|---|
 | `DependencyCacheBase` | Base class to inherit from. Gives your instance a cache and a dependency graph. |
-| `dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=False)` | A footgun-enabled :gun: decorator for a method where you **explicitly declare** direct dependencies. |
-| `automagically_dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=True)` | A decorator which **automagically infers** the direct dependencies with the option to override manually using `dependencies=`. |
+| `dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=False)` | A footgun-enabled decorator for a method where you **explicitly declare** all direct dependencies. |
+| `automagically_dependency_cached(use_cache=True, dependencies=[...], track_runtime_dependencies=True)` | A decorator which **automagically infers** the direct dependencies. Optionally override the defaults and inference using the `dependencies` parameter. |
 | `plot_dependency_graph(obj, **kwargs)` | Visualizes an instance's dependency graph, for inspection/debugging. |
 
 ### Setup

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/pyproject.toml

@@ -11,8 +11,8 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 keywords = ["caching", "dependency-graph", "invalidation"]
-version = "0.1.0"
-description = "A caching system with a dependency graph for invalidation"
+version = "0.1.1"
+description = "A caching system for object methods that utilises a dependency graph to track relationships and trigger invalidation"
 readme = "README.md"
 license = { text = "MIT" }
 dependencies = [

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/python/dependency_cache/dependency_cache.pyi

@@ -3,11 +3,13 @@ from typing import Any, final
 class DependencyCacheBase:
     def __new__(cls, /, *_args, **_kwargs) -> DependencyCacheBase: ...
     def clear_cache(self, /) -> None: ...
+    def dump_cache(self, /) -> dict: ...
     def get_cached_value(self, /, method_name: str, **kwargs) -> Any | None: ...
     def get_cached_value_by_hash(self, /, hash: int) -> Any | None: ...
     def get_cached_values(self, /) -> dict: ...
     def get_dependency_graph(self, /) -> dict: ...
     def get_validation_state(self, /) -> dict: ...
+    def load_cache(self, /, data: dict) -> None: ...
     def update_cached_value(
         self, /, method_name: str, value: Any, **kwargs
     ) -> None: ...
@@ -21,6 +23,7 @@ class automagically_dependency_cached:
         use_cache: bool = True,
         dependencies: Any | None = None,
         track_runtime_dependencies: bool = True,
+        serialisable: bool = False,
     ) -> automagically_dependency_cached: ...
 
 @final
@@ -32,4 +35,5 @@ class dependency_cached:
         use_cache: bool = True,
         dependencies: Any | None = None,
         track_runtime_dependencies: bool = False,
+        serialisable: bool = False,
     ) -> dependency_cached: ...

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/python/test_python.py

@@ -11,15 +11,6 @@ class IncorrectInheritance:
         return 1
 
 
-class IncorrectMethod(DependencyCacheBase):
-    def __init__(self):
-        super().__init__()
-
-    @dependency_cached()
-    def A():
-        return 1
-
-
 class SimpleTestObj(DependencyCacheBase):
     def __init__(self, x, y):
         super().__init__()
@@ -130,14 +121,41 @@ class FunctionCallObj(DependencyCacheBase):
         return total
 
 
+class SerialisableObj(DependencyCacheBase):
+    @dependency_cached(serialisable=True)
+    def A(self):
+        return None
+
+    @dependency_cached(serialisable=True)
+    def B(self):
+        return None
+
+    @dependency_cached(dependencies=["A", "B"])
+    def C(self):
+        a = self.A()
+        b = self.B()
+        if a and b:
+            return a + b
+        return None
+
+
 def test_raises_typeerror():
-    c = IncorrectInheritance()
     with pytest.raises(TypeError):
+        c = IncorrectInheritance()
         c.A()
 
 
 def test_incorrect_method_raises_valueerror():
     with pytest.raises(TypeError):
+
+        class IncorrectMethod(DependencyCacheBase):
+            def __init__(self):
+                super().__init__()
+
+            @dependency_cached()
+            def A():
+                return 1
+
         c = IncorrectMethod()
         c.A()
 
@@ -308,3 +326,22 @@ def test_incorrect_decorator_format():
             @dependency_cached()
             def B(self):
                 return 2
+
+
+@pytest.mark.parametrize(
+    ("data", "result"),
+    [
+        ({"A": 1, "B": 2}, 3),
+        ({"A": 1.45, "B": 2.55}, 4.0),
+        ({"A": "1", "B": "2"}, "12"),
+        ({"A": [1], "B": [2]}, [1, 2]),
+    ],
+)
+def test_serialising_data(data, result):
+    obj = SerialisableObj()
+
+    obj.load_cache(data)
+
+    assert obj.C() is not None
+
+    assert obj.C() == result

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/python/test_python_automagic.py

@@ -11,15 +11,6 @@ class IncorrectInheritance:
         return 1
 
 
-class IncorrectMethod(DependencyCacheBase):
-    def __init__(self):
-        super().__init__()
-
-    @automagically_dependency_cached()
-    def A():
-        return 1
-
-
 class SimpleTestObj(DependencyCacheBase):
     def __init__(self, x, y):
         super().__init__()
@@ -138,6 +129,15 @@ def test_raises_typeerror():
 
 def test_incorrect_method_raises_valueerror():
     with pytest.raises(TypeError):
+
+        class IncorrectMethod(DependencyCacheBase):
+            def __init__(self):
+                super().__init__()
+
+            @automagically_dependency_cached()
+            def A():
+                return 1
+
         c = IncorrectMethod()
         c.A()
 

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/src/decorator.rs

@@ -12,6 +12,7 @@ pub struct DependencyCacheDecorator {
     pub dependencies: Vec<isize>,
     pub method_name: String,
     pub track_runtime_dependencies: bool,
+    pub serialisable: bool,
 }
 
 #[pymethods]

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/src/decorator_factory.rs

@@ -6,6 +6,26 @@ use crate::decorator::DependencyCacheDecorator;
 use crate::normalise_method_args::normalise_and_hash_method;
 
 
+pub fn validate_self_only_method(py: Python<'_>, func: &Bound<'_, PyAny>) -> PyResult<()> {
+    let inspect = py.import("inspect")?;
+    let builtins = py.import("builtins")?;
+    let signature = inspect.call_method1("signature", (func,))?;
+    // really ugly, but the inspect.Signature type is not extractable
+    let parameters = signature.getattr("parameters")?;
+    let list_obj = builtins.call_method1("list", (parameters,))?;
+    let param_names: Vec<String> = list_obj.extract()?;
+
+    if param_names.len() != 1 || param_names[0] != "self" {
+        let msg = format!(
+            "Serialisable method must have exactly one parameter named 'self', got: {:?}",
+            param_names
+        );
+        return Err(PyValueError::new_err(msg));
+    }
+    Ok(())
+}
+
+
 fn parse_dependencies(py: Python<'_>, dep_list: &Bound<'_, PyAny>) -> PyResult<Vec<(String, Py<PyDict>)>> {
     let list = dep_list.cast::<PyList>()?;
     let mut parsed = Vec::with_capacity(list.len());
@@ -40,17 +60,20 @@ pub struct ManualDependencyCacheDecoratorFactory {
     use_cache: bool,
     dependencies: Vec<(String, Py<PyDict>)>,
     track_runtime_dependencies: bool,
+    serialisable: bool,
 }
 
 #[pymethods]
 impl ManualDependencyCacheDecoratorFactory {
+
     #[new]
-    #[pyo3(signature = (use_cache=true, dependencies=None, track_runtime_dependencies=false))]
+    #[pyo3(signature = (use_cache=true, dependencies=None, track_runtime_dependencies=false, serialisable=false))]
     fn new(
         py: Python<'_>,
         use_cache: bool,
         dependencies: Option<&Bound<'_, PyAny>>,
         track_runtime_dependencies: bool,
+        serialisable: bool,
     ) -> PyResult<Self> {
         let parsed_deps = if let Some(list) = dependencies {
             parse_dependencies(py, list)?
@@ -61,6 +84,7 @@ impl ManualDependencyCacheDecoratorFactory {
             use_cache,
             dependencies: parsed_deps,
             track_runtime_dependencies,
+            serialisable,
         });
     }
 
@@ -81,12 +105,16 @@ impl ManualDependencyCacheDecoratorFactory {
                 Ok(hash)
             })
             .collect::<PyResult<Vec<_>>>()?;
+        if self.serialisable {
+            validate_self_only_method(py, func.bind(py))?;
+        }
         return Ok(DependencyCacheDecorator {
             func,
             use_cache: self.use_cache,
             dependencies: hashed_dependencies,
             method_name,
             track_runtime_dependencies: self.track_runtime_dependencies,
+            serialisable: self.serialisable,
         });
     }
 }
@@ -96,17 +124,19 @@ pub struct AutomagicDependencyCacheDecoratorFactory {
     use_cache: bool,
     dependencies: Vec<(String, Py<PyDict>)>,
     track_runtime_dependencies: bool,
+    serialisable: bool,
 }
 
 #[pymethods]
 impl AutomagicDependencyCacheDecoratorFactory {
     #[new]
-    #[pyo3(signature = (use_cache=true, dependencies=None, track_runtime_dependencies=true))]
+    #[pyo3(signature = (use_cache=true, dependencies=None, track_runtime_dependencies=true, serialisable=false))]
     fn new(
         py: Python<'_>,
         use_cache: bool,
         dependencies: Option<&Bound<'_, PyAny>>,
         track_runtime_dependencies: bool,
+        serialisable: bool,
     ) -> PyResult<Self> {
         let parsed_deps = if let Some(list) = dependencies {
             parse_dependencies(py, list)?
@@ -117,6 +147,7 @@ impl AutomagicDependencyCacheDecoratorFactory {
             use_cache,
             dependencies: parsed_deps,
             track_runtime_dependencies,
+            serialisable,
         });
     }
 
@@ -137,12 +168,16 @@ impl AutomagicDependencyCacheDecoratorFactory {
                 Ok(hash)
             })
             .collect::<PyResult<Vec<_>>>()?;
+        if self.serialisable {
+            validate_self_only_method(py, func.bind(py))?;
+        }
         return Ok(DependencyCacheDecorator {
             func,
             use_cache: self.use_cache,
             dependencies: hashed_dependencies,
             method_name,
             track_runtime_dependencies: self.track_runtime_dependencies,
+            serialisable: self.serialisable,
         });
     }
 }

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/src/dependency_cache_base.rs

@@ -1,11 +1,12 @@
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyTuple, PyString, PySet};
+use pyo3::types::{PyDict, PyTuple, PyString, PySet, PyType};
+use pyo3::exceptions::PyValueError;
 
-use std::collections::{HashMap};
+use std::collections::{HashMap, HashSet};
 
 use crate::dependency_graph::{MethodDependencyGraph, ValidationState};
 use crate::normalise_method_args::normalise_and_hash_method;
-
+use crate::decorator::DependencyCacheDecorator;
 
 #[pyclass(subclass)]
 pub struct DependencyCacheBase {
@@ -269,4 +270,55 @@ impl DependencyCacheBase {
         }
         Ok(dict)
     }
+
+    pub fn dump_cache<'py>(slf: &Bound<'py, Self>, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        let cls = slf.get_type();
+
+        let mut visited = HashSet::new();
+        let mut serialisable_methods = Vec::new();
+
+        for mro_class in cls.mro().iter() {
+            let mro_class: Bound<'_, PyType> = mro_class.extract()?;
+            let namespace = mro_class.getattr("__dict__")?;
+            for item in namespace.call_method0("items")?.try_iter()? {
+                let (name, value): (String, Bound<'_, PyAny>) = item?.extract()?;
+                if name.starts_with("__") || !visited.insert(name.clone()) {
+                    continue;
+                }
+                if let Ok(decorator) = value.cast::<DependencyCacheDecorator>() {
+                    if decorator.borrow().serialisable {
+                        serialisable_methods.push(name);
+                    }
+                }
+            }
+        }
+
+        let result = PyDict::new(py);
+        for method_name in serialisable_methods {
+            let value = slf.call_method(&method_name, (), None)?;
+            result.set_item(method_name, value)?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn load_cache<'py>(
+        slf: &Bound<'_, Self>,
+        py: Python<'py>,
+        data: Bound<'py, PyDict>,
+    ) -> PyResult<()> {
+        for (key, loaded_value) in data.iter() {
+            let method_name: String = key.extract()?;
+
+            let _ = slf.call_method(&method_name, (), None)?;
+
+            let empty_args = PyTuple::empty(py);
+            let (hash, _) = normalise_and_hash_method(py, &method_name, None, &empty_args, None)
+                .map_err(|e| PyValueError::new_err(format!("Failed to hash '{}': {}", method_name, e)))?;
+
+            slf.borrow_mut().cache.insert(hash, loaded_value.unbind());
+        }
+
+        Ok(())
+    }
 }

{dependency_cache-0.1.0 → dependency_cache-0.1.1}/uv.lock

@@ -329,7 +329,7 @@ wheels = [
 
 [[package]]
 name = "dependency-cache"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "matplotlib", version = "3.7.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" },