machineconfig 6.51__py3-none-any.whl → 6.53__py3-none-any.whl

machineconfig/utils/code.py

@@ -2,94 +2,16 @@ import atexit
 import platform
 from typing import Optional
 import subprocess
-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  # 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):
-    if executable is None: exe_resolved = "python"
-    else: exe_resolved = executable
-    if func is None: exec_line = f"""{exe_resolved} {python_file}"""
-    else: exec_line = f"""{exe_resolved} -m fire {python_file} {func}"""
-    if ve_path is None: ve_activate_line = ""
-    else: ve_activate_line = get_ve_activate_line(ve_path)
-    shell_script = f"""
-echo "Executing {exec_line}"
-{ve_activate_line}
-{exec_line}
-deactivate || true
-"""
-    if strict_execution:
-        if platform.system() == "Windows":
-            shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
-        if platform.system() in ["Linux", "Darwin"]:
-            shell_script = "set -e" + "\n" + shell_script
-    if platform.system() in ["Linux", "Darwin"]:
-        shell_script = "#!/bin/bash" + "\n" + shell_script  # vs #!/usr/bin/env bash
-    return shell_script
+from machineconfig.utils.path_extended import PathExtended
+from pathlib import Path
 
 
-def get_shell_file_executing_python_script(python_script: str, ve_path: Optional[str], executable: Optional[str], verbose: bool = True):
-    if verbose:
-        python_script = f"""
-code = r'''{python_script}'''
-try:
-    from machineconfig.utils.utils import print_code
-    print_code(code=code, lexer="python", desc="Python Script")
-except ImportError:
+def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
+    import platform
     from rich.console import Console
     from rich.panel import Panel
-    console = Console()
-    console.print(Panel(f'''📜 PYTHON SCRIPT:\n\n{{code}}''', title="Python Script", expand=False))
-""" + python_script
-    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
-    python_file.write_text(python_script, encoding="utf-8")
-    shell_script = get_shell_script_executing_python_file(python_file=str(python_file), func=None, ve_path=ve_path, executable=executable)
-    shell_file = write_shell_script_to_file(shell_script)
-    return shell_file
-
-
-def write_shell_script_to_file(shell_script: str):
-    if platform.system() in ["Linux", "Darwin"]:
-        suffix = ".sh"
-    elif platform.system() == "Windows":
-        suffix = ".ps1"
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-    shell_file = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix)
-    shell_file.parent.mkdir(parents=True, exist_ok=True)
-    shell_file.write_text(shell_script, encoding="utf-8")
-    return shell_file
-
-
-def write_shell_script_to_default_program_path(program: str, desc: str, preserve_cwd: bool, display: bool, execute: bool):
-    if preserve_cwd:
-        if platform.system() == "Windows":
-            program = "$orig_path = $pwd\n" + program + "\ncd $orig_path"
-        else:
-            program = 'orig_path=$(cd -- "." && pwd)\n' + program + '\ncd "$orig_path" || exit'
-    if display:
-        print_code(code=program, lexer="shell", desc=desc, subtitle="PROGRAM")
-    if execute:
-        result = subprocess.run(program, shell=True, capture_output=True, text=True)
-        success = result.returncode == 0 and result.stderr == ""
-        if not success:
-            print("❌ 🛠️  EXECUTION | Shell script running failed")
-            if result.stdout:
-                print(f"STDOUT: {result.stdout}")
-            if result.stderr:
-                print(f"STDERR: {result.stderr}")
-            print(f"Return code: {result.returncode}")
-    return None
-
-
-def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
+    from rich.syntax import Syntax
     if lexer == "shell":
         if platform.system() == "Windows":
             lexer = "powershell"
@@ -101,8 +23,43 @@ def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
 
 
+def get_shell_file_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> Path:
+    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    python_file.write_text(python_script, encoding="utf-8")
+    if uv_with is not None and len(uv_with) > 0:
+        uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
+    else:
+        uv_with_arg = ""
+    if uv_project_dir is not None:
+        uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
+    else:
+        uv_project_dir_arg = ""
+    
+    from machineconfig.utils.meta import lambda_to_defstring
+    print_code_string = lambda_to_defstring(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"), in_global=True)
+    python_file_tmp = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
+    python_file_tmp.parent.mkdir(parents=True, exist_ok=True)
+    python_file_tmp.write_text(print_code_string, encoding="utf-8")
+
+    shell_script = f"""
+uv run --with rich {python_file_tmp}
+uv run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} 
+"""
+    
+    shell_path = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + (".ps1" if platform.system() == "Windows" else ".sh"))
+    shell_path.parent.mkdir(parents=True, exist_ok=True)
+    shell_path.write_text(shell_script, encoding="utf-8")    
+    return shell_path
+
+
 def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
     import tempfile
+    import platform
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+
     if platform.system() == "Windows":
         suffix = ".ps1"
         lexer = "powershell"
@@ -112,6 +69,7 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
     with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False, encoding='utf-8') as temp_file:
         temp_file.write(script)
         temp_script_path = PathExtended(temp_file.name)
+
     console = Console()
     if display_script:
         from rich.syntax import Syntax
@@ -138,8 +96,12 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
 
 
 def run_shell_script_after_exit(script: str, display_script: bool = True) -> None:
+    import platform
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+
     console = Console()
-    
     def execute_script_at_exit() -> None:
         if platform.system() == "Windows":
             suffix = ".ps1"

machineconfig/utils/installer.py

@@ -5,7 +5,7 @@ from machineconfig.utils.installer_utils.installer_class import Installer
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
 from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS, PACKAGE_GROUP2NAMES
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH, LIBRARY_ROOT
+from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH
 from machineconfig.utils.io import read_json
 
 from rich.console import Console
@@ -123,9 +123,14 @@ def dynamically_extract_installers_system_groups_from_scripts():
     res_final: list[InstallerData] = []
     from platform import system
     if system() == "Windows":
-        options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
+        from machineconfig.setup_windows import APPS
+        options_system = parse_apps_installer_windows(APPS.read_text(encoding="utf-8"))
     elif system() == "Linux" or system() == "Darwin":
-        options_system = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text(encoding="utf-8"))
+        from machineconfig.setup_linux import APPS
+        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
+    elif system() == "Darwin":
+        from machineconfig.setup_mac import APPS
+        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
     else:
         raise NotImplementedError(f"❌ System {system()} not supported")
     os_name = get_os_name()

machineconfig/utils/meta.py

@@ -1,252 +1,14 @@
 """Metaprogramming utilities for analyzing and serializing Python functions."""
 
-import ast
-import inspect
-import textwrap
-from collections.abc import Callable, Mapping
-from types import FunctionType, ModuleType
-from typing import Any, ParamSpec
-
-P = ParamSpec("P")
-
-
-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
-    that includes all necessary imports, global variables, the function definition,
-    and optionally a function call.
-    
-    Args:
-        func: The function to convert to a script
-        call_with_kwargs: Optional dict of keyword arguments to call the function with
-    
-    Returns:
-        A complete Python script as a string that can be executed independently
-    
-    Raises:
-        ValueError: If the function cannot be inspected or analyzed
-    """
-    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)
-
-    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)
-
-    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)
-
-
-def _get_function_source(func: FunctionType) -> str:
-    """Extract the source code of a function."""
-    try:
-        source = inspect.getsource(func)
-        return textwrap.dedent(source)
-    except (OSError, TypeError) as e:
-        raise ValueError(f"Cannot get source code for function {func.__name__}: {e}") from e
-
-
-def _extract_imports(func: FunctionType) -> str:
-    """Extract all import statements needed by the function."""
-    import_statements: set[str] = set()
-    
-    source = _get_function_source(func)
-    func_globals = func.__globals__
-    
-    try:
-        tree = ast.parse(source)
-    except SyntaxError as e:
-        raise ValueError(f"Failed to parse function source: {e}") from e
-    
-    used_names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name):
-            used_names.add(node.id)
-        elif isinstance(node, ast.Attribute):
-            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]
-            
-            if isinstance(obj, ModuleType):
-                module_name = obj.__name__
-                if name == module_name.split('.')[-1]:
-                    import_statements.add(f"import {module_name}")
-                else:
-                    import_statements.add(f"import {module_name} as {name}")
-            
-            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
-                    
-                    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
-    
-    return "\n".join(sorted(import_statements))
-
-
-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__
-    
-    try:
-        tree = ast.parse(source)
-    except SyntaxError as e:
-        raise ValueError(f"Failed to parse function source: {e}") from e
-    
-    used_names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name):
-            used_names.add(node.id)
-        elif isinstance(node, ast.Attribute):
-            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]
-            
-            if not isinstance(obj, (ModuleType, FunctionType, type)):
-                if not (hasattr(obj, '__module__') and hasattr(obj, '__name__')):
-                    try:
-                        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}")
-    
-    result_parts: list[str] = []
-    
-    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("")
-    
-    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})"
+from collections.abc import Callable
+from typing import Any
 
 
 def lambda_to_defstring(lmb: Callable[[], Any], in_global: bool = False) -> str:
     """
+    caveats: always use keyword arguments in the lambda call for best results.
+    return statement not allowed in the wrapped function (otherwise it can be put in the global space)
+
     Given a no-arg lambda like `lambda: func(a=var1, b=var2)`,
     return a string containing the full function definition of `func`
     but with the defaults for the parameters provided in the call replaced
@@ -423,12 +185,4 @@ def lambda_to_defstring(lmb: Callable[[], Any], in_global: bool = False) -> 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/scheduling.py

@@ -1,7 +1,6 @@
 # """Task scheduler
 # """
 
-# from machineconfig.utils.utils import get_shell_script_executing_python_file
 # from machineconfig.utils.utils2 import read_ini
 # from dataclasses import dataclass
 # from datetime import datetime, timedelta