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

machineconfig/utils/terminal.py

@@ -1,5 +1,4 @@
-
-from machineconfig.utils.path_reduced import P, OPLike
+from machineconfig.utils.path_reduced import PathExtended, OPLike
 import subprocess
 from typing import Any, BinaryIO, Optional, Union
 import platform
@@ -29,48 +28,70 @@ class Response:
         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
+    def op(self) -> str:
+        return self.output.stdout
+
     @property
-    def ip(self) -> str: return self.output.stdin
+    def ip(self) -> str:
+        return self.output.stdin
+
     @property
-    def err(self) -> str: return self.output.stderr
+    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())
+    def returncode(self) -> int:
+        return self.output.returncode
+
+    def op2path(self, strict_returncode: bool = True, strict_err: bool = False) -> Union[PathExtended, None]:
+        if self.is_successful(strict_returcode=strict_returncode, strict_err=strict_err):
+            return PathExtended(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 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 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()
+        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")
@@ -80,10 +101,12 @@ class Response:
         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()
@@ -91,88 +114,110 @@ class Terminal:
         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"
+        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 self.machine == "Linux":
+            script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
+        script_file = PathExtended.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"
+                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)]
+        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.")
+            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)
+        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 = PathExtended.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}
+{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"
+        shell_script = PathExtended.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()
+        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 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"""
+    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."}

machineconfig/utils/utils.py

@@ -2,17 +2,17 @@
 Utils
 """
 
-from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 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
 from rich.panel import Panel
 from machineconfig.utils.links import build_links, symlink_copy, symlink_func
-from machineconfig.utils.code import get_shell_script_executing_python_file, get_shell_file_executing_python_script, write_shell_script_to_default_program_path, print_code, PROGRAM_PATH
+from machineconfig.utils.code import write_shell_script_to_default_program_path, print_code, PROGRAM_PATH
 from machineconfig.utils.path import sanitize_path, match_file_name
 
 # Split into multiple assignments to fix incompatible tuple sizes
-_ = get_shell_script_executing_python_file, get_shell_file_executing_python_script, print_code, PROGRAM_PATH, display_options, write_shell_script_to_default_program_path
+_ = print_code, PROGRAM_PATH, display_options, write_shell_script_to_default_program_path
 _ = build_links
 _ = symlink_copy
 _ = symlink_func
@@ -47,31 +47,34 @@ DEFAULTS_PATH = PathExtended.home().joinpath("dotfiles/machineconfig/defaults.in
 #     else: print(f"\n❌ ERROR | API request failed: {response.status_code}\n")
 
 
-
-
 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)
     last_commit = repo.head.commit
     dtm = last_commit.committed_datetime
     from datetime import datetime  # make it tz unaware
+
     dtm = datetime(dtm.year, dtm.month, dtm.day, dtm.hour, dtm.minute, dtm.second)
-    res =  dtm > datetime.fromisoformat(commit_dtm)
+    res = dtm > datetime.fromisoformat(commit_dtm)
     if res is False and update is True:
         console = Console()
         console.print(Panel(f"🔄 UPDATE REQUIRED | Updating dotfiles because {dtm} < {datetime.fromisoformat(commit_dtm)}", border_style="bold blue", expand=False))
         from machineconfig.scripts.python.cloud_repo_sync import main
+
         main(cloud=None, path=dotfiles_path)
     return res
 
+
 def wait_for_jobs_to_finish(root: PathExtended, pattern: str, wait_for_n_jobs: int, max_wait_minutes: float) -> bool:
-    wait_finished: bool=False
+    wait_finished: bool = False
     import time
+
     t0 = time.time()
     while not wait_finished:
         parts = root.search(pattern, folders=False, r=False)
-        counter  =  len(parts)
+        counter = len(parts)
         if counter == wait_for_n_jobs:
             wait_finished = True
             console = Console()
@@ -88,8 +91,7 @@ def wait_for_jobs_to_finish(root: PathExtended, pattern: str, wait_for_n_jobs: i
     return False
 
 
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     # import typer
     # typer.run(check_tool_exists)
     pass

machineconfig/utils/utils2.py

@@ -1,5 +1,3 @@
-
-
 from pathlib import Path
 from typing import Optional, Any
 # import time
@@ -9,77 +7,69 @@ from typing import Optional, Any
 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:
         import secrets
+
         return secrets.token_urlsafe(length)  # interannly, it uses: random.SystemRandom or os.urandom which is hardware-based, not pseudo
     if noun:
         import randomname
+
         return randomname.get_name()
     import string
     import random
+
     population = (string.ascii_lowercase if lower else "") + (string.ascii_uppercase if upper else "") + (string.digits if digits else "") + (string.punctuation if punctuation else "")
-    return ''.join(random.choices(population, k=length))
+    return "".join(random.choices(population, k=length))
 
 
-def read_ini(path: 'Path', encoding: Optional[str] = None):
-    if not Path(path).exists() or Path(path).is_dir(): raise FileNotFoundError(f"File not found or is a directory: {path}")
+def read_ini(path: "Path", encoding: Optional[str] = None):
+    if not Path(path).exists() or Path(path).is_dir():
+        raise FileNotFoundError(f"File not found or is a directory: {path}")
     import configparser
+
     res = configparser.ConfigParser()
     res.read(filenames=[str(path)], encoding=encoding)
     return res
-def read_json(path: 'Path', r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
+
+
+def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
     import json
+
     try:
-        mydict = json.loads(Path(path).read_text(encoding='utf-8'), **kwargs)
+        mydict = json.loads(Path(path).read_text(encoding="utf-8"), **kwargs)
     except Exception:
         import pyjson5
-        mydict = pyjson5.loads(Path(path).read_text(encoding='utf-8'), **kwargs)  # file has C-style comments.
+
+        mydict = pyjson5.loads(Path(path).read_text(encoding="utf-8"), **kwargs)  # file has C-style comments.
     _ = r
     return mydict
-def read_toml(path: 'Path'):
+
+
+def read_toml(path: "Path"):
     import tomli
-    return tomli.loads(path.read_text(encoding='utf-8'))
+
+    return tomli.loads(path.read_text(encoding="utf-8"))
+
 
 def pprint(obj: dict[Any, Any], title: str) -> None:
     from rich import inspect
     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
+def human_friendly_dict(d: dict[str, Any]) -> dict[str, Any]:
+    from datetime import datetime
+
+    result = {}
+    for k, v in d.items():
+        if isinstance(v, float):
+            result[k] = f"{v:.2f}"
+        elif isinstance(v, bool):
+            result[k] = "✓" if v else "✗"
+        elif isinstance(v, int) and len(str(v)) == 13 and v > 0:  # assuming ms timestamp
+            dt = datetime.fromtimestamp(v / 1000)
+            result[k] = dt.strftime("%Y-%m-%d %H:%M")
+        else:
+            result[k] = v
+    return result