cachier 3.1.1__py3-none-any.whl → 3.2.1__py3-none-any.whl

cachier/__init__.py

@@ -1,4 +1,4 @@
-from ._version import *  # noqa: F403
+from ._version import __version__
 from .config import (
     disable_caching,
     enable_caching,
@@ -17,4 +17,5 @@ __all__ = [
     "get_global_params",
     "enable_caching",
     "disable_caching",
+    "__version__",
 ]

cachier/_version.py

@@ -18,7 +18,8 @@ with open(_PATH_VERSION) as fopen:
 def _get_git_sha() -> str:
     from subprocess import DEVNULL, check_output
 
-    out = check_output(["git", "rev-parse", "--short", "HEAD"], stderr=DEVNULL)  # noqa: S603, S607
+    args = ["git", "rev-parse", "--short", "HEAD"]
+    out = check_output(args, stderr=DEVNULL)  # noqa: S603
     return out.decode("utf-8").strip()
 
 

cachier/config.py

@@ -1,10 +1,9 @@
-import datetime
 import hashlib
 import os
 import pickle
 import threading
-from collections.abc import Mapping
 from dataclasses import dataclass, replace
+from datetime import datetime, timedelta
 from typing import Any, Optional, Union
 
 from ._types import Backend, HashFunc, Mongetter
@@ -27,7 +26,7 @@ class Params:
     hash_func: HashFunc = _default_hash_func
     backend: Backend = "pickle"
     mongetter: Optional[Mongetter] = None
-    stale_after: datetime.timedelta = datetime.timedelta.max
+    stale_after: timedelta = timedelta.max
     next_time: bool = False
     cache_dir: Union[str, os.PathLike] = "~/.cachier/"
     pickle_reload: bool = True
@@ -65,7 +64,7 @@ def _update_with_defaults(
     return param
 
 
-def set_default_params(**params: Mapping) -> None:
+def set_default_params(**params: Any) -> None:
     """Configure default parameters applicable to all memoized functions."""
     # It is kept for backwards compatibility with desperation warning
     import warnings
@@ -79,7 +78,7 @@ def set_default_params(**params: Mapping) -> None:
     set_global_params(**params)
 
 
-def set_global_params(**params: Mapping) -> None:
+def set_global_params(**params: Any) -> None:
     """Configure global parameters applicable to all memoized functions.
 
     This function takes the same keyword parameters as the ones defined in the
@@ -100,7 +99,8 @@ def set_global_params(**params: Mapping) -> None:
         if hasattr(cachier.config._global_params, k)
     }
     cachier.config._global_params = replace(
-        cachier.config._global_params, **valid_params
+        cachier.config._global_params,
+        **valid_params,  # type: ignore[arg-type]
     )
 
 

cachier/core.py

@@ -7,14 +7,14 @@
 # http://www.opensource.org/licenses/MIT-license
 # Copyright (c) 2016, Shay Palachy <shaypal5@gmail.com>
 
-import datetime
 import inspect
 import os
 import warnings
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta
 from functools import wraps
-from typing import Any, Optional, Union
+from typing import Any, Callable, Optional, Union
 from warnings import warn
 
 from .config import (
@@ -27,6 +27,7 @@ from .cores.base import RecalculationNeeded, _BaseCore
 from .cores.memory import _MemoryCore
 from .cores.mongo import _MongoCore
 from .cores.pickle import _PickleCore
+from .cores.sql import _SQLCore
 
 MAX_WORKERS_ENVAR_NAME = "CACHIER_MAX_WORKERS"
 DEFAULT_MAX_WORKERS = 8
@@ -107,7 +108,8 @@ def cachier(
     hash_params: Optional[HashFunc] = None,
     backend: Optional[Backend] = None,
     mongetter: Optional[Mongetter] = None,
-    stale_after: Optional[datetime.timedelta] = None,
+    sql_engine: Optional[Union[str, Any, Callable[[], Any]]] = None,
+    stale_after: Optional[timedelta] = None,
     next_time: Optional[bool] = None,
     cache_dir: Optional[Union[str, os.PathLike]] = None,
     pickle_reload: Optional[bool] = None,
@@ -134,13 +136,16 @@ def cachier(
     hash_params : callable, optional
     backend : str, optional
         The name of the backend to use. Valid options currently include
-        'pickle', 'mongo' and 'memory'. If not provided, defaults to
+        'pickle', 'mongo', 'memory', and 'sql'. If not provided, defaults to
         'pickle' unless the 'mongetter' argument is passed, in which
         case the mongo backend is automatically selected.
     mongetter : callable, optional
         A callable that takes no arguments and returns a pymongo.Collection
         object with writing permissions. If unset a local pickle cache is used
         instead.
+    sql_engine : str, Engine, or callable, optional
+        SQLAlchemy connection string, Engine, or callable returning an Engine.
+        Used for the SQL backend.
     stale_after : datetime.timedelta, optional
         The time delta after which a cached result is considered stale. Calls
         made after the result goes stale will trigger a recalculation of the
@@ -208,6 +213,12 @@ def cachier(
         core = _MemoryCore(
             hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
         )
+    elif backend == "sql":
+        core = _SQLCore(
+            hash_func=hash_func,
+            sql_engine=sql_engine,
+            wait_for_calc_timeout=wait_for_calc_timeout,
+        )
     else:
         raise ValueError("specified an invalid core: %s" % backend)
 
@@ -259,7 +270,7 @@ def cachier(
             _print("Entry found.")
             if _allow_none or entry.value is not None:
                 _print("Cached result found.")
-                now = datetime.datetime.now()
+                now = datetime.now()
                 if now - entry.time <= _stale_after:
                     _print("And it is fresh!")
                     return entry.value

cachier/cores/base.py

@@ -1,4 +1,5 @@
 """Defines the interface of a cachier caching core."""
+
 # This file is part of Cachier.
 # https://github.com/python-cachier/cachier
 
@@ -28,7 +29,11 @@ def _get_func_str(func: Callable) -> str:
 class _BaseCore:
     __metaclass__ = abc.ABCMeta
 
-    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+    def __init__(
+        self,
+        hash_func: Optional[HashFunc],
+        wait_for_calc_timeout: Optional[int],
+    ):
         self.hash_func = _update_with_defaults(hash_func, "hash_func")
         self.wait_for_calc_timeout = wait_for_calc_timeout
         self.lock = threading.RLock()

cachier/cores/memory.py

@@ -2,7 +2,7 @@
 
 import threading
 from datetime import datetime
-from typing import Any, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 from .._types import HashFunc
 from ..config import CacheEntry
@@ -12,9 +12,13 @@ from .base import _BaseCore, _get_func_str
 class _MemoryCore(_BaseCore):
     """The memory core class for cachier."""
 
-    def __init__(self, hash_func: HashFunc, wait_for_calc_timeout: int):
+    def __init__(
+        self,
+        hash_func: Optional[HashFunc],
+        wait_for_calc_timeout: Optional[int],
+    ):
         super().__init__(hash_func, wait_for_calc_timeout)
-        self.cache = {}
+        self.cache: Dict[str, CacheEntry] = {}
 
     def _hash_func_key(self, key: str) -> str:
         return f"{_get_func_str(self.func)}:{key}"
@@ -79,8 +83,12 @@ class _MemoryCore(_BaseCore):
         hash_key = self._hash_func_key(key)
         with self.lock:  # pragma: no cover
             entry = self.cache[hash_key]
+            if entry is None:
+                return None
             if not entry._processing:
                 return entry.value
+        if entry._condition is None:
+            raise RuntimeError("No condition set for entry")
         entry._condition.acquire()
         entry._condition.wait()
         entry._condition.release()

cachier/cores/mongo.py

@@ -37,9 +37,9 @@ class _MongoCore(_BaseCore):
 
     def __init__(
         self,
-        hash_func: HashFunc,
-        mongetter: Mongetter,
-        wait_for_calc_timeout: int,
+        hash_func: Optional[HashFunc],
+        mongetter: Optional[Mongetter],
+        wait_for_calc_timeout: Optional[int],
     ):
         if "pymongo" not in sys.modules:
             warnings.warn(
@@ -48,7 +48,9 @@ class _MongoCore(_BaseCore):
                 stacklevel=2,
             )  # pragma: no cover
 
-        super().__init__(hash_func, wait_for_calc_timeout)
+        super().__init__(
+            hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
+        )
         if mongetter is None:
             raise MissingMongetter(
                 "must specify ``mongetter`` when using the mongo core"
@@ -73,7 +75,9 @@ class _MongoCore(_BaseCore):
         )
         if not res:
             return key, None
-        val = pickle.loads(res["value"]) if "value" in res else None  # noqa: S301
+        val = None
+        if "value" in res:
+            val = pickle.loads(res["value"])  # noqa: S301
         entry = CacheEntry(
             value=val,
             time=res.get("time", None),

cachier/cores/pickle.py

@@ -9,7 +9,7 @@
 import os
 import pickle  # for local caching
 from datetime import datetime
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, Union
 
 import portalocker  # to lock on pickle cache IO
 from watchdog.events import PatternMatchingEventHandler
@@ -54,7 +54,7 @@ class _PickleCore(_BaseCore):
                     self.observer.stop()
                 # else:
                 #     print('NOT stopping observer... :(')
-            except TypeError:
+            except AttributeError:  # catching entry being None
                 self.value = None
                 self.observer.stop()
 
@@ -68,14 +68,14 @@ class _PickleCore(_BaseCore):
 
     def __init__(
         self,
-        hash_func: HashFunc,
-        pickle_reload: bool,
-        cache_dir: str,
-        separate_files: bool,
-        wait_for_calc_timeout: int,
+        hash_func: Optional[HashFunc],
+        pickle_reload: Optional[bool],
+        cache_dir: Optional[Union[str, os.PathLike]],
+        separate_files: Optional[bool],
+        wait_for_calc_timeout: Optional[int],
     ):
         super().__init__(hash_func, wait_for_calc_timeout)
-        self.cache = None
+        self._cache_dict: Dict[str, CacheEntry] = {}
         self.reload = _update_with_defaults(pickle_reload, "pickle_reload")
         self.cache_dir = os.path.expanduser(
             _update_with_defaults(cache_dir, "cache_dir")
@@ -83,6 +83,7 @@ class _PickleCore(_BaseCore):
         self.separate_files = _update_with_defaults(
             separate_files, "separate_files"
         )
+        self._cache_used_fpath = ""
 
     @property
     def cache_fname(self) -> str:
@@ -96,28 +97,52 @@ class _PickleCore(_BaseCore):
             os.path.join(os.path.realpath(self.cache_dir), self.cache_fname)
         )
 
-    def _reload_cache(self) -> None:
-        with self.lock:
-            try:
-                with portalocker.Lock(self.cache_fpath, mode="rb") as cf:
-                    self.cache = pickle.load(cf)  # noqa: S301
-            except (FileNotFoundError, EOFError):
-                self.cache = {}
+    @staticmethod
+    def _convert_legacy_cache_entry(
+        entry: Union[dict, CacheEntry],
+    ) -> CacheEntry:
+        if isinstance(entry, CacheEntry):
+            return entry
+        return CacheEntry(
+            value=entry["value"],
+            time=entry["time"],
+            stale=entry["stale"],
+            _processing=entry["being_calculated"],
+            _condition=entry.get("condition", None),
+        )
 
-    def _get_cache(self) -> Dict[str, CacheEntry]:
+    def _load_cache_dict(self) -> Dict[str, CacheEntry]:
+        try:
+            with portalocker.Lock(self.cache_fpath, mode="rb") as cf:
+                cache = pickle.load(cf)  # noqa: S301
+            self._cache_used_fpath = str(self.cache_fpath)
+        except (FileNotFoundError, EOFError):
+            cache = {}
+        return {
+            k: _PickleCore._convert_legacy_cache_entry(v)
+            for k, v in cache.items()
+        }
+
+    def get_cache_dict(self, reload: bool = False) -> Dict[str, CacheEntry]:
+        if self._cache_used_fpath != self.cache_fpath:
+            # force reload if the cache file has changed
+            # this change is dies to using different wrapped function
+            reload = True
+        if self._cache_dict and not (self.reload or reload):
+            return self._cache_dict
         with self.lock:
-            if not self.cache:
-                self._reload_cache()
-            return self.cache
+            self._cache_dict = self._load_cache_dict()
+        return self._cache_dict
 
-    def _get_cache_by_key(
+    def _load_cache_by_key(
         self, key=None, hash_str=None
-    ) -> Optional[Dict[str, CacheEntry]]:
+    ) -> Optional[CacheEntry]:
         fpath = self.cache_fpath
         fpath += f"_{hash_str or key}"
         try:
             with portalocker.Lock(fpath, mode="rb") as cache_file:
-                return pickle.load(cache_file)  # noqa: S301
+                entry = pickle.load(cache_file)  # noqa: S301
+            return _PickleCore._convert_legacy_cache_entry(entry)
         except (FileNotFoundError, EOFError):
             return None
 
@@ -131,35 +156,42 @@ class _PickleCore(_BaseCore):
         path, name = os.path.split(self.cache_fpath)
         for subpath in os.listdir(path):
             if subpath.startswith(name):
-                entry = self._get_cache_by_key(hash_str=subpath.split("_")[-1])
+                entry = self._load_cache_by_key(
+                    hash_str=subpath.split("_")[-1]
+                )
                 if entry is not None:
-                    entry.being_calculated = False
+                    entry._processing = False
                     self._save_cache(entry, hash_str=subpath.split("_")[-1])
 
     def _save_cache(
-        self, cache, key: str = None, hash_str: str = None
+        self,
+        cache: Union[Dict[str, CacheEntry], CacheEntry],
+        separate_file_key: Optional[str] = None,
+        hash_str: Optional[str] = None,
     ) -> None:
+        if separate_file_key and not isinstance(cache, CacheEntry):
+            raise ValueError(
+                "`separate_file_key` should only be used with a CacheEntry"
+            )
         fpath = self.cache_fpath
-        if key is not None:
-            fpath += f"_{key}"
+        if separate_file_key is not None:
+            fpath += f"_{separate_file_key}"
         elif hash_str is not None:
             fpath += f"_{hash_str}"
         with self.lock:
-            self.cache = cache
-            with portalocker.Lock(fpath, mode="wb") as cache_file:
-                pickle.dump(cache, cache_file, protocol=4)
-            if key is None:
-                self._reload_cache()
+            with portalocker.Lock(fpath, mode="wb") as cf:
+                pickle.dump(cache, cf, protocol=4)
+            # the same as check for separate_file, but changed for typing
+            if isinstance(cache, dict):
+                self._cache_dict = cache
+                self._cache_used_fpath = str(self.cache_fpath)
 
     def get_entry_by_key(
         self, key: str, reload: bool = False
-    ) -> Tuple[str, CacheEntry]:
-        with self.lock:
-            if self.separate_files:
-                return key, self._get_cache_by_key(key)
-            if self.reload or reload:
-                self._reload_cache()
-            return key, self._get_cache().get(key, None)
+    ) -> Tuple[str, Optional[CacheEntry]]:
+        if self.separate_files:
+            return key, self._load_cache_by_key(key)
+        return key, self.get_cache_dict(reload).get(key)
 
     def set_entry(self, key: str, func_res: Any) -> None:
         key_data = CacheEntry(
@@ -174,7 +206,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             cache[key] = key_data
             self._save_cache(cache)
 
@@ -186,13 +218,15 @@ class _PickleCore(_BaseCore):
                 stale=False,
                 _processing=True,
             ),
-            key=key,
+            separate_file_key=key,
         )
 
-    def mark_entry_not_calculated_separate_files(self, key: str) -> None:
+    def _mark_entry_not_calculated_separate_files(self, key: str) -> None:
         _, entry = self.get_entry_by_key(key)
+        if entry is None:
+            return  # that's ok, we don't need an entry in that case
         entry._processing = False
-        self._save_cache(entry, key=key)
+        self._save_cache(entry, separate_file_key=key)
 
     def mark_entry_being_calculated(self, key: str) -> None:
         if self.separate_files:
@@ -200,7 +234,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             if key in cache:
                 cache[key]._processing = True
             else:
@@ -214,9 +248,9 @@ class _PickleCore(_BaseCore):
 
     def mark_entry_not_calculated(self, key: str) -> None:
         if self.separate_files:
-            self.mark_entry_not_calculated_separate_files(key)
+            self._mark_entry_not_calculated_separate_files(key)
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             # that's ok, we don't need an entry in that case
             if isinstance(cache, dict) and key in cache:
                 cache[key]._processing = False
@@ -224,14 +258,13 @@ class _PickleCore(_BaseCore):
 
     def wait_on_entry_calc(self, key: str) -> Any:
         if self.separate_files:
-            entry = self._get_cache_by_key(key)
+            entry = self._load_cache_by_key(key)
             filename = f"{self.cache_fname}_{key}"
         else:
             with self.lock:
-                self._reload_cache()
-                entry = self._get_cache()[key]
+                entry = self.get_cache_dict()[key]
             filename = self.cache_fname
-        if not entry._processing:
+        if entry and not entry._processing:
             return entry.value
         event_handler = _PickleCore.CacheChangeHandler(
             filename=filename, core=self, key=key
@@ -259,7 +292,7 @@ class _PickleCore(_BaseCore):
             return  # pragma: no cover
 
         with self.lock:
-            cache = self._get_cache()
+            cache = self.get_cache_dict()
             for key in cache:
                 cache[key]._processing = False
             self._save_cache(cache)

cachier/cores/sql.py

@@ -0,0 +1,288 @@
+"""A SQLAlchemy-based caching core for cachier."""
+
+import pickle
+import threading
+from datetime import datetime
+from typing import Any, Callable, Optional, Tuple, Union
+
+try:
+    from sqlalchemy import (
+        Boolean,
+        Column,
+        DateTime,
+        Index,
+        LargeBinary,
+        String,
+        and_,
+        create_engine,
+        delete,
+        insert,
+        select,
+        update,
+    )
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.orm import declarative_base, sessionmaker
+
+    SQLALCHEMY_AVAILABLE = True
+except ImportError:
+    SQLALCHEMY_AVAILABLE = False
+
+from .._types import HashFunc
+from ..config import CacheEntry
+from .base import RecalculationNeeded, _BaseCore, _get_func_str
+
+if SQLALCHEMY_AVAILABLE:
+    Base = declarative_base()
+
+    class CacheTable(Base):  # type: ignore[misc, valid-type]
+        """SQLAlchemy model for cachier cache entries."""
+
+        __tablename__ = "cachier_cache"
+        id = Column(String, primary_key=True)
+        function_id = Column(String, index=True, nullable=False)
+        key = Column(String, index=True, nullable=False)
+        value = Column(LargeBinary, nullable=True)
+        timestamp = Column(DateTime, nullable=False)
+        stale = Column(Boolean, default=False)
+        processing = Column(Boolean, default=False)
+        completed = Column(Boolean, default=False)
+        __table_args__ = (
+            Index("ix_func_key", "function_id", "key", unique=True),
+        )
+
+
+class _SQLCore(_BaseCore):
+    """SQLAlchemy-based core for Cachier, supporting SQL-based backends.
+
+    This should work with SQLite, PostgreSQL and so on.
+
+    """
+
+    def __init__(
+        self,
+        hash_func: Optional[HashFunc],
+        sql_engine: Optional[Union[str, "Engine", Callable[[], "Engine"]]],
+        wait_for_calc_timeout: Optional[int] = None,
+    ):
+        if not SQLALCHEMY_AVAILABLE:
+            raise ImportError(
+                "SQLAlchemy is required for the SQL core. "
+                "Install with `pip install SQLAlchemy`."
+            )
+        super().__init__(
+            hash_func=hash_func, wait_for_calc_timeout=wait_for_calc_timeout
+        )
+        self._engine = self._resolve_engine(sql_engine)
+        self._Session = sessionmaker(bind=self._engine)
+        Base.metadata.create_all(self._engine)
+        self._lock = threading.RLock()
+        self._func_str = None
+
+    def _resolve_engine(self, sql_engine):
+        if isinstance(sql_engine, Engine):
+            return sql_engine
+        if isinstance(sql_engine, str):
+            return create_engine(sql_engine, future=True)
+        if callable(sql_engine):
+            return sql_engine()
+        raise ValueError(
+            "sql_engine must be a SQLAlchemy Engine, connection string, "
+            "or callable returning an Engine."
+        )
+
+    def set_func(self, func):
+        super().set_func(func)
+        self._func_str = _get_func_str(func)
+
+    def get_entry_by_key(self, key: str) -> Tuple[str, Optional[CacheEntry]]:
+        with self._lock, self._Session() as session:
+            row = session.execute(
+                select(CacheTable).where(
+                    and_(
+                        CacheTable.function_id == self._func_str,
+                        CacheTable.key == key,
+                    )
+                )
+            ).scalar_one_or_none()
+            if not row:
+                return key, None
+            value = pickle.loads(row.value) if row.value is not None else None
+            entry = CacheEntry(
+                value=value,
+                time=row.timestamp,
+                stale=row.stale,
+                _processing=row.processing,
+                _completed=row.completed,
+            )
+            return key, entry
+
+    def set_entry(self, key: str, func_res: Any) -> None:
+        with self._lock, self._Session() as session:
+            thebytes = pickle.dumps(func_res)
+            now = datetime.now()
+            base_insert = insert(CacheTable)
+            stmt = (
+                base_insert.values(
+                    id=f"{self._func_str}:{key}",
+                    function_id=self._func_str,
+                    key=key,
+                    value=thebytes,
+                    timestamp=now,
+                    stale=False,
+                    processing=False,
+                    completed=True,
+                ).on_conflict_do_update(
+                    index_elements=[CacheTable.function_id, CacheTable.key],
+                    set_={
+                        "value": thebytes,
+                        "timestamp": now,
+                        "stale": False,
+                        "processing": False,
+                        "completed": True,
+                    },
+                )
+                if hasattr(base_insert, "on_conflict_do_update")
+                else None
+            )
+            # Fallback for non-SQLite/Postgres: try update, else insert
+            if stmt:
+                session.execute(stmt)
+            else:
+                row = session.execute(
+                    select(CacheTable).where(
+                        and_(
+                            CacheTable.function_id == self._func_str,
+                            CacheTable.key == key,
+                        )
+                    )
+                ).scalar_one_or_none()
+                if row:
+                    session.execute(
+                        update(CacheTable)
+                        .where(
+                            and_(
+                                CacheTable.function_id == self._func_str,
+                                CacheTable.key == key,
+                            )
+                        )
+                        .values(
+                            value=thebytes,
+                            timestamp=now,
+                            stale=False,
+                            processing=False,
+                            completed=True,
+                        )
+                    )
+                else:
+                    session.add(
+                        CacheTable(
+                            id=f"{self._func_str}:{key}",
+                            function_id=self._func_str,
+                            key=key,
+                            value=thebytes,
+                            timestamp=now,
+                            stale=False,
+                            processing=False,
+                            completed=True,
+                        )
+                    )
+            session.commit()
+
+    def mark_entry_being_calculated(self, key: str) -> None:
+        with self._lock, self._Session() as session:
+            row = session.execute(
+                select(CacheTable).where(
+                    and_(
+                        CacheTable.function_id == self._func_str,
+                        CacheTable.key == key,
+                    )
+                )
+            ).scalar_one_or_none()
+            if row:
+                session.execute(
+                    update(CacheTable)
+                    .where(
+                        and_(
+                            CacheTable.function_id == self._func_str,
+                            CacheTable.key == key,
+                        )
+                    )
+                    .values(processing=True)
+                )
+            else:
+                session.add(
+                    CacheTable(
+                        id=f"{self._func_str}:{key}",
+                        function_id=self._func_str,
+                        key=key,
+                        value=None,
+                        timestamp=datetime.now(),
+                        stale=False,
+                        processing=True,
+                        completed=False,
+                    )
+                )
+            session.commit()
+
+    def mark_entry_not_calculated(self, key: str) -> None:
+        with self._lock, self._Session() as session:
+            session.execute(
+                update(CacheTable)
+                .where(
+                    and_(
+                        CacheTable.function_id == self._func_str,
+                        CacheTable.key == key,
+                    )
+                )
+                .values(processing=False)
+            )
+            session.commit()
+
+    def wait_on_entry_calc(self, key: str) -> Any:
+        import time
+
+        time_spent = 0
+        while True:
+            with self._lock, self._Session() as session:
+                row = session.execute(
+                    select(CacheTable).where(
+                        and_(
+                            CacheTable.function_id == self._func_str,
+                            CacheTable.key == key,
+                        )
+                    )
+                ).scalar_one_or_none()
+                if not row:
+                    raise RecalculationNeeded()
+                if not row.processing:
+                    return (
+                        pickle.loads(row.value)
+                        if row.value is not None
+                        else None
+                    )
+            time.sleep(1)
+            time_spent += 1
+            self.check_calc_timeout(time_spent)
+
+    def clear_cache(self) -> None:
+        with self._lock, self._Session() as session:
+            session.execute(
+                delete(CacheTable).where(
+                    CacheTable.function_id == self._func_str
+                )
+            )
+            session.commit()
+
+    def clear_being_calculated(self) -> None:
+        with self._lock, self._Session() as session:
+            session.execute(
+                update(CacheTable)
+                .where(
+                    and_(
+                        CacheTable.function_id == self._func_str,
+                        CacheTable.processing,
+                    )
+                )
+                .values(processing=False)
+            )
+            session.commit()

cachier/version.info

@@ -1 +1 @@
-3.1.1
+3.2.1

{cachier-3.1.1.dist-info → cachier-3.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: cachier
-Version: 3.1.1
+Version: 3.2.1
 Summary: Persistent, stale-free, local and cross-machine caching for Python functions.
 Author-email: Shay Palachy Affek <shay.palachy@gmail.com>
 License: MIT License
@@ -32,11 +32,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Other/Nonlisted Topic
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -45,6 +45,7 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: portalocker>=2.3.2
 Requires-Dist: watchdog>=2.3.1
+Dynamic: license-file
 
 Cachier
 #######
@@ -92,7 +93,7 @@ Features
 ========
 
 * Pure Python.
-* Compatible with Python 3.8+ (Python 2.7 was discontinued in version 1.2.8).
+* Compatible with Python 3.9+ (Python 2.7 was discontinued in version 1.2.8).
 * Supported and `tested on Linux, OS X and Windows <https://travis-ci.org/shaypal5/cachier>`_.
 * A simple interface.
 * Defining "shelf life" for cached values.
@@ -317,7 +318,7 @@ Cachier Cores
 Pickle Core
 -----------
 
-The default core for Cachier is pickle based, meaning each function will store its cache is a separate pickle file in the ``~/.cachier`` directory. Naturally, this kind of cache is both machine-specific and user-specific.
+The default core for Cachier is pickle based, meaning each function will store its cache in a separate pickle file in the ``~/.cachier`` directory. Naturally, this kind of cache is both machine-specific and user-specific.
 
 You can configure ``cachier`` to use another directory by providing the ``cache_dir`` parameter with the path to that directory:
 
@@ -390,11 +391,69 @@ You can set an in-memory cache by assigning the ``backend`` parameter with ``'me
 
 Note, however, that ``cachier``'s in-memory core is simple, and has no monitoring or cap on cache size, and can thus lead to memory errors on large return values - it is mainly intended to be used with future multi-core functionality. As a rule, Python's built-in ``lru_cache`` is a much better stand-alone solution.
 
+SQLAlchemy (SQL) Core
+---------------------
+
+**Note:** The SQL core requires SQLAlchemy to be installed. It is not installed by default with cachier. To use the SQL backend, run::
+
+    pip install SQLAlchemy
+
+Cachier supports a generic SQL backend via SQLAlchemy, allowing you to use SQLite, PostgreSQL, MySQL, and other databases.
+
+**Usage Example (SQLite in-memory):**
+
+.. code-block:: python
+
+    from cachier import cachier
+
+    @cachier(backend="sql", sql_engine="sqlite:///:memory:")
+    def my_func(x):
+        return x * 2
+
+**Usage Example (PostgreSQL):**
+
+.. code-block:: python
+
+    @cachier(backend="sql", sql_engine="postgresql://user:pass@localhost/dbname")
+    def my_func(x):
+        return x * 2
+
+**Usage Example (MySQL):**
+
+.. code-block:: python
+
+    @cachier(backend="sql", sql_engine="mysql+pymysql://user:pass@localhost/dbname")
+    def my_func(x):
+        return x * 2
+
+**Configuration Options:**
+
+- ``sql_engine``: SQLAlchemy connection string, Engine, or callable returning an Engine.
+- All other standard cachier options are supported.
+
+**Table Schema:**
+
+- ``function_id``: Unique identifier for the cached function
+- ``key``: Cache key
+- ``value``: Pickled result
+- ``timestamp``: Datetime of cache entry
+- ``stale``: Boolean, is value stale
+- ``processing``: Boolean, is value being calculated
+- ``completed``: Boolean, is value calculation completed
+
+**Limitations & Notes:**
+
+- Requires SQLAlchemy (install with ``pip install SQLAlchemy``)
+- For production, use a persistent database (not ``:memory:``)
+- Thread/process safety is handled via transactions and row-level locks
+- Value serialization uses ``pickle``. **Warning:** `pickle` can execute arbitrary code during deserialization if the cache database is compromised. Ensure the cache is stored securely and consider using safer serialization methods like `json` if security is a concern.
+- For best performance, ensure your DB supports row-level locking
+
 
 Contributing
 ============
 
-Current maintainers are Shay Palachy Affek (`shay.palachy@gmail.com <mailto:shay.palachy@gmail.com>`_, `@shaypal5 <https://github.com/shaypal5>`_) and Judson Neer (`@lordjabez <https://github.com/lordjabez>`_); You are more than welcome to approach them for help. Contributions are very welcomed! :)
+Current maintainers are Shay Palachy Affek (`shay.palachy@gmail.com <mailto:shay.palachy@gmail.com>`_, `@shaypal5 <https://github.com/shaypal5>`_) and `Jirka Borovec <https://github.com/Borda>`_ (`@Borda <https://github.com/Borda>`_ on GitHub); You are more than welcome to approach them for help. Contributions are very welcomed! :)
 
 Installing for development
 --------------------------

cachier-3.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+cachier/__init__.py,sha256=1isxXaP2l6Vq7gC1Gob6hduRLC07dHfWze1-oCjwSP0,415
+cachier/__main__.py,sha256=upg-TlHs1vngKYvkjoPpl3Pvl6xOx4ut-M1mElMiAo0,443
+cachier/_types.py,sha256=EGJMiw-oCIC_cDLyzw7YC40lfo8jnD3zMmoJpA9Y8Iw,238
+cachier/_version.py,sha256=jnPPRn_qmjNi-qmQjlHnzNGf3LSBTYkMmJdGjxMTOBM,1089
+cachier/config.py,sha256=6hyQtn9T6UXu2UQhKJltWT0Nu4OBS4ION1x7Lt1i8Og,3838
+cachier/core.py,sha256=7pqf_EGvGXu5WWtC5MeY0tVW4M59XljZI9_2R4RVfRU,13627
+cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/version.info,sha256=OCJyh4MEn8LyKlbR7nTWI1LEn7-BxrVLUIMNb2HDryI,6
+cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachier/cores/base.py,sha256=s7qgmDJA4LGub6ydGfMk9vVJW4fgeU0EXl-9gmpuh28,3683
+cachier/cores/memory.py,sha256=fsvqq9rwwmAaMBvYo-oUNAxB6UOyfBpuf8ACW_XTaU0,3572
+cachier/cores/mongo.py,sha256=pCBrxLsmGr68Q50JVD_CUPAYwhaLDrJUQs_6A-_GYLA,4993
+cachier/cores/pickle.py,sha256=FgfvZWAFdWQPOo3G-L57iEV2ujEkIDH8TyGzbarsZeE,10678
+cachier/cores/sql.py,sha256=nuf2-Szo7VTPRa7IC3JGWEtGsBtdkIrx0bhOm3U0mfE,9895
+cachier-3.2.1.dist-info/licenses/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
+cachier-3.2.1.dist-info/METADATA,sha256=xowxZuYhc4r5f4pKxrhROtHGT7FYObRJ4ULWFDXwA-Q,22101
+cachier-3.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cachier-3.2.1.dist-info/entry_points.txt,sha256=x4Y7t6Y0Qev_3fgG-Jv7TrsvVdJty3FnGAdkT8-_5mY,49
+cachier-3.2.1.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
+cachier-3.2.1.dist-info/RECORD,,

{cachier-3.1.1.dist-info → cachier-3.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cachier-3.1.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-cachier/__init__.py,sha256=GZeDebG0EgWIYBmRgPhO19dMiiaam8f9Pu7cWLv3ywY,400
-cachier/__main__.py,sha256=upg-TlHs1vngKYvkjoPpl3Pvl6xOx4ut-M1mElMiAo0,443
-cachier/_types.py,sha256=EGJMiw-oCIC_cDLyzw7YC40lfo8jnD3zMmoJpA9Y8Iw,238
-cachier/_version.py,sha256=yE6UYwvdoIRpw3HmNifiGwV3fqVea5PwZj_EvyosiZ8,1079
-cachier/config.py,sha256=KOGaXkBRgv66BexENrTMtrC_TYCeV1fA5v8l6Vj2CYI,3840
-cachier/core.py,sha256=qQa_GT8WQYD-VFcTS8a2v-Hys4_A1no-aM-d3lw1AFY,13149
-cachier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/version.info,sha256=bcOy3DE5t9Qhtvwmp_hTOJqbA16k8ukEe5UWBQ3WrHM,6
-cachier/cores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachier/cores/base.py,sha256=jo69c2RMOXbTzDvqRV0UGa5UvyToipv3f62bICIII1k,3631
-cachier/cores/memory.py,sha256=SSa7qlSU_54YjNYEWrq9rxXozkMYXr5hadAZ3sz62l4,3336
-cachier/cores/mongo.py,sha256=eRG6XP55G4IcWnoMl5xtDufM1szf8FVbOIBbDH_r-Po,4887
-cachier/cores/pickle.py,sha256=20c5pg2CS6wAX1PdefCOjl-orec5w7tqEHVqNbZZv0s,9074
-cachier-3.1.1.dist-info/LICENSE,sha256=-2WrMJkIa0gVP6YQHXXDT7ws-S3M2NEVEF4XF3K8qrY,1069
-cachier-3.1.1.dist-info/METADATA,sha256=QQxy_bvI6YCcmhvOj0GqWR4Ni31hCEYnDpTJegprWj4,20102
-cachier-3.1.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-cachier-3.1.1.dist-info/entry_points.txt,sha256=x4Y7t6Y0Qev_3fgG-Jv7TrsvVdJty3FnGAdkT8-_5mY,49
-cachier-3.1.1.dist-info/top_level.txt,sha256=_rW_HiJumDCch67YT-WAgzcyvKg5RiYDMZq9d-0ZpaE,8
-cachier-3.1.1.dist-info/RECORD,,