machineconfig 6.52__tar.gz → 6.54__tar.gz

{machineconfig-6.52/src/machineconfig.egg-info → machineconfig-6.54}/PKG-INFO

@@ -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 → machineconfig-6.54}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "6.52"
+version = "6.54"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -99,6 +99,7 @@ dev = [
     "pre-commit>=4.3.0",
     "pudb>=2025.1",
     "pylint>=3.3.8",
+    "pypdf>=6.1.1",
     "pyrefly>=0.33.1",
     "pyright>=1.1.405",
     "pytest>=8.4.2",

{machineconfig-6.52 → machineconfig-6.54}/src/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-6.52 → machineconfig-6.54}/src/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-6.52 → machineconfig-6.54}/src/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-6.52 → machineconfig-6.54}/src/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-6.52 → machineconfig-6.54}/src/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-6.52 → machineconfig-6.54}/src/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-6.54/src/machineconfig/utils/meta.py

@@ -0,0 +1,188 @@
+"""Metaprogramming utilities for analyzing and serializing Python functions."""
+
+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
+    by the *actual* values (repr) taken from the lambda's globals.
+
+    All imports are local to this function.
+    
+    Args:
+        lmb: A lambda function with no arguments
+        in_global: If True, return kwargs as global variable assignments followed by dedented body.
+                   If False (default), return the full function definition with updated defaults.
+    """
+    # local imports
+    import inspect as _inspect
+    import ast as _ast
+    import textwrap as _textwrap
+    import types as _types
+
+    # sanity checks
+    if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
+        raise TypeError("Expected a lambda function object")
+
+    src = _inspect.getsource(lmb)
+    src = _textwrap.dedent(src)
+    tree = _ast.parse(src)
+
+    # find first Lambda node
+    lambda_node = None
+    for n in _ast.walk(tree):
+        if isinstance(n, _ast.Lambda):
+            lambda_node = n
+            break
+    if lambda_node is None:
+        raise ValueError("Could not find a lambda expression in source")
+
+    body = lambda_node.body
+    if not isinstance(body, _ast.Call):
+        raise ValueError("Lambda body is not a call expression")
+
+    globals_dict = getattr(lmb, "__globals__", {})
+    
+    # Also capture closure variables from the lambda
+    closure_dict: dict[str, Any] = {}
+    if lmb.__closure__:
+        code_obj = lmb.__code__
+        freevars = code_obj.co_freevars
+        for i, var_name in enumerate(freevars):
+            closure_dict[var_name] = lmb.__closure__[i].cell_contents
+    
+    # Merge globals and closures (closures take precedence for shadowing)
+    eval_namespace = {**globals_dict, **closure_dict}
+
+    # resolve the function object being called
+    try:
+        func_ref_src = _ast.unparse(body.func)
+    except AttributeError:
+        func_ref_src = _ast.get_source_segment(src, body.func) or ""
+    try:
+        func_obj = eval(func_ref_src, eval_namespace)
+    except Exception as e:
+        raise RuntimeError(f"Could not resolve function reference '{func_ref_src}': {e}")
+
+    if not callable(func_obj):
+        raise TypeError("Resolved object is not callable")
+
+    func_name = getattr(func_obj, "__name__", "<unknown>")
+
+    # Evaluate each keyword argument value in the lambda's globals to get real Python objects
+    call_kwargs = {}
+    for kw in body.keywords:
+        if kw.arg is None:
+            # **kwargs in call — evaluate to dict and merge
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                if isinstance(val, dict):
+                    call_kwargs.update(val)
+                else:
+                    raise ValueError("Keyword expansion did not evaluate to a dict")
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate **kwargs expression: {e}")
+        else:
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                call_kwargs[kw.arg] = val
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate value for kw '{kw.arg}': {e}")
+
+    # Try to get original source and dedent it for body extraction
+    try:
+        orig_src = _inspect.getsource(func_obj)
+        ded = _textwrap.dedent(orig_src)
+        lines = ded.splitlines()
+        # find the line that starts with def <name>(
+        def_index = None
+        for i, ln in enumerate(lines):
+            if ln.lstrip().startswith(f"def {func_name}("):
+                def_index = i
+                break
+        if def_index is None:
+            body_lines = ded.splitlines()
+        else:
+            body_lines = lines[def_index + 1 :]
+        # ensure we have a body, otherwise use pass
+        if not any(line.strip() for line in body_lines):
+            body_text = "    pass\n"
+        else:
+            # keep the dedented body lines exactly as-is (they should be indented)
+            body_text = "\n".join(body_lines) + ("\n" if not body_lines[-1].endswith("\n") else "")
+    except (OSError, IOError, TypeError):
+        body_text = "    pass\n"
+
+    # Build a replaced signature using inspect.signature
+    sig = _inspect.signature(func_obj)
+    new_params = []
+    for name, param in sig.parameters.items():
+        # If the call provided a value for this parameter, replace default
+        if name in call_kwargs:
+            new_default = call_kwargs[name]
+        else:
+            new_default = param.default
+
+        # Recreate the Parameter (keeping annotation and kind)
+        if new_default is _inspect.Parameter.empty:
+            new_param = _inspect.Parameter(name, param.kind, annotation=param.annotation)
+        else:
+            new_param = _inspect.Parameter(
+                name, param.kind, default=new_default, annotation=param.annotation
+            )
+        new_params.append(new_param)
+
+    new_sig = _inspect.Signature(parameters=new_params, return_annotation=sig.return_annotation)
+
+    # If in_global mode, return kwargs as global assignments + dedented body
+    if in_global:
+        global_assignments: list[str] = []
+        for name, param in sig.parameters.items():
+            # Get the value from call_kwargs if provided, else use original default
+            if name in call_kwargs:
+                value = call_kwargs[name]
+            elif param.default is not _inspect.Parameter.empty:
+                value = param.default
+            else:
+                # No value provided and no default - skip this parameter
+                continue
+            
+            # Build type annotation string if available
+            if param.annotation is not _inspect.Parameter.empty:
+                # Try to get a nice string representation of the annotation
+                try:
+                    if hasattr(param.annotation, "__name__"):
+                        type_str = param.annotation.__name__
+                    else:
+                        type_str = str(param.annotation)
+                except Exception:
+                    type_str = str(param.annotation)
+                global_assignments.append(f"{name}: {type_str} = {repr(value)}")
+            else:
+                global_assignments.append(f"{name} = {repr(value)}")
+        
+        # Dedent the body text to remove function indentation
+        dedented_body = _textwrap.dedent(body_text).rstrip()
+        
+        # Combine global assignments and body
+        if global_assignments:
+            result_parts = ["\n".join(global_assignments), "", dedented_body]
+            return "\n".join(result_parts)
+        else:
+            return dedented_body
+
+    # Compose final function definition text
+    header = f"def {func_name}{new_sig}:\n"
+    final_src = header + body_text
+    return final_src
+
+
+if __name__ == "__main__":
+    pass

{machineconfig-6.52 → machineconfig-6.54}/src/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