machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/utils/terminal.py

@@ -0,0 +1,180 @@
+
+from machineconfig.utils.path_reduced import P, OPLike
+import subprocess
+from typing import Any, BinaryIO, Optional, Union
+import platform
+import sys
+import os
+from typing import Literal, TypeAlias
+from dataclasses import dataclass
+
+SHELLS: TypeAlias = Literal["default", "cmd", "powershell", "pwsh", "bash"]  # pwsh.exe is PowerShell (community) and powershell.exe is Windows Powershell (msft)
+CONSOLE: TypeAlias = Literal["wt", "cmd"]
+MACHINE: TypeAlias = Literal["Windows", "Linux", "Darwin"]
+
+
+@dataclass
+class STD:
+    stdin: str
+    stdout: str
+    stderr: str
+    returncode: int
+
+
+class Response:
+    @staticmethod
+    def from_completed_process(cp: subprocess.CompletedProcess[str]):
+        resp = Response(cmd=cp.args)
+        resp.output.stdout = cp.stdout
+        resp.output.stderr = cp.stderr
+        resp.output.returncode = cp.returncode
+        return resp
+    def __init__(self, stdin: Optional[BinaryIO] = None, stdout: Optional[BinaryIO] = None, stderr: Optional[BinaryIO] = None, cmd: Optional[str] = None, desc: str = ""):
+        self.std = dict(stdin=stdin, stdout=stdout, stderr=stderr)
+        self.output = STD(stdin="", stdout="", stderr="", returncode=0)
+        self.input = cmd
+        self.desc = desc  # input command
+    def __call__(self, *args: Any, **kwargs: Any) -> Optional[str]:
+        _ = args, kwargs
+        return self.op.rstrip() if type(self.op) is str else None
+    @property
+    def op(self) -> str: return self.output.stdout
+    @property
+    def ip(self) -> str: return self.output.stdin
+    @property
+    def err(self) -> str: return self.output.stderr
+    @property
+    def returncode(self) -> int: return self.output.returncode
+    def op2path(self, strict_returncode: bool = True, strict_err: bool = False) -> Union[P, None]:
+        if self.is_successful(strict_returcode=strict_returncode, strict_err=strict_err): return P(self.op.rstrip())
+        return None
+    def op_if_successfull_or_default(self, strict_returcode: bool = True, strict_err: bool = False) -> Optional[str]: return self.op if self.is_successful(strict_returcode=strict_returcode, strict_err=strict_err) else None
+    def is_successful(self, strict_returcode: bool = True, strict_err: bool = False) -> bool:
+        return ((self.returncode in {0, None}) if strict_returcode else True) and (self.err == "" if strict_err else True)
+    def capture(self):
+        for key in ["stdin", "stdout", "stderr"]:
+            val: Optional[BinaryIO] = self.std[key]
+            if val is not None and val.readable():
+                self.output.__dict__[key] = val.read().decode().rstrip()
+        return self
+    def print_if_unsuccessful(self, desc: str = "TERMINAL CMD", strict_err: bool = False, strict_returncode: bool = False, assert_success: bool = False):
+        success = self.is_successful(strict_err=strict_err, strict_returcode=strict_returncode)
+        if assert_success: assert success, self.print(capture=False, desc=desc)
+        if success:
+            print(f"✅ {desc} completed successfully")
+        else:
+            self.print(capture=False, desc=desc)
+        return self
+    def print(self, desc: str = "TERMINAL CMD", capture: bool = True):
+        if capture: self.capture()
+        from rich import console
+        con = console.Console()
+        from rich.panel import Panel
+        from rich.text import Text  # from rich.syntax import Syntax; syntax = Syntax(my_code, "python", theme="monokai", line_numbers=True)
+        tmp1 = Text("📥 Input Command:\n")
+        tmp1.stylize("u bold blue")
+        tmp2 = Text("\n📤 Terminal Response:\n")
+        tmp2.stylize("u bold blue")
+        list_str = [f"{f' {idx} - {key} '}".center(40, "═") + f"\n{val}" for idx, (key, val) in enumerate(self.output.__dict__.items())]
+        txt = tmp1 + Text(str(self.input), style="white") + tmp2 + Text("\n".join(list_str), style="white")
+        con.print(Panel(txt, title=f"🖥️  {self.desc}", subtitle=f"📋 {desc}", width=150, style="bold cyan on black"))
+        return self
+
+# DEPRECATED: Use subprocess.run directly instead of Terminal class.
+# The Terminal class has been replaced with inline subprocess calls to underlying primitives.
+# This file is kept for reference but should not be used.
+
+class Terminal:
+    def __init__(self, stdout: Optional[int] = subprocess.PIPE, stderr: Optional[int] = subprocess.PIPE, stdin: Optional[int] = subprocess.PIPE, elevated: bool = False):
+        self.machine: str = platform.system()
+        self.elevated: bool = elevated
+        self.stdout = stdout
+        self.stderr = stderr
+        self.stdin = stdin
+    # def set_std_system(self): self.stdout = sys.stdout; self.stderr = sys.stderr; self.stdin = sys.stdin
+    def set_std_pipe(self):
+        self.stdout = subprocess.PIPE
+        self.stderr = subprocess.PIPE
+        self.stdin = subprocess.PIPE
+    def set_std_null(self):
+        self.stdout, self.stderr, self.stdin = subprocess.DEVNULL, subprocess.DEVNULL, subprocess.DEVNULL  # Equivalent to `echo 'foo' &> /dev/null`
+    def run(self, *cmds: str, shell: Optional[SHELLS] = "default", check: bool = False, ip: Optional[str] = None) -> Response:  # Runs SYSTEM commands like subprocess.run
+        """Blocking operation. Thus, if you start a shell via this method, it will run in the main and won't stop until you exit manually IF stdin is set to sys.stdin, otherwise it will run and close quickly. Other combinations of stdin, stdout can lead to funny behaviour like no output but accept input or opposite.
+        * This method is short for: res = subprocess.run("powershell command", capture_output=True, shell=True, text=True) and unlike os.system(cmd), subprocess.run(cmd) gives much more control over the output and input.
+        * `shell=True` loads up the profile of the shell called so more specific commands can be run. Importantly, on Windows, the `start` command becomes availalbe and new windows can be launched.
+        * `capture_output` prevents the stdout to redirect to the stdout of the script automatically, instead it will be stored in the Response object returned. # `capture_output=True` same as `stdout=subprocess.PIPE, stderr=subprocess.PIPE`"""
+        my_list = list(cmds)  # `subprocess.Popen` (process open) is the most general command. Used here to create asynchronous job. `subprocess.run` is a thin wrapper around Popen that makes it wait until it finishes the task. `suprocess.call` is an archaic command for pre-Python-3.5.
+        if self.machine == "Windows" and shell in {"powershell", "pwsh"}: my_list = [shell, "-Command"] + my_list  # alternatively, one can run "cmd"
+        if self.elevated is False or self.is_user_admin():
+            resp: subprocess.CompletedProcess[str] = subprocess.run(my_list, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=check, input=ip)
+        else:
+            resp = __import__("ctypes").windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
+        return Response.from_completed_process(resp)
+    def run_script(self, script: str, shell: SHELLS = "default", verbose: bool = False):
+        if self.machine == "Linux": script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
+        script_file = P.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts").write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
+        if shell == "default":
+            if self.machine == "Windows":
+                start_cmd = "powershell"  # default shell on Windows is cmd which is not very useful. (./source is not available)
+                full_command: Union[list[str], str] = [start_cmd, str(script_file)]  # shell=True will cause this to be a string anyway (with space separation)
+            else:
+                start_cmd  = "bash"
+                full_command = f"{start_cmd} {script_file}"  # full_command = [start_cmd, str(script_file)]
+        else: full_command = f"{shell} {script_file}"  # full_command = [shell, str(tmp_file)]
+        if verbose:
+            desc="Script to be executed:"
+            if platform.system() == "Windows": lexer = "powershell"
+            elif platform.system() == "Linux": lexer = "sh"
+            elif platform.system() == "Darwin": lexer = "sh"  # macOS uses similar shell to Linux
+            else: raise NotImplementedError(f"Platform {platform.system()} not supported.")
+            from rich.console import Console
+            from rich.panel import Panel
+            from rich.syntax import Syntax
+            import rich.progress as pb
+            console = Console()
+            console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 {desc}"), style="bold red")
+            with pb.Progress(transient=True) as progress:
+                _task = progress.add_task(f"Running Script @ {script_file}", total=None)
+                resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
+        else: resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
+        return Response.from_completed_process(resp)
+    def run_py(self, script: str, wdir: OPLike = None, interactive: bool = True, ipython: bool = True, shell: Optional[str] = None, terminal: str = "", new_window: bool = True, header: bool = True):  # async run, since sync run is meaningless.
+        script = (Terminal.get_header(wdir=wdir, toolbox=True) if header else "") + script + ("\nDisplayData.set_pandas_auto_width()\n" if terminal in {"wt", "powershell", "pwsh"} else "")
+        py_script = P.tmpfile(name="tmp_python_script", suffix=".py", folder="tmp_scripts/terminal")
+        py_script.write_text(f"""print(r'''{script}''')""" + "\n" + script)
+        print(f"""🚀 [ASYNC PYTHON SCRIPT] Script URI:
+   {py_script.absolute().as_uri()}""")
+        print("Script to be executed asyncronously: ", py_script.absolute().as_uri())
+        shell_script = f"""
+{f'cd {wdir}' if wdir is not None else ''}
+{'ipython' if ipython else 'python'} {'-i' if interactive else ''} {py_script}
+"""
+        shell_script = P.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell").write_text(shell_script)
+        if shell is None and self.machine == "Windows": shell = "pwsh"
+        window = "start" if new_window and self.machine == "Windows" else ""
+        os.system(f"{window} {terminal} {shell} {shell_script}")
+    @staticmethod
+    def is_user_admin() -> bool:  # adopted from: https://stackoverflow.com/questions/19672352/how-to-run-script-with-elevated-privilege-on-windows"""
+        if os.name == 'nt':
+            try: return __import__("ctypes").windll.shell32.IsUserAnAdmin()
+            except Exception:
+                import traceback
+                traceback.print_exc()
+                print("Admin check failed, assuming not an admin.")
+                return False
+        else:
+            return os.getuid() == 0  # Check for root on Posix
+#     @staticmethod
+#     def run_as_admin(file: PLike, params: Any, wait: bool = False):
+#         proce_info = install_n_import(library="win32com", package="pywin32", fromlist=["shell.shell.ShellExecuteEx"]).shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params)
+#         # TODO update PATH for this to take effect immediately.
+#         if wait: time.sleep(1)
+#         return proce_info
+
+    @staticmethod
+    def get_header(wdir: OPLike, toolbox: bool): return f"""
+# >> Code prepended
+{"from crocodile.toolbox import *" if toolbox else "# No toolbox import."}
+{'''sys.path.insert(0, r'{wdir}') ''' if wdir is not None else "# No path insertion."}
+# >> End of header, start of script passed
+"""

machineconfig/utils/utils.py

@@ -3,7 +3,6 @@ Utils
 """
 
 from machineconfig.utils.path_reduced import P as PathExtended
-# import crocodile.environment as env
 import machineconfig
 from machineconfig.utils.options import check_tool_exists, choose_cloud_interactively, choose_multiple_options, choose_one_option, choose_ssh_host, display_options
 from rich.console import Console
@@ -50,7 +49,7 @@ DEFAULTS_PATH = PathExtended.home().joinpath("dotfiles/machineconfig/defaults.in
 
 
 
-def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool=False):
+def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool) -> bool:
     dotfiles_path = str(PathExtended.home().joinpath("dotfiles"))
     from git import Repo
     repo = Repo(path=dotfiles_path)

machineconfig/utils/utils2.py

@@ -2,6 +2,9 @@
 
 from pathlib import Path
 from typing import Optional, Any
+# import time
+# from typing import Callable, Literal, TypeVar, ParamSpec
+
 
 def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bool = True, punctuation: bool = False, safe: bool = False, noun: bool = False) -> str:
     if safe:
@@ -40,3 +43,43 @@ def pprint(obj: dict[Any, Any], title: str) -> None:
     inspect(type("TempStruct", (object,), obj)(), value=False, title=title, docs=False, dunder=False, sort=False)
 def get_repr(obj: dict[Any, Any], sep: str = "\n", justify: int = 15, quotes: bool = False):
     return sep.join([f"{key:>{justify}} = {repr(val) if quotes else val}" for key, val in obj.items()])
+
+
+# T = TypeVar('T')
+# PS = ParamSpec('PS')
+
+# class RepeatUntilNoException:
+#     """
+#     Repeat function calling if it raised an exception and/or exceeded the timeout, for a maximum of `retry` times.
+#     * Alternative: `https://github.com/jd/tenacity`
+#     """
+#     def __init__(self, retry: int, sleep: float, timeout: Optional[float] = None, scaling: Literal["linear", "exponential"] = "exponential"):
+#         self.retry = retry
+#         self.sleep = sleep
+#         self.timeout = timeout
+#         self.scaling: Literal["linear", "exponential"] = scaling
+#     def __call__(self, func: Callable[PS, T]) -> Callable[PS, T]:
+#         from functools import wraps
+#         if self.timeout is not None:
+#             import warpt_time_decorator
+#             func = wrapt_timeout_decorator.timeout(self.timeout)(func)
+#         @wraps(wrapped=func)
+#         def wrapper(*args: PS.args, **kwargs: PS.kwargs):
+#             t0 = time.time()
+#             for idx in range(self.retry):
+#                 try:
+#                     return func(*args, **kwargs)
+#                 except Exception as ex:
+#                     match self.scaling:
+#                         case "linear":
+#                             sleep_time = self.sleep * (idx + 1)
+#                         case "exponential":
+#                             sleep_time = self.sleep * (idx + 1)**2
+#                     print(f"""💥 [RETRY] Function {func.__name__} call failed with error:
+# {ex}
+# Retry count: {idx}/{self.retry}. Sleeping for {sleep_time} seconds.
+# Total elapsed time: {time.time() - t0:0.1f} seconds.""")
+#                     print(f"""💥 Robust call of `{func}` failed with ```{ex}```.\nretrying {idx}/{self.retry} more times after sleeping for {sleep_time} seconds.\nTotal wait time so far {time.time() - t0: 0.1f} seconds.""")
+#                     time.sleep(sleep_time)
+#             raise RuntimeError(f"💥 Robust call failed after {self.retry} retries and total wait time of {time.time() - t0: 0.1f} seconds.\n{func=}\n{args=}\n{kwargs=}")
+#         return wrapper

machineconfig/utils/utils5.py

@@ -1,39 +1,52 @@
 
-from typing import Callable, Optional, Union, Any
-from logging import Logger as Log
-from machineconfig.utils.utils2 import randstr, get_repr
+from typing import Callable, Optional, Union, Any, NoReturn, TypeVar, Protocol, List
+import logging
 import time
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
+
+
+class LoggerTemplate(Protocol):
+    handlers: List[logging.Handler]
+    def debug(self, msg: str) -> None:
+        pass  # 10
+    def info(self, msg: str) -> None:
+        pass  # 20
+    def warning(self, msg: str) -> None:
+        pass  # 30
+    def error(self, msg: str) -> None:
+        pass  # 40
+    def critical(self, msg: str) -> None:
+        pass  # 50
+    def fatal(self, msg: str) -> None:
+        pass  # 50
 
 
 class Scheduler:
-    def __init__(self, routine: Callable[['Scheduler'], Any],
-                 wait_ms: int,
+    def __init__(self, routine: Callable[['Scheduler'], Any], wait_ms: int,
+                 logger: LoggerTemplate,  sess_stats: Optional[Callable[['Scheduler'], dict[str, Any]]] = None,
                  exception_handler: Optional[Callable[[Union[Exception, KeyboardInterrupt], str, 'Scheduler'], Any]] = None,
-                 logger: Optional[Log] = None,
-                 sess_stats: Optional[Callable[['Scheduler'], dict[str, Any]]] = None,
-                 max_cycles: int = 1_000_000_000,
-                 records: Optional[list[list[Any]]] = None):
+                 max_cycles: int = 1_000_000_000, records: Optional[list[list[Any]]] = None):
         self.routine = routine  # main routine to be repeated every `wait` time period
-        self.logger = logger if logger is not None else Log(name="SchedLogger_" + randstr(noun=True))
+        self.logger = logger
         self.exception_handler = exception_handler if exception_handler is not None else self.default_exception_handler
         self.records: list[list[Any]] = records if records is not None else []
         self.wait_ms = wait_ms  # wait period between routine cycles.
         self.cycle: int = 0
         self.max_cycles: int = max_cycles
-        self.sess_start_time_ms: int
+        self.sess_start_utc_ms: int
         self.sess_stats = sess_stats or (lambda _sched: {})
-    def __repr__(self): return f"Scheduler with {self.cycle} cycles ran so far. Last cycle was at {self.sess_start_time_ms}."
+    def __repr__(self): return f"Scheduler with {self.cycle} cycles ran so far. Last cycle was at {self.sess_start_utc_ms}."
     def run(self, max_cycles: Optional[int]=None, until_ms: Optional[int]=None):
         if max_cycles is not None:
             self.max_cycles = max_cycles
         if until_ms is None:
-            until_ms = 1_000_000_000_000
-        self.sess_start_time_ms = time.time_ns() // 1_000_000
+            until_ms = 1_000_000_000_000_000
+        self.sess_start_utc_ms = time.time_ns() // 1_000_000
         while (time.time_ns() // 1_000_000) < until_ms and self.cycle < self.max_cycles:
             # 1- Time before Ops, and Opening Message
             time1_ms = time.time_ns() // 1_000_000
-            self.logger.info(f"Starting Cycle {str(self.cycle).zfill(5)}. Total Run Time = {str(time1_ms - self.sess_start_time_ms).split('.', maxsplit=1)[0]}. UTC🕜 {datetime.now(tz=timezone.utc).strftime('%d %H:%M:%S')}")
+            duration = timedelta(milliseconds=time1_ms - self.sess_start_utc_ms)
+            self.logger.info(f"Starting Cycle {str(self.cycle).zfill(5)}. Total Run Time = {str(duration).split('.', maxsplit=1)[0]}. UTC🕜 {datetime.now(tz=timezone.utc).strftime('%d %H:%M:%S')}")
             try:
                 self.routine(self)
             except Exception as ex:
@@ -41,44 +54,160 @@ class Scheduler:
             time2_ms = time.time_ns() // 1_000_000
             time_left_ms = int(self.wait_ms - (time2_ms - time1_ms))  # 4- Conclude Message
             self.cycle += 1
-            self.logger.info(f"Finishing Cycle {str(self.cycle - 1).zfill(5)} in {str((time2_ms - time1_ms)*0.001).split('.', maxsplit=1)[0]}s. Sleeping for {self.wait_ms*0.001:0.1f}s ({time_left_ms*0.001:0.1}s left)\n" + "-" * 100)
+            self.logger.info(f"Finishing Cycle {str(self.cycle - 1).zfill(5)} in {str((time2_ms - time1_ms)*0.001).split('.', maxsplit=1)[0]}s. Sleeping for {self.wait_ms*0.001:0.1f}s ({time_left_ms*0.001:0.1f}s left)\n" + "-" * 100)
             try: time.sleep(time_left_ms*0.001 if time_left_ms > 0 else 0.0)  # # 5- Sleep. consider replacing by Asyncio.sleep
             except KeyboardInterrupt as ex:
                 self.exception_handler(ex, "sleep", self)
                 return  # that's probably the only kind of exception that can rise during sleep.
         self.record_session_end(reason=f"Reached maximum number of cycles ({self.max_cycles})" if self.cycle >= self.max_cycles else f"Reached due stop time ({until_ms})")
-    def get_records_df(self):
-        import polars as pl
-        columns = ["start", "finish", "duration", "cycles", "termination reason", "logfile"] + list(self.sess_stats(self).keys())
-        return pl.DataFrame(self.records, schema=columns)
+    def get_records_df(self) -> List[dict[str, Any]]:
+        columns = ["start", "finish", "duration", "cycles", "termination reason"] + list(self.sess_stats(self).keys())
+        return [dict(zip(columns, row)) for row in self.records]
     def record_session_end(self, reason: str):
-        import polars as pl
         end_time_ms = time.time_ns() // 1_000_000
-        duration_ms = end_time_ms - self.sess_start_time_ms
+        duration_ms = end_time_ms - self.sess_start_utc_ms
         sess_stats = self.sess_stats(self)
-        self.records.append([self.sess_start_time_ms, end_time_ms, duration_ms, self.cycle, reason,
+        self.records.append([self.sess_start_utc_ms, end_time_ms, duration_ms, self.cycle, reason,
                             #  self.logger.file_path
                              ] + list(sess_stats.values()))
-        summ = {"start time": f"{str(self.sess_start_time_ms)}",
+        records_df = self.get_records_df()
+        total_cycles = sum(row["cycles"] for row in records_df)
+        summ = {"start time": f"{str(self.sess_start_utc_ms)}",
                 "finish time": f"{str(end_time_ms)}.",
                 "duration": f"{str(duration_ms)} | wait time {self.wait_ms/1_000: 0.1f}s",
-                "cycles ran": f"{self.cycle} | Lifetime cycles = {self.get_records_df().select(pl.col('cycles').sum()).item()}",
+                "cycles ran": f"{self.cycle} | Lifetime cycles = {total_cycles}",
                 "termination reason": reason,
                 # "logfile": self.logger.file_path
                 }
         summ.update(sess_stats)
+        from machineconfig.utils.utils2 import get_repr
         tmp = get_repr(summ)
         self.logger.critical("\n--> Scheduler has finished running a session. \n" + tmp + "\n" + "-" * 100)
-        df = self.get_records_df()
-        df = df.with_columns([
-            pl.col("start").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String),
-            pl.col("finish").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String),
-            pl.col("duration").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String)
-        ])
-        self.logger.critical("\n--> Logger history.\n" + str(df))
+        # Format records as table
+        if records_df:
+            headers = list(records_df[0].keys())
+            # Process start, finish, duration to strings without milliseconds
+            processed_records = []
+            for row in records_df:
+                processed = row.copy()
+                processed["start"] = str(row["start"]).split(".", maxsplit=1)[0]
+                processed["finish"] = str(row["finish"]).split(".", maxsplit=1)[0]
+                processed["duration"] = str(row["duration"]).split(".", maxsplit=1)[0]
+                processed_records.append(processed)
+            # Simple aligned table formatting
+            max_lengths = {col: max(len(str(row.get(col, ""))) for row in processed_records) for col in headers}
+            table_lines = ["| " + " | ".join(col.ljust(max_lengths[col]) for col in headers) + " |"]
+            table_lines.append("|" + "-+-".join("-" * max_lengths[col] for col in headers) + "|")
+            for row in processed_records:
+                table_lines.append("| " + " | ".join(str(row.get(col, "")).ljust(max_lengths[col]) for col in headers) + " |")
+            table_str = "\n".join(table_lines)
+        else:
+            table_str = "No records available."
+        self.logger.critical("\n--> Logger history.\n" + table_str)
         return self
     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.exception(ex)
+        self.logger.fatal(str(ex))
         raise ex
+
+
+T = TypeVar('T')
+T2 = TypeVar('T2')
+class PrintFunc(Protocol):
+    def __call__(self, msg: str) -> Union[NoReturn, None]: ...
+
+
+# class CacheV2(Generic[T]):
+#     def __init__(self, source_func: Callable[[], T],
+#                  expire_ms: int, logger: Optional[PrintFunc] = None, path: OPLike = None,
+#                  saver: Callable[[T, PLike], Any] = Save.pickle, reader: Callable[[PLike], T] = Read.pickle, name: Optional[str] = None) -> None:
+#         self.cache: Optional[T] = None
+#         self.source_func = source_func
+#         self.path: Optional[P] = P(path) if path else None
+#         self.time_produced = time.time_ns() // 1_000_000
+#         self.save = saver
+#         self.reader = reader
+#         self.logger = logger
+#         self.expire = expire_ms  # in milliseconds
+#         self.name = name if isinstance(name, str) else str(self.source_func)
+#     @property
+#     def age(self):
+#         if self.path is None:
+#             return time.time_ns() // 1_000_000 - self.time_produced
+#         return time.time_ns() // 1_000_000 - int(self.path.stat().st_mtime * 1000)
+#     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.relative_to(P.home()) if self.path is not None else state["path"]
+#         return state
+#     def __call__(self, fresh: bool = False) -> T:
+#         if fresh or self.cache is None:
+#             if not fresh and self.path is not None and self.path.exists():
+#                 age = time.time_ns() // 1_000_000 - int(self.path.stat().st_mtime * 1000)
+#                 msg1 = f"""
+# 📦 ════════════════════ CACHE V2 OPERATION ════════════════════
+# 🔄 {self.name} cache: Reading cached values from `{self.path}`
+# ⏱️  Lag = {age} ms
+# ════════════════════════════════════════════════════════════════"""
+#                 try:
+#                     self.cache = self.reader(self.path)
+#                 except Exception as ex:
+#                     if self.logger:
+#                         msg2 = f"""
+# ❌ ════════════════════ CACHE V2 ERROR ════════════════════
+# ⚠️  {self.name} cache: Cache file is corrupted
+# 🔍 Error: {ex}
+# ════════════════════════════════════════════════════════════"""
+#                         self.logger(msg1 + msg2)
+#                     self.cache = self.source_func()
+#                     self.save(self.cache, self.path)
+#                     return self.cache
+#                 return self(fresh=False)
+#             else:
+#                 if self.logger:
+#                     self.logger(f"""
+# 🆕 ════════════════════ NEW CACHE V2 ════════════════════
+# 🔄 {self.name} cache: Populating fresh cache from source func
+# ℹ️  Reason: Previous cache never existed or there was an explicit fresh order
+# ════════════════════════════════════════════════════════════""")
+#                 self.cache = self.source_func()
+#                 if self.path is None:
+#                     self.time_produced = time.time_ns() // 1_000_000
+#                 else:
+#                     self.save(self.cache, self.path)
+#         else:
+#             try:
+#                 age = self.age
+#             except AttributeError:
+#                 self.cache = None
+#                 return self(fresh=fresh)
+#             if age > self.expire:
+#                 if self.logger:
+#                     self.logger(f"""
+# 🔄 ════════════════════ CACHE V2 UPDATE ════════════════════
+# ⚠️  {self.name} cache: Updating cache from source func
+# ⏱️  Age = {age} ms > {self.expire} ms
+# ════════════════════════════════════════════════════════════""")
+#                 self.cache = self.source_func()
+#                 if self.path is None:
+#                     self.time_produced = time.time_ns() // 1_000_000
+#                 else:
+#                     self.save(self.cache, self.path)
+#             else:
+#                 if self.logger:
+#                     self.logger(f"""
+# ✅ ════════════════════ USING CACHE V2 ════════════════════
+# 📦 {self.name} cache: Using cached values
+# ⏱️  Lag = {age} ms
+# ════════════════════════════════════════════════════════════""")
+#         return self.cache
+    # @staticmethod
+    # def as_decorator(expire: int = 60000, logger: Optional[PrintFunc] = None, path: OPLike = None,
+    #                  name: Optional[str] = None):
+    #     def decorator(source_func: Callable[[], T2]) -> CacheV2['T2']:
+    #         res = CacheV2(source_func=source_func, expire_ms=expire, logger=logger, path=path, name=name)
+    #         return res
+    #     return decorator

machineconfig/utils/ve.py

@@ -19,10 +19,10 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
                 ipy_profile = ini["specs"]["ipy_profile"]
                 print(f"✨ Using IPython profile: {ipy_profile}")
         if ipy_profile is None and tmp.joinpath(".ipy_profile").exists():
-            ipy_profile = tmp.joinpath(".ipy_profile").read_text().rstrip()
+            ipy_profile = tmp.joinpath(".ipy_profile").read_text(encoding="utf-8").rstrip()
             print(f"✨ Using IPython profile: {ipy_profile}. This is based on this file {tmp.joinpath('.ipy_profile')}")
         if ve_path is None and tmp.joinpath(".ve_path").exists():
-            ve_path = tmp.joinpath(".ve_path").read_text().rstrip().replace("\n", "")
+            ve_path = tmp.joinpath(".ve_path").read_text(encoding="utf-8").rstrip().replace("\n", "")
             print(f"🔮 Using Virtual Environment found @ {tmp}/.ve_path: {ve_path}")
         if ve_path is None and tmp.joinpath(".venv").exists():
             print(f"🔮 Using Virtual Environment found @ {tmp}/.venv")

{machineconfig-1.96.dist-info → machineconfig-2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 1.96
+Version: 2.0
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -9,22 +9,27 @@ Project-URL: Bug Tracker, https://github.com/thisismygitrepo/machineconfig/issue
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
-Requires-Dist: crocodile
 Requires-Dist: rich>=14.0.0
 Requires-Dist: paramiko>=3.5.1
 Requires-Dist: psutil>=7.0.0
-Requires-Dist: openai>=1.75.0
-Requires-Dist: nbformat>=5.10.4
 Requires-Dist: fire>=0.7.0
 Requires-Dist: pydantic>=2.11.3
-Requires-Dist: clipboard>=0.0.4
 Requires-Dist: gitpython>=3.1.44
-Requires-Dist: pudb>=2024.1.3
 Requires-Dist: pyfzf>=0.3.1
-Requires-Dist: call-function-with-timeout>=1.1.1
 Requires-Dist: rclone-python>=0.1.23
+Requires-Dist: pytz>=2025.2
+Requires-Dist: tomli>=2.2.1
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: pyjson5>=1.6.9
+Requires-Dist: requests>=2.32.5
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: randomname>=0.2.1
+Requires-Dist: cryptography>=44.0.2
+Requires-Dist: tenacity>=9.1.2
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
 Provides-Extra: docs