machineconfig 3.99__py3-none-any.whl → 7.66__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/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

@@ -127,7 +127,7 @@
 # ⏱️  Total execution time: {delta}
 # 🔍 Error message: {params.error_message}
 # 📂 Results located at: {res_folder.collapseuser().as_posix()}
-# ═════════════════════════════════════════════════════════════════
+# ════════════════════════════════════════════════════════════════
 # """)
 
 # # Capture exec_times as string for the readme
@@ -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/{enhanced_command_runner.py → 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/helpers/load_balancer_helper.py

@@ -0,0 +1,145 @@
+from machineconfig.utils.accessories import split_list
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
+
+from typing import Literal
+
+
+def split_tabs_by_weight(tabs: list[TabConfig], max_weight: int) -> list[list[TabConfig]]:
+    """Split tabs into chunks where each chunk's total weight <= max_weight."""
+    chunks: list[list[TabConfig]] = []
+    current_chunk: list[TabConfig] = []
+    current_weight = 0
+    for tab in tabs:
+        tab_weight = tab.get("tabWeight", 1)
+        if current_weight + tab_weight > max_weight and current_chunk:
+            chunks.append(current_chunk)
+            current_chunk = [tab]
+            current_weight = tab_weight
+        else:
+            current_chunk.append(tab)
+            current_weight += tab_weight
+    
+    if current_chunk:
+        chunks.append(current_chunk)
+    
+    return chunks
+
+
+def combine_tabs_into_super_tabs(tabs: list[TabConfig], num_super_tabs: int) -> list[TabConfig]:
+    """Combine tabs into num_super_tabs super tabs with combined commands."""
+    if len(tabs) <= num_super_tabs:
+        return tabs  # No need to combine
+    
+    tab_groups = split_list(tabs, to=num_super_tabs)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            # Use startDir of the first tab
+            start_dir = group[0]["startDir"]
+            # Sum weights
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def combine_tabs_by_weight_into_super_tabs(tabs: list[TabConfig], max_weight: int) -> list[TabConfig]:
+    """Combine tabs into super tabs where each super tab has weight <= max_weight."""
+    tab_groups = split_tabs_by_weight(tabs, max_weight=max_weight)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            start_dir = group[0]["startDir"]
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def restrict_num_tabs_helper1(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh tabs each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        if len(a_layout_config["layoutTabs"]) > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({len(a_layout_config['layoutTabs'])} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_list(a_layout_config["layoutTabs"], every=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({len(a_layout_config['layoutTabs'])} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper2(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs to reduce count to max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        num_tabs = len(a_layout_config["layoutTabs"])
+        if num_tabs > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({num_tabs} > {max_thresh}). Combining into {max_thresh} super tabs.")
+            super_tabs = combine_tabs_into_super_tabs(a_layout_config["layoutTabs"], num_super_tabs=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({num_tabs} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper3(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh total weight each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_tabs_by_weight(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper4(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs with weight <= max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Combining into super tabs with weight <= {max_thresh}.")
+            super_tabs = combine_tabs_by_weight_into_super_tabs(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs

machineconfig/cluster/sessions_managers/utils/load_balancer.py

@@ -0,0 +1,53 @@
+
+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.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]: ...
+
+
+def limit_tab_num(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number", "weight"], breaking_method: Literal["moreLayouts", "combineTabs"]) -> list[LayoutConfig]:
+    match threshold_type, breaking_method:
+        case "number", "moreLayouts":
+            return restrict_num_tabs_helper1(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "number", "combineTabs":
+            return restrict_num_tabs_helper2(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "weight", "moreLayouts":
+            return restrict_num_tabs_helper3(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "weight", "combineTabs":
+            return restrict_num_tabs_helper4(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case _:
+            raise NotImplementedError(f"The combination {threshold_type}, {breaking_method} is not implemented")
+def limit_tab_weight(layout_configs: list[LayoutConfig], max_weight: int, command_splitter: COMMAND_SPLITTER) -> list[LayoutConfig]:
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        new_tabs: list[TabConfig] = []
+        for tab in a_layout_config["layoutTabs"]:
+            tab_weight = tab.get("tabWeight", 1)
+            if tab_weight > max_weight:
+                print(f"Tab '{tab['tabName']}' in layout '{a_layout_config['layoutName']}' has too much weight ({tab_weight} > {max_weight}). Splitting command.")
+                split_commands = command_splitter(tab["command"], to=max_weight)
+                for idx, cmd in enumerate(split_commands):
+                    new_tabs.append({
+                        "tabName": f"{tab['tabName']}_part{idx+1}",
+                        "startDir": tab["startDir"],
+                        "command": cmd,
+                        "tabWeight": max_weight
+                    })
+            else:
+                new_tabs.append(tab)
+        new_layout_configs.append({
+            "layoutName": a_layout_config["layoutName"],
+            "layoutTabs": new_tabs
+        })
+    return new_layout_configs
+
+
+def run(layouts: list[LayoutConfig]):
+    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+    manager = ZellijLocalManager(session_layouts=layouts)
+    manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+    manager.run_monitoring_routine(wait_ms=2000)
+    manager.kill_all_sessions()

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(lmb=func,
+                                             in_global=True, import_module=import_module)
+    else:
+        py_script =  lambda_to_python_script(lmb=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