persistent-function-cache 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

persistent_cache/caches/deep_learning.py

@@ -1,18 +1,5 @@
-from collections.abc import Callable
+import functools
 
 from persistent_cache.main import decorator
-from persistent_cache.models import F, Path
-from persistent_cache.reducers import Reducer
 
-
-def cache(
-    function: F | None = None,
-    *,
-    key_reducer: type[Reducer] | None = None,
-    cache_path: Path = Path.cache,
-) -> Callable[[F], F]:
-    if key_reducer is None:
-        from persistent_cache.reducers import deep_learning
-
-        key_reducer = deep_learning.Reducer
-    return decorator.cache(function, key_reducer=key_reducer, cache_path=cache_path)
+cache = functools.partial(decorator.cache, deep_learning=True)

persistent_cache/caches/speedup_deep_learning.py

@@ -1,18 +1,5 @@
-from collections.abc import Callable
+import functools
 
 from persistent_cache.main import decorator
-from persistent_cache.models import F, Path
-from persistent_cache.reducers import Reducer
 
-
-def cache(
-    function: F | None = None,
-    *,
-    key_reducer: type[Reducer] | None = None,
-    cache_path: Path = Path.cache,
-) -> Callable[[F], F]:
-    if key_reducer is None:
-        from persistent_cache.reducers import speedup_deep_learning
-
-        key_reducer = speedup_deep_learning.Reducer
-    return decorator.cache(function, key_reducer=key_reducer, cache_path=cache_path)
+cache = functools.partial(decorator.cache, speedup_deep_learning=True)

persistent_cache/main/cache_slot.py

@@ -0,0 +1,90 @@
+import inspect
+import pickle
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any
+
+from persistent_cache.models import Path
+from persistent_cache.reducers.base import Reducer
+
+from . import hashing
+
+
+@dataclass
+class CacheSlot:
+    function: Callable[..., Any]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+    directory: Path
+    key_arguments: Iterable[str] | str | None
+    extra_keys: Any
+    key_reducer: type[Reducer] | None
+    deep_learning: bool
+    speedup_deep_learning: bool
+
+    @property
+    def value(self) -> Any:
+        try:
+            with self.path.open("rb") as fp:
+                return pickle.Unpickler(fp).load()  # noqa: S301
+        except (pickle.UnpicklingError, EOFError):
+            # discard values of corrupted or empty slots
+            raise KeyError from None
+
+    @value.setter
+    def value(self, value: Any) -> None:
+        self.path.byte_content = pickle.dumps(value)
+
+    @cached_property
+    def path(self) -> Path:
+        return (
+            self.directory
+            / self.function.__module__.replace(".", "_")
+            / self.function.__name__
+            / hashing.compute_hash(self.reducer, self.keys)
+        )
+
+    @property
+    def keys(self) -> Iterator[Any]:
+        yield self.function
+        is_iterable = isinstance(self.extra_keys, Iterable) and not isinstance(
+            self.extra_keys,
+            str | bytes | bytearray,
+        )
+        if is_iterable:
+            yield from self.extra_keys
+        else:
+            yield self.extra_keys
+        yield from self.argument_values
+
+    @property
+    def argument_values(self) -> Iterator[Any]:
+        if self.key_arguments is None:
+            yield from self.args
+            yield from self.kwargs.values()
+        else:
+            arguments = inspect.signature(self.function).bind(*self.args, **self.kwargs)
+            arguments.apply_defaults()
+            if isinstance(self.key_arguments, str):
+                yield arguments.arguments.get(self.key_arguments)
+            else:
+                for name in self.key_arguments:
+                    yield arguments.arguments.get(name)
+
+    @property
+    def reducer(self) -> type[Reducer]:
+        if self.key_reducer is not None:
+            return self.key_reducer
+        if self.deep_learning:
+            from persistent_cache.reducers.deep_learning import Reducer as Reducer_
+
+            return Reducer_
+        if self.speedup_deep_learning:
+            from persistent_cache.reducers.speedup_deep_learning import (
+                Reducer as Reducer_,
+            )
+
+            return Reducer_
+
+        return Reducer

persistent_cache/main/decorator.py

@@ -1,19 +1,25 @@
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from functools import wraps
-from typing import Any, cast, overload
+from typing import Any, TypeVar, cast, overload
 
-from persistent_cache.models import F, Path
+from persistent_cache.models import Path
 from persistent_cache.reducers.base import Reducer
 
-from .cacheslot import CacheSlot
+from .cache_slot import CacheSlot
+
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 @overload
 def cache(
     function: F,
     *,
+    cache_directory: Path = Path.cache,
+    cache_key_arguments: Iterable[str] | str | None = None,
+    extra_cache_keys: Iterable[Any] | None = None,
     key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
+    deep_learning: bool = False,
+    speedup_deep_learning: bool = False,
 ) -> F: ...
 
 
@@ -21,16 +27,24 @@ def cache(
 def cache(
     function: None = None,
     *,
+    cache_directory: Path = Path.cache,
+    cache_key_arguments: Iterable[str] | str | None = None,
+    extra_cache_keys: Any = None,
     key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
+    deep_learning: bool = False,
+    speedup_deep_learning: bool = False,
 ) -> Callable[[F], F]: ...
 
 
-def cache(
+def cache(  # noqa: PLR0913
     function: F | None = None,
     *,
-    key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
+    cache_directory: Path = Path.cache,
+    cache_key_arguments: Iterable[str] | str | None = None,
+    extra_cache_keys: Any = None,
+    key_reducer: type[Reducer] | None = None,
+    deep_learning: bool = False,
+    speedup_deep_learning: bool = False,
 ) -> F | Callable[[F], F]:
     """A decorator to cache function results. Decorated functions are only executed if
     result is not present in cache. The arguments of the function can be any nested
@@ -45,16 +59,26 @@ def cache(
         ...
     """
 
-    def cache_decorator(function: F) -> F:
-        @wraps(function)
+    def cache_decorator(function_: F) -> F:
+        @wraps(function_)
         def wrapped_function(*args: Any, **kwargs: Any) -> Any:
-            cache_slot = CacheSlot(function, args, kwargs, key_reducer, cache_path)
+            cache_slot = CacheSlot(
+                function_,
+                args,
+                kwargs,
+                cache_directory,
+                cache_key_arguments,
+                extra_cache_keys,
+                key_reducer,
+                deep_learning,
+                speedup_deep_learning,
+            )
             try:
-                value = cache_slot.value
+                result = cache_slot.value
             except KeyError:
-                value = function(*args, **kwargs)
-                cache_slot.value = value
-            return value
+                result = function_(*args, **kwargs)
+                cache_slot.value = result
+            return result
 
         return cast(F, wrapped_function)
 

persistent_cache/main/hashing.py

@@ -54,7 +54,7 @@ class HashPickler(pickle.Pickler):
             reduction = NotImplemented
         else:
             mapping = reducer(obj)
-            str_mapping = str(object_to_bytes(self.reducer, mapping))
+            str_mapping = str(item_to_bytes(self.reducer, mapping))
             reduction = str, (str_mapping,)
         return reduction
 
@@ -65,15 +65,16 @@ class HashPickler(pickle.Pickler):
                     yield reducer
 
 
-def compute_hash(key_reducer: type[Reducer], *args: Any) -> str:
-    data = object_to_bytes(key_reducer, args)
+def compute_hash(key_reducer: type[Reducer], items: Iterator[Any]) -> str:
+    data = item_to_bytes(key_reducer, tuple(items))
     # use fast hash function because it is not used for security
     return hashlib.new("sha1", data=data, usedforsecurity=False).hexdigest()
 
 
-def object_to_bytes(key_reducer: type[Reducer], args: Any) -> bytes:
+def item_to_bytes(key_reducer: type[Reducer], item: Any) -> bytes:
     with io.BytesIO() as fp:
         # Use custom pickler to generate bytes from complex structures
-        HashPickler(fp, key_reducer).dump(args)
+        pickler = HashPickler(fp, key_reducer)
+        pickler.dump(item)
         fp.seek(0)
         return fp.read()

persistent_cache/models/__init__.py

@@ -1,2 +1 @@
-from .function import F
 from .path import Path

{persistent_function_cache-0.1.1.dist-info → persistent_function_cache-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: persistent-function-cache
-Version: 0.1.1
+Version: 0.2.1
 Summary: Persistent cache for expensive functions
 Author-email: Quinten Roets <qdr2104@columbia.edu>
 License: MIT

{persistent_function_cache-0.1.1.dist-info → persistent_function_cache-0.2.1.dist-info}/RECORD

@@ -1,24 +1,23 @@
 persistent_cache/__init__.py,sha256=VUq2BaLpsu66LXVBmRSBHGspctti2qavBqJNyja2yf8,91
 persistent_cache/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 persistent_cache/caches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-persistent_cache/caches/deep_learning.py,sha256=mFqdc72GylCrM6rDjN0gTt13xYQhDVOghdpF9htHL7o,545
-persistent_cache/caches/speedup_deep_learning.py,sha256=zebw9KM1JkOxQIFHEvc1iBwfzu0D3oX9N_u_FmdcHgQ,561
+persistent_cache/caches/deep_learning.py,sha256=tJQrRJK2Sbv7tIGwnrnFAn8nP-Fh7ZgugocKcXeiMnU,126
+persistent_cache/caches/speedup_deep_learning.py,sha256=bywNXeEZsg8Rs2A1_w-ZrJi9Ew2TvNCz59YryGyV0NI,134
 persistent_cache/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 persistent_cache/cli/clear_cache.py,sha256=YbKfqzUB9IyEpU-2n0h5BrK9kZKjbayqiMTzjPbDl3s,1541
 persistent_cache/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-persistent_cache/main/cacheslot.py,sha256=XIobyDDtMx1KpVxcz9dKo6-QEsFmK9Xej5j6dFieXk4,1246
-persistent_cache/main/decorator.py,sha256=ekRSAru2cRA6yU0rkpwzyQVnIw1qmW_kTCgSUSrm4nk,1572
-persistent_cache/main/hashing.py,sha256=YP_HO9nJe2_ZkiQf-unM6W9y_k5TJW1JvWeZfPIXtug,2650
-persistent_cache/models/__init__.py,sha256=No2WagrzFJdeQE3hTIeFd2H8hhvvAFcdVH6z07D1vmI,47
-persistent_cache/models/function.py,sha256=C1w0rVOhUkqvpPkXNj85rc4GSJDqT0oIZLsZvhVwn58,113
+persistent_cache/main/cache_slot.py,sha256=9zBrcTGJ-oEUryftiGqBks_mdrkX2s_c0b2Pisc5vvU,2716
+persistent_cache/main/decorator.py,sha256=tvrgv_lTxldgxfWnvzJKvDC00oE8eenPY5VdPZxiywM,2439
+persistent_cache/main/hashing.py,sha256=6GYzUJcqjfjHPWMqPOCEY9FUSH2k2zUGrUza2fKaMTQ,2688
+persistent_cache/models/__init__.py,sha256=1OeLZ6FZ5gAjlerAjc69Vx0AqWLSx6OSqNCpuzkCZQg,23
 persistent_cache/models/path.py,sha256=-HRJ4yqqmBPlax4H0KS8guhndBXNwCnl7WZXhtaWmGQ,441
 persistent_cache/reducers/__init__.py,sha256=hCozFuvrAb_gXLcqMMq92v4KdwBbQugwGwCmyLGt5RE,26
 persistent_cache/reducers/base.py,sha256=HsodcuE8Id5oV93_b_RN18I69UWsJ21yazXCwT1f6YU,1428
 persistent_cache/reducers/deep_learning.py,sha256=cyVolwmwm_ZN2gRxPtfJFqiNQlNuq_CrehO7ZSVWeVw,800
 persistent_cache/reducers/speedup_deep_learning.py,sha256=kMkr1467zUsQUPOi_N8tWKWAtKUcFgsk3rh94QhETg0,1970
-persistent_function_cache-0.1.1.dist-info/LICENSE,sha256=ENpNaBSvIV7ifD7iNz_-lBhImbiYowqPzBc5V5R8IhM,1070
-persistent_function_cache-0.1.1.dist-info/METADATA,sha256=XvGcWqgMSIS0u2b0zM9y5zxiW6KZ5h-Bkr-lG0ZhuHs,2164
-persistent_function_cache-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-persistent_function_cache-0.1.1.dist-info/entry_points.txt,sha256=fSZfuL6Wn42mZldojgGyg7dzSPCRVAuZox3w6dLd2ZI,88
-persistent_function_cache-0.1.1.dist-info/top_level.txt,sha256=Jj-Z9wxHRlRyDUxrfC9GeaV5-8hAf8R4LclQFZesxi8,17
-persistent_function_cache-0.1.1.dist-info/RECORD,,
+persistent_function_cache-0.2.1.dist-info/LICENSE,sha256=ENpNaBSvIV7ifD7iNz_-lBhImbiYowqPzBc5V5R8IhM,1070
+persistent_function_cache-0.2.1.dist-info/METADATA,sha256=E_GxkYLEh9vSXGpVYv9cKAMDTjqHRJDZc6d44WcqQXs,2164
+persistent_function_cache-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+persistent_function_cache-0.2.1.dist-info/entry_points.txt,sha256=fSZfuL6Wn42mZldojgGyg7dzSPCRVAuZox3w6dLd2ZI,88
+persistent_function_cache-0.2.1.dist-info/top_level.txt,sha256=Jj-Z9wxHRlRyDUxrfC9GeaV5-8hAf8R4LclQFZesxi8,17
+persistent_function_cache-0.2.1.dist-info/RECORD,,

persistent_cache/main/cacheslot.py

@@ -1,43 +0,0 @@
-import pickle
-from collections.abc import Callable
-from typing import Any, Generic, TypeVar, cast
-
-from persistent_cache.models import Path
-from persistent_cache.reducers.base import Reducer
-
-from . import hashing
-
-T = TypeVar("T")
-
-
-class CacheSlot(Generic[T]):
-    def __init__(
-        self,
-        function: Callable[..., T],
-        args: tuple[Any, ...],
-        kwargs: Any,
-        key_reducer: type[Reducer] = Reducer,
-        cache_path: Path = Path.cache,
-    ) -> None:
-        # change cache key when implementation changes
-        cache_keys = (function, args, kwargs)
-        self.location = (
-            cache_path
-            / function.__module__.replace(".", "_")
-            / function.__name__
-            / hashing.compute_hash(key_reducer, cache_keys)
-        )
-
-    @property
-    def value(self) -> T:
-        try:
-            with self.location.open("rb") as fp:
-                value = pickle.Unpickler(fp).load()  # noqa: S301
-        except (pickle.UnpicklingError, EOFError):
-            # discard values of corrupted or empty slots
-            raise KeyError from None
-        return cast(T, value)
-
-    @value.setter
-    def value(self, value: T) -> None:
-        self.location.byte_content = pickle.dumps(value)

persistent_cache/models/function.py

@@ -1,4 +0,0 @@
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-F = TypeVar("F", bound=Callable[..., Any])