persistent-function-cache 0.1.0__tar.gz

persistent_function_cache-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Quinten Roets
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

persistent_function_cache-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: persistent-function-cache
+Version: 0.1.0
+Summary: Persistent cache for expensive functions
+Author-email: Quinten Roets <qdr2104@columbia.edu>
+License: MIT
+Project-URL: Source Code, https://github.com/quintenroets/persistent-cache
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: package-utils<1,>=0.6.7
+Requires-Dist: powercli<1,>=0.3.2
+Requires-Dist: superpathlib<3,>=2.0.9
+Provides-Extra: dev
+Requires-Dist: package-dev-tools<1,>=0.5.11; extra == "dev"
+Requires-Dist: package-dev-utils<1,>=0.1.6; extra == "dev"
+Requires-Dist: numpy<3,>=1.26.0; extra == "dev"
+Requires-Dist: torch<3,>=1.26.0; extra == "dev"
+
+# Cache
+[![PyPI version](https://badge.fury.io/py/persistent-function-cache.svg)](https://badge.fury.io/py/persistent-function-cache)
+![PyPI downloads](https://img.shields.io/pypi/dm/persistent-function-cache)
+![Python version](https://img.shields.io/badge/python-3.10--3.12-brightgreen)
+![Operating system](https://img.shields.io/badge/os-linux%20%7c%20macOS%20%7c%20windows-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen)
+
+## Usage
+Use
+
+```shell
+from persistent_cache import cache
+
+@cache
+def expensive_function(..):
+    ..
+
+to cache the result of a function
+```
+
+The cache key for the result is determined by:
+* the function signature
+* the implementation of the function
+* the values of the function arguments
+  * custom transformations/reductions can be specified
+
+Advantages compared to existing solutions:
+* the cache in invalidated when the behavior of the function changes
+* Each cache value is saved to a separate location. Only values that are effectively needed are loaded.
+* works with function arguments of any complex data type.
+* configurable: custom transformations/reductions can be specified based on the object type.
+* 3 custom transformation groups available out-of-the-box:
+  * from persistent_cache import cache
+  * from persistent_cache.caches.deep_learning import cache
+  * from persistent_cache.caches.speedup_deep_learning import cache`
+
+## Installation
+```shell
+pip install persistent-function-cache
+```

persistent_function_cache-0.1.0/README.md

@@ -0,0 +1,40 @@
+# Cache
+[![PyPI version](https://badge.fury.io/py/persistent-function-cache.svg)](https://badge.fury.io/py/persistent-function-cache)
+![PyPI downloads](https://img.shields.io/pypi/dm/persistent-function-cache)
+![Python version](https://img.shields.io/badge/python-3.10--3.12-brightgreen)
+![Operating system](https://img.shields.io/badge/os-linux%20%7c%20macOS%20%7c%20windows-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen)
+
+## Usage
+Use
+
+```shell
+from persistent_cache import cache
+
+@cache
+def expensive_function(..):
+    ..
+
+to cache the result of a function
+```
+
+The cache key for the result is determined by:
+* the function signature
+* the implementation of the function
+* the values of the function arguments
+  * custom transformations/reductions can be specified
+
+Advantages compared to existing solutions:
+* the cache in invalidated when the behavior of the function changes
+* Each cache value is saved to a separate location. Only values that are effectively needed are loaded.
+* works with function arguments of any complex data type.
+* configurable: custom transformations/reductions can be specified based on the object type.
+* 3 custom transformation groups available out-of-the-box:
+  * from persistent_cache import cache
+  * from persistent_cache.caches.deep_learning import cache
+  * from persistent_cache.caches.speedup_deep_learning import cache`
+
+## Installation
+```shell
+pip install persistent-function-cache
+```

persistent_function_cache-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[project]
+name = "persistent-function-cache"
+version = "0.1.0"
+description = "Persistent cache for expensive functions"
+authors = [{name = "Quinten Roets", email = "qdr2104@columbia.edu"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10, <3.13"
+dependencies = [
+    "package-utils >=0.6.7, <1",
+    "powercli >=0.3.2, <1",
+    "superpathlib >=2.0.9, <3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "package-dev-tools >=0.5.11, <1",
+    "package-dev-utils >=0.1.6, <1",
+    "numpy >=1.26.0, <3",
+    "torch >=1.26.0, <3",
+]
+
+[project.urls]
+"Source Code" = "https://github.com/quintenroets/persistent-cache"
+
+[project.scripts]
+clear-persistent-cache = "persistent_cache.cli.clear_cache:entry_point"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+command_line = "-m pytest tests"
+
+[tool.coverage.report]
+precision = 4
+fail_under = 80
+
+[tool.mypy]
+strict = true
+no_implicit_reexport = false
+
+[tool.pytest.ini_options]
+pythonpath = [
+    "src", ".",
+]
+
+[tool.ruff]
+fix = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "ANN101",   # annotate self
+    "ANN102",   # annotate cls
+    "ANN401",   # annotated with Any
+    "D",        # docstrings
+    "G004",     # logging f-string
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = [
+    "F401"  # unused import
+]
+"tests/*" = [
+    "S101"  # assert used
+]
+
+[tool.setuptools.package-data]
+persistent_cache = ["py.typed"]

persistent_function_cache-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

persistent_function_cache-0.1.0/src/persistent_cache/__init__.py

@@ -0,0 +1 @@
+from .caches.base import cache

persistent_function_cache-0.1.0/src/persistent_cache/caches/base.py

@@ -0,0 +1,4 @@
+from persistent_cache.main import decorator
+from persistent_cache.reducers.base import Reducer
+
+cache = decorator.cache(Reducer)

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

@@ -0,0 +1,4 @@
+from persistent_cache.main import decorator
+from persistent_cache.reducers.deep_learning import Reducer
+
+cache = decorator.cache(Reducer)

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

@@ -0,0 +1,4 @@
+from persistent_cache.main import decorator
+from persistent_cache.reducers.speedup_deep_learning import Reducer
+
+cache = decorator.cache(Reducer)

persistent_function_cache-0.1.0/src/persistent_cache/cli/clear_cache.py

@@ -0,0 +1,53 @@
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from functools import cached_property
+from typing import Annotated
+
+import cli
+import typer
+from package_utils.cli import create_entry_point
+
+from persistent_cache.models import Path
+
+
+@dataclass
+class Options:
+    max_age: Annotated[
+        int | None,
+        typer.Option(help="Maximal age of entries to delete"),
+    ] = None
+    cache_path: Annotated[Path, typer.Option(help="Root of cache directory")] = (
+        Path.cache
+    )
+    verbose: Annotated[bool, typer.Option(help="Show removed entries")] = True
+
+    @cached_property
+    def min_mtime_to_clear(self) -> float | None:
+        return time.time() - self.max_age * 60 if self.max_age else None
+
+
+def main(options: Options) -> None:
+    """
+    Clear cached values.
+    """
+
+    def should_remove(path_: Path) -> bool:
+        return path_.is_file() and (
+            options.min_mtime_to_clear is None
+            or path_.mtime > options.min_mtime_to_clear
+        )
+
+    with cli.status("Removing.."):
+        for path in Options.cache_path.find(should_remove, recurse_on_match=True):
+            if options.verbose:
+                relative_path = path.relative_to(Options.cache_path)
+                timestamp = datetime.fromtimestamp(path.mtime).astimezone(
+                    tz=timezone.utc,
+                )
+                message = f"{relative_path} ({timestamp})"
+                cli.console.print(message)
+            path.unlink()
+
+
+entry_point = create_entry_point(main)

persistent_function_cache-0.1.0/src/persistent_cache/main/cacheslot.py

@@ -0,0 +1,43 @@
+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_function_cache-0.1.0/src/persistent_cache/main/decorator.py

@@ -0,0 +1,44 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, TypeVar, cast
+
+from persistent_cache.models import Path
+from persistent_cache.reducers.base import Reducer
+
+from .cacheslot import CacheSlot
+
+T = TypeVar("T")
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def cache(
+    key_reducer: type[Reducer] = Reducer,
+    cache_path: Path = Path.cache,
+) -> 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)
+
+    return cache_decorator

persistent_function_cache-0.1.0/src/persistent_cache/main/hashing.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import hashlib
+import inspect
+import io
+import pickle
+from typing import TYPE_CHECKING, Any, get_args, get_type_hints
+
+from persistent_cache.reducers.base import Reducer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+    from typing import BinaryIO
+
+
+class HashPickler(pickle.Pickler):
+    def __init__(
+        self,
+        file_pointer: BinaryIO,
+        reducer: type[Reducer] = Reducer,
+    ) -> None:
+        super().__init__(file_pointer)
+        self.reducer = reducer
+        self.reducers = {}
+        for _, method in inspect.getmembers(reducer, predicate=inspect.ismethod):
+            type_hints = get_type_hints(method).values()
+            if type_hints:
+                argument_type = next(iter(type_hints))
+                argument_types = get_args(argument_type) or (argument_type,)
+                for argument_type in argument_types:
+                    self.reducers[argument_type] = method
+        self.reducers.pop(Any, None)
+
+    def reducer_override(self, obj: Any) -> Any:
+        """The goal of this pickler is to create hashes of complex objects, not to
+        reconstruct complex objects.
+
+        So mapping does not need to be reversible.
+        """
+        reducer = next(self.determine_reducer(obj), None)
+        reduction: Any
+        if reducer is None:
+            reduction = NotImplemented
+        else:
+            mapping = reducer(obj)
+            str_mapping = str(object_to_bytes(self.reducer, mapping))
+            reduction = str, (str_mapping,)
+        return reduction
+
+    def determine_reducer(self, obj: Any) -> Iterator[Callable[[Any], Any]]:
+        if obj is not str:
+            for obj_type, reducer in self.reducers.items():
+                if isinstance(obj, obj_type):
+                    yield reducer
+
+
+def compute_hash(key_reducer: type[Reducer], *args: Any) -> str:
+    data = object_to_bytes(key_reducer, args)
+    # 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:
+    with io.BytesIO() as fp:
+        # Use custom pickler to generate bytes from complex structures
+        HashPickler(fp, key_reducer).dump(args)
+        fp.seek(0)
+        return fp.read()

persistent_function_cache-0.1.0/src/persistent_cache/models/__init__.py

@@ -0,0 +1 @@
+from .path import Path

persistent_function_cache-0.1.0/src/persistent_cache/models/path.py

@@ -0,0 +1,19 @@
+from typing import TypeVar, cast
+
+import superpathlib
+from simple_classproperty import classproperty
+
+T = TypeVar("T", bound="Path")
+
+
+class Path(superpathlib.Path):
+    @classmethod
+    @classproperty
+    def source_root(cls: type[T]) -> T:
+        return cls(__file__).parent.parent
+
+    @classmethod
+    @classproperty
+    def cache(cls: type[T]) -> T:
+        path = cls.script_assets / cls.source_root.name
+        return cast(T, path)

persistent_function_cache-0.1.0/src/persistent_cache/reducers/base.py

@@ -0,0 +1,37 @@
+import inspect
+import io
+from types import FunctionType, ModuleType
+
+
+class Reducer:
+    """Inherit from this class to implement own custom pickler.
+
+    The result of each function are pickled further with their custom
+    pickling function, so make sure to reduce each object to a new
+    object in each reduction function in order to avoid infinity
+    recursive calls.
+    """
+
+    @classmethod
+    def reduce_code(cls, code_object: FunctionType | ModuleType | type) -> str:
+        """
+        custom lambda reduction needed:
+            https://www.pythonpool.com/cant-pickle-local-object/
+        custom module reduction needed:
+            https://stackoverflow.com/questions/2790828/python-cant-pickle-module-objects-error
+        name reduction for function/module/class is not enough because we assume
+        cache result can change when function/module/class implementation changes
+        """
+
+        try:
+            reduction = inspect.getsource(code_object)
+        except (TypeError, OSError):
+            # cannot access source code of builtins or common libraries
+            # but no problem because we assume this code does not change
+            reduction = code_object.__name__
+        return reduction
+
+    @classmethod
+    def reduce_file_objects(cls, _: io.BytesIO | io.BufferedWriter) -> str:
+        # Closed file pointers cannot and should not be pickled for cache functionality
+        return ""

persistent_function_cache-0.1.0/src/persistent_cache/reducers/deep_learning.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+import torch
+from numpy.typing import NDArray
+
+from . import base
+
+
+class Reducer(base.Reducer):
+    @classmethod
+    def reduce_model(cls, model: torch.nn.Module) -> tuple[dict[str, Any], Any]:
+        """
+        Avoid pickling _forward_hooks of model:
+            implemented as OrderedDict with nondeterministic keys
+        Model outputs determined by:
+            - model weights
+            - class implementation (forward method)
+        """
+        return model.state_dict(), model.__class__
+
+    @classmethod
+    def reduce_tensor(cls, tensor: torch.Tensor) -> NDArray[Any]:
+        # Pickling a Tensor or a Storage is not deterministic #39382 => convert to numpy
+        # https://github.com/pytorch/pytorch/issues/3938
+        return tensor.detach().cpu().numpy()

persistent_function_cache-0.1.0/src/persistent_cache/reducers/speedup_deep_learning.py

@@ -0,0 +1,63 @@
+import math
+from typing import Any
+
+import torch
+from numpy.typing import NDArray
+from torch.utils.data import Dataset
+
+from . import deep_learning
+
+SEED_VALUE = 493
+LARGE_DIMENSION = 10000
+
+
+class Reducer(deep_learning.Reducer):
+    @classmethod
+    def reduce_np_array(cls, array: NDArray[Any]) -> Any:
+        shape = array.shape
+        reduction: Any
+        if shape:
+            if math.prod(shape) > LARGE_DIMENSION:
+                # only use part of array large for speedup
+                length = shape[0] if shape else 0
+                data = (array[13**17 % length]) if length > 0 else []
+                reduction = shape, data
+            else:
+                reduction = list(array)
+        else:
+            reduction = array.item()
+        return reduction
+
+    @classmethod
+    def reduce_model(cls, model: torch.nn.Module) -> tuple[Any, Any]:
+        weights: Any
+        weights, implementation = super().reduce_model(model)
+        length = len(weights)
+        if length > 0:
+            # only use part of weights for speedup
+            values = list(weights.values())
+            reduction_indices = (0, length // 2, -1)
+            weights = tuple(values[i] for i in reduction_indices)
+
+        return weights, implementation
+
+    @classmethod
+    def reduce_dataset(cls, dataset: Dataset[Any]) -> tuple[int, Any, Any]:
+        length = len(dataset)  # type: ignore[arg-type]
+
+        # fix random seed to have deterministic hash
+        # for datasets with random augmentation
+        torch.random.manual_seed(SEED_VALUE)
+
+        # only use part of dataset for speedup
+        data = dataset[13**17 % length] if length > 0 else []
+        if isinstance(data, tuple):
+            data, label = data
+        else:
+            label = None
+
+        return length, data, label
+
+    @classmethod
+    def reduce_tensor(cls, tensor: torch.Tensor) -> NDArray[Any]:
+        return tensor.detach().cpu().numpy()

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: persistent-function-cache
+Version: 0.1.0
+Summary: Persistent cache for expensive functions
+Author-email: Quinten Roets <qdr2104@columbia.edu>
+License: MIT
+Project-URL: Source Code, https://github.com/quintenroets/persistent-cache
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: package-utils<1,>=0.6.7
+Requires-Dist: powercli<1,>=0.3.2
+Requires-Dist: superpathlib<3,>=2.0.9
+Provides-Extra: dev
+Requires-Dist: package-dev-tools<1,>=0.5.11; extra == "dev"
+Requires-Dist: package-dev-utils<1,>=0.1.6; extra == "dev"
+Requires-Dist: numpy<3,>=1.26.0; extra == "dev"
+Requires-Dist: torch<3,>=1.26.0; extra == "dev"
+
+# Cache
+[![PyPI version](https://badge.fury.io/py/persistent-function-cache.svg)](https://badge.fury.io/py/persistent-function-cache)
+![PyPI downloads](https://img.shields.io/pypi/dm/persistent-function-cache)
+![Python version](https://img.shields.io/badge/python-3.10--3.12-brightgreen)
+![Operating system](https://img.shields.io/badge/os-linux%20%7c%20macOS%20%7c%20windows-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen)
+
+## Usage
+Use
+
+```shell
+from persistent_cache import cache
+
+@cache
+def expensive_function(..):
+    ..
+
+to cache the result of a function
+```
+
+The cache key for the result is determined by:
+* the function signature
+* the implementation of the function
+* the values of the function arguments
+  * custom transformations/reductions can be specified
+
+Advantages compared to existing solutions:
+* the cache in invalidated when the behavior of the function changes
+* Each cache value is saved to a separate location. Only values that are effectively needed are loaded.
+* works with function arguments of any complex data type.
+* configurable: custom transformations/reductions can be specified based on the object type.
+* 3 custom transformation groups available out-of-the-box:
+  * from persistent_cache import cache
+  * from persistent_cache.caches.deep_learning import cache
+  * from persistent_cache.caches.speedup_deep_learning import cache`
+
+## Installation
+```shell
+pip install persistent-function-cache
+```

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+README.md
+pyproject.toml
+src/persistent_cache/__init__.py
+src/persistent_cache/py.typed
+src/persistent_cache/caches/__init__.py
+src/persistent_cache/caches/base.py
+src/persistent_cache/caches/deep_learning.py
+src/persistent_cache/caches/speedup_deep_learning.py
+src/persistent_cache/cli/__init__.py
+src/persistent_cache/cli/clear_cache.py
+src/persistent_cache/main/__init__.py
+src/persistent_cache/main/cacheslot.py
+src/persistent_cache/main/decorator.py
+src/persistent_cache/main/hashing.py
+src/persistent_cache/models/__init__.py
+src/persistent_cache/models/path.py
+src/persistent_cache/reducers/__init__.py
+src/persistent_cache/reducers/base.py
+src/persistent_cache/reducers/deep_learning.py
+src/persistent_cache/reducers/speedup_deep_learning.py
+src/persistent_function_cache.egg-info/PKG-INFO
+src/persistent_function_cache.egg-info/SOURCES.txt
+src/persistent_function_cache.egg-info/dependency_links.txt
+src/persistent_function_cache.egg-info/entry_points.txt
+src/persistent_function_cache.egg-info/requires.txt
+src/persistent_function_cache.egg-info/top_level.txt
+tests/test_cache.py
+tests/test_clear_cache.py

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clear-persistent-cache = persistent_cache.cli.clear_cache:entry_point

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/requires.txt

@@ -0,0 +1,9 @@
+package-utils<1,>=0.6.7
+powercli<1,>=0.3.2
+superpathlib<3,>=2.0.9
+
+[dev]
+package-dev-tools<1,>=0.5.11
+package-dev-utils<1,>=0.1.6
+numpy<3,>=1.26.0
+torch<3,>=1.26.0

persistent_function_cache-0.1.0/src/persistent_function_cache.egg-info/top_level.txt

@@ -0,0 +1 @@
+persistent_cache

persistent_function_cache-0.1.0/tests/test_cache.py

@@ -0,0 +1,26 @@
+import io
+import math
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+import cli
+import pytest
+
+from persistent_cache.caches import base, deep_learning, speedup_deep_learning
+
+F = TypeVar("F", bound=Callable)  # type: ignore[type-arg]
+
+
+def calculate(*args: Any, **kwargs: Any) -> None:
+    cli.console.print("calculation started")
+    cli.console.print(args, kwargs)
+
+
+caches = [base.cache, deep_learning.cache, speedup_deep_learning.cache]
+
+
+@pytest.mark.parametrize("cache", caches)
+def test_cache_with_argument_combination(cache: Callable) -> None:  # type: ignore[type-arg]
+    cached_function = cache(calculate)
+    with io.BytesIO() as fp:
+        cached_function(fp, lambda x: x, math, {})

persistent_function_cache-0.1.0/tests/test_clear_cache.py

@@ -0,0 +1,8 @@
+from package_dev_utils.tests.args import cli_args
+
+from persistent_cache.cli.clear_cache import entry_point
+
+
+def test_entry_point() -> None:
+    with cli_args("--max-age", 0):
+        entry_point()