persistent-function-cache 0.1.1__tar.gz → 0.2.0__tar.gz

{persistent_function_cache-0.1.1/src/persistent_function_cache.egg-info → persistent_function_cache-0.2.0}/PKG-INFO

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

{persistent_function_cache-0.1.1 → persistent_function_cache-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "persistent-function-cache"
-version = "0.1.1"
+version = "0.2.0"
 description = "Persistent cache for expensive functions"
 authors = [{name = "Quinten Roets", email = "qdr2104@columbia.edu"}]
 license = {text = "MIT"}

persistent_function_cache-0.2.0/src/persistent_cache/caches/deep_learning.py

@@ -0,0 +1,5 @@
+import functools
+
+from persistent_cache.main import decorator
+
+cache = functools.partial(decorator.cache, deep_learning=True)

persistent_function_cache-0.2.0/src/persistent_cache/caches/speedup_deep_learning.py

@@ -0,0 +1,5 @@
+import functools
+
+from persistent_cache.main import decorator
+
+cache = functools.partial(decorator.cache, speedup_deep_learning=True)

{persistent_function_cache-0.1.1 → persistent_function_cache-0.2.0}/src/persistent_cache/main/cacheslot.py

@@ -15,12 +15,11 @@ class CacheSlot(Generic[T]):
         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)
+        cache_keys = (function, args)
         self.location = (
             cache_path
             / function.__module__.replace(".", "_")

persistent_function_cache-0.2.0/src/persistent_cache/main/decorator.py

@@ -0,0 +1,122 @@
+import inspect
+from collections.abc import Callable, Iterator
+from functools import wraps
+from typing import Any, cast, overload
+
+from persistent_cache.models import F, Path
+from persistent_cache.reducers.base import Reducer
+
+from .cacheslot import CacheSlot
+
+
+@overload
+def cache(
+    function: F,
+    *,
+    cache_path: Path = Path.cache,
+    cache_key_arguments: tuple[str, ...] | str | None = None,
+    key_reducer: type[Reducer] = Reducer,
+    deep_learning: bool = False,
+    speedup_deep_learning: bool = False,
+) -> F: ...
+
+
+@overload
+def cache(
+    function: None = None,
+    *,
+    cache_path: Path = Path.cache,
+    cache_key_arguments: tuple[str, ...] | str | None = None,
+    key_reducer: type[Reducer] = Reducer,
+    deep_learning: bool = False,
+    speedup_deep_learning: bool = False,
+) -> Callable[[F], F]: ...
+
+
+def cache(  # noqa: PLR0913
+    function: F | None = None,
+    *,
+    cache_path: Path = Path.cache,
+    cache_key_arguments: tuple[str, ...] | str | None = 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
+    complex object.
+
+    Use as:
+
+    from persistent_cache import cache
+
+    @cache
+    def long_function(complex_object):
+        ...
+    """
+
+    reducer = extract_reducer(
+        key_reducer,
+        deep_learning=deep_learning,
+        speedup_deep_learning=speedup_deep_learning,
+    )
+
+    def cache_decorator(function: F) -> F:
+        @wraps(function)
+        def wrapped_function(*args: Any, **kwargs: Any) -> Any:
+            arguments = tuple(
+                extract_argument_values(function, args, kwargs, cache_key_arguments),
+            )
+            cache_slot = CacheSlot(function, arguments, reducer, cache_path)
+            try:
+                value = cache_slot.value
+            except KeyError:
+                value = function(*args, **kwargs)
+                cache_slot.value = value
+            return value
+
+        return cast(F, wrapped_function)
+
+    if function is not None:
+        cache_decorator = cache_decorator(function)
+    return cache_decorator
+
+
+def extract_argument_values(
+    function: F,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    cache_key_arguments: tuple[str, ...] | str | None = None,
+) -> Iterator[Any]:
+    if cache_key_arguments is None:
+        yield from (args, kwargs)
+    else:
+        arguments = inspect.signature(function).bind(*args, **kwargs)
+        arguments.apply_defaults()
+        if isinstance(cache_key_arguments, str):
+            yield arguments.arguments.get(cache_key_arguments)
+        else:
+            for name in cache_key_arguments:
+                yield arguments.arguments.get(name)
+
+
+def extract_reducer(
+    reducer: type[Reducer] | None,
+    *,
+    deep_learning: bool,
+    speedup_deep_learning: bool,
+) -> type[Reducer]:
+    if reducer is None:
+        if deep_learning:
+            from persistent_cache.reducers.deep_learning import Reducer as Reducer_
+
+            reducer = Reducer_
+        elif speedup_deep_learning:
+            from persistent_cache.reducers.speedup_deep_learning import (
+                Reducer as Reducer_,
+            )
+
+            reducer = Reducer_
+        else:
+            reducer = Reducer
+    return reducer

{persistent_function_cache-0.1.1 → persistent_function_cache-0.2.0/src/persistent_function_cache.egg-info}/PKG-INFO

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

{persistent_function_cache-0.1.1 → persistent_function_cache-0.2.0}/tests/test_cache.py

@@ -11,6 +11,10 @@ from persistent_cache import cache, deep_learning, speedup_deep_learning
 caches = [cache, deep_learning.cache, speedup_deep_learning.cache]
 
 
+def calculate_with_name(value: str) -> None:
+    cli.console.print(value)
+
+
 def calculate(*args: Any, **kwargs: Any) -> None:
     cli.console.print("calculation started")
     cli.console.print(args, kwargs)
@@ -31,3 +35,21 @@ def test_cache_with_argument_combination(cache_decorator: Callable[..., Any]) ->
 def test_cache_as_function(cache_decorator: Callable[..., Any]) -> None:
     cached_function = cache_decorator()(calculate)
     verify_cached_function(cached_function)
+
+
+@pytest.mark.parametrize("cache_decorator", caches)
+def test_cache_with_argument_name(
+    cache_decorator: Callable[..., Any],
+) -> None:
+    cached_function = cache_decorator(calculate_with_name, cache_key_arguments="value")
+    cached_function("test")
+
+
+@pytest.mark.parametrize("cache_decorator", caches)
+def test_cache_with_argument_names(cache_decorator: Callable[..., Any]) -> None:
+    cache_key_arguments = ("value",)
+    cached_function = cache_decorator(
+        calculate_with_name,
+        cache_key_arguments=cache_key_arguments,
+    )
+    cached_function("test")

persistent_function_cache-0.1.1/src/persistent_cache/caches/deep_learning.py

@@ -1,18 +0,0 @@
-from collections.abc import Callable
-
-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)

persistent_function_cache-0.1.1/src/persistent_cache/caches/speedup_deep_learning.py

@@ -1,18 +0,0 @@
-from collections.abc import Callable
-
-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)

persistent_function_cache-0.1.1/src/persistent_cache/main/decorator.py

@@ -1,63 +0,0 @@
-from collections.abc import Callable
-from functools import wraps
-from typing import Any, cast, overload
-
-from persistent_cache.models import F, Path
-from persistent_cache.reducers.base import Reducer
-
-from .cacheslot import CacheSlot
-
-
-@overload
-def cache(
-    function: F,
-    *,
-    key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
-) -> F: ...
-
-
-@overload
-def cache(
-    function: None = None,
-    *,
-    key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
-) -> Callable[[F], F]: ...
-
-
-def cache(
-    function: F | None = None,
-    *,
-    key_reducer: type[Reducer] = Reducer,
-    cache_path: Path = Path.cache,
-) -> 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
-    complex object.
-
-    Use as:
-
-    from persistent_cache import cache
-
-    @cache
-    def long_function(complex_object):
-        ...
-    """
-
-    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)
-            try:
-                value = cache_slot.value
-            except KeyError:
-                value = function(*args, **kwargs)
-                cache_slot.value = value
-            return value
-
-        return cast(F, wrapped_function)
-
-    if function is not None:
-        cache_decorator = cache_decorator(function)
-    return cache_decorator