machineconfig 7.50__py3-none-any.whl → 8.14__py3-none-any.whl

machineconfig/utils/options_tv.py

@@ -0,0 +1,119 @@
+
+
+#!/usr/bin/env python3
+import base64
+import pathlib
+import subprocess
+import tempfile
+import os
+
+
+def main(options_to_preview_mapping: dict[str, str]) -> str | None:
+    keys = list(options_to_preview_mapping.keys())
+    if not keys:
+        return None
+    with tempfile.TemporaryDirectory(prefix="tv_channel_") as tmpdir:
+        tempdir = pathlib.Path(tmpdir)
+        entries: list[str] = []
+        index_map: dict[int, str] = {}
+        preview_map_path = tempdir / "previews.tsv"
+        preview_rows: list[str] = []
+        for idx, key in enumerate(keys):
+            display_key = key.replace("\t", "    ").replace("\n", " ")
+            entries.append(f"{idx}\t{display_key}")
+            index_map[idx] = key
+            encoded_preview = base64.b64encode(options_to_preview_mapping[key].encode("utf-8")).decode("ascii")
+            preview_rows.append(f"{idx}\t{encoded_preview}")
+        preview_map_path.write_text("\n".join(preview_rows), encoding="utf-8")
+        entries_path = tempdir / "entries.tsv"
+        entries_path.write_text("\n".join(entries), encoding="utf-8")
+        preview_script = tempdir / "preview.sh"
+        preview_script.write_text(
+            """#!/usr/bin/env bash
+set -euo pipefail
+
+idx="$1"
+script_dir="$(cd -- "$(dirname -- "$0")" && pwd)"
+previews_file="${script_dir}/previews.tsv"
+
+if [[ ! -f "${previews_file}" ]]; then
+    exit 0
+fi
+
+encoded_preview="$(awk -F '\t' -v idx="${idx}" '($1==idx){print $2; exit}' "${previews_file}" || true)"
+
+if [[ -z "${encoded_preview}" ]]; then
+    exit 0
+fi
+
+preview_content="$(printf '%s' "${encoded_preview}" | base64 --decode)"
+
+if command -v bat >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | glow -
+elif command -v bat >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | bat --language=markdown --color=always --style=plain --paging=never
+elif command -v glow >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | glow -
+else
+    printf '%s' "${preview_content}"
+fi
+""",
+            encoding="utf-8"
+        )
+        preview_script.chmod(0o755)
+        channel_config = f"""[metadata]
+name = "temp_options"
+description = "Temporary channel for selecting options"
+
+[source]
+command = "cat '{entries_path}'"
+display = "{{split:\\t:1}}"
+output = "{{split:\\t:0}}"
+
+[preview]
+command = "{preview_script} {{split:\\t:0}}"
+
+[ui.preview_panel]
+size = 50
+"""
+        channel_path = tempdir / "temp_options.toml"
+        channel_path.write_text(channel_config, encoding="utf-8")
+        env = os.environ.copy()
+        tv_config_dir = pathlib.Path.home() / ".config" / "television"
+        if not tv_config_dir.exists():
+            tv_config_dir = pathlib.Path(os.getenv("XDG_CONFIG_HOME", str(pathlib.Path.home() / ".config"))) / "television"
+        cable_dir = tv_config_dir / "cable"
+        cable_dir.mkdir(parents=True, exist_ok=True)
+        temp_channel_link = cable_dir / "temp_options.toml"
+        if temp_channel_link.exists() or temp_channel_link.is_symlink():
+            temp_channel_link.unlink()
+        temp_channel_link.symlink_to(channel_path)
+        output_file = tempdir / "selection.txt"
+        try:
+            result = subprocess.run(["tv", "temp_options"], check=False, stdout=output_file.open("w"), text=True, env=env)
+        finally:
+            if temp_channel_link.exists() or temp_channel_link.is_symlink():
+                temp_channel_link.unlink()
+        if result.returncode not in (0, 130):
+            raise SystemExit(result.returncode)
+        if result.returncode == 130:
+            return None
+        if not output_file.exists():
+            return None
+        selected = output_file.read_text().strip()
+        if not selected:
+            return None
+        try:
+            index = int(selected)
+        except ValueError:
+            return None
+        return index_map.get(index)
+
+
+if __name__ == "__main__":
+    demo_mapping = {
+        "Option 1": "# Option 1\nThis is the preview for option 1.",
+        "Option 2": "# Option 2\nThis is the preview for option 2.",
+        "Option 3": "# Option 3\nThis is the preview for option 3."
+    }
+    main(demo_mapping)

machineconfig/utils/path_extended.py

@@ -16,6 +16,8 @@ OPLike: TypeAlias = Union[str, "PathExtended", Path, None]
 PLike: TypeAlias = Union[str, "PathExtended", Path]
 FILE_MODE: TypeAlias = Literal["r", "w", "x", "a"]
 SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
+DECOMPRESS_SUPPORTED_FORMATS = [".tar.gz", ".tgz", ".tar", ".gz", ".tar.bz", ".tbz", ".tar.xz", ".zip", ".7z",
+                                ".tar.bz2", ".tbz2", ".xz"]
 
 
 def _is_user_admin() -> bool:
@@ -152,7 +154,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     # ======================================= File Editing / Reading ===================================
     def download(self, folder: OPLike = None, name: Optional[str] = None, allow_redirects: bool = True, timeout: Optional[int] = None, params: Any = None) -> "PathExtended":
         import requests
-
         response = requests.get(self.as_url_str(), allow_redirects=allow_redirects, timeout=timeout, params=params)  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
         assert response.status_code == 200, f"Download failed with status code {response.status_code}\n{response.text}"
         if name is not None:
@@ -480,9 +481,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         **kwargs: Any,
     ) -> "PathExtended":
         path_resolved, slf = self._resolve_path(folder, name, path, self.name).expanduser().resolve(), self.expanduser().resolve()
-        # if use_7z:  # benefits over regular zip and encrypt: can handle very large files with low memory footprint
-        #     path_resolved = path_resolved + '.7z' if not path_resolved.suffix == '.7z' else path_resolved
-        #     with install_n_import("py7zr").SevenZipFile(file=path_resolved, mode=mode, password=pwd) as archive: archive.writeall(path=str(slf), arcname=None)
         arcname_obj = PathExtended(arcname or slf.name)
         if arcname_obj.name != slf.name:
             arcname_obj /= slf.name  # arcname has to start from somewhere and end with filename
@@ -555,15 +553,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         folder = folder if not content else folder.parent
         if slf.suffix == ".7z":
             raise NotImplementedError("I have not implemented this yet")
-            # if overwrite: P(folder).delete(sure=True)
-            # result = folder
-            # import py7zr
-            # with py7zr.SevenZipFile(file=slf, mode='r', password=pwd) as archive:
-            #     if pattern is not None:
-            #         import re
-            #         pat = re.compile(pattern)
-            #         archive.extract(path=folder, targets=[f for f in archive.getnames() if pat.match(f)])
-            #     else: archive.extractall(path=folder)
         else:
             if overwrite:
                 if not content:
@@ -698,21 +687,54 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return ret
 
     def decompress(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, inplace: bool = False, orig: bool = False, verbose: bool = True) -> "PathExtended":
-        if ".tar.gz" in str(self) or ".tgz" in str(self):
+        if str(self).endswith(".tar.gz") or str(self).endswith(".tgz"):
             # res = self.ungz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             return self.ungz(name=f"tmp_{randstr()}.tar", inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)  # this works for .tgz suffix as well as .tar.gz
-        elif ".gz" in str(self):
+        elif str(self).endswith(".tar"):
+            res = self.untar(folder=folder, name=name, path=path, inplace=inplace, orig=orig, verbose=verbose)
+        elif str(self).endswith(".gz"):
             res = self.ungz(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
-        elif ".tar.bz" in str(self) or "tbz" in str(self):
+        elif str(self).endswith(".tar.bz") or str(self).endswith(".tbz") or str(self).endswith(".tar.bz2"):
             res = self.unbz(name=f"tmp_{randstr()}.tar", inplace=inplace)
             return res.untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".tar.xz" in str(self):
+        elif str(self).endswith(".tar.xz"):
             # res = self.unxz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             res = self.unxz(inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".zip" in str(self):
+        elif str(self).endswith(".zip"):
             res = self.unzip(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
+        elif str(self).endswith(".7z"):
+            def unzip_7z(archive_path: str, dest_dir: Optional[str] = None) -> Path:
+                """
+                Uncompresses a .7z archive to a directory and returns the Path to the extraction directory.
+
+                :param archive_path: path to the .7z archive file
+                :param dest_dir: optional path to directory to extract into; if None a temporary dir will be created
+                :return: pathlib.Path pointing to the destination directory where contents were extracted
+                :raises: FileNotFoundError if archive does not exist; py7zr.Bad7zFile or other error if extraction fails
+                """
+                import py7zr  # type: ignore
+                import tempfile
+                from pathlib import Path
+                archive_path_obj = Path(archive_path)
+                if not archive_path_obj.is_file():
+                    raise FileNotFoundError(f"Archive file not found: {archive_path_obj!r}")
+                if dest_dir is None:
+                    # create a temporary directory
+                    dest = Path(tempfile.mkdtemp(prefix=f"unzip7z_{archive_path_obj.stem}_"))
+                else:
+                    dest = Path(dest_dir)
+                    dest.mkdir(parents=True, exist_ok=True)
+                # Perform extraction
+                with py7zr.SevenZipFile(str(archive_path_obj), mode='r') as archive:
+                    archive.extractall(path=str(dest))
+                # Return the extraction directory path
+                return dest
+            from machineconfig.utils.code import run_lambda_function
+            destination_dir = str(self.expanduser().resolve()).replace(".7z", "")
+            run_lambda_function(lambda: unzip_7z(archive_path=str(self), dest_dir=destination_dir), uv_project_dir=None, uv_with=["py7zr"])
+            res = PathExtended(destination_dir)
         else:
-            res = self
+            raise ValueError(f"Cannot decompress file with unknown extension: {self}")
         return res
 
     def encrypt(
@@ -788,7 +810,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path = self
         else:
             try:
-                path = self.rel2home()
+                path = PathExtended(self.expanduser().absolute().relative_to(Path.home()))
             except ValueError as ve:
                 if strict:
                     raise ve

machineconfig/utils/path_helper.py

@@ -1,18 +1,16 @@
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.options import choose_from_options
 from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 from rich.console import Console
 from rich.panel import Panel
 import platform
 import subprocess
 from pathlib import Path
-
+from typing import Optional
 
 console = Console()
 
 
-def sanitize_path(a_path: str) -> PathExtended:
-    path = PathExtended(a_path)
+def sanitize_path(a_path: str) -> Path:
+    path = Path(a_path)
     if Path.cwd() == Path.home() and not path.exists():
         result = input("Current working directory is home, and passed path is not full path, are you sure you want to continue, [y]/n? ") or "y"
         if result == "y":
@@ -23,13 +21,13 @@ def sanitize_path(a_path: str) -> PathExtended:
         if platform.system() == "Windows":  # path copied from Linux/Mac to Windows
             # For Linux: /home/username, for Mac: /Users/username
             skip_parts = 3 if path.as_posix().startswith("/home") else 3  # Both have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | {source_os} → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() in ["Linux", "Darwin"] and PathExtended.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
+        elif platform.system() in ["Linux", "Darwin"] and Path.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
             skip_parts = 3  # Both /home/username and /Users/username have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             current_os = "Linux" if platform.system() == "Linux" else "macOS"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
@@ -37,12 +35,12 @@ def sanitize_path(a_path: str) -> PathExtended:
     elif path.as_posix().startswith("C:"):
         if platform.system() in ["Linux", "Darwin"]:  # path copied from Windows to Linux/Mac
             xx = str(a_path).replace("\\\\", "/")
-            path = PathExtended.home().joinpath(*PathExtended(xx).parts[3:])  # exclude C:\\Users\\username
+            path = Path.home().joinpath(*Path(xx).parts[3:])  # exclude C:\\Users\\username
             assert path.exists(), f"File not found: {path}"
             target_os = "Linux" if platform.system() == "Linux" else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → {target_os}: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() == "Windows" and PathExtended.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
-            path = PathExtended.home().joinpath(*path.parts[2:])
+        elif platform.system() == "Windows" and Path.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
+            path = Path.home().joinpath(*path.parts[2:])
             assert path.exists(), f"File not found: {path}"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
     return path.expanduser().absolute()
@@ -67,12 +65,12 @@ def find_scripts(root: Path, name_substring: str, suffixes: set[str]) -> tuple[l
     return filename_matches, partial_path_matches
 
 
-def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[str]) -> PathExtended:
+def match_file_name(sub_string: str, search_root: Path, suffixes: set[str]) -> Path:
     search_root_obj = search_root.absolute()
     # assume subscript is filename only, not a sub_path. There is no need to fzf over the paths.
     filename_matches, partial_path_matches = find_scripts(search_root_obj, sub_string, suffixes)
     if len(filename_matches) == 1:
-        return PathExtended(filename_matches[0])
+        return Path(filename_matches[0])
     console.print(Panel(f"Partial filename {search_root_obj} match with case-insensitivity failed. This generated #{len(filename_matches)} results.", title="Search", expand=False))
     if len(filename_matches) < 20:
         print("\n".join([a_potential_match.as_posix() for a_potential_match in filename_matches]))
@@ -81,35 +79,44 @@ def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[st
         # let's see if avoiding .lower() helps narrowing down to one result
         reduced_scripts = [a_potential_match for a_potential_match in filename_matches if sub_string in a_potential_match.name]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
+            return Path(reduced_scripts[0])
         elif len(reduced_scripts) > 1:
-            choice = choose_from_options(multi=False, msg="Multiple matches found", options=reduced_scripts, fzf=True)
-            return PathExtended(choice)
+            from machineconfig.utils.options import choose_from_options
+            choice = choose_from_options(multi=False, msg="Multiple matches found", options=reduced_scripts, tv=True)
+            return Path(choice)
         print(f"Result: This still generated {len(reduced_scripts)} results.")
         if len(reduced_scripts) < 10:
             print("\n".join([a_potential_match.as_posix() for a_potential_match in reduced_scripts]))
 
     console.print(Panel(f"Partial path match with case-insensitivity failed. This generated #{len(partial_path_matches)} results.", title="Search", expand=False))
     if len(partial_path_matches) == 1:
-        return PathExtended(partial_path_matches[0])
+        return Path(partial_path_matches[0])
     elif len(partial_path_matches) > 1:
         print("Try to narrow down partial_path_matches search by case-sensitivity.")
         reduced_scripts = [a_potential_match for a_potential_match in partial_path_matches if sub_string in a_potential_match.as_posix()]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
-        print(f"Result: This still generated {len(reduced_scripts)} results.")
+            return Path(reduced_scripts[0])
+        print(f"Result: This still generated {len(reduced_scripts)} results.")        
+
     try:
-        fzf_cmd = f"cd '{search_root_obj}'; fd --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
+
+        if len(partial_path_matches) == 0:
+            print("No partial path matches found, trying to do fd with --no-ignore ...")
+            fzf_cmd = f"cd '{search_root_obj}'; fd --no-ignore --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
+        else:
+            fzf_cmd = f"cd '{search_root_obj}'; fd --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
         console.print(Panel(f"🔍 Second attempt: SEARCH STRATEGY | Using fd to search for '{sub_string}' in '{search_root_obj}' ...\n{fzf_cmd}", title="Search Strategy", expand=False))
         search_res_raw = subprocess.run(fzf_cmd, stdout=subprocess.PIPE, text=True, check=True, shell=True).stdout
-        search_res = search_res_raw.strip().split("\\n")[:-1]
+        search_res = search_res_raw.strip().split("\n")
     except subprocess.CalledProcessError as cpe:
         console.print(Panel(f"❌ ERROR | FZF search failed with '{sub_string}' in '{search_root_obj}'.\n{cpe}", title="Error", expand=False))
         import sys
-
         sys.exit(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results.")
     if len(search_res) == 1:
         return search_root_obj.joinpath(search_res_raw)
+    elif len(search_res) == 0:
+        msg = Panel(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results", title="File Not Found", expand=False)
+        raise FileNotFoundError(msg)
 
     print(f"⚠️ WARNING | Multiple search results found for `{sub_string}`:\n'{search_res}'")
     cmd = f"cd '{search_root_obj}'; fd --type file | fzf --select-1 --query={sub_string}"
@@ -121,3 +128,49 @@ def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[st
         msg = Panel(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results", title="File Not Found", expand=False)
         raise FileNotFoundError(msg) from cpe
     return search_root_obj.joinpath(res)
+
+
+def search_for_files_of_interest(path_obj: Path, suffixes: set[str]) -> list[Path]:
+    if path_obj.is_file():
+        return [path_obj]
+    files: list[Path] = []
+    directories_to_visit: list[Path] = [path_obj]
+    while directories_to_visit:
+        current_dir = directories_to_visit.pop()
+        for entry in current_dir.iterdir():
+            if entry.is_dir():
+                if entry.name == ".venv":
+                    continue
+                directories_to_visit.append(entry)
+                continue
+            if entry.suffix not in suffixes:
+                continue
+            if entry.suffix == ".py" and entry.name == "__init__.py":
+                continue
+            files.append(entry)
+    return files
+
+
+def get_choice_file(path: str, suffixes: Optional[set[str]]):
+    path_obj = sanitize_path(path)
+    if suffixes is None:
+        import platform
+        if platform.system() == "Windows":
+            suffixes = {".py", ".ps1", ".sh"}
+        elif platform.system() in ["Linux", "Darwin"]:
+            suffixes = {".py", ".sh"}
+        else:
+            suffixes = {".py"}
+    if not path_obj.exists():
+        print(f"🔍 Searching for file matching `{path}` under `{Path.cwd()}`, but only if suffix matches {suffixes}")
+        choice_file = match_file_name(sub_string=path, search_root=Path.cwd(), suffixes=suffixes)
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj, suffixes=suffixes)
+        print(f"🔍 Got #{len(files)} results.")
+        from machineconfig.utils.options import choose_from_options
+        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
+        choice_file = Path(choice_file)
+    else:
+        choice_file = path_obj
+    return choice_file

machineconfig/utils/procs.py

@@ -129,7 +129,7 @@ class ProcessManager:
         all_lines = formatted_data.split("\n")
         header_and_separator = all_lines[:2]  # First two lines: header and separator
         options = all_lines[2:]  # Skip header and separator, only process lines
-        res = choose_from_options(options=all_lines, msg="📋 Select processes to manage:", fzf=True, multi=True)
+        res = choose_from_options(options=all_lines, msg="📋 Select processes to manage:", tv=True, multi=True)
         # Filter out header and separator if they were selected
         selected_lines = [line for line in res if line not in header_and_separator]
         indices = [options.index(val) for val in selected_lines]

machineconfig/utils/scheduler.py

@@ -1,31 +1,26 @@
 
 from pathlib import Path
 from typing import Callable, Optional, Union, Any, Protocol, List, TypeVar
-import logging
+# import logging
 import time
 from datetime import datetime, timezone, timedelta
 from machineconfig.utils.io import from_pickle
 
 
 class LoggerTemplate(Protocol):
-    handlers: List[logging.Handler]
-
-    def debug(self, msg: str) -> None:
+    def trace(self,  __message: str, *args: Any, **kwargs: Any) -> None:
+        pass  # 5
+    def success(self,  __message: str, *args: Any, **kwargs: Any) -> None:
+        pass  # 25
+    def debug(self,  __message: str, *args: Any, **kwargs: Any) -> None:
         pass  # 10
-
-    def info(self, msg: str) -> None:
+    def info(self,  __message: str, *args: Any, **kwargs: Any) -> None:
         pass  # 20
-
-    def warning(self, msg: str) -> None:
+    def warning(self,  __message: str, *args: Any, **kwargs: Any) -> None:
         pass  # 30
-
-    def error(self, msg: str) -> None:
+    def error(self,  __message: str, *args: Any, **kwargs: Any) -> None:
         pass  # 40
-
-    def critical(self, msg: str) -> None:
-        pass  # 50
-
-    def fatal(self, msg: str) -> None:
+    def critical(self,  __message: str, *args: Any, **kwargs: Any) -> None:
         pass  # 50
 
 
@@ -139,7 +134,7 @@ class Scheduler:
     def default_exception_handler(self, ex: Union[Exception, KeyboardInterrupt], during: str, sched: "Scheduler") -> None:  # user decides on handling and continue, terminate, save checkpoint, etc.  # Use signal library.
         print(sched)
         self.record_session_end(reason=f"during {during}, " + str(ex))
-        self.logger.fatal(str(ex))
+        self.logger.critical(str(ex))
         raise ex
 
 
@@ -164,28 +159,20 @@ class CacheMemory[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.logger.warning(f"""🆕  NEW CACHE 🔄 {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}""")
+                self.logger.warning(f"""🔄 CACHE UPDATE ⚠️  {self.name} cache: Updating cache from source func. """ + f""" ⏱️  Age = {age} > {self.expire}""" if not fresh else f""" ⏱️  Age = {age}. Fresh flag raised.""")
                 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}""")
+                self.logger.warning(f"""✅ USING CACHE 📦 {self.name} cache: Using cached values ⏱️  Lag = {age} < {self.expire} < {tolerance_seconds} seconds.""")
         return self.cache
 
     @staticmethod
@@ -215,28 +202,18 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
             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}""")
+                    self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ if not fresh else """⚠️  Fresh flag raised.""")
                     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}"""
+                msg1 = f"""📦 CACHE OPERATION 🔄 {self.name} cache: Reading cached values from `{self.path}` ⏱️  Lag = {age}"""
                 try:
                     self.cache = self.reader(self.path)
                 except Exception as ex:
-                    msg2 = f"""
-❌ ════════════════════ CACHE ERROR ════════════════════
-⚠️  {self.name} cache: Cache file is corrupted
-🔍 Error: {ex}"""
+                    msg2 = f"""❌ CACHE ERROR ⚠️  {self.name} cache: Cache file is corrupted 🔍 Error: {ex}"""
                     self.logger.warning(msg1 + msg2)
                     t0 = time.time()
                     self.cache = self.source_func()
@@ -245,11 +222,7 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                     self.save(self.cache, self.path)
                     return self.cache
             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}""")
+                self.logger.warning(f"""🆕  NEW CACHE 🔄 {self.name} cache: Populating fresh cache from source func ℹ️  Reason: Previous cache never existed.""")
                 t0 = time.time()
                 self.cache = self.source_func()  # fresh data.
                 self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
@@ -258,20 +231,14 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
         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}""")
+                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()
                 self.save(self.cache, self.path)
             else:
-                self.logger.warning(f"""
-✅ ════════════════════ USING CACHE ════════════════════
-📦 {self.name} cache: Using cached values
-⏱️  Lag = {age}""")
+                self.logger.warning(f"""✅ USING CACHE 📦 {self.name} cache: Using cached values ⏱️  Lag = {age} < {self.expire} < {tolerance_seconds} seconds.""")
         return self.cache
 
     @staticmethod

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):