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

machineconfig/scripts/python/helpers_repos/grource.py

@@ -0,0 +1,340 @@
+"""Gource visualization tool for git repositories."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+import subprocess
+import platform
+import zipfile
+import typer
+
+
+def get_gource_install_dir() -> Path:
+    """Get the installation directory for portable Gource."""
+    if platform.system() == "Windows":
+        appdata = Path.home() / "AppData" / "Local"
+        return appdata / "gource"
+    else:
+        return Path.home() / ".local" / "bin" / "gource"
+
+
+def get_gource_executable() -> Path:
+    """Get the path to the gource executable (inside the extracted directory with DLLs)."""
+    install_dir = get_gource_install_dir()
+    if platform.system() == "Windows":
+        possible_paths = [
+            install_dir / "gource.exe",
+            install_dir / f"gource-{get_default_version()}.win64" / "gource.exe",
+        ]
+        for path in possible_paths:
+            if path.exists():
+                return path
+        return install_dir / f"gource-{get_default_version()}.win64" / "gource.exe"
+    else:
+        return install_dir / "gource"
+
+
+def get_default_version() -> str:
+    """Get the default gource version."""
+    return "0.53"
+
+
+def install_gource_windows(version: Optional[str] = None) -> None:
+    """Install portable Gource on Windows by downloading and extracting the zip archive."""
+    if platform.system() != "Windows":
+        raise OSError(f"This installer is for Windows only. Current OS: {platform.system()}")
+
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR
+
+    print("\n" + "=" * 80)
+    print("🚀 GOURCE PORTABLE INSTALLATION 🚀")
+    print("=" * 80 + "\n")
+
+    version_str = version or get_default_version()
+    portable_url = f"https://github.com/acaudwell/Gource/releases/download/gource-{version_str}/gource-{version_str}.win64.zip"
+    install_dir = get_gource_install_dir()
+
+    print(f"📥 Downloading portable Gource from: {portable_url}")
+    downloaded_zip = PathExtended(portable_url).download(folder=INSTALL_TMP_DIR)
+    print(f"✅ Downloaded to: {downloaded_zip}")
+
+    print(f"\n� Extracting to: {install_dir}")
+    install_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with zipfile.ZipFile(downloaded_zip, 'r') as zip_ref:
+            zip_ref.extractall(install_dir)
+        print(f"✅ Extracted successfully to: {install_dir}")
+        print(f"   (The zip contains gource-{version_str}.win64/ directory with exe and DLL dependencies)")
+    except Exception as e:
+        print(f"❌ Extraction failed with error: {e}")
+        raise
+
+    print("\n🗑️  Cleaning up zip file...")
+    try:
+        downloaded_zip.unlink()
+        print(f"✅ Removed zip file: {downloaded_zip}")
+    except Exception as e:
+        print(f"⚠️  Warning: Could not remove zip file: {e}")
+
+    gource_exe = get_gource_executable()
+    if gource_exe.exists():
+        print(f"\n✅ Gource executable found at: {gource_exe}")
+        dll_dir = gource_exe.parent
+        dll_count = len(list(dll_dir.glob("*.dll")))
+        print(f"   Found {dll_count} DLL dependencies in: {dll_dir}")
+    else:
+        print(f"\n⚠️  Warning: Expected executable not found at: {gource_exe}")
+        print(f"   Contents of {install_dir}:")
+        for item in install_dir.rglob("*"):
+            if item.is_file():
+                print(f"     - {item.relative_to(install_dir)}")
+
+    print("\n" + "=" * 80)
+    print("✅ GOURCE PORTABLE INSTALLATION COMPLETED")
+    print("=" * 80)
+    print(f"\n📌 Gource installed to: {install_dir}")
+    print(f"   Executable: {gource_exe}")
+    print("   All DLL dependencies are kept together in the same directory.")
+    print("   This script will automatically use the portable version.")
+
+
+def visualize(
+    repo: Annotated[str, typer.Option("--repo", "-r", help="Path to git repository to visualize")] = ".",
+    output_file: Annotated[Optional[Path], typer.Option("--output", "-o", help="Output video file (e.g., output.mp4). If specified, gource will render to video.")] = None,
+    resolution: Annotated[str, typer.Option("--resolution", "-res", help="Video resolution (e.g., 1920x1080, 1280x720)")] = "1920x1080",
+    seconds_per_day: Annotated[float, typer.Option("--seconds-per-day", "-spd", help="Speed of simulation (lower = faster)")] = 0.1,
+    auto_skip_seconds: Annotated[float, typer.Option("--auto-skip-seconds", "-as", help="Skip to next entry if nothing happens for X seconds")] = 1.0,
+    title: Annotated[Optional[str], typer.Option("--title", "-t", help="Title for the visualization")] = None,
+    hide_items: Annotated[list[str], typer.Option("--hide", "-h", help="Items to hide: bloom, date, dirnames, files, filenames, mouse, progress, root, tree, users, usernames")] = [],
+    key_items: Annotated[bool, typer.Option("--key", "-k", help="Show file extension key")] = False,
+    fullscreen: Annotated[bool, typer.Option("--fullscreen", "-f", help="Run in fullscreen mode")] = False,
+    viewport: Annotated[Optional[str], typer.Option("--viewport", "-v", help="Camera viewport (e.g., '1000x1000')")] = None,
+    start_date: Annotated[Optional[str], typer.Option("--start-date", help="Start date (YYYY-MM-DD)")] = None,
+    stop_date: Annotated[Optional[str], typer.Option("--stop-date", help="Stop date (YYYY-MM-DD)")] = None,
+    user_image_dir: Annotated[Optional[Path], typer.Option("--user-image-dir", help="Directory with user avatar images")] = None,
+    max_files: Annotated[int, typer.Option("--max-files", help="Maximum number of files to show (0 = no limit)")] = 0,
+    max_file_lag: Annotated[float, typer.Option("--max-file-lag", help="Max time files remain on screen after last change")] = 5.0,
+    file_idle_time: Annotated[int, typer.Option("--file-idle-time", help="Time in seconds files remain idle before being removed")] = 0,
+    framerate: Annotated[int, typer.Option("--framerate", help="Frames per second for video output")] = 60,
+    background_color: Annotated[str, typer.Option("--background-color", help="Background color in hex (e.g., 000000 for black)")] = "000000",
+    font_size: Annotated[int, typer.Option("--font-size", help="Font size")] = 22,
+    camera_mode: Annotated[str, typer.Option("--camera-mode", help="Camera mode: overview or track")] = "overview",
+) -> None:
+    """
+    Visualize git repository history using Gource with reasonable defaults.
+    
+    Examples:
+        # Basic visualization of current directory
+        python grource.py visualize
+        
+        # Visualize specific repository
+        python grource.py visualize --repo-path /path/to/repo
+        
+        # Create video output
+        python grource.py visualize --output output.mp4
+        
+        # Fast visualization with custom title
+        python grource.py visualize --seconds-per-day 0.01 --title "My Project"
+        
+        # Hide specific elements
+        python grource.py visualize --hide filenames --hide date
+        
+        # Custom resolution and viewport
+        python grource.py visualize --resolution 2560x1440 --viewport 1200x1200
+    """
+    print("\n" + "=" * 80)
+    print("🎬 GOURCE VISUALIZATION 🎬")
+    print("=" * 80 + "\n")
+    repo_path: Path = Path(repo).expanduser().resolve()
+    if not repo_path.exists():
+        print(f"❌ Error: Repository path does not exist: {repo_path}")
+        raise typer.Exit(1)
+
+    if not repo_path.joinpath(".git").exists():
+        print(f"❌ Error: Not a git repository: {repo_path}")
+        raise typer.Exit(1)
+
+    print(f"📁 Repository: {repo_path}")
+    print("⚙️  Configuration:")
+    print(f"   - Resolution: {resolution}")
+    print(f"   - Speed: {seconds_per_day} seconds per day")
+    print(f"   - Auto-skip: {auto_skip_seconds} seconds")
+    if output_file:
+        print(f"   - Output: {output_file}")
+    print()
+
+    gource_exe: Path = get_gource_executable()
+    if not gource_exe.exists():
+        if platform.system() == "Windows":
+            print(f"⚠️  Portable gource not found at {gource_exe}, installing...")
+            install_gource_windows()
+            # Check again after installation
+            if gource_exe.exists():
+                print(f"✅ Gource installed successfully at: {gource_exe}")
+                gource_cmd: str = str(gource_exe)
+            else:
+                print("❌ Installation failed, falling back to system gource")
+                raise typer.Exit(1)
+        else:
+            raise FileNotFoundError(f"Gource executable not found at {gource_exe}. Please install gource using your package manager.")
+    else:
+        gource_cmd = str(gource_exe)
+
+    cmd: list[str] = [gource_cmd, str(repo_path)]
+
+    cmd.extend(["--seconds-per-day", str(seconds_per_day)])
+    cmd.extend(["--auto-skip-seconds", str(auto_skip_seconds)])
+
+    if resolution:
+        width, height = resolution.split("x")
+        cmd.extend(["-{}x{}".format(width, height)])
+
+    if title:
+        cmd.extend(["--title", title])
+    elif not title and not output_file:
+        cmd.extend(["--title", repo_path.name])
+
+    for hide_item in hide_items:
+        cmd.extend(["--hide", hide_item])
+
+    if key_items:
+        cmd.append("--key")
+
+    if fullscreen and not output_file:
+        cmd.append("--fullscreen")
+
+    if viewport:
+        cmd.extend(["--viewport", viewport])
+
+    if start_date:
+        cmd.extend(["--start-date", start_date])
+
+    if stop_date:
+        cmd.extend(["--stop-date", stop_date])
+
+    if user_image_dir and user_image_dir.exists():
+        cmd.extend(["--user-image-dir", str(user_image_dir)])
+
+    if max_files > 0:
+        cmd.extend(["--max-files", str(max_files)])
+
+    cmd.extend(["--max-file-lag", str(max_file_lag)])
+
+    if file_idle_time > 0:
+        cmd.extend(["--file-idle-time", str(file_idle_time)])
+
+    cmd.extend(["--background-colour", background_color])
+    cmd.extend(["--font-size", str(font_size)])
+    cmd.extend(["--camera-mode", camera_mode])
+
+    if output_file:
+        cmd.extend(["-r", str(framerate)])
+        if platform.system() == "Windows":
+            cmd.extend(["-o", "-"])
+            ffmpeg_cmd: list[str] = [
+                "ffmpeg",
+                "-y",
+                "-r", str(framerate),
+                "-f", "image2pipe",
+                "-vcodec", "ppm",
+                "-i", "-",
+                "-vcodec", "libx264",
+                "-preset", "medium",
+                "-pix_fmt", "yuv420p",
+                "-crf", "23",
+                str(output_file),
+            ]
+            print("🎥 Rendering video...")
+            print(f"   Command: {' '.join(cmd)} | {' '.join(ffmpeg_cmd)}")
+            print()
+            try:
+                gource_proc: subprocess.Popen[bytes] = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+                ffmpeg_proc: subprocess.Popen[bytes] = subprocess.Popen(ffmpeg_cmd, stdin=gource_proc.stdout)
+                if gource_proc.stdout:
+                    gource_proc.stdout.close()
+                ffmpeg_proc.communicate()
+                print(f"\n✅ Video saved to: {output_file}")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Error during video rendering: {e}")
+                raise typer.Exit(1)
+            except FileNotFoundError:
+                print("❌ Error: ffmpeg not found. Please install ffmpeg to create video output.")
+                print("   Download from: https://ffmpeg.org/download.html")
+                raise typer.Exit(1)
+        else:
+            cmd.extend(["-o", "-"])
+            ffmpeg_cmd = [
+                "ffmpeg",
+                "-y",
+                "-r", str(framerate),
+                "-f", "image2pipe",
+                "-vcodec", "ppm",
+                "-i", "-",
+                "-vcodec", "libx264",
+                "-preset", "medium",
+                "-pix_fmt", "yuv420p",
+                "-crf", "23",
+                str(output_file),
+            ]
+            print("🎥 Rendering video...")
+            print(f"   Command: {' '.join(cmd)} | {' '.join(ffmpeg_cmd)}")
+            print()
+            try:
+                gource_proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+                ffmpeg_proc = subprocess.Popen(ffmpeg_cmd, stdin=gource_proc.stdout)
+                if gource_proc.stdout:
+                    gource_proc.stdout.close()
+                ffmpeg_proc.communicate()
+                print(f"\n✅ Video saved to: {output_file}")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Error during video rendering: {e}")
+                raise typer.Exit(1)
+            except FileNotFoundError:
+                print("❌ Error: ffmpeg not found. Please install ffmpeg to create video output.")
+                raise typer.Exit(1)
+    else:
+        print("🎬 Launching interactive visualization...")
+        print(f"   Command: {' '.join(cmd)}")
+        print()
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Error running gource: {e}")
+            raise typer.Exit(1)
+        except FileNotFoundError:
+            print("❌ Error: gource not found. Please install gource first.")
+            if platform.system() == "Windows":
+                print("   Run: uv run python src/machineconfig/scripts/python/grource.py install")
+            else:
+                print("   For Linux/Mac, use your package manager:")
+                print("     - Ubuntu/Debian: sudo apt install gource")
+                print("     - macOS: brew install gource")
+                print("     - Fedora: sudo dnf install gource")
+            raise typer.Exit(1)
+
+    print("\n" + "=" * 80)
+    print("✅ VISUALIZATION COMPLETED")
+    print("=" * 80)
+
+
+def install(
+    version: Annotated[Optional[str], typer.Option(..., "--version", "-v", help="Gource version to install")] = "0.53",
+) -> None:
+    """Install portable Gource on Windows (no admin privileges required)."""
+    if platform.system() == "Windows":
+        install_gource_windows(version=version)
+    else:
+        print(f"❌ Portable installer currently supports Windows only. Current OS: {platform.system()}")
+        print("For Linux/Mac, please use your package manager:")
+        print("  - Ubuntu/Debian: sudo apt install gource")
+        print("  - macOS: brew install gource")
+        print("  - Fedora: sudo dnf install gource")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app = typer.Typer(help="Gource visualization tool for git repositories", add_help_option=False, add_completion=False)
+    app.command()(install)
+    app.command()(visualize)
+    app()

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

@@ -3,7 +3,7 @@ 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_PATH
+from machineconfig.utils.source_of_truth import CONFIG_ROOT
 from machineconfig.utils.io import save_json
 
 from typing import Optional
@@ -186,7 +186,7 @@ def record_repos_recursively(repos_root: str, r: bool, progress: Progress | None
     return res
 
 
-def main(repos_root: Path):
+def main_record(repos_root: Path):
     print("\n📝 Recording repositories...")
     repos_root = PathExtended(repos_root).expanduser().absolute()
 
@@ -242,7 +242,8 @@ def main(repos_root: Path):
     tree_structure = build_tree_structure(repo_records, repos_root)
     print(tree_structure)
 
-    save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
+    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)}")
     print(">>>>>>>>> Finished Recording")

machineconfig/scripts/python/helpers_repos/sync.py

@@ -0,0 +1,66 @@
+from machineconfig.utils.path_extended import PathExtended
+import platform
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def get_zellij_cmd(wd1: Path, wd2: Path) -> str:
+    _ = wd1, wd2
+    lines = [
+        """ zellij action new-tab --name gitdiff""",
+        """zellij action new-pane --direction down --name local --cwd ./data """,
+        """zellij action write-chars "cd '{wd1}'; git status" """,
+        """zellij action move-focus up; zellij action close-pane """,
+        """zellij action new-pane --direction down --name remote --cwd code """,
+        """zellij action write-chars "cd '{wd2}' """,
+        """git status" """,
+    ]
+    return "; ".join(lines)
+
+def delete_remote_repo_copy_and_push_local(remote_repo: str, local_repo: str, cloud: str):
+    console.print(Panel("🗑️  Deleting remote repo copy and pushing local copy", title="[bold blue]Repo Sync[/bold blue]", border_style="blue"))
+    repo_sync_root = PathExtended(remote_repo).expanduser().absolute()
+    repo_root_path = PathExtended(local_repo).expanduser().absolute()
+    repo_sync_root.delete(sure=True)
+    print("🧹 Removed temporary remote copy")
+    from git.remote import Remote
+    from git.repo import Repo
+
+    try:
+        Remote.remove(Repo(repo_root_path), "originEnc")
+        console.print(Panel("🔗 Removed originEnc remote reference", border_style="blue"))
+    except Exception:
+        pass  # type: ignore
+    console.print(Panel("📈 Deleting remote repository copy and pushing local changes", width=150, border_style="blue"))
+
+    repo_root_path.to_cloud(cloud=cloud, zip=True, encrypt=True, rel2home=True, os_specific=False)
+
+    console.print(Panel("✅ Repository successfully pushed to cloud", title="[bold green]Repo Sync[/bold green]", border_style="green"))
+
+
+
+def get_wt_cmd(wd1: PathExtended, wd2: PathExtended) -> str:
+    lines = [
+        f"""wt --window 0 new-tab --profile pwsh --title "gitdiff" --tabColor `#3b04d1 --startingDirectory {wd1} ` --colorScheme "Solarized Dark" """,
+        f"""split-pane --horizontal --profile pwsh --startingDirectory {wd2} --size 0.5 --colorScheme "Tango Dark" -- pwsh -Interactive """,
+    ]
+    return " `; ".join(lines)
+
+
+def inspect_repos(repo_local_root: str, repo_remote_root: str):
+    console.print(Panel(f"📂 Local:  {repo_local_root}\n📂 Remote: {repo_remote_root}", title="[bold blue]🔍 Inspecting Repositories[/bold blue]", border_style="blue"))
+
+    if platform.system() == "Windows":
+        program = get_wt_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_local_root))
+    elif platform.system() in ["Linux", "Darwin"]:
+        program = get_zellij_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_remote_root))
+    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/scripts/python/{repos_helper_update.py → helpers_repos/update.py}

@@ -45,7 +45,7 @@ def run_uv_sync(repo_path: Path) -> bool:
     try:
         print(f"🔄 Running uv sync in {repo_path}")
         # Run uv sync with output directly to terminal (no capture)
-        subprocess.run(["uv", "sync"], cwd=repo_path, check=True)
+        subprocess.run(["uv", "sync", "--no-dev"], cwd=repo_path, check=True)
         print("✅ uv sync completed successfully")
         return True
     except subprocess.CalledProcessError as e:
@@ -65,7 +65,7 @@ def get_file_hash(file_path: Path) -> str | None:
     return hashlib.sha256(file_path.read_bytes()).hexdigest()
 
 
-def update_repository(repo: git.Repo, auto_sync: bool, allow_password_prompt: bool) -> RepositoryUpdateResult:
+def update_repository(repo: git.Repo, auto_uv_sync: bool, allow_password_prompt: bool) -> RepositoryUpdateResult:
     """Update a single repository and return detailed information about what happened."""
     repo_path = Path(repo.working_dir)
     print(f"🔄 {'Updating ' + str(repo_path):.^80}")
@@ -253,7 +253,7 @@ def update_repository(repo: git.Repo, auto_sync: bool, allow_password_prompt: bo
                 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_sync:
+        if result["dependencies_changed"] and auto_uv_sync:
             result["uv_sync_ran"] = True
             result["uv_sync_success"] = run_uv_sync(repo_path)
 

machineconfig/scripts/python/helpers_sessions/sessions_multiprocess.py

@@ -0,0 +1,58 @@
+
+
+from typing import Optional, Annotated
+import typer
+
+
+def create_from_function(
+        num_process: Annotated[int, typer.Option(..., "--num-process", "-n", help="Number of parallel processes to run")],
+        path: Annotated[str, typer.Option(..., "--path", "-p", help="Path to a Python or Shell script file or a directory containing such files")] = ".",
+        function: Annotated[Optional[str], typer.Option(..., "--function", "-f", help="Function to run from the Python file. If not provided, you will be prompted to choose.")] = None,
+):
+    from machineconfig.utils.ve import get_ve_activate_line, get_ve_path_and_ipython_profile
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.path_helper import match_file_name, sanitize_path
+    from machineconfig.utils.accessories import get_repo_root
+    from pathlib import Path
+
+
+    path_obj = sanitize_path(path)
+    if not path_obj.exists():
+        suffixes = {".py"}
+        choice_file = match_file_name(sub_string=path, search_root=Path.cwd(), suffixes=suffixes)
+    elif path_obj.is_dir():
+        from machineconfig.utils.path_helper import search_for_files_of_interest
+        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, fzf=True, msg="Choose one option")
+        choice_file = Path(choice_file)
+    else:
+        choice_file = path_obj
+
+
+    repo_root = get_repo_root(Path(choice_file))
+    print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
+    ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
+    if ipy_profile is None:
+        ipy_profile = "default"
+    if ve_root_from_file is None:
+        raise ValueError(f"Could not determine virtual environment for file {choice_file}. Please ensure it is within a recognized project structure.")
+
+    _activate_ve_line = get_ve_activate_line(ve_root=ve_root_from_file)
+
+    # =========================  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
+        choice_function, choice_file, _kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict={})
+    else:
+        choice_function = function
+
+    from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+    layout: LayoutConfig = {"layoutName": "fireNprocess", "layoutTabs": []}
+    for an_arg in range(num_process):
+        layout["layoutTabs"].append({"tabName": f"tab{an_arg}", "startDir": str(Path.cwd()), "command": f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={num_process}"})
+    print(layout)
+    run_zellij_layout(layout_config=layout)
+

machineconfig/scripts/python/helpers_utils/download.py

@@ -0,0 +1,152 @@
+
+
+from typing import Annotated, Optional
+import typer
+from pathlib import Path
+
+
+def download(
+    url: Annotated[Optional[str], typer.Argument(..., help="The URL to download the file from.")] = None,
+    decompress: Annotated[bool, typer.Option(..., "--decompress", "-d", help="Decompress the file if it's an archive.")] = False,
+    output: Annotated[Optional[str], typer.Option("--output", "-o", help="The output file path.")] = None,
+    output_dir: Annotated[Optional[str], typer.Option("--output-dir", help="Directory to place the downloaded file in.")] = None,
+) -> Optional["Path"]:
+
+    import subprocess
+    from urllib.parse import parse_qs, unquote, urlparse
+    from requests import Response
+    import requests
+    from pathlib import Path
+    if url is None:
+        typer.echo("❌ Error: URL is required.", err=True)
+        return None
+    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}")
+
+    def _sanitize_candidate_filename(name: str) -> Optional[str]:
+        candidate = Path(name).name.strip()
+        if not candidate or candidate in {".", ".."}:
+            return None
+        return candidate
+
+    def _filename_from_content_disposition(header_value: Optional[str]) -> Optional[str]:
+        if header_value is None:
+            return None
+        parts = [segment.strip() for segment in header_value.split(";")]
+        for part in parts:
+            lower = part.lower()
+            if lower.startswith("filename*="):
+                value = part.split("=", 1)[1]
+                value = value.strip().strip('"')
+                if "''" in value:
+                    value = value.split("''", 1)[1]
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+            if lower.startswith("filename="):
+                value = part.split("=", 1)[1].strip().strip('"')
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+        return None
+
+    def _filename_from_url(source_url: str) -> Optional[str]:
+        parsed = urlparse(source_url)
+        url_candidate = _sanitize_candidate_filename(unquote(Path(parsed.path).name))
+        if url_candidate is not None:
+            return url_candidate
+        query_params = parse_qs(parsed.query, keep_blank_values=True)
+        for key, values in query_params.items():
+            lower_key = key.lower()
+            if "name" in lower_key or "file" in lower_key:
+                for value in values:
+                    sanitized = _sanitize_candidate_filename(unquote(value))
+                    if sanitized is not None:
+                        return sanitized
+        return None
+
+    def _resolve_download_path(request_url: str, response: Response, requested_output: Optional[str], requested_output_dir: Optional[str]) -> Path:
+        if requested_output is not None:
+            return Path(requested_output)
+        header_candidate = _filename_from_content_disposition(response.headers.get("content-disposition"))
+        if header_candidate is None:
+            header_candidate = _filename_from_url(response.url)
+        if header_candidate is None:
+            header_candidate = _filename_from_url(request_url)
+        if header_candidate is None:
+            header_candidate = "downloaded_file"
+        if requested_output_dir is not None:
+            return Path(requested_output_dir) / header_candidate
+        return Path(header_candidate)
+
+    try:
+        with requests.get(url, allow_redirects=True, stream=True, timeout=60) as response:
+            response.raise_for_status()
+            download_path = _resolve_download_path(url, response, output, output_dir)
+            download_path.parent.mkdir(parents=True, exist_ok=True)
+            total_size_header = response.headers.get("content-length", "0")
+            try:
+                total_size = int(total_size_header)
+            except (TypeError, ValueError):
+                total_size = 0
+            if total_size <= 0:
+                with open(download_path, "wb") as file_handle:
+                    file_handle.write(response.content)
+            else:
+                downloaded = 0
+                chunk_size = 8192 * 4
+                with open(download_path, "wb") as file_handle:
+                    for chunk in response.iter_content(chunk_size=chunk_size):
+                        if not chunk:
+                            continue
+                        file_handle.write(chunk)
+                        downloaded += len(chunk)
+                        progress = (downloaded / total_size) * 100
+                        typer.echo(f"\r⏬ Progress: {progress:.1f}% ({downloaded}/{total_size} bytes)", nl=False)
+                typer.echo()
+    except requests.exceptions.RequestException as exception:
+        typer.echo(f"❌ Download failed: {exception}", err=True)
+        return None
+    except OSError as exception:
+        typer.echo(f"❌ File write error: {exception}", err=True)
+        return None
+
+    typer.echo(f"✅ Downloaded to: {download_path}")
+    result_path: Path = download_path
+
+    if decompress:
+        typer.echo(f"📦 Decompressing: {download_path}")
+        base_name = download_path.stem
+        if base_name in {"", ".", ".."}:
+            base_name = "extracted"
+        extract_dir = download_path.parent / base_name
+        extract_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            subprocess.run(
+                ["ouch", "decompress", str(download_path), "--dir", str(extract_dir)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            typer.echo(f"✅ Decompressed to: {extract_dir}")
+            if download_path.exists():
+                download_path.unlink()
+                typer.echo(f"🗑️  Removed archive: {download_path}")
+            result_path = extract_dir
+        except subprocess.CalledProcessError as exception:
+            typer.echo(f"❌ Decompression failed: {exception.stderr}", err=True)
+            return None
+        except FileNotFoundError:
+            typer.echo("❌ Error: ouch command not found. Please install ouch.", err=True)
+            typer.echo("💡 Install with: cargo install ouch", err=True)
+            return None
+
+    return result_path.resolve()
+
+
+if __name__ == "__main__":
+    pass