machineconfig 7.98__py3-none-any.whl → 8.61__py3-none-any.whl

machineconfig/utils/options_utils/options_tv_linux.py

@@ -0,0 +1,211 @@
+
+#!/usr/bin/env python3
+import base64
+import pathlib
+import pprint
+import shutil
+import subprocess
+import tempfile
+import os
+from typing import Any, overload, Literal, Union
+
+from git import Optional
+
+
+def _format_preview_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return pprint.pformat(value, width=88, sort_dicts=True)
+
+
+def _toml_inline_table(values: dict[str, str]) -> str:
+    if not values:
+        return ""
+    parts: list[str] = []
+    for key in sorted(values.keys()):
+        raw_value = values[key]
+        escaped = raw_value.replace("\\", "\\\\").replace('"', '\\"')
+        parts.append(f'{key} = "{escaped}"')
+    return "env = { " + ", ".join(parts) + " }\n"
+
+
+def _normalize_extension(extension: str | None) -> str | None:
+    if extension is None:
+        return None
+    trimmed = extension.strip()
+    if trimmed.startswith("."):
+        trimmed = trimmed[1:]
+    if not trimmed:
+        return None
+    return trimmed
+
+
+def _infer_extension_from_key(key: Optional[str]) -> str | None:
+    if not isinstance(key, str):
+        return None
+    candidate = key.strip()
+    if not candidate or any(char.isspace() for char in candidate):
+        return None
+    suffix = pathlib.Path(candidate).suffix
+    if not suffix:
+        return None
+    return _normalize_extension(suffix)
+
+
+@overload
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[True], preview_size_percent: float) -> list[str]: ...
+@overload
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[False], preview_size_percent: float) -> Union[str, None]: ...
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: bool, preview_size_percent: float) -> Union[Union[str, None], list[str]]:
+    keys = list(options_to_preview_mapping.keys())
+    if not keys:
+        return [] if multi else None
+    normalized_extension = _normalize_extension(extension)
+    preview_panel_size = max(10, min(90, int(preview_size_percent)))
+    terminal_width = shutil.get_terminal_size(fallback=(120, 40)).columns
+    preview_width = max(20, int(terminal_width * preview_panel_size / 100) - 4)
+    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
+            preview_value = _format_preview_value(options_to_preview_mapping[key])
+            encoded_preview = base64.b64encode(preview_value.encode("utf-8")).decode("ascii")
+            entry_extension = normalized_extension or _infer_extension_from_key(key) or ""
+            preview_rows.append(f"{idx}\t{encoded_preview}\t{entry_extension}")
+        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)"
+
+preview_ext_from_row="$(awk -F '\t' -v idx="${idx}" '($1==idx){print $3; exit}' "${previews_file}" || true)"
+preview_ext="${MCFG_PREVIEW_EXT:-${preview_ext_from_row}}"
+preview_width="${MCFG_PREVIEW_WIDTH:-}"
+preview_size_pct="${MCFG_PREVIEW_SIZE_PCT:-}"
+
+if [[ -z "${preview_width}" && -n "${COLUMNS:-}" ]]; then
+    if [[ "${preview_size_pct}" =~ ^[0-9]+$ ]]; then
+        preview_width=$((COLUMNS * preview_size_pct / 100))
+    else
+        preview_width="${COLUMNS}"
+    fi
+fi
+
+if command -v bat >/dev/null 2>&1; then
+    bat_args=(--force-colorization --style=plain --paging=never --wrap=character)
+    if [[ -n "${preview_ext}" ]]; then
+        bat_args+=(--language "${preview_ext}")
+    fi
+    if [[ "${preview_width}" =~ ^[0-9]+$ ]]; then
+        bat_args+=(--terminal-width "${preview_width}")
+    fi
+    printf '%s' "${preview_content}" | bat "${bat_args[@]}"
+elif command -v glow >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | glow -
+elif command -v fold >/dev/null 2>&1 && [[ "${preview_width}" =~ ^[0-9]+$ ]]; then
+    printf '%s' "${preview_content}" | fold -s -w "${preview_width}"
+else
+    printf '%s' "${preview_content}"
+fi
+""",
+            encoding="utf-8"
+        )
+        preview_script.chmod(0o755)
+        preview_env: dict[str, str] = {
+            "BAT_THEME": "ansi",
+            "MCFG_PREVIEW_SIZE_PCT": str(preview_panel_size),
+        }
+        if normalized_extension is not None:
+            preview_env["MCFG_PREVIEW_EXT"] = normalized_extension
+        if preview_width > 0:
+            preview_env["MCFG_PREVIEW_WIDTH"] = str(preview_width)
+        preview_env_line = _toml_inline_table(preview_env)
+        channel_config = f"""[metadata]
+name = "temp_options"
+description = "Temporary channel for selecting options"
+
+[source]
+command = "bat '{entries_path}'"
+display = "{{split:\\t:1}}"
+output = "{{split:\\t:0}}"
+
+[preview]
+command = "{preview_script} {{split:\\t:0}}"
+{preview_env_line}
+
+[ui.preview_panel]
+size = {preview_panel_size}
+"""
+        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 [] if multi else None
+        if not output_file.exists():
+            return [] if multi else None
+        selected_lines = [line.strip() for line in output_file.read_text().splitlines() if line.strip()]
+        if not selected_lines:
+            return [] if multi else None
+        selected_keys: list[str] = []
+        for line in selected_lines:
+            try:
+                index = int(line)
+                key = index_map.get(index)
+                if key is not None:
+                    selected_keys.append(key)
+            except ValueError:
+                continue
+        if multi:
+            return selected_keys
+        return selected_keys[0] if selected_keys else None
+
+
+if __name__ == "__main__":
+    demo_mapping: dict[str, str] = {
+        "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."
+    }
+    result = select_from_options(demo_mapping, multi=True, extension="md", preview_size_percent=50)
+    print(f"Selected: {result}")

machineconfig/utils/options_utils/options_tv_windows.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+import pathlib
+import pprint
+import shutil
+from typing import Any, Literal, Union, overload
+
+
+def _format_preview_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return pprint.pformat(value, width=88, sort_dicts=True)
+
+
+def _normalize_extension(extension: str | None) -> str | None:
+    if extension is None:
+        return None
+    trimmed = extension.strip()
+    if trimmed.startswith("."):
+        trimmed = trimmed[1:]
+    if not trimmed:
+        return None
+    return trimmed
+
+
+@overload
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[True], preview_size_percent: float) -> list[str]: ...
+@overload
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[False], preview_size_percent: float) -> str | None: ...
+def select_from_options(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: bool, preview_size_percent: float) -> Union[list[str], Union[str, None]]:
+    keys = list(options_to_preview_mapping.keys())
+    if not keys:
+        return [] if multi else None
+    normalized_extension = _normalize_extension(extension)
+    preview_panel_size = max(10, min(90, int(preview_size_percent)))
+    from machineconfig.utils.accessories import randstr
+    tempdir = pathlib.Path.home() / "tmp_results" / "tmp_files" / f"tv_channel_{randstr(6)}"
+    tempdir.mkdir(parents=True, exist_ok=True)
+    try:
+        index_map: dict[str, str] = {}
+        ext_for_preview = normalized_extension or "txt"
+        entries_lines: list[str] = []
+        for idx, key in enumerate(keys):
+            display_key = key.replace("\n", " ")
+            entries_lines.append(f"{idx}|{display_key}")
+            index_map[str(idx)] = key
+            preview_value = _format_preview_value(options_to_preview_mapping[key])
+            preview_file = tempdir / f"{idx}.{ext_for_preview}"
+            preview_file.write_text(preview_value, encoding="utf-8")
+        entries_path = tempdir / "entries.txt"
+        entries_path.write_text("\n".join(entries_lines), encoding="utf-8")
+        output_file = tempdir / "selection.txt"
+        tempdir_fwd = str(tempdir).replace("\\", "/")
+        source_cmd = f"cmd /C type \"{entries_path}\""
+        preview_cmd = f"bat --force-colorization --style=plain --paging=never {tempdir_fwd}/{{split:|:0}}.{ext_for_preview}"
+        tv_cmd = f'''$OutputEncoding = [Console]::InputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new()
+tv --ansi --source-command '{source_cmd}' --source-display '{{split:|:1}}' --source-output '{{split:|:0}}' --preview-command '{preview_cmd}' --preview-size {preview_panel_size} --no-remote | Out-File -Encoding utf8 -FilePath "{output_file}"
+'''
+        from machineconfig.utils.code import run_shell_script
+        result = run_shell_script(tv_cmd, display_script=False, clean_env=False)
+        if result.returncode not in (0, 130) and not output_file.exists():
+            raise SystemExit(result.returncode)
+        if result.returncode == 130:
+            return [] if multi else None
+        if not output_file.exists():
+            return [] if multi else None
+        selected_lines = [line.strip() for line in output_file.read_text(encoding="utf-8-sig").splitlines() if line.strip()]
+        if not selected_lines:
+            return [] if multi else None
+        selected_keys: list[str] = []
+        for line in selected_lines:
+            key = index_map.get(line)
+            if key is not None:
+                selected_keys.append(key)
+        if multi:
+            return selected_keys
+        return selected_keys[0] if selected_keys else None
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    demo_mapping: dict[str, str] = {
+        "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."
+    }
+    result = select_from_options(demo_mapping, multi=True, extension="md", preview_size_percent=50)
+    print(f"Selected: {result}")

machineconfig/utils/options_utils/tv_options.py

@@ -0,0 +1,37 @@
+from typing import Any, Literal, overload
+import platform
+
+
+@overload
+def choose_from_dict_with_preview(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[False], preview_size_percent: float) -> str | None: ...
+@overload
+def choose_from_dict_with_preview(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: Literal[True], preview_size_percent: float) -> list[str]: ...
+def choose_from_dict_with_preview(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: bool, preview_size_percent: float) -> str | list[str] | None:
+    if not options_to_preview_mapping:
+        return [] if multi else None
+    system = platform.system()
+    if system == "Windows":
+        from machineconfig.utils.options_utils.options_tv_windows import select_from_options
+        return select_from_options(options_to_preview_mapping, extension=extension, multi=multi, preview_size_percent=preview_size_percent)
+    else:
+        from machineconfig.utils.options_utils.options_tv_linux import select_from_options
+        return select_from_options(options_to_preview_mapping= options_to_preview_mapping, extension=extension, multi=multi, preview_size_percent=preview_size_percent)
+
+
+if __name__ == "__main__":
+    demo_mapping: dict[str, str] = {
+        "config.py": """from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config"
+DEBUG = True
+""",
+        "utils.py": """def greet(name: str) -> str:
+    return f"Hello, {name}!"
+""",
+        "main.rs": """fn main() {
+    println!("Hello, world!");
+}
+""",
+    }
+    result = choose_from_dict_with_preview(demo_mapping, extension="py", multi=True, preview_size_percent=50)
+    print(f"Selected: {result}")

machineconfig/utils/path_extended.py

@@ -103,7 +103,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         slf = self.expanduser().resolve()
         if content:
             assert self.is_dir(), NotADirectoryError(f"💥 When `content` flag is set to True, path must be a directory. It is not: `{repr(self)}`")
-            [x.move(folder=path.parent, content=False, overwrite=overwrite) for x in self.search("*")]
+            [x.move(folder=path.parent, content=False, overwrite=overwrite) for x in self.glob("*")]
             return path  # contents live within this directory.
         if overwrite:
             tmp_path = slf.rename(path.parent.absolute() / randstr())
@@ -174,7 +174,8 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             appended_name = f"""{name}_{len(self.parent.search(f"*{self.name.split('.')[0]}*"))}"""
             return self.append(name=appended_name, index=False, verbose=verbose, suffix=suffix, **kwargs)
         full_name = name or ("_" + str(timestamp()))
-        full_suffix = suffix or "".join(("bruh" + self).suffixes)
+        whatever = ("bruh" + self)
+        full_suffix = suffix or "".join(whatever.suffixes)
         subpath = self.name.split(".")[0] + full_name + full_suffix
         dest = self.parent.joinpath(subpath)
         res = PathExtended(dest)
@@ -294,7 +295,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 target = "BROKEN LINK " + str(self)  # avoid infinite recursions for broken links.
             return "🔗 Symlink '" + str(self) + "' ==> " + (str(target) if target == self else str(target))
         elif self.is_absolute():
-            return self._type() + " '" + str(self.clickable()) + "'" + (" | " + datetime.fromtimestamp(self.stat().st_ctime).isoformat()[:-7].replace("T", "  ") if self.exists() else "") + (f" | {self.size()} Mb" if self.is_file() else "")
+            return self._type() + " '" + str(self.clickable()) + "'" + (" | " + datetime.fromtimestamp(self.stat().st_ctime).isoformat()[:-7].replace("T", "  ") if self.exists() else "") + (f" | {round(self.stat().st_size / (1024**2), 1)} Mb" if self.is_file() else "")
         elif "http" in str(self):
             return "🕸️ URL " + str(self.as_url_str())
         else:
@@ -476,7 +477,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         verbose: bool = True,
         content: bool = False,
         orig: bool = False,
-        pwd: Optional[str] = None,
         mode: FILE_MODE = "w",
         **kwargs: Any,
     ) -> "PathExtended":
@@ -493,7 +493,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path_resolved = PathExtended(op_zip)
         else:
             import shutil
-
             if content:
                 root_dir, base_dir = slf, "."
             else:
@@ -501,7 +500,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             base_name = str(path_resolved)[:-4] if str(path_resolved).endswith(".zip") else str(path_resolved)
             op_zip = shutil.make_archive(base_name=base_name, format="zip", root_dir=str(root_dir), base_dir=str(base_dir), verbose=False, **kwargs)
             path_resolved = PathExtended(op_zip)
-        msg = f"ZIPPED {repr(slf)} ==>  {repr(path)}"
+        msg = f"ZIPPED {repr(slf)} ==> {repr(path_resolved)}"
         res_out = PathExtended(path_resolved)
         ret = self if orig else res_out
         delayed_msg = ""
@@ -538,7 +537,9 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         assert merge is False, "I have not implemented this yet"
         assert path is None, "I have not implemented this yet"
         if tmp:
-            return self.unzip(folder=PathExtended.tmp().joinpath("tmp_unzips").joinpath(randstr()), content=True).joinpath(self.stem)
+            tmp_root = PathExtended("~/tmp_results").expanduser()
+            tmp_root.mkdir(parents=True, exist_ok=True)
+            return self.unzip(folder=tmp_root.joinpath("tmp_unzips").joinpath(randstr()), content=True).joinpath(self.stem)
         slf = zipfile__ = self.expanduser().resolve()
         if any(ztype in str(slf.parent) for ztype in (".zip", ".7z")):  # path include a zip archive in the middle.
             tmp__ = [item for item in (".zip", ".7z", "") if item in str(slf)]

machineconfig/utils/procs.py

@@ -2,8 +2,7 @@
 
 import psutil
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from machineconfig.utils.options import choose_from_options
-from typing import Optional, TypedDict, List, Dict
+from typing import Optional, TypedDict, List
 from rich.console import Console
 from rich.panel import Panel
 from datetime import datetime
@@ -36,7 +35,7 @@ def get_processes_accessing_file(path: str) -> List[FileAccessInfo]:
     # header for searching processes
     title = "🔍  SEARCHING FOR PROCESSES ACCESSING FILE"
     console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-    res: Dict[int, List[str]] = {}
+    res: list[FileAccessInfo] = []
 
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
         progress.add_task("🔎 Scanning processes...", total=None)
@@ -48,10 +47,10 @@ def get_processes_accessing_file(path: str) -> List[FileAccessInfo]:
                 continue
             tmp = [file.path for file in files if path in file.path]
             if len(tmp) > 0:
-                res[proc.pid] = tmp
+                res.append({"pid": proc.pid, "files": tmp})
 
     # Convert to list of dictionaries for consistent data structure
-    result_data: List[FileAccessInfo] = [{"pid": pid, "files": files} for pid, files in res.items()]
+    result_data: List[FileAccessInfo] = res
     console.print(Panel(f"✅ Found {len(res)} processes accessing the specified file", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
     return result_data
 
@@ -99,7 +98,7 @@ class ProcessManager:
 
         # Sort by memory usage (descending)
         process_info.sort(key=lambda x: x["memory_usage_mb"], reverse=True)
-        self.data = process_info
+        self.data: list[ProcessInfo] = process_info
         console.print(Panel(f"✅ Process Manager initialized with {len(process_info)} processes", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
 
     def _format_process_table(self) -> str:
@@ -121,22 +120,36 @@ class ProcessManager:
         return "\n".join(lines)
 
     def choose_and_kill(self):
-        # header for interactive process selection
-        title = "🎯  INTERACTIVE PROCESS SELECTION AND TERMINATION"
-        console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-        # Format data as table for display
-        formatted_data = self._format_process_table()
-        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:", 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]
-        selected_processes = [self.data[i] for i in indices]
-        print("\n📊 All Processes:")
-        print(formatted_data)
-        print("\n🎯 Selected Processes:")
+        # # header for interactive process selection
+        # title = "🎯  INTERACTIVE PROCESS SELECTION AND TERMINATION"
+        # console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
+        # # Format data as table for display
+        # formatted_data = self._format_process_table()
+        # 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
+        # from machineconfig.utils.options import choose_from_options
+        # 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]
+        # selected_processes = [self.data[i] for i in indices]
+        # print("\n📊 All Processes:")
+        # print(formatted_data)
+        # print("\n🎯 Selected Processes:")
+
+        from machineconfig.utils.options_utils.tv_options import choose_from_dict_with_preview
+        # def choose_from_dict_with_preview(options_to_preview_mapping: dict[str, Any], extension: str | None, multi: bool, preview_size_percent: float) -> str | list[str] | None:
+
+        import json
+        commands = choose_from_dict_with_preview(
+            options_to_preview_mapping={str(proc["command"]): json.dumps({k: str(v) for k, v in proc.items()}, indent=2) for proc in self.data},
+            multi=True,
+            extension="json",
+            preview_size_percent=70,
+        )
+        selected_processes = [proc for proc in self.data if str(proc["command"]) in commands]
+
         for process in selected_processes:
             print(f"PID: {process['pid']}, Name: {process['name']}, Memory: {process['memory_usage_mb']:.2f}MB")
         for idx, process in enumerate(selected_processes):
@@ -216,10 +229,5 @@ def get_age(create_time: datetime) -> str:
     return str(delta).split(".")[0]  # remove microseconds
 
 
-def main():
-    from machineconfig.utils.procs import ProcessManager
-    ProcessManager().choose_and_kill()
-
-
 if __name__ == "__main__":
     pass

machineconfig/utils/scheduler.py

@@ -166,7 +166,10 @@ class CacheMemory[T]():
         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. """ + f""" ⏱️  Age = {age} > {self.expire}""" if not fresh else f""" ⏱️  Age = {age}. Fresh flag raised.""")
+                if not fresh:
+                    self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ )
+                else:
+                    self.logger.warning(f"""⚠️ Fresh flag raised, age = {age} > {tolerance_seconds} seconds of tolerance. Updating {self.name} cache from source func.""")
                 t0 = time.time()
                 self.cache = self.source_func()
                 self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
@@ -202,7 +205,10 @@ 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. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ if not fresh else """⚠️  Fresh flag raised.""")
+                    if not fresh:
+                        self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ )
+                    else:
+                        self.logger.warning(f"""⚠️ Fresh flag raised, age = {age} > {tolerance_seconds} seconds of tolerance. Updating {self.name} cache from source func.""")
                     t0 = time.time()
                     self.cache = self.source_func()  # fresh data.
                     self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")

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.helpers_agents.fire_agents_help_launch import AGENTS
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_help_launch import AGENTS
 
 SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
 

machineconfig/utils/schemas/layouts/layout_types.py

@@ -60,3 +60,13 @@ def serialize_layouts_to_file(layouts: list[LayoutConfig], version: Literal["0.1
             existing_content_layout["layouts"].append(a_new_layout)
     p.write_text(json.dumps(existing_content_layout, indent=4), encoding="utf-8")
     return None
+
+
+def substitute_home(tabs: list[TabConfig]) -> list["TabConfig"]:
+    import json
+    from pathlib import Path
+    json_str = json.dumps(tabs)
+    json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
+    json_str = json_str.replace("""command": "f """, """command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
+    json_str = json_str.replace("""command": "s """, """command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
+    return json.loads(json_str)

machineconfig/utils/source_of_truth.py

@@ -5,8 +5,14 @@ Utils
 import machineconfig
 from pathlib import Path
 
-EXCLUDE_DIRS = [".links", ".ai", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"]
+EXCLUDE_DIRS = [".links", "notebooks",
+                "GEMINI.md", "CLAUDE.md", "CRUSH.md", "AGENTS.md",
+                ".cursor", ".clinerules", ".github/instructions", ".github/agents", ".github/prompts",
+                ".ai",
+                ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"
+                ]
 LIBRARY_ROOT = Path(machineconfig.__file__).resolve().parent
+REPO_ROOT = LIBRARY_ROOT.parent.parent
 
 CONFIG_ROOT = Path.home().joinpath(".config/machineconfig")
 DEFAULTS_PATH = Path.home().joinpath("dotfiles/machineconfig/defaults.ini")