machineconfig 6.45__py3-none-any.whl → 6.48__py3-none-any.whl

machineconfig/utils/code.py

@@ -1,15 +1,14 @@
+import atexit
 import platform
 from typing import Optional
 import subprocess
-import os
-# import time
 from rich.console import Console
 from rich.panel import Panel
 from rich.syntax import Syntax
 
 from machineconfig.utils.accessories import randstr
 from machineconfig.utils.ve import get_ve_activate_line
-from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.path_extended import PathExtended  # type: ignore[import-not-found]
 
 
 def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: Optional[str], executable: Optional[str], strict_execution: bool = True):
@@ -138,71 +137,33 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
     return proc
 
 
-def run_shell_script_after_exit(script: str, check_interval: float = 0.1, display_script: bool = True) -> subprocess.Popen[bytes]:
-    current_pid = os.getpid()
+def run_shell_script_after_exit(script: str, display_script: bool = True) -> None:
     console = Console()
     
-    if platform.system() == "Windows":
-        monitor_script = f"""$ErrorActionPreference = "Stop"
-$targetPid = {current_pid}
-$checkInterval = {check_interval}
-
-Write-Host "🔍 Monitoring process PID: $targetPid"
-
-while ($true) {{
-    $process = Get-Process -Id $targetPid -ErrorAction SilentlyContinue
-    if (-not $process) {{
-        Write-Host "✅ Process $targetPid has exited. Running script..."
-        break
-    }}
-    Start-Sleep -Seconds $checkInterval
-}}
-
-# Execute the provided script
-{script}
-"""
-        suffix = ".ps1"
-        cmd = ["powershell", "-ExecutionPolicy", "Bypass", "-NoProfile", "-WindowStyle", "Hidden", "-File"]
-    else:
-        monitor_script = f"""#!/bin/bash
-target_pid={current_pid}
-check_interval={check_interval}
-
-echo "🔍 Monitoring process PID: $target_pid"
-
-while kill -0 $target_pid 2>/dev/null; do
-    sleep $check_interval
-done
-
-echo "✅ Process $target_pid has exited. Running script..."
-
-# Execute the provided script
-{script}
-"""
-        suffix = ".sh"
-        cmd = ["bash"]
-    
-    monitor_script_path = PathExtended.tmp().joinpath("tmp_scripts", "monitor", randstr() + suffix)
-    monitor_script_path.parent.mkdir(parents=True, exist_ok=True)
-    monitor_script_path.write_text(monitor_script, encoding="utf-8")
-    
-    if display_script:
-        lexer = "powershell" if platform.system() == "Windows" else "bash"
-        console.print(Panel(Syntax(code=monitor_script, lexer=lexer), title=f"📄 Monitor script @ {monitor_script_path}", subtitle="Will run after current process exits"), style="bold yellow")
-    
-    if platform.system() != "Windows":
-        monitor_script_path.chmod(0o755)
-    
-    cmd.append(str(monitor_script_path))
-    
-    if platform.system() == "Windows":
-        creation_flags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS  # type: ignore
-        process = subprocess.Popen(cmd, creationflags=creation_flags, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)
-    else:
-        process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, start_new_session=True)
-    if display_script:
-        console.print(f"🚀 [green]Monitor process started with PID:[/green] [blue]{process.pid}[/blue]")
-        console.print(f"📍 [yellow]Watching PID:[/yellow] [blue]{current_pid}[/blue]")
+    def execute_script_at_exit() -> None:
+        if platform.system() == "Windows":
+            suffix = ".ps1"
+            lexer = "powershell"
+        else:
+            suffix = ".sh"
+            lexer = "bash"
+        
+        script_path = PathExtended.tmp().joinpath("tmp_scripts", "exit", randstr() + suffix)
+        script_path.parent.mkdir(parents=True, exist_ok=True)
+        script_path.write_text(script, encoding="utf-8")
+        
+        if display_script:
+            console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 Exit script @ {script_path}", subtitle="Running at exit"), style="bold yellow")
+        
+        if platform.system() != "Windows":
+            script_path.chmod(0o755)
+        
+        if platform.system() == "Windows":
+            subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-NoProfile", "-File", str(script_path)], check=False)
+        else:
+            subprocess.run(["bash", str(script_path)], check=False)
+        
+        script_path.unlink(missing_ok=True)
     
-    return process
+    atexit.register(execute_script_at_exit)
 

machineconfig/utils/meta.py

@@ -3,11 +3,14 @@
 import ast
 import inspect
 import textwrap
+from collections.abc import Callable, Mapping
 from types import FunctionType, ModuleType
-from typing import Any
+from typing import ParamSpec
 
+P = ParamSpec("P")
 
-def function_to_script(func: FunctionType, call_with_args: tuple[Any, ...] | None = None, call_with_kwargs: dict[str, Any] | None = None) -> str:
+
+def function_to_script(func: Callable[P, object], call_with_kwargs: Mapping[str, object] | None) -> str:
     """Convert a function to a standalone executable Python script.
     
     This function analyzes a given function and generates a complete Python script
@@ -16,7 +19,6 @@ def function_to_script(func: FunctionType, call_with_args: tuple[Any, ...] | Non
     
     Args:
         func: The function to convert to a script
-        call_with_args: Optional tuple of positional arguments to call the function with
         call_with_kwargs: Optional dict of keyword arguments to call the function with
     
     Returns:
@@ -25,35 +27,37 @@ def function_to_script(func: FunctionType, call_with_args: tuple[Any, ...] | Non
     Raises:
         ValueError: If the function cannot be inspected or analyzed
     """
-    if not callable(func) or not hasattr(func, '__code__'):
-        raise ValueError(f"Expected a function, got {type(func)}")
-    
-    call_with_args = call_with_args or ()
-    call_with_kwargs = call_with_kwargs or {}
-    
-    imports = _extract_imports(func)
-    globals_needed = _extract_globals(func)
-    source_code = _get_function_source(func)
-    call_statement = _generate_call_statement(func, call_with_args, call_with_kwargs)
-    
+    if not isinstance(func, FunctionType):
+        raise ValueError(f"""Expected a Python function, got {type(func)}""")
+
+    python_func = func
+
+    imports = _extract_imports(python_func)
+    globals_needed = _extract_globals(python_func)
+    source_code = _get_function_source(python_func).rstrip()
+    validated_kwargs = _prepare_call_kwargs(python_func, call_with_kwargs)
+    call_statement = _generate_call_statement(python_func, validated_kwargs) if validated_kwargs is not None else None
+
     script_parts: list[str] = []
-    
+
     if imports:
         script_parts.append(imports)
-        script_parts.append("")
-    
+
     if globals_needed:
+        if script_parts:
+            script_parts.append("")
         script_parts.append(globals_needed)
+
+    if script_parts:
         script_parts.append("")
-    
+
     script_parts.append(source_code)
-    script_parts.append("")
-    
-    if call_statement:
+
+    if call_statement is not None:
         script_parts.append("")
         script_parts.append("if __name__ == '__main__':")
         script_parts.append(f"    {call_statement}")
-    
+
     return "\n".join(script_parts)
 
 
@@ -149,18 +153,47 @@ def _extract_globals(func: FunctionType) -> str:
     return "\n".join(global_assignments)
 
 
-def _generate_call_statement(func: FunctionType, args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
-    """Generate a function call statement with the given arguments."""
-    if not args and not kwargs:
+def _prepare_call_kwargs(func: FunctionType, call_with_kwargs: Mapping[str, object] | None) -> dict[str, object] | None:
+    if call_with_kwargs is None:
+        return None
+
+    normalized_kwargs = dict(call_with_kwargs)
+
+    if not normalized_kwargs:
+        return {}
+
+    signature = inspect.signature(func)
+    positional_only = [parameter.name for parameter in signature.parameters.values() if parameter.kind is inspect.Parameter.POSITIONAL_ONLY]
+
+    if positional_only:
+        joined = ", ".join(positional_only)
+        raise ValueError(f"""Cannot call {func.__name__} with positional-only parameters: {joined}""")
+
+    try:
+        signature.bind(**normalized_kwargs)
+    except TypeError as error:
+        raise ValueError(f"""Invalid call_with_kwargs for {func.__name__}: {error}""") from error
+
+    return normalized_kwargs
+
+
+def _generate_call_statement(func: FunctionType, kwargs: dict[str, object]) -> str:
+    """Generate a function call statement with the given keyword arguments."""
+    if not kwargs:
         return f"{func.__name__}()"
-    
-    arg_parts: list[str] = []
-    
-    for arg in args:
-        arg_parts.append(repr(arg))
-    
-    for key, value in kwargs.items():
-        arg_parts.append(f"{key}={repr(value)}")
-    
+
+    arg_parts: list[str] = [f"{key}={repr(value)}" for key, value in kwargs.items()]
     args_str = ", ".join(arg_parts)
     return f"{func.__name__}({args_str})"
+
+
+if __name__ == "__main__":
+    # Example usage
+    a = True
+    b = 3
+    def func(no_copy_assets: bool = a):
+        from machineconfig.scripts.python.helpers_devops.cli_self import update
+        update(no_copy_assets=no_copy_assets)
+    script = function_to_script(func, call_with_kwargs=None)
+    print(script)
+    pass

machineconfig/utils/procs.py

@@ -106,51 +106,45 @@ class ProcessManager:
         """Format process data as table string for display."""
         if not self.data:
             return ""
-
         # Create header
         _headers = ["Command", "PID", "Name", "Username", "CPU%", "Memory(MB)", "Status", "Create Time"]
         header_line = f"{'Command':<50} {'PID':<8} {'Name':<20} {'Username':<12} {'CPU%':<8} {'Memory(MB)':<12} {'Status':<12} {'Create Time':<20}"
         separator = "-" * len(header_line)
-
         lines = [header_line, separator]
-
         for process in self.data:
             # Format create_time as string
             create_time_str = process["create_time"].strftime("%Y-%m-%d %H:%M:%S")
             # Truncate command if too long
             command = process["command"][:47] + "..." if len(process["command"]) > 50 else process["command"]
-
             line = f"{command:<50} {process['pid']:<8} {process['name'][:19]:<20} {process['username'][:11]:<12} {process['cpu_percent']:<8.1f} {process['memory_usage_mb']:<12.2f} {process['status'][:11]:<12} {create_time_str:<20}"
             lines.append(line)
-
         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()
-        options = formatted_data.split("\n")[1:]  # Skip header
-        res = choose_from_options(options=formatted_data.split("\n"), msg="📋 Select processes to manage:", fzf=True, multi=True)
-        indices = [options.index(val) for val in res]
+        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)
+        # 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:")
         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):
             pprint(dict(process), f"📌 Process {idx}")
-
         kill_all = input("\n⚠️  Confirm killing ALL selected processes? y/[n] ").lower() == "y"
         if kill_all:
             self.kill(pids=[p["pid"] for p in selected_processes])
             return
-
         kill_by_index = input("\n🔫 Kill by index? (enter numbers separated by spaces, e.g. '1 4') or [n] to cancel: ")
         if kill_by_index != "" and kill_by_index != "n":
             indices = [int(val) for val in kill_by_index.split(" ")]
@@ -164,12 +158,10 @@ class ProcessManager:
         # header for filtering processes by name
         title = "🔍  FILTERING AND TERMINATING PROCESSES BY NAME"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-
         # Filter processes by name
         filtered_processes = [p for p in self.data if p["name"] == name]
         # Sort by create_time (ascending)
         filtered_processes.sort(key=lambda x: x["create_time"])
-
         print(f"🎯 Found {len(filtered_processes)} processes matching name: '{name}'")
         self.kill(pids=[p["pid"] for p in filtered_processes])
         console.print(Panel("", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
@@ -186,40 +178,35 @@ class ProcessManager:
             pids = []
         if commands is None:
             commands = []
-
         killed_count = 0
-
         for name in names:
             matching_processes = [p for p in self.data if p["name"] == name]
             if len(matching_processes) > 0:
                 for process in matching_processes:
                     psutil.Process(process["pid"]).kill()
-                    print(f"💀 Killed process {name} with PID {process['pid']}. It lived {get_age(process['create_time'])}. RIP 🪦💐")
+                    print(f"💀 Killed process {name} with PID {process['pid']}. It lived {get_age(process['create_time'])}. RIP 💐")
                     killed_count += 1
             else:
                 print(f'❓ No process named "{name}" found')
-
         for pid in pids:
             try:
                 proc = psutil.Process(pid)
                 proc_name = proc.name()
                 proc_lifetime = get_age(datetime.fromtimestamp(proc.create_time(), tz=None))
                 proc.kill()
-                print(f'💀 Killed process with PID {pid} and name "{proc_name}". It lived {proc_lifetime}. RIP 🪦💐')
+                print(f'💀 Killed process with PID {pid} and name "{proc_name}". It lived {proc_lifetime}. RIP 💐')
                 killed_count += 1
             except psutil.NoSuchProcess:
                 print(f"❓ No process with PID {pid} found")
-
         for command in commands:
             matching_processes = [p for p in self.data if command in p["command"]]
             if len(matching_processes) > 0:
                 for process in matching_processes:
                     psutil.Process(process["pid"]).kill()
-                    print(f'💀 Killed process with "{command}" in its command & PID {process["pid"]}. It lived {get_age(process["create_time"])}. RIP 🪦💐')
+                    print(f'💀 Killed process with "{command}" in its command & PID {process["pid"]}. It lived {get_age(process["create_time"])}. RIP 💐')
                     killed_count += 1
             else:
                 print(f'❓ No process has "{command}" in its command.')
-
         console.print(Panel(f"✅ Termination complete: {killed_count} processes terminated", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
 
 

machineconfig/utils/scheduler.py

@@ -170,35 +170,32 @@ class CacheMemory[T]():
     def __call__(self, fresh: bool = False) -> T:
         self.last_call_is_fresh = False
         if fresh or not hasattr(self, "cache"):
-            if self.logger:
-                why = "There was an explicit fresh order." if fresh else "Previous cache never existed."
-                self.logger.warning(f"""
-🆕 ════════════════════ NEW CACHE ════════════════════
-🔄 {self.name} cache: Populating fresh cache from source func
-ℹ️  Reason: {why}
-════════════════════════════════════════════════════════""")
+            why = "There was an explicit fresh order." if fresh else "Previous cache never existed."
+            t0 = time.time()
+            self.logger.warning(f"""
+🆕 ════════════════════ NEW {self.name} CACHE ════════════════════
+ℹ️ Reason: {why}""")
             self.cache = self.source_func()
+            self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
             self.last_call_is_fresh = True
             self.time_produced = datetime.now()
         else:
             age = self.age
             if age > self.expire:
-                if self.logger:
-                    self.logger.warning(f"""
+                self.logger.warning(f"""
 🔄 ════════════════════ CACHE UPDATE ════════════════════
 ⚠️  {self.name} cache: Updating cache from source func
-⏱️  Age = {age} > {self.expire}
-════════════════════════════════════════════════════════""")
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
                 self.cache = self.source_func()
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.last_call_is_fresh = True
                 self.time_produced = datetime.now()
             else:
-                if self.logger:
-                    self.logger.warning(f"""
+                self.logger.warning(f"""
 ✅ ════════════════════ USING CACHE ════════════════════
 📦 {self.name} cache: Using cached values
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════""")
+⏱️  Lag = {age}""")
         return self.cache
 
     @staticmethod
@@ -236,19 +233,18 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                 msg1 = f"""
 📦 ════════════════════ CACHE OPERATION ════════════════════
 🔄 {self.name} cache: Reading cached values from `{self.path}`
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════════"""
+⏱️  Lag = {age}"""
                 try:
                     self.cache = self.reader(self.path)
                 except Exception as ex:
-                    if self.logger:
-                        msg2 = f"""
+                    msg2 = f"""
 ❌ ════════════════════ CACHE ERROR ════════════════════
 ⚠️  {self.name} cache: Cache file is corrupted
-🔍 Error: {ex}
-════════════════════════════════════════════════════════"""
-                        self.logger.warning(msg1 + msg2)
+🔍 Error: {ex}"""
+                    self.logger.warning(msg1 + msg2)
+                    t0 = time.time()
                     self.cache = self.source_func()
+                    self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                     self.last_call_is_fresh = True
                     self.time_produced = datetime.now()
                     # if self.path is not None:
@@ -256,15 +252,15 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                     return self.cache
                 return self(fresh=False)  # may be the cache is old ==> check that by passing it through the logic again.
             else:
-                if self.logger:
-                    # Previous cache never existed or there was an explicit fresh order.
-                    why = "There was an explicit fresh order." if fresh else "Previous cache never existed or is corrupted."
-                    self.logger.warning(f"""
+                # Previous cache never existed or there was an explicit fresh order.
+                why = "There was an explicit fresh order." if fresh else "Previous cache never existed or is corrupted."
+                self.logger.warning(f"""
 🆕 ════════════════════ NEW CACHE ════════════════════
 🔄 {self.name} cache: Populating fresh cache from source func
-ℹ️  Reason: {why}
-════════════════════════════════════════════════════════""")
+ℹ️  Reason: {why}""")
+                t0 = time.time()
                 self.cache = self.source_func()  # fresh data.
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.last_call_is_fresh = True
                 self.time_produced = datetime.now()
                 self.save(self.cache, self.path)
@@ -274,23 +270,21 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
             except AttributeError:  # path doesn't exist (may be deleted) ==> need to repopulate cache form source_func.
                 return self(fresh=True)
             if age > self.expire:
-                if self.logger:
-                    self.logger.warning(f"""
+                self.logger.warning(f"""
 🔄 ════════════════════ CACHE UPDATE ════════════════════
 ⚠️  {self.name} cache: Updating cache from source func
-⏱️  Age = {age} > {self.expire}
-════════════════════════════════════════════════════════""")
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
                 self.cache = self.source_func()
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.last_call_is_fresh = True
                 self.time_produced = datetime.now()
                 self.save(self.cache, self.path)
             else:
-                if self.logger:
-                    self.logger.warning(f"""
+                self.logger.warning(f"""
 ✅ ════════════════════ USING CACHE ════════════════════
 📦 {self.name} cache: Using cached values
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════""")
+⏱️  Lag = {age}""")
         return self.cache
 
     @staticmethod

machineconfig/utils/ssh.py

@@ -6,7 +6,7 @@ from machineconfig.utils.terminal import Response, MACHINE
 from machineconfig.utils.accessories import pprint
 
 UV_RUN_CMD = "$HOME/.local/bin/uv run"
-MACHINECONFIG_VERSION = "machineconfig>=6.45"
+MACHINECONFIG_VERSION = "machineconfig>=6.48"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
 

{machineconfig-6.45.dist-info → machineconfig-6.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 6.45
+Version: 6.48
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0