machineconfig 5.15__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/utils/scheduler.py

@@ -1,10 +1,10 @@
+
 from pathlib import Path
-from typing import Callable, Optional, Union, Any, NoReturn, TypeVar, Protocol, List, Generic
+from typing import Callable, Optional, Union, Any, Protocol, List, TypeVar
 import logging
 import time
 from datetime import datetime, timezone, timedelta
 from machineconfig.utils.io import from_pickle
-from machineconfig.utils.path_extended import PathExtended
 
 
 class LoggerTemplate(Protocol):
@@ -143,145 +143,142 @@ class Scheduler:
         raise ex
 
 
-T = TypeVar("T")
+# T = TypeVar("T")
 T2 = TypeVar("T2")
-
-
-class PrintFunc(Protocol):
-    def __call__(self, msg: str) -> Union[NoReturn, None]: ...
-
-
 def to_pickle(obj: Any, path: Path) -> None:
     import pickle
-
-    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_bytes(pickle.dumps(obj))
 
 
-class Cache(Generic[T]):  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
-    # source_func: Callable[[], T]
+class CacheMemory[T]():
+    def __init__(
+        self, source_func: Callable[[], T], expire: timedelta, logger: LoggerTemplate, name: Optional[str] = None
+    ) -> None:
+        self.cache: T
+        self.source_func = source_func
+        self.time_produced = datetime.now()
+        self.logger = logger
+        self.expire = expire
+        self.name = name if isinstance(name, str) else self.source_func.__name__
+    def __call__(self, fresh: bool, tolerance_seconds: float | int) -> T:
+        if fresh or not hasattr(self, "cache"):
+            why = "There was an explicit fresh order." if fresh else "Previous cache never existed."
+            t0 = time.time()
+            self.logger.warning(f"""
+🆕 ════════════════════ NEW {self.name} CACHE ════════════════════
+ℹ️ Reason: {why}""")
+            self.cache = self.source_func()
+            self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+            self.time_produced = datetime.now()
+        else:
+            age = datetime.now() - self.time_produced
+            if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):
+                self.logger.warning(f"""
+🔄 ════════════════════ CACHE UPDATE ════════════════════
+⚠️  {self.name} cache: Updating cache from source func
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
+                self.cache = self.source_func()
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+                self.time_produced = datetime.now()
+            else:
+                self.logger.warning(f"""
+✅ ════════════════════ USING CACHE ════════════════════
+📦 {self.name} cache: Using cached values
+⏱️  Lag = {age}""")
+        return self.cache
+
+    @staticmethod
+    def as_decorator(expire: timedelta, logger: LoggerTemplate, name: Optional[str] = None):
+        def decorator(source_func: Callable[[], T2]) -> CacheMemory["T2"]:
+            res = CacheMemory(source_func=source_func, expire=expire, logger=logger, name=name)
+            return res
+        return decorator
+
+
+class Cache[T]():  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
     def __init__(
-        self, source_func: Callable[[], T], expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None, saver: Callable[[T, Path], Any] = to_pickle, reader: Callable[[Path], T] = from_pickle, name: Optional[str] = None
+        self, source_func: Callable[[], T], expire: timedelta, logger: LoggerTemplate, path: Path, saver: Callable[[T, Path], Any] = to_pickle, reader: Callable[[Path], T] = from_pickle, name: Optional[str] = None
     ) -> None:
         self.cache: T
         self.source_func = source_func  # function which when called returns a fresh object to be frozen.
-        self.path: Optional[PathExtended] = PathExtended(path) if path is not None else None  # if path is passed, it will function as disk-based flavour.
+        self.path: Path = path
+        _ = self.path.parent.mkdir(parents=True, exist_ok=True)
         self.time_produced = datetime.now()  # if path is None else
         self.save = saver
         self.reader = reader
         self.logger = logger
         self.expire = expire
-        self.name = name if isinstance(name, str) else str(self.source_func)
-        self.last_call_is_fresh = False
-
-    @property
-    def age(self):
-        """Throws AttributeError if called before cache is populated and path doesn't exists"""
-        if self.path is None:  # memory-based cache.
-            return datetime.now() - self.time_produced
-        return datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
-
-    # def __setstate__(self, state: dict[str, Any]) -> None:
-    #     self.__dict__.update(state)
-    #     self.path = P.home() / self.path if self.path is not None else self.path
-    # def __getstate__(self) -> dict[str, Any]:
-    #     state = self.__dict__.copy()
-    #     state["path"] = self.path.rel2home() if self.path is not None else state["path"]
-    #     return state  # With this implementation, instances can be pickled and loaded up in different machine and still works.
-    def __call__(self, fresh: bool = False) -> T:
-        self.last_call_is_fresh = False
-        if fresh or not hasattr(self, "cache"):  # populate cache for the first time
-            if not fresh and self.path is not None and self.path.exists():
+        self.name = name if isinstance(name, str) else self.source_func.__name__
+    def __call__(self, fresh: bool, tolerance_seconds: float | int) -> T:
+        if not hasattr(self, "cache"):  # populate cache for the first time: we have two options, populate from disk or from source func.
+            if self.path.exists():  # prefer to read from disk over source func as a default source of cache.
                 age = datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
+                if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):  # cache is old or if fresh flag is raised
+                    self.logger.warning(f"""
+🔄 ════════════════════ CACHE STALE ════════════════════
+📦 {self.name} cache: Populating fresh cache from source func
+⏱️  Lag = {age}""")
+                    t0 = time.time()
+                    self.cache = self.source_func()  # fresh data.
+                    self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+                    self.time_produced = datetime.now()
+                    self.save(self.cache, self.path)
+                    return self.cache
+
                 msg1 = f"""
 📦 ════════════════════ CACHE OPERATION ════════════════════
 🔄 {self.name} cache: Reading cached values from `{self.path}`
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════════
-"""
+⏱️  Lag = {age}"""
                 try:
                     self.cache = self.reader(self.path)
                 except Exception as ex:
-                    if self.logger:
-                        msg2 = f"""
+                    msg2 = f"""
 ❌ ════════════════════ CACHE ERROR ════════════════════
 ⚠️  {self.name} cache: Cache file is corrupted
-🔍 Error: {ex}
-════════════════════════════════════════════════════════
-"""
-                        self.logger(msg1 + msg2)
+🔍 Error: {ex}"""
+                    self.logger.warning(msg1 + msg2)
+                    t0 = time.time()
                     self.cache = self.source_func()
-                    self.last_call_is_fresh = True
+                    self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                     self.time_produced = datetime.now()
-                    # if self.path is not None:
-                    #     self.save(self.cache, self.path)
+                    self.save(self.cache, self.path)
                     return self.cache
-                return self(fresh=False)  # may be the cache is old ==> check that by passing it through the logic again.
-            else:
-                if self.logger:
-                    # Previous cache never existed or there was an explicit fresh order.
-                    why = "There was an explicit fresh order." if fresh else "Previous cache never existed or is corrupted."
-                    self.logger(f"""
+            else:  # disk cache does not exist, populate from source func.
+                why = "Previous cache never existed."
+                self.logger.warning(f"""
 🆕 ════════════════════ NEW CACHE ════════════════════
 🔄 {self.name} cache: Populating fresh cache from source func
-ℹ️  Reason: {why}
-════════════════════════════════════════════════════════
-""")
+ℹ️  Reason: {why}""")
+                t0 = time.time()
                 self.cache = self.source_func()  # fresh data.
-                self.last_call_is_fresh = True
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.time_produced = datetime.now()
-                if self.path is not None:
-                    self.save(self.cache, self.path)
-        else:  # cache exists
-            try:
-                age = self.age
-            except AttributeError:  # path doesn't exist (may be deleted) ==> need to repopulate cache form source_func.
-                return self(fresh=True)
-            if age > self.expire:
-                if self.logger:
-                    self.logger(f"""
+                self.save(self.cache, self.path)
+        else:  # memory cache exists
+            age = datetime.now() - self.time_produced
+            if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):  # cache is old or if fresh flag is raised
+                self.logger.warning(f"""
 🔄 ════════════════════ CACHE UPDATE ════════════════════
 ⚠️  {self.name} cache: Updating cache from source func
-⏱️  Age = {age} > {self.expire}
-════════════════════════════════════════════════════════""")
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
                 self.cache = self.source_func()
-                self.last_call_is_fresh = True
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.time_produced = datetime.now()
-                if self.path is not None:
-                    self.save(self.cache, self.path)
+                self.save(self.cache, self.path)
             else:
-                if self.logger:
-                    self.logger(f"""
+                self.logger.warning(f"""
 ✅ ════════════════════ USING CACHE ════════════════════
 📦 {self.name} cache: Using cached values
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════""")
+⏱️  Lag = {age}""")
         return self.cache
 
     @staticmethod
     def as_decorator(
-        expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None, saver: Callable[[T2, Path], Any] = to_pickle, reader: Callable[[Path], T2] = from_pickle, name: Optional[str] = None
+        expire: timedelta, logger: LoggerTemplate, path: Path, saver: Callable[[T2, Path], Any] = to_pickle, reader: Callable[[Path], T2] = from_pickle, name: Optional[str] = None
     ):  # -> Callable[..., 'Cache[T2]']:
         def decorator(source_func: Callable[[], T2]) -> Cache["T2"]:
             res = Cache(source_func=source_func, expire=expire, logger=logger, path=path, name=name, reader=reader, saver=saver)
             return res
-
         return decorator
-
-    def from_cloud(self, cloud: str, rel2home: bool = True, root: Optional[str] = None):
-        assert self.path is not None
-        exists = self.path.exists()
-        exists_but_old = exists and ((datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)) > self.expire)
-        if not exists or exists_but_old:
-            returned_path = self.path.from_cloud(cloud=cloud, rel2home=rel2home, root=root)
-            if returned_path is None and not exists:
-                raise FileNotFoundError(f"❌ Failed to get @ {self.path}. Build the cache first with signed API.")
-            elif returned_path is None and exists and self.logger is not None:
-                self.logger(f"""
-⚠️ ════════════════════ CLOUD FETCH WARNING ════════════════════
-🔄 Failed to get fresh data from cloud
-📦 Using old cache @ {self.path}
-════════════════════════════════════════════════════════════════""")
-        else:
-            pass  # maybe we don't need to fetch it from cloud, if its too hot
-        return self.reader(self.path)

machineconfig/utils/scheduling.py

@@ -1,7 +1,6 @@
 # """Task scheduler
 # """
 
-# from machineconfig.utils.utils import get_shell_script_executing_python_file
 # from machineconfig.utils.utils2 import read_ini
 # from dataclasses import dataclass
 # from datetime import datetime, timedelta
@@ -140,8 +139,6 @@
 #     start: datetime
 #     end: datetime
 #     status: str
-
-#     @classmethod
 #     def from_path(cls, path: PathExtended, return_default_if_not_found: bool=False):
 #         if not path.exists():
 #             if return_default_if_not_found:

machineconfig/utils/schemas/fire_agents/fire_agents_input.py

@@ -6,7 +6,7 @@ capturing all user inputs collected during interactive execution.
 
 from pathlib import Path
 from typing import TypedDict, Literal, NotRequired
-from machineconfig.scripts.python.fire_agents_help_launch import AGENTS
+from machineconfig.scripts.python.helpers_agents.fire_agents_help_launch import AGENTS
 
 SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
 

machineconfig/utils/schemas/layouts/layout_types.py

@@ -13,7 +13,7 @@ class TabConfig(TypedDict):
     tabName: str
     startDir: str
     command: str
-    tabWeight: NotRequired[int]  # Optional, defaults to 1 if not provided
+    tabWeight: NotRequired[int]
 
 
 class LayoutConfig(TypedDict):

machineconfig/utils/source_of_truth.py

@@ -5,19 +5,16 @@ Utils
 import machineconfig
 from pathlib import Path
 
-EXCLUDE_DIRS = [".links", ".ai", ".scripts", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"]
-
+EXCLUDE_DIRS = [".links", ".ai", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"]
 LIBRARY_ROOT = Path(machineconfig.__file__).resolve().parent
-REPO_ROOT = LIBRARY_ROOT.parent.parent
 
-CONFIG_PATH = Path.home().joinpath(".config/machineconfig")
+CONFIG_ROOT = Path.home().joinpath(".config/machineconfig")
 DEFAULTS_PATH = Path.home().joinpath("dotfiles/machineconfig/defaults.ini")
 
-INSTALL_VERSION_ROOT = CONFIG_PATH.joinpath("cli_tools_installers/versions")
+INSTALL_VERSION_ROOT = CONFIG_ROOT.joinpath("cli_tools_installers/versions")
 INSTALL_TMP_DIR = Path.home().joinpath("tmp_results", "tmp_installers")
 
 # LINUX_INSTALL_PATH = '/usr/local/bin'
-# LINUX_INSTALL_PATH = '~/.local/bin'
 LINUX_INSTALL_PATH = Path.home().joinpath(".local/bin").__str__()
 WINDOWS_INSTALL_PATH = Path.home().joinpath("AppData/Local/Microsoft/WindowsApps").__str__()