machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/__init__.py

@@ -1,29 +1 @@
-from __future__ import annotations
 
-from importlib.metadata import PackageNotFoundError, version as _pkg_version
-from pathlib import Path
-import tomllib
-
-
-def _get_version() -> str:
-    name: str = "machineconfig"
-    try:
-        return _pkg_version(name)
-    except PackageNotFoundError:
-        pass
-
-    root: Path = Path(__file__).resolve().parents[2]
-    pyproject: Path = root / "pyproject.toml"
-    if pyproject.is_file():
-        with pyproject.open("rb") as f:
-            data: dict[str, object] = tomllib.load(f)
-        project = data.get("project")
-        if isinstance(project, dict):
-            version = project.get("version")
-            if isinstance(version, str) and version:
-                return version
-    return "0.0.0"
-
-
-__version__: str = _get_version()
-__all__: list[str] = ["__version__"]

machineconfig/cluster/remote/cloud_manager.py

@@ -243,7 +243,7 @@
 #         The reason it is not automated for remotes is because even though the server might have failed, the processes therein might be running, so there is no automated way to tell."""
 #         log = self.read_log()
 #         jobs_all: list[str] = [p.name for p in self.base_path.expanduser().joinpath("jobs").iterdir()]
-#         jobs_selected = choose_from_options(options=jobs_all, msg="Select Jobs to Redo", multi=True, fzf=True)
+#         jobs_selected = choose_from_options(options=jobs_all, msg="Select Jobs to Redo", multi=True, tv=True)
 #         for a_job in jobs_selected:
 #             # find in which log list does this job live:
 #             found_log_type = None

machineconfig/cluster/remote/distribute.py

@@ -7,7 +7,6 @@
 # from math import ceil, floor
 # from enum import Enum
 # from dataclasses import dataclass
-# import psutil
 
 # from machineconfig.utils.utils2 import randstr
 # from machineconfig.utils.io_save import save_pickle

machineconfig/cluster/remote/file_manager.py

@@ -85,7 +85,6 @@
 #                 self.execution_log_dir.expanduser().joinpath("status.txt").write_text(status)
 #                 return status
 #             pid: int = int(pid_path.read_text(encoding="utf-8").rstrip())
-#             import psutil
 #             try: proc = psutil.Process(pid=pid)
 #             except psutil.NoSuchProcess:
 #                 print(f"Something wrong happened to job `{self.job_id}`.. Its status log file says `{status}`, but its declared `{pid=}` is dead. Moving to failed.")
@@ -142,7 +141,6 @@
 #                 break
 
 #             # --------------- Clearning up queue_file from dead processes -----------------
-#             import psutil
 #             next_job_in_queue = queue_file[0]  # only consider the first job in the queue
 #             try: _ = psutil.Process(next_job_in_queue.pid)
 #             except psutil.NoSuchProcess:

machineconfig/cluster/remote/script_execution.py

@@ -169,7 +169,6 @@
 # if params.session_name != "":
 #     if platform.system() in ["Linux", "Darwin"]:
 #         Terminal().run(f"""zellij --session {params.session_name} action new-tab --name results  """)
-#         # --layout ~/code/machineconfig/src/machineconfig/settings/zellij/layouts/d.kdl --cwd {res_folder.as_posix()}
 #         Terminal().run(f"""zellij --session {params.session_name} action write-chars "cd {res_folder.as_posix()};lf" """)
 #     elif platform.system() == "Windows":
 #         Terminal().run(f"""wt --window {params.session_name} new-tab --title results -startingDirectory {res_folder.as_posix()} lf """)

machineconfig/cluster/sessions_managers/{utils → helpers}/enhanced_command_runner.py

@@ -95,17 +95,15 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
     # Start new session (use -b for background to avoid hanging)
     start_cmd = f"zellij --layout {layout_path} a -b {session_name}"
     start_result = run_enhanced_command(
-        start_cmd,
-        f"Starting session '{session_name}' with layout",
-        False,
-        10,  # Add timeout to prevent hanging
+        command=start_cmd, description=f"Starting session '{session_name}' with layout", show_progress=False,
+        timeout=10,  # Add timeout to prevent hanging
     )
-
     if start_result["success"]:
         console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]", style="green", title="🎉 Success"))
     else:
         console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]", style="red", title="💥 Error"))
-
+    # print("Sleeping for 3 seconds to allow zellij to initialize...")
+    # time.sleep(3)  # Brief pause for readability
     return start_result
 
 

machineconfig/cluster/sessions_managers/utils/load_balancer.py

@@ -2,7 +2,7 @@
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 # from machineconfig.utils.accessories import split_list
 from typing import Literal, Protocol
-from machineconfig.cluster.sessions_managers.utils.load_balancer_helper import restrict_num_tabs_helper1, restrict_num_tabs_helper2, restrict_num_tabs_helper3, restrict_num_tabs_helper4
+from machineconfig.cluster.sessions_managers.helpers.load_balancer_helper import restrict_num_tabs_helper1, restrict_num_tabs_helper2, restrict_num_tabs_helper3, restrict_num_tabs_helper4
 
 class COMMAND_SPLITTER(Protocol):
     def __call__(self, command: str, to: int) -> list[str]: ...

machineconfig/cluster/sessions_managers/utils/maker.py

@@ -0,0 +1,69 @@
+
+from types import FunctionType
+from typing import Optional, Literal
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
+from pathlib import Path
+
+def get_fire_tab_using_uv(func: FunctionType, tab_weight: int, import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[TabConfig, Path]:
+    from machineconfig.utils.meta import lambda_to_python_script
+    if func.__name__ == "<lambda>":
+        py_script =  lambda_to_python_script(func,
+                                             in_global=True, import_module=import_module)
+    else:
+        py_script =  lambda_to_python_script(lambda: func(),
+                                             in_global=True, import_module=import_module)
+    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__,
+        "tabWeight": tab_weight
+    }
+    return tab_config, py_script_path
+def get_fire_tab_using_fire(func: FunctionType, tab_weight: int) -> TabConfig:
+    import inspect
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    import platform
+    if platform.system().lower() == "windows":
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg.ps1"
+        wrap_mcfg = f'& "{wrap_mcfg}"'
+    elif platform.system().lower() == "linux" or platform.system().lower() == "darwin":
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg"
+    else:
+        raise ValueError(f"Unsupported platform: {platform.system()}")
+    path = Path(inspect.getfile(func))
+    path_relative = path.relative_to(Path.home())
+    command_to_run = f"""{wrap_mcfg} fire {path_relative} {func.__name__} """
+    tab_config: TabConfig = {
+        "command": command_to_run,
+        "startDir": "$HOME",
+        "tabName": func.__name__,
+        "tabWeight": tab_weight
+    }
+    return tab_config
+
+
+
+def make_layout_from_functions(functions: list[FunctionType], functions_weights: Optional[list[int]], import_module: bool, tab_configs: list[TabConfig],
+                               layout_name: str, method: Literal["script", "fire"],
+                               uv_with: Optional[list[str]] = None, uv_project_dir: Optional[str] = None
+                               ) -> LayoutConfig:
+    tabs2artifacts: list[tuple[TabConfig, list[Path]]] = []
+    for a_func, tab_weight in zip(functions, functions_weights or [1]*len(functions)):
+        match method:
+            case "script":
+                tab_config, artifact_files_1 = get_fire_tab_using_uv(a_func, tab_weight=tab_weight, import_module=import_module,
+                                                                     uv_with=uv_with, uv_project_dir=uv_project_dir
+                                                                     )
+                artifact_files = [artifact_files_1]
+            case "fire":
+                tab_config = get_fire_tab_using_fire(a_func, tab_weight=tab_weight)
+                artifact_files = []
+        tabs2artifacts.append((tab_config, artifact_files))
+    list_of_tabs = [tab for tab, _ in tabs2artifacts] + tab_configs
+    layout_config: LayoutConfig = {
+        "layoutName": layout_name,
+        "layoutTabs": list_of_tabs,
+    }
+    return layout_config