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

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/record.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from machineconfig.utils.schemas.repos.repos_types import GitVersionInfo, RepoRecordDict, RepoRemote
 
 from machineconfig.utils.schemas.repos.repos_types import RepoRecordFile
-from machineconfig.utils.source_of_truth import CONFIG_ROOT
 from machineconfig.utils.io import save_json
 
 from typing import Optional
@@ -12,7 +11,7 @@ from rich import print as pprint
 from rich.progress import Progress, TaskID, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn, MofNCompleteColumn
 
 
-def build_tree_structure(repos: list[RepoRecordDict], repos_root: PathExtended) -> str:
+def build_tree_structure(repos: list[RepoRecordDict], repos_root: Path) -> str:
     """Build a tree structure representation of all repositories."""
     if not repos:
         return "No repositories found."
@@ -186,10 +185,18 @@ def record_repos_recursively(repos_root: str, r: bool, progress: Progress | None
     return res
 
 
-def main_record(repos_root: Path):
-    print("\n📝 Recording repositories...")
-    repos_root = PathExtended(repos_root).expanduser().absolute()
+def _resolve_directory(directory: Optional[str]) -> Path:
+    import typer
+    if directory is None:
+        directory = Path.cwd().as_posix()
+        typer.echo(f"📁 Using directory: {directory}")
+    return Path(directory).expanduser().absolute().resolve()
+
 
+def main_record(repos_root_str: Optional[str]) -> Path:
+    print("\n📝 Recording repositories...")
+    repos_root = _resolve_directory(directory=repos_root_str)
+    
     # Count total directories and repositories for accurate progress tracking
     print("🔍 Analyzing directory structure...")
     total_dirs = count_total_directories(str(repos_root), r=True)
@@ -222,7 +229,7 @@ def main_record(repos_root: Path):
     if repos_with_no_remotes:
         print(f"\n⚠️  WARNING: {len(repos_with_no_remotes)} repositories have no remotes configured:")
         for repo in repos_with_no_remotes:
-            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            repo_path = Path(repo["parentDir"]).joinpath(repo["name"])
             print(f"   • {repo['name']} ({repo_path})")
         print("   These repositories may be local-only or have configuration issues.")
     else:
@@ -231,7 +238,7 @@ def main_record(repos_root: Path):
     if dirty_repos:
         print(f"\n⚠️  WARNING: {len(dirty_repos)} repositories have uncommitted changes:")
         for repo in dirty_repos:
-            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            repo_path = Path(repo["parentDir"]).joinpath(repo["name"])
             print(f"   • {repo['name']} ({repo_path}) [branch: {repo['currentBranch']}]")
         print("   These repositories have uncommitted changes that may need attention.")
     else:
@@ -239,12 +246,25 @@ def main_record(repos_root: Path):
 
     # Display repository tree structure
     print("\n🌳 Repository Tree Structure:")
-    tree_structure = build_tree_structure(repo_records, repos_root)
+    tree_structure = build_tree_structure(repos=repo_records, repos_root=repos_root)
     print(tree_structure)
 
-    relative_repos_root = PathExtended(repos_root).expanduser().absolute().relative_to(Path.home())
-    save_path = CONFIG_ROOT.joinpath("repos").joinpath(relative_repos_root).joinpath("repos.json")
-    save_json(obj=res, path=save_path, indent=4)
-    pprint(f"📁 Result saved at {PathExtended(save_path)}")
+    spec_path_default = Path(repos_root).expanduser().absolute().joinpath("repos.json")
+    from machineconfig.scripts.python.helpers.helpers_devops.cli_config_dotfile import get_backup_path, record_mapping
+    spec_path_self_managed = get_backup_path(
+        orig_path=spec_path_default,
+        sensitivity="private",
+        destination=None,
+        shared=False,
+    )
+    save_json(obj=res, path=spec_path_self_managed, indent=4)
+    pprint(f"📁 Result saved at {PathExtended(spec_path_self_managed)}")
+
+    # record_mapping(
+    #     orig_path=spec_path_default,
+
+    # )
+    _ = record_mapping
+
     print(">>>>>>>>> Finished Recording")
-    return save_path
+    return spec_path_self_managed

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/repo_analyzer_2.py

@@ -1,13 +1,23 @@
 from git import Repo
-from machineconfig.scripts.python.helpers_repos.repo_analyzer_1 import count_python_lines, get_default_branch
+from machineconfig.scripts.python.helpers.helpers_repos.repo_analyzer_1 import count_python_lines, get_default_branch
 from datetime import datetime
 import polars as pl
 from pathlib import Path
-from typing import Any, Dict, List, Union, Optional
+from typing import cast, TypedDict
 
 
-def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exception]":
-    import polars as pl
+class FileDataRow(TypedDict):
+    filename: str
+    lines: int
+
+
+class CommitDataRow(TypedDict):
+    hash: str
+    dtmExit: datetime
+    lines: int
+
+
+def print_python_files_by_size_impl(repo_path: str) -> pl.DataFrame | Exception:
     import plotly.graph_objects as go
     import plotly.express as px
 
@@ -16,7 +26,7 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         if not os.path.exists(repo_path):
             return ValueError(f"Repository path does not exist: {repo_path}")
         # Initialize data storage
-        file_data: "List[Dict[str, Union[str, int]]]" = []
+        file_data: list[FileDataRow] = []
 
         # Walk through the repository
         for root, _, files in os.walk(repo_path):
@@ -66,7 +76,8 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         table.add_column("Lines", justify="right")
 
         for idx, row in enumerate(df.iter_rows(named=True), 1):
-            table.add_row(str(idx), row["filename"], f"{row['lines']:,}")
+            typed_row = cast(FileDataRow, row)
+            table.add_row(str(idx), typed_row["filename"], f"{typed_row['lines']:,}")
 
         console.print(table)
         print(f"\n📁 Total Python files: {file_count}")
@@ -118,7 +129,7 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         )
 
         # Define pie chart figure before conditionally using it
-        fig2: "Optional[go.Figure]" = None
+        fig2: go.Figure | None = None
 
         # Add pie chart showing distribution
         if len(df) > top_n:
@@ -175,14 +186,15 @@ def analyze_over_time(repo_path: str):
     repo: Repo = Repo(repo_path)
     branch_name: str = get_default_branch(repo)
     print(f"🔍 Using branch: {branch_name}")
-    commit_data: "List[Dict[str, Any]]" = []
+    commit_data: list[CommitDataRow] = []
     print("⏳ Analyzing commits...")
     try:
         commits = list(repo.iter_commits(branch_name))
         from datetime import timezone
         from rich.progress import track
         for commit in track(commits, description="Processing commits..."):
-            commit_data.append({"hash": commit.hexsha, "dtmExit": datetime.fromtimestamp(commit.committed_date, tz=timezone.utc), "lines": count_python_lines(commit)})
+            lines, _files = count_python_lines(commit)
+            commit_data.append({"hash": commit.hexsha, "dtmExit": datetime.fromtimestamp(commit.committed_date, tz=timezone.utc), "lines": lines})
     except Exception as e:
         print(f"❌ Error analyzing commits: {str(e)}")
         return
@@ -199,20 +211,50 @@ def analyze_over_time(repo_path: str):
     # Add markers for significant points (min, max, last)
     min_idx = df["lines"].arg_min()
     max_idx = df["lines"].arg_max()
-    min_point = df.slice(min_idx, 1).to_dicts()[0] if min_idx is not None else {}
-    max_point = df.slice(max_idx, 1).to_dicts()[0] if max_idx is not None else {}
-    last_point = df.slice(-1, 1).to_dicts()[0]
+    last_point = cast(CommitDataRow, df.slice(-1, 1).to_dicts()[0])
+    
+    marker_x: list[datetime] = []
+    marker_y: list[int] = []
+    marker_sizes: list[int] = []
+    marker_colors: list[str] = []
+    marker_symbols: list[str] = []
+    marker_texts: list[str] = []
+    
+    if min_idx is not None:
+        min_point = cast(CommitDataRow, df.slice(min_idx, 1).to_dicts()[0])
+        marker_x.append(min_point["dtmExit"])
+        marker_y.append(min_point["lines"])
+        marker_sizes.append(10)
+        marker_colors.append("#ff4f4f")
+        marker_symbols.append("circle")
+        marker_texts.append(f"🔽 Min: {min_point['lines']:,} lines")
+    
+    if max_idx is not None:
+        max_point = cast(CommitDataRow, df.slice(max_idx, 1).to_dicts()[0])
+        marker_x.append(max_point["dtmExit"])
+        marker_y.append(max_point["lines"])
+        marker_sizes.append(14)
+        marker_colors.append("#4fff4f")
+        marker_symbols.append("star")
+        marker_texts.append(f"🔼 Max: {max_point['lines']:,} lines")
+    
+    marker_x.append(last_point["dtmExit"])
+    marker_y.append(last_point["lines"])
+    marker_sizes.append(12)
+    marker_colors.append("#4f4fff")
+    marker_symbols.append("diamond")
+    marker_texts.append(f"📊 Current: {last_point['lines']:,} lines")
 
     # Add markers for significant points
     fig.add_trace(
         go.Scatter(
-            x=[min_point["dtmExit"], max_point["dtmExit"], last_point["dtmExit"]],
-            y=[min_point["lines"], max_point["lines"], last_point["lines"]],
+            x=marker_x,
+            y=marker_y,
             mode="markers",
-            marker={"size": [10, 14, 12], "color": ["#ff4f4f", "#4fff4f", "#4f4fff"], "line": {"width": 2, "color": "white"}, "symbol": ["circle", "star", "diamond"]},
+            marker={"size": marker_sizes, "color": marker_colors, "line": {"width": 2, "color": "white"}, "symbol": marker_symbols},
             name="Key Points",
             hovertemplate="<b>%{text}</b><br>Date: %{x}<br>Lines: %{y:,}<extra></extra>",
-            text=[f"🔽 Min: {min_point['lines']:,} lines", f"🔼 Max: {max_point['lines']:,} lines", f"📊 Current: {last_point['lines']:,} lines"],
+            text=marker_texts,
         )
     )
 
@@ -264,6 +306,8 @@ def analyze_over_time(repo_path: str):
     # Print statistics
     print("\n📊 Repository Statistics:")
     print(f"📚 Total commits analyzed: {len(df)}")
-    print(f"🔙 Initial line count: {df['lines'][-1]:,}")
-    print(f"🔜 Final line count: {df['lines'][0]:,}")
-    print(f"📈 Net change: {df['lines'][0] - df['lines'][-1]:,} lines")
+    initial_lines = int(df['lines'][-1])
+    final_lines = int(df['lines'][0])
+    print(f"🔙 Initial line count: {initial_lines:,}")
+    print(f"🔜 Final line count: {final_lines:,}")
+    print(f"📈 Net change: {final_lines - initial_lines:,} lines")

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/update.py

@@ -246,12 +246,6 @@ def update_repository(repo: git.Repo, auto_uv_sync: bool, allow_password_prompt:
                 result["permissions_updated"] = True
                 print(f"✅ Set permissions for {linux_jobs_path}")
 
-            lf_exe_path = repo_path / "src" / "machineconfig" / "settings" / "lf" / "linux" / "exe"
-            if lf_exe_path.exists():
-                set_permissions_recursive(lf_exe_path)
-                result["permissions_updated"] = True
-                print(f"✅ Set permissions for {lf_exe_path}")
-
         # Run uv sync if dependencies changed and auto_sync is enabled
         if result["dependencies_changed"] and auto_uv_sync:
             result["uv_sync_ran"] = True

machineconfig/scripts/python/helpers/helpers_search/script_help.py

@@ -0,0 +1,81 @@
+
+from typing import Literal
+
+
+def list_available_scripts(where: Literal["all", "a", "private", "p", "public", "b", "library", "l", "dynamic", "d", "custom", "c"]) -> None:
+    from pathlib import Path
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT, LIBRARY_ROOT, DEFAULTS_PATH
+
+    private_root = Path.home().joinpath("dotfiles/scripts")
+    public_root = CONFIG_ROOT.joinpath("scripts")
+    library_root = LIBRARY_ROOT.joinpath("jobs", "scripts")
+
+    def get_custom_roots() -> list[Path]:
+        custom_roots: list[Path] = []
+        if DEFAULTS_PATH.is_file():
+            from configparser import ConfigParser
+            config = ConfigParser()
+            config.read(DEFAULTS_PATH)
+            if config.has_section("general") and config.has_option("general", "scripts"):
+                custom_dirs = config.get("general", "scripts").split(",")
+                for custom_dir in custom_dirs:
+                    custom_path = Path(custom_dir.strip()).expanduser().resolve()
+                    if custom_path.is_dir():
+                        custom_roots.append(custom_path)
+        return custom_roots
+
+    locations: dict[str, Path | str] = {}
+    match where:
+        case "all" | "a":
+            locations = {"private": private_root, "public": public_root, "library": library_root}
+            for idx, custom in enumerate(get_custom_roots()): locations[f"custom_{idx}"] = custom
+            locations["dynamic"] = "https://github.com/thisismygitrepo/machineconfig/tree/main/src/machineconfig/jobs/scripts_dynamic"
+        case "private" | "p":
+            locations = {"private": private_root}
+        case "public" | "b":
+            locations = {"public": public_root}
+        case "library" | "l":
+            locations = {"library": library_root}
+        case "dynamic" | "d":
+            locations = {"dynamic": "https://github.com/thisismygitrepo/machineconfig/tree/main/src/machineconfig/jobs/scripts_dynamic"}
+        case "custom" | "c":
+            for idx, custom in enumerate(get_custom_roots()): locations[f"custom_{idx}"] = custom
+
+    def _print_files_by_type(files: list[str]) -> None:
+        categories: dict[str, list[str]] = {".py": [], ".sh": [], ".ps1": [], ".cmd": [], ".bat": [], "other": []}
+        for f in files:
+            ext = Path(f).suffix.lower() if "." in str(f) else ""
+            if ext in categories: categories[ext].append(str(f))
+            else: categories["other"].append(str(f))
+        for ext, cat_files in categories.items():
+            if cat_files:
+                label = ext if ext else "other"
+                print(f"    [{label}]")
+                for cf in sorted(cat_files): print(f"      • {cf}")
+
+    for loc_name, loc_path in locations.items():
+        print(f"\n📁 {loc_name.upper()} ({loc_path}):")
+        print("-" * 60)
+        if isinstance(loc_path, Path):
+            if loc_path.is_dir():
+                files = [f for f in loc_path.rglob("*") if f.is_file() and f.suffix in (".py", ".sh", ".ps1", ".bat", ".cmd", "")]
+                if files:
+                    relative_files = [str(f.relative_to(loc_path)) for f in files]
+                    _print_files_by_type(relative_files)
+                else:
+                    print("  (empty)")
+            else:
+                print("  ⚠️  Directory does not exist")
+        else:
+            api_url = "https://api.github.com/repos/thisismygitrepo/machineconfig/contents/src/machineconfig/jobs/scripts_dynamic"
+            try:
+                import requests
+                response = requests.get(api_url, timeout=10)
+                if response.status_code == 200:
+                    items = response.json()
+                    files = [item["name"] for item in items if item["type"] == "file"]
+                    _print_files_by_type(files)
+                else:
+                    print(f"  ⚠️  Could not fetch from GitHub (status: {response.status_code})")
+            except Exception as e:
+                print(f"  ⚠️  Could not fetch from GitHub: {e}")

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

@@ -0,0 +1,87 @@
+
+import subprocess
+from pathlib import Path
+from machineconfig.settings.zellij import layouts
+
+root = layouts.__path__[0]
+STANDARD = Path(root).joinpath("st2.kdl")
+# STANDARD = "st2.kdl"
+# a = 1 + "sd"
+
+def strip_ansi_codes(text: str) -> str:
+    import re
+    _ANSI_ESCAPE_RE = re.compile(
+        r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
+    )
+    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'."""
+    # from machineoncif
+
+    if name is not None:
+        return ("run_script", f"zellij attach {name}")
+    if new_session:
+        cmd = f"zellij --layout {STANDARD}"
+        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", f"zellij --layout {STANDARD}")
+    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 = f"zellij --layout {STANDARD}"
+        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", f"zellij kill-all-sessions --yes\nzellij --layout {STANDARD}")
+    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
+
+

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

@@ -0,0 +1,114 @@
+"""Pure Python implementations for sessions commands - no typer dependencies."""
+
+from typing import Literal
+from pathlib import Path
+
+
+def select_layout(layouts_json_file: str, selected_layouts_names: list[str], select_interactively: bool) -> list["LayoutConfig"]:
+    """Select layout(s) from a layout file."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    json_str = Path(layouts_json_file).read_text(encoding="utf-8")
+    try:
+        layout_file: LayoutsFile = json.loads(json_str)
+    except Exception:
+        print(f"Failed to parse the json file {layouts_json_file}, trying to clean the comments and giving it another shot ... ")
+        from machineconfig.utils.io import remove_c_style_comments
+        json_str = remove_c_style_comments(json_str)
+        layout_file: LayoutsFile = json.loads(json_str)
+    if len(layout_file["layouts"]) == 0:
+        raise ValueError(f"No layouts found in {layouts_json_file}")
+    if len(selected_layouts_names) == 0:
+        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")
+        from machineconfig.utils.options_utils.tv_options import choose_from_dict_with_preview
+        selected_layouts_names = choose_from_dict_with_preview(
+            {layout["layoutName"]: json.dumps(layout, indent=4) for layout in layout_file["layouts"]},
+            extension="json",
+            multi=True,
+            preview_size_percent=40,
+        )
+
+    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(
+    sleep_inbetween: float,
+    monitor: bool,
+    sequential: bool,
+    kill_upon_completion: bool,
+    backend: Literal["zellij", "windows-terminal"],
+    layouts_selected: list["LayoutConfig"],
+) -> None:
+    """Launch terminal sessions based on a layout configuration file."""
+    import time
+    match backend:
+        case "zellij":
+            from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+            if sequential:
+                iterable: list[list[LayoutConfig]] = [[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)
+        case "windows-terminal":
+            if sequential:
+                from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+                for a_layout in layouts_selected:
+                    run_wt_layout(layout_config=a_layout)
+                return
+            iterable = [layouts_selected]
+            from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+            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)
+        case _:
+            raise ValueError(f"Unsupported backend: {backend}")
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+    _ = LayoutConfig

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

@@ -15,7 +15,6 @@ def create_from_function(
     from machineconfig.utils.accessories import get_repo_root
     from pathlib import Path
 
-
     path_obj = sanitize_path(path)
     if not path_obj.exists():
         suffixes = {".py"}
@@ -46,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_sessions/utils.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+from typing import Literal, Optional
+
+
+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 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] = []
+    import platform
+    if platform.system().lower() == "windows":
+        default_command = "powershell"
+    else:
+        default_command = "bash"
+    for i in range(1, num_tabs + 1):
+        tab: TabConfig = {
+            "tabName": f"Tab{i}",
+            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
+            "command": default_command,
+        }
+        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_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_devops/cli_utils.py → helpers/helpers_utils/pdf.py}

@@ -40,7 +40,7 @@ def merge_pdfs(
                                    in_global=True, import_module=False)
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
+    run_shell_script(uv_command, display_script=True, clean_env=False)
 
 
 def compress_pdf(
@@ -92,5 +92,5 @@ def compress_pdf(
     )
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
+    run_shell_script(uv_command, display_script=True, clean_env=False)