machineconfig 6.52__py3-none-any.whl → 6.54__py3-none-any.whl

machineconfig/cluster/sessions_managers/utils/maker.py

@@ -1,24 +1,21 @@
 
 from types import FunctionType
-from typing import Literal
+from typing import Optional, Literal
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 from pathlib import Path
 
-def get_fire_command_and_artifact_files(func: FunctionType):
-    from machineconfig.utils.meta import function_to_script
-    py_script =  function_to_script(func, call_with_kwargs=None)
-    from machineconfig.utils.accessories import randstr
-    py_script_path = Path.home().joinpath("tmp_results", "tmp_py_scripts", f"tmp_{randstr(10)}.py")
-    py_script_path.parent.mkdir(parents=True, exist_ok=True)
-    py_script_path.write_text(py_script, encoding="utf-8")
-    command_to_run = f"uv run --project $HOME/ {py_script_path}"
+def get_fire_tab_using_uv(func: FunctionType, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[TabConfig, Path]:
+    from machineconfig.utils.meta import lambda_to_defstring
+    py_script =  lambda_to_defstring(lmb=lambda: func, in_global=True)
+    from machineconfig.utils.code import get_uv_command_executing_python_script
+    command_to_run, py_script_path = get_uv_command_executing_python_script(python_script=py_script, uv_with=uv_with, uv_project_dir=uv_project_dir)
     tab_config: TabConfig = {
         "command": command_to_run,
         "startDir": "$HOME",
         "tabName": func.__name__
     }
     return tab_config, py_script_path
-def get_fire_command_and_artifact_files_v2(func: FunctionType):
+def get_fire_tab_using_fire(func: FunctionType):
     import inspect
     path = Path(inspect.getfile(func))
     path_relative = path.relative_to(Path.home())
@@ -36,10 +33,10 @@ def make_layout_from_functions(functions: list[FunctionType], tab_configs: list[
     for a_func in functions:
         match method:
             case "script":
-                tab_config, artifact_files_1 = get_fire_command_and_artifact_files(a_func)
+                tab_config, artifact_files_1 = get_fire_tab_using_uv(a_func, uv_with=None, uv_project_dir=None)
                 artifact_files = [artifact_files_1]
             case "fire":
-                tab_config = get_fire_command_and_artifact_files_v2(a_func)
+                tab_config = get_fire_tab_using_fire(a_func)
                 artifact_files = []
         tabs2artifacts.append((tab_config, artifact_files))
     list_of_tabs = [tab for tab, _ in tabs2artifacts] + tab_configs

machineconfig/scripts/python/helpers_devops/cli_utils.py

@@ -78,8 +78,51 @@ def download(
             raise typer.Exit(code=1)
 
 
+def merge_pdfs(
+        pdf1: Annotated[str, typer.Argument(..., help="Path to the first PDF file.")],
+        pdf2: Annotated[str, typer.Argument(..., help="Path to the second PDF file.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output merged PDF file path.")] = None,
+        compress: Annotated[bool, typer.Option("--compress", "-c", help="Compress the output PDF.")] = False,
+    ) -> None:
+    def merge_pdfs_internal(pdf1: str, pdf2: str, output: Optional[str], compress: bool) -> None:
+        from pypdf import PdfReader, PdfWriter
+        writer = PdfWriter()
+        for pdf_path in [pdf1, pdf2]:
+            reader = PdfReader(pdf_path)
+            for page in reader.pages:
+                writer.add_page(page)
+        output_path = output if output else "merged.pdf"
+        if compress:
+            try:
+                for p in writer.pages:
+                    try:
+                        # PageObject.compress_content_streams exists in pypdf
+                        p.compress_content_streams()
+                    except Exception:
+                        # best-effort: ignore per-page compression failures
+                        continue
+            except Exception:
+                pass
+            try:
+                writer.compress_identical_objects()
+            except Exception:
+                # non-fatal if this fails
+                pass
+        writer.write(output_path)
+        print(f"✅ Merged PDF saved to: {output_path}")
+    from machineconfig.utils.meta import lambda_to_defstring
+    code = lambda_to_defstring(lambda : merge_pdfs_internal(pdf1=pdf1, pdf2=pdf2, output=output, compress=compress), in_global=True)
+    import tempfile
+    tmp_py_file = Path(tempfile.mkstemp(suffix=".py")[1])
+    tmp_py_file.write_text(code, encoding="utf-8")
+    from machineconfig.utils.code import run_shell_script
+    run_shell_script(f"""uv run --with pypdf {tmp_py_file} """)
+
+
 def get_app() -> typer.Typer:
     app = typer.Typer(help="🛠️ [u]  utilities operations", no_args_is_help=True, add_help_option=False, add_completion=False)
     app.command(name="download", no_args_is_help=True, help="[d] Download a file from a URL and optionally decompress it.")(download)
     app.command(name="d", no_args_is_help=True, hidden=True)(download)
+    app.command(name="merge-pdfs", no_args_is_help=True, help="[m] Merge two PDF files into one.")(merge_pdfs)
+    app.command(name="m", no_args_is_help=True, hidden=True)(merge_pdfs)
     return app

machineconfig/scripts/python/helpers_repos/cloud_repo_sync.py

@@ -6,7 +6,7 @@ import typer
 from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.terminal import Response
 from machineconfig.utils.source_of_truth import CONFIG_ROOT, DEFAULTS_PATH
-from machineconfig.utils.code import get_shell_file_executing_python_script, write_shell_script_to_file
+from machineconfig.utils.code import get_uv_command_executing_python_script
 from pathlib import Path
 import platform
 import subprocess
@@ -76,10 +76,17 @@ git pull originEnc master
 
 """
 
-    if Path.home().joinpath("code/machineconfig").exists(): executable = f"""uv run --project "{str(Path.home().joinpath("code/machineconfig"))}" """
-    else: executable = """uv run --with "machineconfig>=6.52" """
+    if Path.home().joinpath("code/machineconfig").exists():
+        uv_project_dir = f"""{str(Path.home().joinpath("code/machineconfig"))}"""
+        uv_with = None
+    else:
+        uv_with = ["machineconfig>=6.52"]
+        uv_project_dir = None
+
+    import tempfile
+    shell_path = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+    shell_path.write_text(script, encoding="utf-8")
 
-    shell_path = write_shell_script_to_file(shell_script=script)
     command = f". {shell_path}"
     if platform.system() == "Windows":
         completed = subprocess.run(["powershell", "-Command", command], capture_output=True, check=False, text=True)
@@ -100,20 +107,12 @@ git pull originEnc master
 
         # ================================================================================
         option1 = "Delete remote copy and push local:"
-        from machineconfig.utils.meta import function_to_script
+        from machineconfig.utils.meta import lambda_to_defstring
         def func2(remote_repo: str, local_repo: str, cloud: str):
             from machineconfig.scripts.python.helpers_repos.sync import delete_remote_repo_copy_and_push_local
             delete_remote_repo_copy_and_push_local(remote_repo=remote_repo, local_repo=local_repo, cloud=cloud)
-            return "done"
-        # def func2(remote_repo: str=str(repo_remote_root), local_repo: str=str(repo_local_root), cloud: str=str(cloud_resolved)):
-        #     from machineconfig.scripts.python.helpers_repos.sync import delete_remote_repo_copy_and_push_local
-        #     delete_remote_repo_copy_and_push_local(remote_repo=remote_repo, local_repo=local_repo, cloud=cloud)
-        #     return "done"
-        # program_1_py = function_to_script(func=func2, call_with_kwargs=None)
-        program_1_py = function_to_script(func=func2, call_with_kwargs={"remote_repo": str(repo_remote_root), "local_repo": str(repo_local_root), "cloud": cloud_resolved})
-
-
-        shell_file_1 = get_shell_file_executing_python_script(python_script=program_1_py, ve_path=None, executable=executable)
+        program_1_py = lambda_to_defstring(lambda: func2(remote_repo=str(repo_remote_root), local_repo=str(repo_local_root), cloud=str(cloud_resolved)), in_global=True)
+        uv_command_1, _pyfile1 = get_uv_command_executing_python_script(python_script=program_1_py, uv_with=uv_with, uv_project_dir=uv_project_dir)
         # ================================================================================
         option2 = "Delete local repo and replace it with remote copy:"
         program_2 = f"""
@@ -126,15 +125,19 @@ sudo chmod 600 $HOME/.ssh/*
 sudo chmod 700 $HOME/.ssh
 sudo chmod +x $HOME/dotfiles/scripts/linux -R
 """
-        shell_file_2 = write_shell_script_to_file(shell_script=program_2)
+        import tempfile
+        shell_file_2 = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+        shell_file_2.write_text(program_2, encoding="utf-8")
+
         # ================================================================================
         option3 = "Inspect repos:"
         def func(repo_local_root: str, repo_remote_root: str):
             from machineconfig.scripts.python.helpers_repos.sync import inspect_repos
             inspect_repos(repo_local_root=repo_local_root, repo_remote_root=repo_remote_root)
-            return "done"
-        program_3_py = function_to_script(func=func, call_with_kwargs={"repo_local_root": str(repo_local_root), "repo_remote_root": str(repo_remote_root)})
-        shell_file_3 = get_shell_file_executing_python_script(python_script=program_3_py, ve_path=None, executable=executable)
+        # program_3_py = function_to_script(func=func, call_with_kwargs={"repo_local_root": str(repo_local_root), "repo_remote_root": str(repo_remote_root)})
+        # shell_file_3 = get_shell_file_executing_python_script(python_script=program_3_py, ve_path=None, executable=executable)
+        program_3_py = lambda_to_defstring(lambda: func(repo_local_root=str(repo_local_root), repo_remote_root=str(repo_remote_root)), in_global=True)
+        uv_command_3, _pyfile3 = get_uv_command_executing_python_script(python_script=program_3_py, uv_with=uv_with, uv_project_dir=uv_project_dir)
         # ================================================================================
 
         option4 = "Remove problematic rclone file from repo and replace with remote:"
@@ -143,16 +146,17 @@ rm $HOME/dotfiles/creds/rclone/rclone.conf
 cp $HOME/.config/machineconfig/remote/dotfiles/creds/rclone/rclone.conf $HOME/dotfiles/creds/rclone
 cd $HOME/dotfiles
 git commit -am "finished merging"
-. {shell_file_1}
+{uv_command_1}
 """
-        shell_file_4 = write_shell_script_to_file(shell_script=program_4)
+        shell_file_4 = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+        shell_file_4.write_text(program_4, encoding="utf-8")
         # ================================================================================
 
         console.print(Panel("🔄 RESOLVE MERGE CONFLICT\nChoose an option to resolve the conflict:", title_align="left", border_style="blue"))
 
-        print(f"• {option1:75} 👉 {shell_file_1}")
+        print(f"• {option1:75} 👉 {uv_command_1}")
         print(f"• {option2:75} 👉 {shell_file_2}")
-        print(f"• {option3:75} 👉 {shell_file_3}")
+        print(f"• {option3:75} 👉 {uv_command_3}")
         print(f"• {option4:75} 👉 {shell_file_4}")
         print("\n\n")
 
@@ -162,21 +166,21 @@ git commit -am "finished merging"
                 import questionary
                 choice = questionary.select("Choose one option:", choices=[option1, option2, option3, option4]).ask()
                 if choice == option1:
-                    program_content = shell_file_1.read_text(encoding="utf-8")
+                    program_content = uv_command_1
                 elif choice == option2:
                     program_content = program_2
                 elif choice == option3:
-                    program_content = shell_file_3.read_text(encoding="utf-8")
+                    program_content = uv_command_3
                 elif choice == option4:
                     program_content = program_4
                 else:
                     raise NotImplementedError(f"Choice {choice} not implemented.")
             case "push-local-merge":
-                program_content = shell_file_1.read_text(encoding="utf-8")
+                program_content = uv_command_1
             case "overwrite-local":
                 program_content = program_2
             case "stop-on-conflict":
-                program_content = shell_file_3.read_text(encoding="utf-8")
+                program_content = uv_command_3
             case "remove-rclone-conflict":
                 program_content = program_4
             case _:

machineconfig/scripts/python/helpers_repos/sync.py

@@ -1,5 +1,4 @@
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.code import write_shell_script_to_file
 import platform
 from pathlib import Path
 from rich.console import Console
@@ -56,11 +55,12 @@ def inspect_repos(repo_local_root: str, repo_remote_root: str):
 
     if platform.system() == "Windows":
         program = get_wt_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_local_root))
-        write_shell_script_to_file(shell_script=program)
-        return None
     elif platform.system() in ["Linux", "Darwin"]:
         program = get_zellij_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_remote_root))
-        write_shell_script_to_file(shell_script=program)
-        return None
     else:
         raise NotImplementedError(f"Platform {platform.system()} not implemented.")
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".sh" if platform.system() != "Windows" else ".ps1", delete=False, encoding='utf-8') as temp_file:
+        temp_file.write(program)
+        temp_script_path = PathExtended(temp_file.name)
+    console.print(Panel(f"🚀 Launching repo inspection tool...\n\n[blue]{temp_script_path}[/blue]", border_style="blue"))

machineconfig/utils/code.py

@@ -1,95 +1,18 @@
+
 import atexit
-import platform
+# 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 +24,32 @@ 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_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[str, Path]:
+    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    if uv_with is not None and len(uv_with) > 0:
+        uv_with.append("rich")
+        uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
+    else:
+        uv_with_arg = "--with rich"
+    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.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
+    shell_script = f"""uv run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    return shell_script, python_file
+
+
 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 +59,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 +86,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

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

machineconfig/utils/ssh.py

@@ -1,11 +1,12 @@
 from typing import Callable, Optional, Any, Union
 import os
 from pathlib import Path
+import platform
 import rich.console
 from machineconfig.utils.terminal import Response, MACHINE
 from machineconfig.utils.accessories import pprint
 
-UV_RUN_CMD = "$HOME/.local/bin/uv run"
+UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
 MACHINECONFIG_VERSION = "machineconfig>=6.52"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
@@ -176,7 +177,6 @@ class SSH:
         res.output.returncode = os.system(command)
         return res
 
-
     def run_shell(self, command: str, verbose_output: bool, description: str, strict_stderr: bool, strict_return_code: bool) -> Response:
         raw = self.ssh.exec_command(command)
         res = Response(stdin=raw[0], stdout=raw[1], stderr=raw[2], cmd=command, desc=description)  # type: ignore
@@ -186,31 +186,30 @@ class SSH:
             res.capture().print_if_unsuccessful(desc=description, strict_err=strict_stderr, strict_returncode=strict_return_code, assert_success=False)
         self.terminal_responses.append(res)
         return res
-    def run_py(self, python_code: str, dependencies: list[str], venv_path: Optional[str],
+    def run_py(self, python_code: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
                description: str, verbose_output: bool, strict_stderr: bool, strict_return_code: bool) -> Response:
         from machineconfig.utils.accessories import randstr
-        cmd_path = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/runpy_{randstr()}.py")
-        cmd_path.parent.mkdir(parents=True, exist_ok=True)
-        cmd_path.write_text(python_code, encoding="utf-8")
-        self.copy_from_here(source_path=cmd_path, target_path=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
-        if len(dependencies) > 0:
-            with_clause = " --with " + '"', ",".join(dependencies) + '"'
+        py_path = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/runpy_{randstr()}.py")
+        py_path.parent.mkdir(parents=True, exist_ok=True)
+        py_path.write_text(python_code, encoding="utf-8")
+        self.copy_from_here(source_path=py_path, target_path=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
+        if uv_with is not None and len(uv_with) > 0:
+            with_clause = " --with " + '"' + ",".join(uv_with) + '"'
         else:
             with_clause = ""
-        uv_cmd = f"""{UV_RUN_CMD} {with_clause} python {cmd_path.relative_to(Path.home())}"""
-        if venv_path is not None:
-            if self.get_remote_machine() == "Windows":
-                venv_export = f"$env:VIRTUAL_ENV='{venv_path}';"
-                uv_cmd = venv_export + uv_cmd
-            else:
-                venv_export = f"VIRTUAL_ENV={venv_path}"
-                uv_cmd = venv_export + " " + uv_cmd
+        if uv_project_dir is not None:
+            with_clause += f" --project {uv_project_dir}"
+        else:
+            with_clause += ""
+        uv_cmd = f"""{UV_RUN_CMD} {with_clause} python {py_path.relative_to(Path.home())}"""
         return self.run_shell(command=uv_cmd, verbose_output=verbose_output, description=description or f"run_py on {self.get_remote_repr(add_machine=False)}", strict_stderr=strict_stderr, strict_return_code=strict_return_code)
 
-    def run_py_func(self, func: Callable[..., Any], dependencies: list[str], venv_path: Optional[str]) -> Response:
-        from machineconfig.utils.meta import function_to_script
-        command = function_to_script(func=func, call_with_kwargs={})
-        return self.run_py(python_code=command, dependencies=dependencies, venv_path=venv_path, description=f"run_py_func {func.__name__} on {self.get_remote_repr(add_machine=False)}", verbose_output=True, strict_stderr=True, strict_return_code=True)
+    def run_py_func(self, func: Callable[..., Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> Response:
+        from machineconfig.utils.meta import lambda_to_defstring
+        command = lambda_to_defstring(lmb=lambda: func, in_global=True)
+        return self.run_py(python_code=command, uv_with=uv_with, uv_project_dir=uv_project_dir,
+                           description=f"run_py_func {func.__name__} on {self.get_remote_repr(add_machine=False)}",
+                           verbose_output=True, strict_stderr=True, strict_return_code=True)
 
     def _simple_sftp_get(self, remote_path: str, local_path: Path) -> None:
         """Simple SFTP get without any recursion or path expansion - for internal use only."""
@@ -238,11 +237,14 @@ class SSH:
             json_result_path.write_text(json.dumps(result_path_posix, indent=2), encoding="utf-8")
             print(json_result_path.as_posix())
             return result_path_posix
-        from machineconfig.utils.meta import function_to_script
+        from machineconfig.utils.meta import lambda_to_defstring
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-        command = function_to_script(func=create_target_dir, call_with_kwargs={"target_dir_path": Path(target_path).as_posix(), "overwrite": overwrite_existing, "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Creating target directory `{Path(target_path).parent.as_posix()}` @ {self.get_remote_repr(add_machine=False)}", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        # command = function_to_script(func=create_target_dir, call_with_kwargs={"target_dir_path": Path(target_path).as_posix(), "overwrite": overwrite_existing, "json_output_path": remote_json_output})
+        command = lambda_to_defstring(lmb=lambda: create_target_dir(target_dir_path=str(target_path), overwrite=overwrite_existing, json_output_path=remote_json_output), in_global=True)
+        response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,
+                               description=f"Creating target directory `{Path(target_path).parent.as_posix()}` @ {self.get_remote_repr(add_machine=False)}",
+                               verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Failed to create target directory {target_path} - no response from remote")
@@ -323,11 +325,10 @@ class SSH:
                 with zipfile.ZipFile(archive_path, "r") as archive_handle:
                     archive_handle.extractall(extraction_directory)
                 archive_path.unlink()
-            from machineconfig.utils.meta import function_to_script
-            command = function_to_script(func=unzip_archive, call_with_kwargs={"zip_file_path": remotepath.as_posix(), "overwrite_flag": overwrite_existing})
-            _resp = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"UNZIPPING {remotepath.as_posix()}", verbose_output=False, strict_stderr=True, strict_return_code=True)
+            from machineconfig.utils.meta import lambda_to_defstring
+            command = lambda_to_defstring(lmb=lambda: unzip_archive(zip_file_path=remotepath.as_posix(), overwrite_flag=overwrite_existing), in_global=True)
+            _resp = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"UNZIPPING {remotepath.as_posix()}", verbose_output=False, strict_stderr=True, strict_return_code=True)
             source_obj.unlink()
-            print("\n")        
         return source_obj
 
     def _check_remote_is_dir(self, source_path: Union[str, Path]) -> bool:
@@ -342,11 +343,11 @@ class SSH:
             print(json_result_path.as_posix())
             return is_directory
         
-        from machineconfig.utils.meta import function_to_script
+        from machineconfig.utils.meta import lambda_to_defstring
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-        command = function_to_script(func=check_is_dir, call_with_kwargs={"path_to_check": str(source_path), "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Check if source `{source_path}` is a dir", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        command = lambda_to_defstring(lmb=lambda: check_is_dir(path_to_check=str(source_path), json_output_path=remote_json_output), in_global=True)
+        response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"Check if source `{source_path}` is a dir", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Failed to check if {source_path} is directory - no response from remote")
@@ -376,11 +377,11 @@ class SSH:
             print(json_result_path.as_posix())
             return expanded_path_posix
         
-        from machineconfig.utils.meta import function_to_script
+        from machineconfig.utils.meta import lambda_to_defstring
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-        command = function_to_script(func=expand_source, call_with_kwargs={"path_to_expand": str(source_path), "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Resolving source path by expanding user", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        command = lambda_to_defstring(lmb=lambda: expand_source(path_to_expand=str(source_path), json_output_path=remote_json_output), in_global=True)
+        response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Resolving source path by expanding user", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Could not resolve source path {source_path} - no response from remote")
@@ -425,11 +426,11 @@ class SSH:
                     print(json_result_path.as_posix())
                     return file_paths_list
                 
-                from machineconfig.utils.meta import function_to_script
+                from machineconfig.utils.meta import lambda_to_defstring
                 from machineconfig.utils.accessories import randstr
                 remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-                command = function_to_script(func=search_files, call_with_kwargs={"directory_path": expanded_source, "json_output_path": remote_json_output})
-                response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Searching for files in source", verbose_output=False, strict_stderr=False, strict_return_code=False)
+                command = lambda_to_defstring(lmb=lambda: search_files(directory_path=expanded_source, json_output_path=remote_json_output), in_global=True)
+                response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Searching for files in source", verbose_output=False, strict_stderr=False, strict_return_code=False)
                 remote_json_path = response.op.strip()
                 if not remote_json_path:
                     raise RuntimeError(f"Could not resolve source path {source} - no response from remote")
@@ -463,11 +464,11 @@ class SSH:
                         except ValueError:
                             raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
                     
-                    from machineconfig.utils.meta import function_to_script
+                    from machineconfig.utils.meta import lambda_to_defstring
                     from machineconfig.utils.accessories import randstr
                     remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-                    command = function_to_script(func=collapse_to_home_dir, call_with_kwargs={"absolute_path": expanded_source, "json_output_path": remote_json_output})
-                    response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
+                    command = lambda_to_defstring(lmb=lambda: collapse_to_home_dir(absolute_path=expanded_source, json_output_path=remote_json_output), in_global=True)
+                    response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
                     remote_json_path_dir = response.op.strip()
                     if not remote_json_path_dir:
                         raise RuntimeError("Could not resolve target path - no response from remote")
@@ -515,11 +516,11 @@ class SSH:
                 print(json_result_path.as_posix())
                 return zip_file_path
             
-            from machineconfig.utils.meta import function_to_script
+            from machineconfig.utils.meta import lambda_to_defstring
             from machineconfig.utils.accessories import randstr
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-            command = function_to_script(func=zip_source, call_with_kwargs={"path_to_zip": expanded_source, "json_output_path": remote_json_output})
-            response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Zipping source file {source}", verbose_output=False, strict_stderr=False, strict_return_code=False)
+            command = lambda_to_defstring(lmb=lambda: zip_source(path_to_zip=expanded_source, json_output_path=remote_json_output), in_global=True)
+            response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"Zipping source file {source}", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError(f"Could not zip {source} - no response from remote")
@@ -554,11 +555,11 @@ class SSH:
                 except ValueError:
                     raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
             
-            from machineconfig.utils.meta import function_to_script
+            from machineconfig.utils.meta import lambda_to_defstring
             from machineconfig.utils.accessories import randstr
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-            command = function_to_script(func=collapse_to_home, call_with_kwargs={"absolute_path": expanded_source, "json_output_path": remote_json_output})
-            response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
+            command = lambda_to_defstring(lmb=lambda: collapse_to_home(absolute_path=expanded_source, json_output_path=remote_json_output), in_global=True)
+            response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError("Could not resolve target path - no response from remote")
@@ -612,9 +613,9 @@ class SSH:
                     else:
                         file_or_dir_path.unlink()
             
-            from machineconfig.utils.meta import function_to_script
-            command = function_to_script(func=delete_temp_zip, call_with_kwargs={"path_to_delete": expanded_source})
-            self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Cleaning temp zip files @ remote.", verbose_output=False, strict_stderr=True, strict_return_code=True)
+            from machineconfig.utils.meta import lambda_to_defstring
+            command = lambda_to_defstring(lmb=lambda: delete_temp_zip(path_to_delete=expanded_source), in_global=True)
+            self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Cleaning temp zip files @ remote.", verbose_output=False, strict_stderr=True, strict_return_code=True)
         
         print("\n")
         return target_obj

{machineconfig-6.52.dist-info → machineconfig-6.54.dist-info}/METADATA

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

{machineconfig-6.52.dist-info → machineconfig-6.54.dist-info}/RECORD

@@ -25,7 +25,7 @@ machineconfig/cluster/sessions_managers/zellij_remote_manager.py,sha256=xzih0y8_
 machineconfig/cluster/sessions_managers/helpers/enhanced_command_runner.py,sha256=3vcQVg-HHa_WTxBGPtKMAdoSqJVa2EO5KAtrY8a6I3c,5264
 machineconfig/cluster/sessions_managers/helpers/load_balancer_helper.py,sha256=i5TRittC1IWTgMZNyG8AR5qq-3WrGp3xgIx2m5ktT7g,7526
 machineconfig/cluster/sessions_managers/utils/load_balancer.py,sha256=Y4RQmhROY6o7JXSJXRrBTkoAuEmu1gvmvN_7JKPw5sc,3178
-machineconfig/cluster/sessions_managers/utils/maker.py,sha256=kUJLOctqRR_jumdDIssxBI65pBhBEHxDOOq_RohnoeU,2133
+machineconfig/cluster/sessions_managers/utils/maker.py,sha256=GPt1A17LcU7hsrG_OHoy8jmD3HTrzJR5rPFAa70xn60,2102
 machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py,sha256=OA50j16uUS9ZTjL38TLuR3jufIOln_EszMZpbWyejTo,6972
 machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py,sha256=Mitm7mKiKl5lT0OiEUHAqVg2Q21RjsKO1-hpJTHJ5lM,15196
 machineconfig/cluster/sessions_managers/wt_utils/remote_executor.py,sha256=lApUy67_WhfaBXqt0meZSx_QvwiXjN0YLdyE3c7kP_s,6744
@@ -186,7 +186,7 @@ machineconfig/scripts/python/helpers_devops/cli_repos.py,sha256=Xwkv1adqHZvTfRSP
 machineconfig/scripts/python/helpers_devops/cli_self.py,sha256=-IyJpuw8Wnttls8y2vcNNkxtI9jUveROMPT-eudOoC4,6171
 machineconfig/scripts/python/helpers_devops/cli_share_server.py,sha256=q9pFJ6AxPuygMr3onMNOKEuuQHbVE_6Qoyo7xRT5FX0,4196
 machineconfig/scripts/python/helpers_devops/cli_terminal.py,sha256=k_PzXaiGyE0vXr0Ii1XcJz2A7UvyPJrR31TRWt4RKRI,6019
-machineconfig/scripts/python/helpers_devops/cli_utils.py,sha256=G2RHnOvNfEWjxETZjXVu688xyLL-c0Zq22p24kXLLQ8,3487
+machineconfig/scripts/python/helpers_devops/cli_utils.py,sha256=FcvC_795dKxZQM7hL4uRzmhysKi9YV-v9qu2Gb_Fun8,5622
 machineconfig/scripts/python/helpers_devops/devops_backup_retrieve.py,sha256=Dn8luB6QJzxKiiFSC-NMqiYddWZoca3A8eOjMYZDzTc,5598
 machineconfig/scripts/python/helpers_devops/devops_status.py,sha256=PJVPhfhXq8der6Xd-_fjZfnizfM-RGfJApkRGhGBmNo,20525
 machineconfig/scripts/python/helpers_devops/devops_update_repos.py,sha256=kSln8_-Wn7Qu0NaKdt-QTN_bBVyTIAWHH8xVYKK-vCM,10133
@@ -222,14 +222,14 @@ machineconfig/scripts/python/helpers_navigator/main_app.py,sha256=R1vOBMUKaiFHOg
 machineconfig/scripts/python/helpers_navigator/search_bar.py,sha256=kDi8Jhxap8wdm7YpDBtfhwcPnSqDPFrV2LqbcSBWMT4,414
 machineconfig/scripts/python/helpers_repos/action.py,sha256=9AxWy8mB9HFeV5t11-qD_l-KA5jkUmm0pXVKT1L6-Qk,14894
 machineconfig/scripts/python/helpers_repos/clone.py,sha256=UULEG5xJuXlPGU0nqXH6U45jA9DOFqLw8B4iPytCwOQ,5471
-machineconfig/scripts/python/helpers_repos/cloud_repo_sync.py,sha256=fLWZN1ZRlfFvKQHBLyFNHayYZAYQTZqBerRcpb7XBII,10412
+machineconfig/scripts/python/helpers_repos/cloud_repo_sync.py,sha256=Ewl-flfosUO3jL23ixKcysKjR149ySlNe22W_2osmPA,10432
 machineconfig/scripts/python/helpers_repos/count_lines.py,sha256=Q5c7b-DxvTlQmljoic7niTuiAVyFlwYvkVQ7uRJHiTo,16009
 machineconfig/scripts/python/helpers_repos/count_lines_frontend.py,sha256=epbXDwuXe_9jXaX3KA2JlG1sPXybdGq1NX4dRljHpF8,607
 machineconfig/scripts/python/helpers_repos/entrypoint.py,sha256=WYEFGUJp9HWImlFjbs_hiFZrUqM_KEYm5VvSUjWd04I,2810
 machineconfig/scripts/python/helpers_repos/grource.py,sha256=oJj1-gqlkV3Z_BrIOXRmtzoXcuBl0xTYfulJ5D0srOc,14656
 machineconfig/scripts/python/helpers_repos/record.py,sha256=FQo0swuJZOp0I2XGK-t1OQU4zJHmQ2z9zTpDD30Tmg4,11001
 machineconfig/scripts/python/helpers_repos/secure_repo.py,sha256=fW_GyHqWrpnf7nexHojfWHv4eLBa71IhVL_LSVMyGnE,1115
-machineconfig/scripts/python/helpers_repos/sync.py,sha256=CLLWy2n2gY9beXPF-mblOQ6R7cKoenkJjMiX7tHQsBk,3091
+machineconfig/scripts/python/helpers_repos/sync.py,sha256=P0P7Dog2uFDvwxcLP3YHPwm6AtvCm6QOz1BLqw53xOo,3259
 machineconfig/scripts/python/helpers_repos/update.py,sha256=cUIMUMm-50HrY6fzxSMZnFplhToVjVPZMm1j_otTha4,11060
 machineconfig/scripts/python/helpers_sessions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 machineconfig/scripts/python/helpers_sessions/sessions_multiprocess.py,sha256=zLssrCT3WRReiK0AFwctELN_o_svKypagUwJj0nT6i4,3122
@@ -390,20 +390,20 @@ machineconfig/setup_windows/wt_and_pwsh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 machineconfig/setup_windows/wt_and_pwsh/set_wt_settings.py,sha256=ogxJnwpdcpH7N6dFJu95UCNoGYirZKQho_3X0F_hmXs,6791
 machineconfig/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 machineconfig/utils/accessories.py,sha256=W_9dLzjwNTW5JQk_pe3B2ijQ1nA2-8Kdg2r7VBtzgQs,4340
-machineconfig/utils/code.py,sha256=W0JFDF1ynJJIYtrAP6IqCcmrhvS-_zyDz43etnWW7_4,7543
-machineconfig/utils/installer.py,sha256=afQgxDGsiS6HM0UQzQ85cPT4EcoXX2H0QOH5mQ18wtM,10391
+machineconfig/utils/code.py,sha256=jf9RbO0daBkUUuj6jyoTY-0judpBZ4Wfp7i8PZoxzuY,5344
+machineconfig/utils/installer.py,sha256=UzI_DtTcKbgvkAkWkNLAPUtx-RVqITHCpvZyLiCpD9g,10377
 machineconfig/utils/io.py,sha256=4dSieoqZO8Vvi4vW8lLoITDHBvmFp4dtl3kyeZHQ6Co,2528
 machineconfig/utils/links.py,sha256=KM6vIn3hag9FYEzLSHP5MAM9tU_RStw2mCq2_OvmmZA,23672
-machineconfig/utils/meta.py,sha256=r557UPqgNLXzQpk8Umeujj9RnRBeIz3RwOwjZ7hWsw0,17309
+machineconfig/utils/meta.py,sha256=-ki5JxPZoPhg5omM2YChUNExNx5mOoX-a2w0rx51NBE,7453
 machineconfig/utils/notifications.py,sha256=tuXIudcip0tEioG-bm8BbLr3FMDve4f6BktlznBhKxM,9013
 machineconfig/utils/options.py,sha256=vUO4Kej-vDOv64wHr2HNDyu6PATURpjd7xp6N8OOoJg,7083
 machineconfig/utils/path_extended.py,sha256=WyJwoHnXdvSQQJ-yrxTX78FpqYmgVeKDYpNEB9UsRck,53223
 machineconfig/utils/path_helper.py,sha256=0e3Xh3BAEv27oqcezNeVLHJllGmLEgLH4T1l90m-650,8014
 machineconfig/utils/procs.py,sha256=YPA_vEYQGwPd_o_Lc6nOTBo5BrB1tSs8PJ42XiGpenM,10957
 machineconfig/utils/scheduler.py,sha256=44CASABJg3epccxhAwv2CX7TVgZh6zVy3K4vqHKTuf4,14228
-machineconfig/utils/scheduling.py,sha256=RF1iXJpqf4Dg18jdZWtBixz97KAHC6VKYqTFSpdLWuc,11188
+machineconfig/utils/scheduling.py,sha256=6x5zLA7sY5gohrEtN6zGrXIqNFasMoyBfwLcOjrjiME,11109
 machineconfig/utils/source_of_truth.py,sha256=ZAnCRltiM07ig--P6g9_6nEAvNFC4X4ERFTVcvpIYsE,764
-machineconfig/utils/ssh.py,sha256=pBGZPmai5x_9zhIsmd66xiZvHZLDVUbeOn8pBZibKp4,39079
+machineconfig/utils/ssh.py,sha256=eRNatbyhxnMFSzzEEnbuORiVnQVUiAYVhVohIYuEu-Q,39310
 machineconfig/utils/terminal.py,sha256=IlmOByfQG-vjhaFFxxzU5rWzP5_qUzmalRfuey3PAmc,11801
 machineconfig/utils/tst.py,sha256=6u1GI49NdcpxH2BYGAusNfY5q9G_ytCGVzFM5b6HYpM,674
 machineconfig/utils/upgrade_packages.py,sha256=mSFyKvB3JhHte_x1dtmEgrJZCAXgTUQoaJUSx1OXQ3Y,4145
@@ -432,8 +432,8 @@ machineconfig/utils/schemas/installer/installer_types.py,sha256=QClRY61QaduBPJoS
 machineconfig/utils/schemas/layouts/layout_types.py,sha256=TcqlZdGVoH8htG5fHn1KWXhRdPueAcoyApppZsPAPto,2020
 machineconfig/utils/schemas/repos/repos_types.py,sha256=ECVr-3IVIo8yjmYmVXX2mnDDN1SLSwvQIhx4KDDQHBQ,405
 machineconfig/utils/ssh_utils/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-machineconfig-6.52.dist-info/METADATA,sha256=Utdnwcdeihed2hrfWbWheAB2vgB30EKxqNlPxUk6OSI,2928
-machineconfig-6.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-6.52.dist-info/entry_points.txt,sha256=M0jwN_brZdXWhmNVeXLvdKxfkv8WhhXFZYcuKBA9qnk,418
-machineconfig-6.52.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-6.52.dist-info/RECORD,,
+machineconfig-6.54.dist-info/METADATA,sha256=FhrF7ZV12PTSmzsuC6JizwhGhEvBC4r2zrzaX7fvheg,2928
+machineconfig-6.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machineconfig-6.54.dist-info/entry_points.txt,sha256=M0jwN_brZdXWhmNVeXLvdKxfkv8WhhXFZYcuKBA9qnk,418
+machineconfig-6.54.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
+machineconfig-6.54.dist-info/RECORD,,