refactor: simplify using property line methods (#199)

* refactor: simplify using property line methods
* public & just property

Author: Borda

cachier/cores/base.py

@@ -9,6 +9,7 @@
 import abc  # for the _BaseCore abstract base class
 import inspect
 import threading
+from typing import Callable
 
 from .._types import HashFunc
 from ..config import _update_with_defaults
@@ -18,6 +19,10 @@ class RecalculationNeeded(Exception):
     pass
 
 
+def _get_func_str(func: Callable) -> str:
+    return f".{func.__module__}.{func.__name__}"
+
+
 class _BaseCore:
     __metaclass__ = abc.ABCMeta
 

cachier/cores/mongo.py

@@ -21,7 +21,7 @@
     from pymongo import ASCENDING, IndexModel
     from pymongo.errors import OperationFailure
 
-from .base import RecalculationNeeded, _BaseCore
+from .base import RecalculationNeeded, _BaseCore, _get_func_str
 
 MONGO_SLEEP_DURATION_IN_SEC = 1
 
@@ -60,13 +60,13 @@ def __init__(
             )
             self.mongo_collection.create_indexes([func1key1])
 
-    @staticmethod
-    def _get_func_str(func):
-        return f".{func.__module__}.{func.__name__}"
+    @property
+    def _func_str(self) -> str:
+        return _get_func_str(self.func)
 
     def get_entry_by_key(self, key):
         res = self.mongo_collection.find_one(
-            {"func": _MongoCore._get_func_str(self.func), "key": key}
+            {"func": self._func_str, "key": key}
         )
         if not res:
             return key, None
@@ -89,10 +89,10 @@ def get_entry_by_key(self, key):
     def set_entry(self, key, func_res):
         thebytes = pickle.dumps(func_res)
         self.mongo_collection.update_one(
-            filter={"func": _MongoCore._get_func_str(self.func), "key": key},
+            filter={"func": self._func_str, "key": key},
             update={
                 "$set": {
-                    "func": _MongoCore._get_func_str(self.func),
+                    "func": self._func_str,
                     "key": key,
                     "value": Binary(thebytes),
                     "time": datetime.now(),
@@ -105,7 +105,7 @@ def set_entry(self, key, func_res):
 
     def mark_entry_being_calculated(self, key):
         self.mongo_collection.update_one(
-            filter={"func": _MongoCore._get_func_str(self.func), "key": key},
+            filter={"func": self._func_str, "key": key},
             update={"$set": {"being_calculated": True}},
             upsert=True,
         )
@@ -114,7 +114,7 @@ def mark_entry_not_calculated(self, key):
         with suppress(OperationFailure):  # don't care in this case
             self.mongo_collection.update_one(
                 filter={
-                    "func": _MongoCore._get_func_str(self.func),
+                    "func": self._func_str,
                     "key": key,
                 },
                 update={"$set": {"being_calculated": False}},
@@ -134,14 +134,12 @@ def wait_on_entry_calc(self, key):
             self.check_calc_timeout(time_spent)
 
     def clear_cache(self):
-        self.mongo_collection.delete_many(
-            filter={"func": _MongoCore._get_func_str(self.func)}
-        )
+        self.mongo_collection.delete_many(filter={"func": self._func_str})
 
     def clear_being_calculated(self):
         self.mongo_collection.update_many(
             filter={
-                "func": _MongoCore._get_func_str(self.func),
+                "func": self._func_str,
                 "being_calculated": True,
             },
             update={"$set": {"being_calculated": False}},

cachier/cores/pickle.py

@@ -86,30 +86,33 @@ def __init__(
         self.separate_files = _update_with_defaults(
             separate_files, "separate_files"
         )
-        self.cache_fname = None
-        self.cache_fpath = None
+        self._cache_fname = None
+        self._cache_fpath = None
 
-    def _cache_fname(self):
-        if self.cache_fname is None:
+    @property
+    def cache_fname(self) -> str:
+        if self._cache_fname is None:
             fname = f".{self.func.__module__}.{self.func.__qualname__}"
-            self.cache_fname = fname.replace("<", "_").replace(">", "_")
-        return self.cache_fname
+            self._cache_fname = fname.replace("<", "_").replace(">", "_")
+        return self._cache_fname
 
-    def _cache_fpath(self):
-        if self.cache_fpath is None:
+    @property
+    def cache_fpath(self) -> str:
+        if self._cache_fpath is None:
             os.makedirs(self.cache_dir, exist_ok=True)
-            self.cache_fpath = os.path.abspath(
+            self._cache_fpath = os.path.abspath(
                 os.path.join(
-                    os.path.realpath(self.cache_dir), self._cache_fname()
+                    os.path.realpath(self.cache_dir), self.cache_fname
                 )
             )
-        return self.cache_fpath
+        return self._cache_fpath
 
     def _reload_cache(self):
         with self.lock:
-            fpath = self._cache_fpath()
             try:
-                with portalocker.Lock(fpath, mode="rb") as cache_file:
+                with portalocker.Lock(
+                    self.cache_fpath, mode="rb"
+                ) as cache_file:
                     try:
                         self.cache = pickle.load(cache_file)  # noqa: S301
                     except EOFError:
@@ -124,7 +127,7 @@ def _get_cache(self):
             return self.cache
 
     def _get_cache_by_key(self, key=None, hash=None):
-        fpath = self._cache_fpath()
+        fpath = self.cache_fpath
         fpath += f"_{key}" if hash is None else f"_{hash}"
         try:
             with portalocker.Lock(fpath, mode="rb") as cache_file:
@@ -133,15 +136,13 @@ def _get_cache_by_key(self, key=None, hash=None):
             return None
 
     def _clear_all_cache_files(self):
-        fpath = self._cache_fpath()
-        path, name = os.path.split(fpath)
+        path, name = os.path.split(self.cache_fpath)
         for subpath in os.listdir(path):
             if subpath.startswith(f"{name}_"):
                 os.remove(os.path.join(path, subpath))
 
     def _clear_being_calculated_all_cache_files(self):
-        fpath = self._cache_fpath()
-        path, name = os.path.split(fpath)
+        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=subpath.split("_")[-1])
@@ -150,13 +151,13 @@ def _clear_being_calculated_all_cache_files(self):
                     self._save_cache(entry, hash=subpath.split("_")[-1])
 
     def _save_cache(self, cache, key=None, hash=None):
+        fpath = self.cache_fpath
+        if key is not None:
+            fpath += f"_{key}"
+        elif hash is not None:
+            fpath += f"_{hash}"
         with self.lock:
             self.cache = cache
-            fpath = self._cache_fpath()
-            if key is not None:
-                fpath += f"_{key}"
-            elif hash is not None:
-                fpath += f"_{hash}"
             with portalocker.Lock(fpath, mode="wb") as cache_file:
                 pickle.dump(cache, cache_file, protocol=4)
             if key is None:
@@ -231,12 +232,12 @@ def mark_entry_not_calculated(self, key):
     def wait_on_entry_calc(self, key):
         if self.separate_files:
             entry = self._get_cache_by_key(key)
-            filename = f"{self._cache_fname()}_{key}"
+            filename = f"{self.cache_fname}_{key}"
         else:
             with self.lock:
                 self._reload_cache()
                 entry = self._get_cache()[key]
-            filename = self._cache_fname()
+            filename = self.cache_fname
         if not entry["being_calculated"]:
             return entry["value"]
         event_handler = _PickleCore.CacheChangeHandler(