machineconfig 8.12__py3-none-any.whl → 8.45__py3-none-any.whl

machineconfig/scripts/python/helpers/helpers_sessions/sessions_impl.py

@@ -0,0 +1,177 @@
+"""Pure Python implementations for sessions commands - no typer dependencies."""
+
+from typing import Optional, Literal
+from pathlib import Path
+
+
+def balance_load(
+    layout_path: str,
+    max_thresh: int,
+    thresh_type: Literal["number", "n", "weight", "w"],
+    breaking_method: Literal["moreLayouts", "ml", "combineTabs", "ct"],
+    output_path: Optional[str],
+) -> None:
+    """Adjust layout file to limit max tabs per layout, etc."""
+    thresh_type_resolved: dict[str, Literal["number", "weight"]] = {"number": "number", "n": "number", "weight": "weight", "w": "weight"}
+    breaking_method_resolved: dict[str, Literal["moreLayouts", "combineTabs"]] = {"moreLayouts": "moreLayouts", "ml": "moreLayouts", "combineTabs": "combineTabs", "ct": "combineTabs"}
+
+    layout_path_obj = Path(layout_path).expanduser().absolute()
+
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    import json
+    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
+    layout_configs = layoutfile["layouts"]
+    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
+    layoutfile["layouts"] = new_layouts
+    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f"{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json"
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    print(f"Adjusted layout saved to {target_file}")
+
+
+def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool, subsitute_home: bool) -> list["LayoutConfig"]:  # type: ignore[name-defined]
+    """Select layout(s) from a layout file."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, LayoutConfig
+    json_str = Path(layouts_json_file).read_text(encoding="utf-8")
+    if subsitute_home:
+        json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
+        json_str = json_str.replace("""Command": "f """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
+        json_str = json_str.replace("""Command": "s """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
+
+    layout_file: LayoutsFile = json.loads(json_str)
+    if len(layout_file["layouts"]) == 0:
+        raise ValueError(f"No layouts found in {layouts_json_file}")
+    if selected_layouts_names is None:
+        if not select_interactively:
+            return layout_file["layouts"]
+        options = [layout["layoutName"] for layout in layout_file["layouts"]]
+        from machineconfig.utils.options import choose_from_options
+        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
+    print(f"Selected layout(s): {selected_layouts_names}")
+    layouts_chosen: list[LayoutConfig] = []
+    for name in selected_layouts_names:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
+        if layout_chosen is None:
+            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        layouts_chosen.append(layout_chosen)
+    return layouts_chosen
+
+
+def find_layout_file(layout_path: str) -> str:
+    """Find layout file from a path."""
+    from machineconfig.utils.path_helper import search_for_files_of_interest, match_file_name, sanitize_path
+    from machineconfig.utils.options import choose_from_options
+    path_obj = sanitize_path(layout_path)
+    if not path_obj.exists():
+        choice_file = match_file_name(sub_string=layout_path, search_root=Path.cwd(), suffixes={".json"})
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj, suffixes={".py", ".sh", ".ps1"})
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
+        choice_file = Path(choice_file).expanduser().absolute()
+    else:
+        choice_file = path_obj
+    return str(choice_file)
+
+
+def run_layouts(
+    layout_path: Optional[str],
+    max_tabs: int,
+    max_layouts: int,
+    sleep_inbetween: float,
+    monitor: bool,
+    parallel: bool,
+    kill_upon_completion: bool,
+    choose: Optional[str],
+    choose_interactively: bool,
+    subsitute_home: bool,
+) -> None:
+    """Launch terminal sessions based on a layout configuration file."""
+    if layout_path is None:
+        raise ValueError("layout_path is required")
+
+    layout_path_resolved = find_layout_file(layout_path=layout_path)
+    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively, subsitute_home=subsitute_home)
+
+    if parallel and len(layouts_selected) > max_layouts:
+        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
+    for a_layout in layouts_selected:
+        if len(a_layout["layoutTabs"]) > max_tabs:
+            raise ValueError(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
+
+    import time
+    import platform
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+        if not parallel:
+            iterable = [[item] for item in layouts_selected]
+        else:
+            iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = ZellijLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:
+                time.sleep(sleep_inbetween)
+    elif platform.system() == "Windows":
+        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+        if not parallel:
+            iterable = [[item] for item in layouts_selected]
+        else:
+            iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = WTLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions()
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:
+                time.sleep(sleep_inbetween)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+
+
+def create_template(name: Optional[str], num_tabs: int) -> None:
+    """Create a layout template file."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig, LayoutConfig
+    tabs: list[TabConfig] = []
+    for i in range(1, num_tabs + 1):
+        tab: TabConfig = {
+            "tabName": f"Tab{i}",
+            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
+            "command": "bash",
+        }
+        tabs.append(tab)
+    layouts: list[LayoutConfig] = [
+        {
+            "layoutName": f"{Path.cwd().name}Layout",
+            "layoutTabs": tabs,
+        }
+    ]
+    file: LayoutsFile = {
+        "$schema": "https://bit.ly/cfglayout",  # type: ignore
+        "version": "0.1",
+        "layouts": layouts,
+    }
+    import json
+    json_string = json.dumps(file, indent=4)
+    if name is None:
+        layout_path = Path.cwd() / "layout.json"
+    else:
+        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
+    layout_path.parent.mkdir(parents=True, exist_ok=True)
+    if layout_path.exists():
+        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
+        return
+    layout_path.write_text(json_string, encoding="utf-8")
+    print(f"✅ Created layout template at {layout_path}")

machineconfig/scripts/python/{helpers_sessions → helpers/helpers_sessions}/sessions_multiprocess.py

@@ -45,7 +45,7 @@ def create_from_function(
 
     # =========================  choosing function to run
     if function is None or function.strip() == "":
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
         choice_function, choice_file, _kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict={})
     else:
         choice_function = function

machineconfig/scripts/python/helpers/helpers_terminal/terminal_impl.py

@@ -0,0 +1,96 @@
+import re
+import subprocess
+from pathlib import Path
+
+
+_ANSI_ESCAPE_RE = re.compile(
+    r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
+)
+
+
+def strip_ansi_codes(text: str) -> str:
+    return _ANSI_ESCAPE_RE.sub("", text)
+
+
+def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -> tuple[str, str | None]:
+    """Choose a Zellij session. Returns tuple of (action, script_to_run) where action is 'run_script', 'exit', or 'error'."""
+    if name is not None:
+        return ("run_script", f"zellij attach {name}")
+    if new_session:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    sessions = [s for s in sessions if s.strip()]
+    # print(f"Found Zellij sessions: {sessions}")
+    sessions.sort(key=lambda s: "EXITED" in s)
+    if "current" in sessions:
+        return ("error", "Already in a Zellij session, avoiding nesting and exiting.")
+    if len(sessions) == 0:
+        return ("run_script", "zellij --layout st2")
+    if len(sessions) == 1:
+        sn = strip_ansi_codes(sessions[0])
+        session_name = sn.split(" [Created")[0]
+        return ("run_script", f"zellij attach {session_name}")
+    from machineconfig.utils.options import choose_from_options
+    NEW_SESSION_LABEL = "NEW SESSION"
+    KILL_ALL_AND_NEW_LABEL = "KILL ALL SESSIONS & START NEW"
+    options = sessions + [NEW_SESSION_LABEL, KILL_ALL_AND_NEW_LABEL]
+    try:
+        session_name = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, tv=True)
+    except Exception as e:
+        return ("error", f"Error choosing Zellij session: {e}")
+    if session_name == NEW_SESSION_LABEL:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    if session_name == KILL_ALL_AND_NEW_LABEL:
+        return ("run_script", "zellij kill-all-sessions --yes\nzellij --layout st2")
+    session_name_clean = strip_ansi_codes(session_name)
+    session_name_clean = session_name_clean.split(" [Created")[0]
+    return ("run_script", f"zellij attach {session_name_clean}")
+
+
+def get_session_tabs() -> list[tuple[str, str]]:
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    sessions = [strip_ansi_codes(s) for s in sessions]
+    active_sessions = [s for s in sessions if "EXITED" not in s]
+    result: list[tuple[str, str]] = []
+    for session_line in active_sessions:
+        session_name = session_line.split(" [Created")[0].strip()
+        tab_cmd = f"zellij  --session {session_name} action query-tab-names"
+        try:
+            tabs: list[str] = subprocess.check_output(tab_cmd, shell=True).decode().strip().split("\n")
+            for tab in tabs:
+                if tab.strip():
+                    result.append((session_name, tab.strip()))
+        except subprocess.CalledProcessError:
+            continue
+    return result
+
+
+def start_wt(layout_name: str) -> tuple[str, str | None]:
+    """Start a Windows Terminal layout by name. Returns tuple of (status, message) where status is 'success' or 'error'."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+    layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
+    if not layouts_file.exists():
+        return ("error", f"❌ Layouts file not found: {layouts_file}")
+    layouts_data: LayoutsFile = json.loads(layouts_file.read_text(encoding="utf-8"))
+    chosen_layout = next((a_layout for a_layout in layouts_data["layouts"] if a_layout["layoutName"] == layout_name), None)
+    if not chosen_layout:
+        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
+        return ("error", f"❌ Layout '{layout_name}' not found in layouts file.\nAvailable layouts: {', '.join(available_layouts)}")
+    run_wt_layout(layout_config=chosen_layout)
+    return ("success", None)

machineconfig/scripts/python/{helpers_utils → helpers/helpers_utils}/download.py

@@ -22,7 +22,7 @@ def download(
     if output is not None and output_dir is not None:
         typer.echo("❌ Error: --output and --output-dir cannot be used together.", err=True)
         return None
-    typer.echo(f"📥 Downloading from: {url}")
+    typer.echo(f"    {url}")
 
     def _sanitize_candidate_filename(name: str) -> Optional[str]:
         candidate = Path(name).name.strip()

machineconfig/scripts/python/{helpers_utils → helpers/helpers_utils}/python.py

@@ -1,11 +1,10 @@
-from tempfile import tempdir
 import typer
 from typing import Optional, Annotated, Literal, TypedDict, cast
 
 
 def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
     """📚 NAVIGATE PATH variable with TUI"""
-    from machineconfig.scripts.python import env_manager as navigator
+    from machineconfig.scripts.python.helpers import helper_env as navigator
     from pathlib import Path
 
     match which:
@@ -18,7 +17,7 @@ def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(he
     uv_with = ["textual"]
     uv_project_dir = None
     if not Path.home().joinpath("code/machineconfig").exists():
-        uv_with.append("machineconfig>=8.12")
+        uv_with.append("machineconfig>=8.45")
     else:
         uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
     run_shell_script(
@@ -37,7 +36,7 @@ def init_project(
     ] = None,
     group: Annotated[
         Optional[str], typer.Option("--group", "-g", help="group of packages names (no separation) p:plot, t:types, l:linting, i:interactive, d:data")
-    ] = "ptlid",
+    ] = "p,t,l,i,d",
 ) -> None:
     if libraries is not None:
         packages_add_line = f"uv add {libraries}"
@@ -51,7 +50,9 @@ def init_project(
             typer.echo(f"❌ Error: pyproject.toml not found in {repo_root}", err=True)
             raise typer.Exit(code=1)
         starting_code = ""
+        agents_line = ""
     else:
+        agents_line = """agents make-config"""
         if name is not None:
             from machineconfig.utils.accessories import randstr
 
@@ -68,36 +69,49 @@ uv init --python {python}
 uv venv
 """
     print(f"Adding group `{group}` with common data science and plotting packages...")
-    total_packages: list[str] = []
+    total_packages: dict[str, list[str]] = {}
     if group is not None:
-        if "t" in group:
-            total_packages.append(
-                "types-python-dateutil types-pyyaml types-requests types-tqdm types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3"
-            )
-        if "l" in group:
-            total_packages.append("mypy pyright ruff pylint pyrefly cleanpy ipdb pudb")
-        if "i" in group:
-            total_packages.append("ipython ipykernel jupyterlab nbformat marimo")
-        if "p" in group:
-            total_packages.append("python-magic matplotlib plotly kaleido")
-        if "d" in group:
-            total_packages.append("numpy pandas polars duckdb-engine sqlalchemy  psycopg2-binary pyarrow tqdm openpyxl")
+        packages = group.split(",")
+        if "t" in packages or "types" in packages:
+            total_packages["types"] = [
+                "types-python-dateutil",
+                "types-pyyaml",
+                "types-requests",
+                "types-tqdm",
+                "types-mysqlclient",
+                "types-paramiko",
+                "types-pytz",
+                "types-sqlalchemy",
+                "types-toml",
+                "types-urllib3",
+            ]
+        if "l" in packages:
+            total_packages["linting"] = ["mypy", "pyright", "ruff", "pylint", "pyrefly", "cleanpy", "ipdb", "pudb"]
+        if "i" in packages:
+            total_packages["interactive"] = ["ipython", "ipykernel", "jupyterlab", "nbformat", "marimo"]
+        if "p" in packages:
+            total_packages["plot"] = ["python-magic", "matplotlib", "plotly", "kaleido"]
+        if "d" in packages:
+            total_packages["data"] = ["numpy", "pandas", "polars", "duckdb-engine", "sqlalchemy", "psycopg2-binary", "pyarrow", "tqdm", "openpyxl"]
     from machineconfig.utils.ve import get_ve_activate_line
-
+    groups_packages_lines = "\n".join(
+        [f"uv add --group {group_name} {' '.join(packages)}" for group_name, packages in total_packages.items()]
+    )   
     script = f"""
 {starting_code}
 {packages_add_line}
-uv add --group {group} {" ".join(total_packages)}
+{groups_packages_lines}
 {get_ve_activate_line(ve_root=str(repo_root.joinpath(".venv")))}
+{agents_line}
 ls
 """
     from machineconfig.utils.code import exit_then_run_shell_script, run_shell_script
-    # exit_then_run_shell_script(script)
-    _ = exit_then_run_shell_script
-    run_shell_script(script)
-    if tempdir:
-        from machineconfig.scripts.python.ai.initai import add_ai_configs
-        add_ai_configs(repo_root=repo_root)
+    exit_then_run_shell_script(script)
+    _ = exit_then_run_shell_script, run_shell_script
+    # run_shell_script(script)
+    # if tempdir:
+    #     from machineconfig.scripts.python.ai.initai import add_ai_configs
+    #     add_ai_configs(repo_root=repo_root)
 
 
 def edit_file_with_hx(
@@ -144,13 +158,19 @@ class MachineSpecs(TypedDict):
     user: str
 
 
-def get_machine_specs() -> MachineSpecs:
+def get_machine_specs(hardware: Annotated[bool, typer.Option(..., "--hardware", "-h", help="Show compute capability")] = False) -> MachineSpecs:
     """Write print and return the local machine specs."""
+    if hardware:
+        from machineconfig.scripts.python.helpers.helpers_utils.specs import main
+        main()
+        import sys
+        sys.exit()
+
     import platform
-    from machineconfig.utils.code import get_uv_run_command
+    from machineconfig.utils.code import get_uv_command
 
-    uv_run_cmd = get_uv_run_command(platform=platform.system())  # type: ignore
-    command = f"""{uv_run_cmd} --with distro python -c "import distro; print(distro.name(pretty=True))" """
+    uv_cmd = get_uv_command(platform=platform.system())  # type: ignore
+    command = f"""{uv_cmd} run --with distro python -c "import distro; print(distro.name(pretty=True))" """
     import subprocess
     from pathlib import Path
     import socket