machineconfig 6.47__py3-none-any.whl → 6.49__py3-none-any.whl

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)
 
 
@@ -86,6 +90,17 @@ def _extract_imports(func: FunctionType) -> str:
             if isinstance(node.value, ast.Name):
                 used_names.add(node.value.id)
     
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            for default in node.args.defaults + node.args.kw_defaults:
+                if default is not None:
+                    for subnode in ast.walk(default):
+                        if isinstance(subnode, ast.Name):
+                            used_names.add(subnode.id)
+                        elif isinstance(subnode, ast.Attribute):
+                            if isinstance(subnode.value, ast.Name):
+                                used_names.add(subnode.value.id)
+    
     for name in used_names:
         if name in func_globals:
             obj = func_globals[name]
@@ -97,7 +112,20 @@ def _extract_imports(func: FunctionType) -> str:
                 else:
                     import_statements.add(f"import {module_name} as {name}")
             
-            elif hasattr(obj, '__module__') and obj.__module__ != '__main__':
+            elif isinstance(obj, type) and hasattr(obj, '__module__') and obj.__module__ != '__main__':
+                try:
+                    module_name = obj.__module__
+                    obj_name = obj.__name__ if hasattr(obj, '__name__') else name
+                    
+                    if module_name and module_name != 'builtins':
+                        if obj_name == name:
+                            import_statements.add(f"from {module_name} import {obj_name}")
+                        else:
+                            import_statements.add(f"from {module_name} import {obj_name} as {name}")
+                except AttributeError:
+                    pass
+            
+            elif callable(obj) and not isinstance(obj, type) and hasattr(obj, '__module__') and obj.__module__ != '__main__':
                 try:
                     module_name = obj.__module__
                     obj_name = obj.__name__ if hasattr(obj, '__name__') else name
@@ -116,6 +144,7 @@ def _extract_imports(func: FunctionType) -> str:
 def _extract_globals(func: FunctionType) -> str:
     """Extract global variables needed by the function."""
     global_assignments: list[str] = []
+    needed_types: set[type] = set()
     
     source = _get_function_source(func)
     func_globals = func.__globals__
@@ -133,6 +162,17 @@ def _extract_globals(func: FunctionType) -> str:
             if isinstance(node.value, ast.Name):
                 used_names.add(node.value.id)
     
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            for default in node.args.defaults + node.args.kw_defaults:
+                if default is not None:
+                    for subnode in ast.walk(default):
+                        if isinstance(subnode, ast.Name):
+                            used_names.add(subnode.id)
+                        elif isinstance(subnode, ast.Attribute):
+                            if isinstance(subnode.value, ast.Name):
+                                used_names.add(subnode.value.id)
+    
     for name in used_names:
         if name in func_globals:
             obj = func_globals[name]
@@ -140,27 +180,78 @@ def _extract_globals(func: FunctionType) -> str:
             if not isinstance(obj, (ModuleType, FunctionType, type)):
                 if not (hasattr(obj, '__module__') and hasattr(obj, '__name__')):
                     try:
-                        repr_str = repr(obj)
-                        if len(repr_str) < 1000 and '\n' not in repr_str:
-                            global_assignments.append(f"{name} = {repr_str}")
-                    except Exception:
-                        global_assignments.append(f"# Warning: Could not serialize global variable '{name}'")
-    
-    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:
-        return f"{func.__name__}()"
+                        obj_type = type(obj)
+                        
+                        if obj_type.__name__ == 'PathExtended' and obj_type.__module__ == 'machineconfig.utils.path_extended':
+                            global_assignments.append(f"{name} = PathExtended('{str(obj)}')")
+                            if obj_type.__module__ not in ['builtins', '__main__']:
+                                needed_types.add(obj_type)
+                        else:
+                            repr_str = repr(obj)
+                            if len(repr_str) < 1000 and '\n' not in repr_str and all(ord(c) < 128 or c in [' ', '\n', '\t'] for c in repr_str):
+                                global_assignments.append(f"{name} = {repr_str}")
+                                if obj_type.__module__ not in ['builtins', '__main__']:
+                                    needed_types.add(obj_type)
+                            else:
+                                global_assignments.append(f"# Warning: Could not serialize global variable '{name}' (repr too complex or contains non-ASCII)")
+                    except Exception as e:
+                        global_assignments.append(f"# Warning: Could not serialize global variable '{name}': {e}")
     
-    arg_parts: list[str] = []
+    result_parts: list[str] = []
     
-    for arg in args:
-        arg_parts.append(repr(arg))
+    if needed_types:
+        for obj_type in sorted(needed_types, key=lambda t: (t.__module__, t.__name__)):
+            module_name = obj_type.__module__
+            type_name = obj_type.__name__
+            result_parts.append(f"from {module_name} import {type_name}")
+        result_parts.append("")
     
-    for key, value in kwargs.items():
-        arg_parts.append(f"{key}={repr(value)}")
+    result_parts.extend(global_assignments)
     
+    return "\n".join(result_parts)
+
+
+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] = [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

@@ -1,10 +1,10 @@
+
 from pathlib import Path
 from typing import Callable, Optional, Union, Any, Protocol, List, TypeVar
 import logging
 import time
 from datetime import datetime, timezone, timedelta
 from machineconfig.utils.io import from_pickle
-from machineconfig.utils.path_extended import PathExtended
 
 
 class LoggerTemplate(Protocol):
@@ -147,7 +147,6 @@ class Scheduler:
 T2 = TypeVar("T2")
 def to_pickle(obj: Any, path: Path) -> None:
     import pickle
-    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_bytes(pickle.dumps(obj))
 
 
@@ -160,15 +159,12 @@ class CacheMemory[T]():
         self.time_produced = datetime.now()
         self.logger = logger
         self.expire = expire
-        self.name = name if isinstance(name, str) else str(self.source_func)
-        self.last_call_is_fresh = False
-
+        self.name = name if isinstance(name, str) else self.source_func.__name__
     @property
     def age(self) -> timedelta:
         return datetime.now() - self.time_produced
 
     def __call__(self, fresh: bool = False) -> T:
-        self.last_call_is_fresh = False
         if fresh or not hasattr(self, "cache"):
             why = "There was an explicit fresh order." if fresh else "Previous cache never existed."
             t0 = time.time()
@@ -177,7 +173,6 @@ class CacheMemory[T]():
 ℹ️ 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
@@ -189,7 +184,6 @@ class CacheMemory[T]():
                 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:
                 self.logger.warning(f"""
@@ -212,21 +206,19 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
     ) -> None:
         self.cache: T
         self.source_func = source_func  # function which when called returns a fresh object to be frozen.
-        self.path: PathExtended = PathExtended(path)
+        self.path: Path = path
+        _ = self.path.parent.mkdir(parents=True, exist_ok=True)
         self.time_produced = datetime.now()  # if path is None else
         self.save = saver
         self.reader = reader
         self.logger = logger
         self.expire = expire
-        self.name = name if isinstance(name, str) else str(self.source_func)
-        self.last_call_is_fresh = False
-
+        self.name = name if isinstance(name, str) else self.source_func.__name__
     @property
     def age(self):
         """Throws AttributeError if called before cache is populated and path doesn't exists"""
         return datetime.now() - self.time_produced
     def __call__(self, fresh: bool = False) -> T:
-        self.last_call_is_fresh = False
         if fresh or not hasattr(self, "cache"):  # populate cache for the first time
             if not fresh and self.path.exists():
                 age = datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
@@ -245,10 +237,8 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                     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:
-                    #     self.save(self.cache, self.path)
+                    self.save(self.cache, self.path)
                     return self.cache
                 return self(fresh=False)  # may be the cache is old ==> check that by passing it through the logic again.
             else:
@@ -261,7 +251,6 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                 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)
         else:  # cache exists
@@ -277,7 +266,6 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
                 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:
@@ -294,5 +282,4 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
         def decorator(source_func: Callable[[], T2]) -> Cache["T2"]:
             res = Cache(source_func=source_func, expire=expire, logger=logger, path=path, name=name, reader=reader, saver=saver)
             return res
-
         return decorator

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.47"
+MACHINECONFIG_VERSION = "machineconfig>=6.49"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
 

{machineconfig-6.47.dist-info → machineconfig-6.49.dist-info}/METADATA

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