Cachalot 2.0.0__tar.gz

cachalot-2.0.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2018, Radek Sprta
+
+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.

cachalot-2.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.5
+Name: Cachalot
+Version: 2.0.0
+Summary: Minimal persistent memoization cache
+Project-URL: Homepage, https://radek-sprta.gitlab.io/Cachalot/
+Project-URL: Repository, https://gitlab.com/radek-sprta/Cachalot
+Project-URL: Documentation, https://radek-sprta.gitlab.io/Cachalot/
+Author-email: Radek Sprta <mail@radeksprta.eu>
+License: MIT
+License-File: LICENSE
+Keywords: cache,memoization
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: jsonpickle
+Requires-Dist: tinydb>=4
+Description-Content-Type: text/markdown
+
+# Cachalot [![PyPI version](https://badge.fury.io/py/cachalot.svg)](https://badge.fury.io/py/cachalot) [![Pipeline status](https://gitlab.com/radek-sprta/cachalot/badges/master/pipeline.svg)](https://gitlab.com/radek-sprta/cachalot/commits/master) [![Coverage report](https://gitlab.com/radek-sprta/cachalot/badges/master/coverage.svg)](https://gitlab.com/radek-sprta/cachalot/commits/master)[![Downloads](http://pepy.tech/badge/cachalot)](http://pepy.tech/project/cachalot)
+
+Cachalot is a minimal persistent memoization cache. It provides a decorator, that stores function result for future use. Perfect for heavy computations and I/O operation (such as web requests). On backend, it uses TinyDB for storage.
+
+## Features
+- Simple usage via decorator
+- Persistent caching
+- Optional in-memory caching
+- Key expiration
+- Maximum cache size, to prevent bloat
+
+## Installation
+Cachalot requires Python 3.11 or newer to run.
+
+**Python package**
+
+You can easily install Cachalot using pip:
+
+`pip3 install cachalot`
+
+**Manual**
+
+Alternatively, to get the latest development version, you can clone this repository and then manually install it:
+
+```
+git clone git@gitlab.com:radek-sprta/cachalot.git
+cd cachalot
+pip install .
+```
+
+## Usage
+```python
+from cachalot import Cache
+
+
+@Cache()
+def expensive_function():
+    return expensive_calculation()
+```
+
+### Advanced usage
+```python
+from cachalot import Cache
+
+
+@Cache(
+    path="cache.json",
+    timeout=3600,
+    size=5000,
+    filesize=1_000_000,
+    retry=True,
+    renew_on_read=True,
+)
+def expensive_function():
+    return expensive_calculation()
+```
+
+- `path`: Path to the database file. Defaults to .cache.json. If None, the cache is kept in memory.
+- `timeout`: How long should the data be cached in seconds. Defaults to 0 (infinite).
+- `size`: Maximum number of keys cached. Defaults to 0 (infinite).
+- `filesize`: Maximum size of database file in bytes. Defaults to 0 (infinite). Cannot be used with an in-memory cache.
+- `retry`: Retry if the cached result is None. Defaults to False.
+- `renew_on_read`: Renew the entry, i.e refresh the entry timestamp on reads. Defaults to True.
+
+### Caveats
+- Cache keys are the function's module and qualified name plus positional and keyword arguments (keyword order irrelevant). Defaults are not applied: `f(1)` and `f(1, b=2)` differ even if `2` is the default, and so do positional and keyword calls. For methods, `self` is intentionally excluded, so all instances share results.
+- Functions with the same qualified name share a key: lambdas in the same scope, and functions made by the same factory (e.g. `make_scaler(2)` and `make_scaler(3)`). Closure state is not part of the key; use named top-level functions instead.
+- Arguments are encoded with jsonpickle, which is not canonical: sets may encode in a different order between processes, causing misses.
+- When `size` is exceeded, the least recently used entry is evicted. Use is the last read with `renew_on_read=True`, otherwise the last write.
+- Results larger than `filesize` bytes are not cached (the entry is skipped, not stored).
+- Cache objects on the same file within one process share one database. The file is still not locked; do not share it between concurrent processes or threads.
+- Values are stored with jsonpickle; loading a cache file can execute code. Only use cache files from trusted sources.
+
+### Manually deleting entries
+If you want to manually invalidate an entry, you can calculate the hash of the function call and then pass it to the `remove` method.
+
+```python
+cache = Cache()
+
+
+@cache
+def expensive_function(arg):
+    return expensive_calculation(arg)
+
+
+key = cache.calculate_hash(expensive_function)("arg")
+cache.remove(key)
+```
+
+For more information, see [documentation][documentation].
+
+## Contributing
+For information on how to contribute to the project, please check the [Contributor's Guide][contributing]
+
+## Contact
+[mail@radeksprta.eu](mailto:mail@radeksprta.eu)
+
+[incoming+radek-sprta/cachalot@gitlab.com](mailto:incoming+radek-sprta/cachalot@gitlab.com)
+
+## License
+MIT License
+
+## Credits
+This package was created with [Cookiecutter][cookiecutter] and the [python-cookiecutter][python-cookiecutter] project template. Inspired by [Cashier][cachier]
+
+## Contributors ✨
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tr>
+    <td align="center"><a href="https://gitlab.com/Evidlo"><img src="https://secure.gravatar.com/avatar/2670a8eba83e9233eb254fa48a12249f?s=80&d=identicon?s=100" width="100px;" alt=""/><br /><sub><b>Evan Widloski</b></sub></a><br /><a href="https://gitlab.com/radek-sprta/Cachalot/commits/master" title="Code">💻</a></td>
+    <td align="center"><a href="https://gitlab.com/sasa-tomic"><img src="https://assets.gitlab-static.net/uploads/-/system/user/avatar/4715393/avatar.png?s=100" width="100px;" alt=""/><br /><sub><b>Saša Tomić</b></sub></a><br /><a href="https://gitlab.com/radek-sprta/Cachalot/commits/master" title="Code">💻</a></td>
+  </tr>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+[cachier]: https://github.com/atmb4u/cashier
+[contributing]: https://gitlab.com/radek-sprta/cachalot/blob/master/CONTRIBUTING.md
+[cookiecutter]: https://github.com/audreyr/cookiecutter
+[documentation]: https://radek-sprta.gitlab.io/cachalot
+[python-cookiecutter]: https://gitlab.com/radek-sprta/python-cookiecutter

cachalot-2.0.0/README.md

@@ -0,0 +1,130 @@
+# Cachalot [![PyPI version](https://badge.fury.io/py/cachalot.svg)](https://badge.fury.io/py/cachalot) [![Pipeline status](https://gitlab.com/radek-sprta/cachalot/badges/master/pipeline.svg)](https://gitlab.com/radek-sprta/cachalot/commits/master) [![Coverage report](https://gitlab.com/radek-sprta/cachalot/badges/master/coverage.svg)](https://gitlab.com/radek-sprta/cachalot/commits/master)[![Downloads](http://pepy.tech/badge/cachalot)](http://pepy.tech/project/cachalot)
+
+Cachalot is a minimal persistent memoization cache. It provides a decorator, that stores function result for future use. Perfect for heavy computations and I/O operation (such as web requests). On backend, it uses TinyDB for storage.
+
+## Features
+- Simple usage via decorator
+- Persistent caching
+- Optional in-memory caching
+- Key expiration
+- Maximum cache size, to prevent bloat
+
+## Installation
+Cachalot requires Python 3.11 or newer to run.
+
+**Python package**
+
+You can easily install Cachalot using pip:
+
+`pip3 install cachalot`
+
+**Manual**
+
+Alternatively, to get the latest development version, you can clone this repository and then manually install it:
+
+```
+git clone git@gitlab.com:radek-sprta/cachalot.git
+cd cachalot
+pip install .
+```
+
+## Usage
+```python
+from cachalot import Cache
+
+
+@Cache()
+def expensive_function():
+    return expensive_calculation()
+```
+
+### Advanced usage
+```python
+from cachalot import Cache
+
+
+@Cache(
+    path="cache.json",
+    timeout=3600,
+    size=5000,
+    filesize=1_000_000,
+    retry=True,
+    renew_on_read=True,
+)
+def expensive_function():
+    return expensive_calculation()
+```
+
+- `path`: Path to the database file. Defaults to .cache.json. If None, the cache is kept in memory.
+- `timeout`: How long should the data be cached in seconds. Defaults to 0 (infinite).
+- `size`: Maximum number of keys cached. Defaults to 0 (infinite).
+- `filesize`: Maximum size of database file in bytes. Defaults to 0 (infinite). Cannot be used with an in-memory cache.
+- `retry`: Retry if the cached result is None. Defaults to False.
+- `renew_on_read`: Renew the entry, i.e refresh the entry timestamp on reads. Defaults to True.
+
+### Caveats
+- Cache keys are the function's module and qualified name plus positional and keyword arguments (keyword order irrelevant). Defaults are not applied: `f(1)` and `f(1, b=2)` differ even if `2` is the default, and so do positional and keyword calls. For methods, `self` is intentionally excluded, so all instances share results.
+- Functions with the same qualified name share a key: lambdas in the same scope, and functions made by the same factory (e.g. `make_scaler(2)` and `make_scaler(3)`). Closure state is not part of the key; use named top-level functions instead.
+- Arguments are encoded with jsonpickle, which is not canonical: sets may encode in a different order between processes, causing misses.
+- When `size` is exceeded, the least recently used entry is evicted. Use is the last read with `renew_on_read=True`, otherwise the last write.
+- Results larger than `filesize` bytes are not cached (the entry is skipped, not stored).
+- Cache objects on the same file within one process share one database. The file is still not locked; do not share it between concurrent processes or threads.
+- Values are stored with jsonpickle; loading a cache file can execute code. Only use cache files from trusted sources.
+
+### Manually deleting entries
+If you want to manually invalidate an entry, you can calculate the hash of the function call and then pass it to the `remove` method.
+
+```python
+cache = Cache()
+
+
+@cache
+def expensive_function(arg):
+    return expensive_calculation(arg)
+
+
+key = cache.calculate_hash(expensive_function)("arg")
+cache.remove(key)
+```
+
+For more information, see [documentation][documentation].
+
+## Contributing
+For information on how to contribute to the project, please check the [Contributor's Guide][contributing]
+
+## Contact
+[mail@radeksprta.eu](mailto:mail@radeksprta.eu)
+
+[incoming+radek-sprta/cachalot@gitlab.com](mailto:incoming+radek-sprta/cachalot@gitlab.com)
+
+## License
+MIT License
+
+## Credits
+This package was created with [Cookiecutter][cookiecutter] and the [python-cookiecutter][python-cookiecutter] project template. Inspired by [Cashier][cachier]
+
+## Contributors ✨
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tr>
+    <td align="center"><a href="https://gitlab.com/Evidlo"><img src="https://secure.gravatar.com/avatar/2670a8eba83e9233eb254fa48a12249f?s=80&d=identicon?s=100" width="100px;" alt=""/><br /><sub><b>Evan Widloski</b></sub></a><br /><a href="https://gitlab.com/radek-sprta/Cachalot/commits/master" title="Code">💻</a></td>
+    <td align="center"><a href="https://gitlab.com/sasa-tomic"><img src="https://assets.gitlab-static.net/uploads/-/system/user/avatar/4715393/avatar.png?s=100" width="100px;" alt=""/><br /><sub><b>Saša Tomić</b></sub></a><br /><a href="https://gitlab.com/radek-sprta/Cachalot/commits/master" title="Code">💻</a></td>
+  </tr>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+[cachier]: https://github.com/atmb4u/cashier
+[contributing]: https://gitlab.com/radek-sprta/cachalot/blob/master/CONTRIBUTING.md
+[cookiecutter]: https://github.com/audreyr/cookiecutter
+[documentation]: https://radek-sprta.gitlab.io/cachalot
+[python-cookiecutter]: https://gitlab.com/radek-sprta/python-cookiecutter

cachalot-2.0.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "Cachalot"
+version = "2.0.0"
+description = "Minimal persistent memoization cache"
+authors = [{ name = "Radek Sprta", email = "mail@radeksprta.eu" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["memoization", "cache"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: OS Independent",
+    "Natural Language :: English",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "tinydb>=4",
+    "jsonpickle",
+]
+
+[project.urls]
+Homepage = "https://radek-sprta.gitlab.io/Cachalot/"
+Repository = "https://gitlab.com/radek-sprta/Cachalot"
+Documentation = "https://radek-sprta.gitlab.io/Cachalot/"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cachalot"]
+
+[dependency-groups]
+dev = [
+    "mkdocs>=1.6.1",
+    "mkdocs-cinder>=1.2.0",
+    "ruff>=0.16.10",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]
+
+[tool.pytest.ini_options]
+addopts = "--showlocals --verbose -r w --cov=cachalot --cov-report=term-missing"
+norecursedirs = [".*", "build", "site", "dist"]

cachalot-2.0.0/src/cachalot/__init__.py

@@ -0,0 +1,312 @@
+"""Cachalot is a minimal persistent memoization cache, that uses TinyDB."""
+
+import functools
+import hashlib
+import inspect
+import json
+import os
+import pathlib
+import time
+import warnings
+from collections.abc import Callable
+from importlib import metadata
+from typing import Any
+
+import jsonpickle
+import tinydb
+
+try:
+    __version__ = metadata.version(__name__)
+except metadata.PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+
+# Not thread-safe
+_file_databases: dict[str, tinydb.TinyDB] = {}
+
+
+class Cache:
+    """Offline cache for search results.
+
+    Attributes:
+        path: Defaults to .cache.json. Path to the database file. If None, the
+            cache is kept in memory and the storage type is MemoryStorage.
+        timeout: Defaults to infinite. Period after which results should expire.
+        size: Defaults to infinite. Maximum number of cached results.
+        filesize: Defaults to infinite. Maximum size of database file in bytes.
+            Cannot be used with an in-memory cache.
+        retry: Defaults to False. Whether to retry when the cached result is None.
+        renew_on_read: Defaults to True. Whether to refresh timestamps on reads.
+        storage: Deprecated and ignored.
+    """
+
+    def __init__(
+        self,
+        *,
+        path: str | None = ".cache.json",
+        timeout: int = 0,
+        size: int = 0,
+        filesize: int = 0,
+        retry: bool = False,
+        renew_on_read: bool = True,
+        storage: Any = None,
+    ) -> None:
+        if path is None and filesize > 0:
+            raise ValueError("filesize cannot be used with an in-memory cache")
+        if storage is not None:
+            warnings.warn(
+                "storage is ignored and inferred from path",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        self.timeout = timeout
+        self.size = size
+        self.filesize = filesize
+        self.retry = retry
+        self.renew_on_read = renew_on_read
+        self.uncached = object()  # Sentinel object to check uncached functions
+        self.path = (
+            os.path.abspath(os.path.expanduser(path)) if path is not None else None
+        )
+        if self.path is None:
+            self.storage = tinydb.storages.MemoryStorage
+            self._memory_db = tinydb.TinyDB(storage=self.storage)
+        else:
+            self.storage = tinydb.storages.JSONStorage
+            os.makedirs(os.path.dirname(self.path), exist_ok=True)
+            self._open_file_db()
+
+    @property
+    def db(self) -> tinydb.TinyDB:
+        """Database shared by all caches on the same file."""
+        if self.path is None:
+            return self._memory_db
+        if self.path not in _file_databases:
+            _file_databases[self.path] = tinydb.TinyDB(self.path, storage=self.storage)
+        return _file_databases[self.path]
+
+    def close(self) -> None:
+        """Close the database; other caches on the same file reopen it on next use."""
+        if self.path is None:
+            self._memory_db.close()
+        elif (database := _file_databases.pop(self.path, None)) is not None:
+            database.close()
+
+    def _open_file_db(self) -> None:
+        """Replace the shared database of the file, closing the previous one."""
+        if (previous := _file_databases.get(self.path)) is not None:
+            previous.close()
+        _file_databases[self.path] = tinydb.TinyDB(self.path, storage=self.storage)
+
+    @staticmethod
+    def _arguments(
+        function: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> tuple[tuple[Any, ...], dict[str, Any]]:
+        """Return the call arguments that identify a call.
+
+        Keyword arguments are sorted by key and self is dropped for methods,
+        so that calls differing only in keyword order are equal. Defaults are
+        not applied, so passing a default explicitly yields a different key.
+
+        Args:
+            function: Function being called.
+            args: Positional arguments of the call.
+            kwargs: Keyword arguments of the call.
+
+        Returns:
+            Positional arguments and keyword arguments sorted by key.
+        """
+        if Cache._is_method(function):
+            args = args[1:]
+        return args, dict(sorted(kwargs.items()))
+
+    def calculate_hash(self, function: Callable[..., Any]) -> Callable[..., str]:
+        """Calculate hash of a function call.
+
+        Args:
+            function: Function to calculate hash of.
+
+        Returns:
+            Function taking the call arguments and returning their hash.
+
+        Example:
+            >>> cache.calculate_hash(len)('teststring')
+            'a3d600dd2d9a535ca47674474ebbefec'
+        """
+
+        def wrapped(*args, **kwargs):
+            arguments = self._arguments(function, args, kwargs)
+            seed = f"{function.__module__}.{function.__qualname__}" + jsonpickle.encode(
+                arguments, keys=True
+            )
+            return hashlib.md5(seed.encode("utf8")).hexdigest()
+
+        return wrapped
+
+    def clear(self) -> None:
+        """Clear the cache."""
+        try:
+            self.db.truncate()
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+
+    def expiry(self) -> float:
+        """Return expiration time for cached results."""
+        return time.time() + self.timeout
+
+    def _get_with_sentinel(self, key: str) -> Any:
+        """Private get implementation, that returns self.uncached sentinel
+        object, if key is not cached in the database. Exists so we do not
+        break the API.
+
+        Args:
+            key: Key hash.
+
+        Returns:
+            Cached object or self.uncached.
+        """
+        self._remove_expired()
+        entry = tinydb.Query()
+        try:
+            value = self.db.get(entry.key == key)
+            if value:
+                if self.renew_on_read:
+                    self.db.update(
+                        {"time": self.expiry(), "used": time.time()},
+                        entry.key == key,
+                    )
+                return jsonpickle.decode(value["value"])
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+        return self.uncached
+
+    def get(self, key: str) -> Any:
+        """Get entry from database.
+
+        Args:
+            key: Key hash.
+
+        Returns:
+            Cached object.
+        """
+        value = self._get_with_sentinel(key)
+        return None if value is self.uncached else value
+
+    def insert(self, key: str, entry: Any) -> None:
+        """Insert entry into cache.
+
+        Args:
+            key: Key hash of the entry to store.
+            entry: Object to cache.
+        """
+        document = {
+            "key": key,
+            "time": self.expiry(),
+            "used": time.time(),
+            "value": jsonpickle.encode(entry),
+        }
+        if self.filesize > 0:
+            alone = json.dumps({"_default": {"1": document}}).encode()
+            if len(alone) > self.filesize:
+                self.remove(key)
+                return
+        try:
+            self.db.upsert(document, tinydb.Query().key == key)
+            while 0 < self.size < len(self.db):
+                self._remove_oldest()
+            if self.filesize > 0:
+                while os.stat(self.path).st_size > self.filesize and len(self.db) > 0:
+                    self._remove_oldest()
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+            self.db.upsert(document, tinydb.Query().key == key)
+
+    @staticmethod
+    def _is_method(function: Callable[..., Any]) -> bool:
+        """Check if function is actually a method.
+
+        Args:
+            function: Function to check the state of.
+
+        Returns:
+            True if function is method, false otherwise.
+        """
+        if inspect.ismethod(function) or "." not in function.__qualname__:
+            return False
+        return inspect.getfullargspec(function).args[:1] == ["self"]
+
+    def remove(self, key: str) -> None:
+        """Delete key from cache.
+
+        Args:
+            key: Hash key to delete from the cache.
+        """
+        entry = tinydb.Query()
+        try:
+            self.db.remove(entry.key == key)
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+
+    def _remove_expired(self) -> None:
+        """Remove old entries."""
+        if self.timeout < 1:
+            return
+
+        entry = tinydb.Query()
+        now = time.time()
+        try:
+            self.db.remove(entry.time < now)
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+
+    def _recreate_db(self) -> None:
+        if self.path is None:
+            self._memory_db = tinydb.TinyDB(storage=self.storage)
+            return
+        self.close()
+        pathlib.Path(self.path).unlink(missing_ok=True)
+        self._open_file_db()
+
+    def _remove_oldest(self) -> None:
+        """Remove least recently used entry."""
+        try:
+            oldest = min(self.db.all(), key=lambda doc: doc.get("used", 0))["key"]
+            self.remove(oldest)
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+
+    def __len__(self) -> int:
+        """Return the length of cache."""
+        try:
+            return len(self.db)
+        except json.decoder.JSONDecodeError:
+            # Database is corrupted
+            self._recreate_db()
+            return 0
+
+    def __call__(self, function: Callable[..., Any]):
+        """Decorator for caching function results.
+
+        Args:
+            function: Function to decorate.
+
+        Returns:
+            Cached function.
+        """
+
+        @functools.wraps(function)
+        def wrapped(*args, **kwargs):
+            """Cache function."""
+            key = self.calculate_hash(function)(*args, **kwargs)
+            result = self._get_with_sentinel(key)
+            if result is self.uncached or (result is None and self.retry):
+                result = function(*args, **kwargs)
+                self.insert(key, result)
+            return result
+
+        return wrapped