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

machineconfig/scripts/python/helpers/repo_sync_helpers.py

@@ -1,114 +0,0 @@
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.terminal import Terminal
-from machineconfig.scripts.python.get_zellij_cmd import get_zellij_cmd
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.code import write_shell_script_to_file
-import platform
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
-
-
-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"))
-
-
-# import sys
-# import subprocess
-
-
-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))
-        write_shell_script_to_file(shell_script=program)
-        return None
-    elif platform.system() in ["Linux", "Darwin"]:
-        program = get_zellij_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_remote_root))
-        write_shell_script_to_file(shell_script=program)
-        return None
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-
-
-def fetch_dotfiles():
-    console.print(Panel("📁 Fetching Dotfiles", title="[bold blue]Dotfiles[/bold blue]", border_style="blue"))
-
-    cloud_resolved = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
-    console.print(Panel(f"⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}", width=150, border_style="yellow"))
-
-    dotfiles_local = PathExtended.home().joinpath("dotfiles")
-    CONFIG_PATH.joinpath("remote").mkdir(parents=True, exist_ok=True)
-    dotfiles_remote = PathExtended(CONFIG_PATH).joinpath("remote", dotfiles_local.rel2home())
-    remote_path = dotfiles_local.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
-
-    console.print(Panel("📥 Downloading dotfiles from cloud...", width=150, border_style="blue"))
-
-    dotfiles_remote.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=None)
-
-    console.print(Panel("🗑️  Removing old dotfiles and replacing with cloud version...", width=150, border_style="blue"))
-
-    dotfiles_local.delete(sure=True)
-    dotfiles_remote.move(folder=PathExtended.home())
-    script = f"""
-# rm -rf {dotfiles_local}
-# mv {dotfiles_remote} {dotfiles_local}
-"""
-    if platform.system() == "Linux":
-        script += """
-sudo chmod 600 $HOME/.ssh/*
-sudo chmod 700 $HOME/.ssh
-sudo chmod +x $HOME/dotfiles/scripts/linux -R
-"""
-    shell_path = write_shell_script_to_file(shell_script=script)
-    Terminal().run(f". {shell_path}", shell="bash").capture().print()
-
-    console.print(Panel("✅ Dotfiles successfully fetched and installed", title="[bold green]Dotfiles[/bold green]", border_style="green"))
-
-
-def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool) -> bool:
-    dotfiles_path = str(PathExtended.home().joinpath("dotfiles"))
-    from git import Repo
-
-    repo = Repo(path=dotfiles_path)
-    last_commit = repo.head.commit
-    dtm = last_commit.committed_datetime
-    from datetime import datetime  # make it tz unaware
-
-    dtm = datetime(dtm.year, dtm.month, dtm.day, dtm.hour, dtm.minute, dtm.second)
-    res = dtm > datetime.fromisoformat(commit_dtm)
-    if res is False and update is True:
-        console = Console()
-        console.print(Panel(f"🔄 UPDATE REQUIRED | Updating dotfiles because {dtm} < {datetime.fromisoformat(commit_dtm)}", border_style="bold blue", expand=False))
-        from machineconfig.scripts.python.cloud_repo_sync import main
-
-        main(cloud=None, path=dotfiles_path)
-    return res

machineconfig/scripts/python/repos.py

@@ -1,80 +0,0 @@
-"""Repos
-
-# TODO use gh api user --jq '.login' to get the username and use it to clone the repos.
-in the event that username@github.com is not mentioned in the remote url.
-
-"""
-
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.scripts.python.repos_helper_record import main as record_repos
-from machineconfig.scripts.python.repos_helper_clone import clone_repos
-from machineconfig.scripts.python.repos_helper_action import perform_git_operations
-
-import typer
-from typing import Annotated, Optional
-
-
-def main(
-    directory: Annotated[str, typer.Argument(help="📁 Folder containing repos to record or a specs JSON file to follow.")] = "",
-    push: Annotated[bool, typer.Option("--push", help="🚀 Push changes.")] = False,
-    pull: Annotated[bool, typer.Option("--pull", help="⬇️ Pull changes.")] = False,
-    commit: Annotated[bool, typer.Option("--commit", help="💾 Commit changes.")] = False,
-    all: Annotated[bool, typer.Option("--all", help="🔄 Pull, commit, and push changes.")] = False,
-    record: Annotated[bool, typer.Option("--record", help="📝 Record repositories.")] = False,
-    clone: Annotated[bool, typer.Option("--clone", help="📥 Clone repositories from record.")] = False,
-    checkout: Annotated[bool, typer.Option("--checkout", help="🔀 Check out to versions provided in a JSON file.")] = False,
-    checkout_to_branch: Annotated[bool, typer.Option("--checkout-to-branch", help="🔀 Check out to the main branch.")] = False,
-    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="🔍 Recursive flag.")] = False,
-    no_sync: Annotated[bool, typer.Option("--no-sync", help="🚫 Disable automatic uv sync after pulls.")] = False,
-    cloud: Annotated[Optional[str], typer.Option("--cloud", "-c", help="☁️ Cloud storage option.")] = None,
-) -> None:
-    print("\n" + "=" * 50)
-    print("📂 Welcome to the Repository Manager")
-    print("=" * 50 + "\n")
-
-    if directory == "":
-        repos_root = PathExtended.home().joinpath("code")  # it is a positional argument, can never be empty.
-    else:
-        repos_root = PathExtended(directory).expanduser().absolute()
-    auto_sync = not no_sync  # Enable auto sync by default, disable with --no-sync
-    if record:
-        save_path = record_repos(repos_root=repos_root)
-        if cloud is not None:
-            PathExtended(save_path).to_cloud(rel2home=True, cloud=cloud)
-
-    elif clone or checkout or checkout_to_branch:
-        print("\n📥 Cloning or checking out repositories...")
-        if not repos_root.exists() or repos_root.name != "repos.json":
-            repos_root = PathExtended(CONFIG_PATH).joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
-            if not repos_root.exists():
-                if cloud is None:
-                    cloud_name: str = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
-                    print(f"⚠️ Using default cloud: {cloud_name}")
-                else:
-                    cloud_name = cloud
-                    assert cloud_name is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
-                repos_root.from_cloud(cloud=cloud_name, rel2home=True)
-        assert (repos_root.exists() and repos_root.name == "repos.json") or cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
-        clone_repos(spec_path=repos_root, preferred_remote=None, checkout_branch_flag=checkout_to_branch, checkout_commit_flag=checkout)
-
-    elif all or commit or pull or push:
-        perform_git_operations(
-            repos_root=repos_root,
-            pull=pull or all,
-            commit=commit or all,
-            push=push or all,
-            recursive=recursive,
-            auto_sync=auto_sync
-        )
-    else:
-        print("❌ No action specified. Try passing --push, --pull, --commit, or --all.")
-
-
-def main_from_parser() -> None:
-    typer.run(main)
-
-
-if __name__ == "__main__":
-    main_from_parser()

machineconfig/scripts/python/repos_helper_action.py

@@ -1,335 +0,0 @@
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.accessories import randstr
-from machineconfig.scripts.python.repos_helper_update import update_repository
-
-from typing import Optional
-from dataclasses import dataclass
-from enum import Enum
-
-from rich import print as pprint
-
-
-class GitAction(Enum):
-    commit = "commit"
-    push = "push"
-    pull = "pull"
-
-
-@dataclass
-class GitOperationResult:
-    """Result of a git operation on a single repository."""
-    repo_path: PathExtended
-    action: str
-    success: bool
-    message: str
-    is_git_repo: bool = True
-    had_changes: bool = False
-    remote_count: int = 0
-
-
-@dataclass  
-class GitOperationSummary:
-    """Summary of all git operations performed."""
-    # Basic statistics
-    total_paths_processed: int = 0
-    git_repos_found: int = 0
-    non_git_paths: int = 0
-    
-    # Per-operation statistics
-    commits_attempted: int = 0
-    commits_successful: int = 0
-    commits_no_changes: int = 0
-    commits_failed: int = 0
-    
-    pulls_attempted: int = 0
-    pulls_successful: int = 0
-    pulls_failed: int = 0
-    
-    pushes_attempted: int = 0
-    pushes_successful: int = 0
-    pushes_failed: int = 0
-    
-    def __post_init__(self):
-        self.failed_operations: list[GitOperationResult] = []
-        self.repos_without_remotes: list[PathExtended] = []
-
-
-def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, auto_sync: bool = True) -> GitOperationResult:
-    """Perform git actions using Python instead of shell scripts. Returns detailed operation result."""
-    from git.exc import InvalidGitRepositoryError
-    from git.repo import Repo
-
-    try:
-        repo = Repo(str(path), search_parent_directories=False)
-    except InvalidGitRepositoryError:
-        pprint(f"⚠️ Skipping {path} because it is not a git repository.")
-        if r:
-            results = [git_action(path=sub_path, action=action, mess=mess, r=r, auto_sync=auto_sync) for sub_path in path.search()]
-            # For recursive calls, we need to aggregate results somehow
-            # For now, return success if all recursive operations succeeded
-            all_successful = all(result.success for result in results)
-            return GitOperationResult(
-                repo_path=path,
-                action=action.value,
-                success=all_successful,
-                message=f"Recursive operation: {len([r for r in results if r.success])}/{len(results)} succeeded",
-                is_git_repo=False
-            )
-        else:
-            return GitOperationResult(
-                repo_path=path,
-                action=action.value,
-                success=False,
-                message="Not a git repository",
-                is_git_repo=False
-            )
-
-    print(f">>>>>>>>> 🔧{action} - {path}")
-    remote_count = len(repo.remotes)
-
-    try:
-        if action == GitAction.commit:
-            if mess is None:
-                mess = "auto_commit_" + randstr()
-
-            # Check if there are changes to commit
-            if repo.is_dirty() or repo.untracked_files:
-                repo.git.add(A=True)  # Stage all changes
-                repo.index.commit(mess)
-                print(f"✅ Committed changes with message: {mess}")
-                return GitOperationResult(
-                    repo_path=path,
-                    action=action.value,
-                    success=True,
-                    message=f"Committed changes with message: {mess}",
-                    had_changes=True,
-                    remote_count=remote_count
-                )
-            else:
-                print("ℹ️  No changes to commit")
-                return GitOperationResult(
-                    repo_path=path,
-                    action=action.value,
-                    success=True,
-                    message="No changes to commit",
-                    had_changes=False,
-                    remote_count=remote_count
-                )
-
-        elif action == GitAction.push:
-            if not repo.remotes:
-                print("⚠️ No remotes configured for push")
-                return GitOperationResult(
-                    repo_path=path,
-                    action=action.value,
-                    success=False,
-                    message="No remotes configured",
-                    remote_count=0
-                )
-                
-            success = True
-            failed_remotes = []
-            for remote in repo.remotes:
-                try:
-                    print(f"🚀 Pushing to {remote.url}")
-                    remote.push(repo.active_branch.name)
-                    print(f"✅ Pushed to {remote.name}")
-                except Exception as e:
-                    print(f"❌ Failed to push to {remote.name}: {e}")
-                    failed_remotes.append(f"{remote.name}: {str(e)}")
-                    success = False
-                    
-            message = "Push successful" if success else f"Push failed for: {', '.join(failed_remotes)}"
-            return GitOperationResult(
-                repo_path=path,
-                action=action.value,
-                success=success,
-                message=message,
-                remote_count=remote_count
-            )
-
-        elif action == GitAction.pull:
-            # Use the enhanced update function with uv sync support
-            try:
-                update_repository(repo, auto_sync=auto_sync, allow_password_prompt=False)
-                print("✅ Pull completed")
-                return GitOperationResult(
-                    repo_path=path,
-                    action=action.value,
-                    success=True,
-                    message="Pull completed successfully",
-                    remote_count=remote_count
-                )
-            except Exception as e:
-                print(f"❌ Pull failed: {e}")
-                return GitOperationResult(
-                    repo_path=path,
-                    action=action.value,
-                    success=False,
-                    message=f"Pull failed: {str(e)}",
-                    remote_count=remote_count
-                )
-
-    except Exception as e:
-        print(f"❌ Error performing {action} on {path}: {e}")
-        return GitOperationResult(
-            repo_path=path,
-            action=action.value,
-            success=False,
-            message=f"Error: {str(e)}",
-            remote_count=remote_count
-        )
-
-    # This should never be reached, but just in case
-    return GitOperationResult(
-        repo_path=path,
-        action=action.value,
-        success=False,
-        message="Unknown error",
-        remote_count=remote_count
-    )
-
-
-def print_git_operations_summary(summary: GitOperationSummary, operations_performed: list[str]) -> None:
-    """Print a detailed summary of git operations similar to repos_helper_record.py."""
-    print("\n📊 Git Operations Summary:")
-    print(f"   Total paths processed: {summary.total_paths_processed}")
-    print(f"   Git repositories found: {summary.git_repos_found}")
-    print(f"   Non-git paths skipped: {summary.non_git_paths}")
-    
-    # Show per-operation statistics
-    if "commit" in operations_performed:
-        print("\n💾 Commit Operations:")
-        print(f"   Attempted: {summary.commits_attempted}")
-        print(f"   Successful: {summary.commits_successful}")
-        print(f"   No changes: {summary.commits_no_changes}")
-        print(f"   Failed: {summary.commits_failed}")
-        
-    if "pull" in operations_performed:
-        print("\n⬇️ Pull Operations:")
-        print(f"   Attempted: {summary.pulls_attempted}")
-        print(f"   Successful: {summary.pulls_successful}")
-        print(f"   Failed: {summary.pulls_failed}")
-        
-    if "push" in operations_performed:
-        print("\n🚀 Push Operations:")
-        print(f"   Attempted: {summary.pushes_attempted}")
-        print(f"   Successful: {summary.pushes_successful}")
-        print(f"   Failed: {summary.pushes_failed}")
-
-    # Show repositories without remotes (important for push operations)
-    if summary.repos_without_remotes:
-        print(f"\n⚠️  WARNING: {len(summary.repos_without_remotes)} repositories have no remote configurations:")
-        for repo_path in summary.repos_without_remotes:
-            print(f"   • {repo_path.name} ({repo_path})")
-        print("   These repositories cannot be pushed to remote servers.")
-    else:
-        if "push" in operations_performed:
-            print("\n✅ All repositories have remote configurations.")
-
-    # Show failed operations
-    if summary.failed_operations:
-        print(f"\n❌ FAILED OPERATIONS ({len(summary.failed_operations)} total):")
-        
-        # Group failed operations by type
-        failed_by_action = {}
-        for failed_op in summary.failed_operations:
-            if failed_op.action not in failed_by_action:
-                failed_by_action[failed_op.action] = []
-            failed_by_action[failed_op.action].append(failed_op)
-            
-        for action, failures in failed_by_action.items():
-            print(f"\n   {action.upper()} failures ({len(failures)}):")
-            for failure in failures:
-                if not failure.is_git_repo:
-                    print(f"   • {failure.repo_path.name} ({failure.repo_path}) - Not a git repository")
-                else:
-                    print(f"   • {failure.repo_path.name} ({failure.repo_path}) - {failure.message}")
-    else:
-        print("\n✅ All git operations completed successfully!")
-
-    # Overall success assessment
-    total_failed = len(summary.failed_operations)
-    total_operations = (summary.commits_attempted + summary.pulls_attempted + 
-                       summary.pushes_attempted)
-    
-    if total_failed == 0 and total_operations > 0:
-        print(f"\n🎉 SUCCESS: All {total_operations} operations completed successfully!")
-    elif total_operations == 0:
-        print("\n📝 No git operations were performed.")
-    else:
-        success_rate = ((total_operations - total_failed) / total_operations * 100) if total_operations > 0 else 0
-        print(f"\n⚖️  SUMMARY: {total_operations - total_failed}/{total_operations} operations succeeded ({success_rate:.1f}% success rate)")
-        if total_failed > 0:
-            print("   Review the failed operations above for details on what needs attention.")
-
-
-def perform_git_operations(repos_root: PathExtended, pull: bool, commit: bool, push: bool, recursive: bool, auto_sync: bool) -> None:
-    """Perform git operations on all repositories and provide detailed summary."""
-    print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
-    
-    # Initialize summary tracking
-    summary = GitOperationSummary()
-    operations_performed = []
-    
-    # Determine which operations to perform
-    if pull:
-        operations_performed.append("pull")
-    if commit:
-        operations_performed.append("commit")
-    if push:
-        operations_performed.append("push")
-        
-    for a_path in repos_root.search("*"):
-        print(f"{('Handling ' + str(a_path)).center(80, '-')}")
-        summary.total_paths_processed += 1
-        
-        # Check if this is a git repository first
-        from git.exc import InvalidGitRepositoryError
-        from git.repo import Repo
-        
-        try:
-            repo = Repo(str(a_path), search_parent_directories=False)
-            summary.git_repos_found += 1
-            
-            # Track repos without remotes
-            if len(repo.remotes) == 0:
-                summary.repos_without_remotes.append(a_path)
-                
-            # Now perform the actual operations
-            if pull:
-                result = git_action(path=a_path, action=GitAction.pull, r=recursive, auto_sync=auto_sync)
-                summary.pulls_attempted += 1
-                if result.success:
-                    summary.pulls_successful += 1
-                else:
-                    summary.pulls_failed += 1
-                    summary.failed_operations.append(result)
-                    
-            if commit:
-                result = git_action(a_path, action=GitAction.commit, r=recursive, auto_sync=auto_sync)
-                summary.commits_attempted += 1
-                if result.success:
-                    if result.had_changes:
-                        summary.commits_successful += 1
-                    else:
-                        summary.commits_no_changes += 1
-                else:
-                    summary.commits_failed += 1
-                    summary.failed_operations.append(result)
-                    
-            if push:
-                result = git_action(a_path, action=GitAction.push, r=recursive, auto_sync=auto_sync)
-                summary.pushes_attempted += 1
-                if result.success:
-                    summary.pushes_successful += 1
-                else:
-                    summary.pushes_failed += 1
-                    summary.failed_operations.append(result)
-                    
-        except InvalidGitRepositoryError:
-            summary.non_git_paths += 1
-            pprint(f"⚠️ Skipping {a_path} because it is not a git repository.")
-
-    # Print the detailed summary
-    print_git_operations_summary(summary, operations_performed)

machineconfig/scripts/python/share_terminal.py

@@ -1,104 +0,0 @@
-
-
-from pathlib import Path
-from typing import Optional, Annotated
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from rich.align import Align
-
-
-"""
-uv run --python 3.13 --with machineconfig 
-reference:
-# https://github.com/tsl0922/ttyd/wiki/Serving-web-fonts
-# -t "fontFamily=CaskaydiaCove" bash
-# --terminal-type xterm-kitty
-
-"""
-
-
-def display_terminal_url(local_ip_v4: str, port: int) -> None:
-    """Display a flashy, unmissable terminal URL announcement."""
-    console = Console()
-    
-    # Create the main message with styling
-    url_text = Text(f"http://{local_ip_v4}:{port}", style="bold bright_cyan underline")
-    message = Text.assemble(
-        ("🚀 ", "bright_red"),
-        ("Terminal is now accessible at: ", "bright_white bold"),
-        url_text,
-        (" 🚀", "bright_red")
-    )
-    
-    # Create a fancy panel with borders and styling
-    panel = Panel(
-        Align.center(message),
-        title="[bold bright_green]🌐 WEB TERMINAL READY 🌐[/bold bright_green]",
-        subtitle="[italic bright_yellow]⚡ Click the link above to access your terminal! ⚡[/italic bright_yellow]",
-        border_style="bright_magenta",
-        padding=(1, 2),
-        expand=False
-    )
-    
-    # Print with extra spacing and attention-grabbing elements
-    # console.print("\n" + "🔥" * 60 + "\n", style="bright_red bold")
-    console.print(panel)
-    # console.print("🔥" * 60 + "\n", style="bright_red bold")
-
-
-def install_ttyd():
-    # uv run --python 3.13 --with machineconfig devops install ttyd
-    from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
-    exists = check_tool_exists("ttyd")
-    if exists:
-        print("✅ ttyd is already installed.")
-        return
-    print("⏳ ttyd not found. Installing...")
-    from machineconfig.scripts.python.devops_devapps_install import main
-    main(which="ttyd")
-
-
-
-def main(
-    port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the terminal server on (default: 7681)")] = None,
-    username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for terminal access (default: current user)")] = None,
-    password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for terminal access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None
-) -> None:
-    install_ttyd()
-    if username is None:
-        import getpass
-        username = getpass.getuser()
-    if password is None:
-        pwd_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
-        if pwd_path.exists():
-            password = pwd_path.read_text(encoding="utf-8").strip()
-        else:
-            raise ValueError("Password not provided and default password file does not exist.")
-
-    if port is None:
-        port = 7681  # Default port for ttyd
-
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(('8.8.8.8',80))
-    local_ip_v4 = s.getsockname()[0]
-    s.close()
-
-    # Display the flashy terminal announcement
-    display_terminal_url(local_ip_v4, port)
-    
-    code = f"""#!/bin/bash
-ttyd --writable -t enableSixel=true --port {port} --credential "{username}:{password}" -t 'theme={{"background": "black"}}' bash
-"""
-    import subprocess
-    subprocess.run(code, shell=True, check=True)
-
-
-def main_with_parser():
-    typer.run(main)
-
-
-if __name__ == "__main__":
-    pass

machineconfig/scripts/python/snapshot.py

@@ -1,25 +0,0 @@
-# def main():
-#     print("\n" + "=" * 50)
-#     print("📸 Welcome to the Snapshot Tool")
-#     print("=" * 50 + "\n")
-
-#     parser = argparse.ArgumentParser(description='📷 Capture snapshots using your webcam.')
-#     parser.add_argument("--to_text", "-t", help="📝 Convert the snapshot to text using OCR.", action="store_true")
-#     args = parser.parse_args()
-
-#     print("📷 Capturing image from webcam...")
-#     img_path = capture_from_webcam(show=False, wait=False, save=True)
-#     print(f"✅ Image captured and saved at: {img_path}\n")
-
-#     if args.to_text:
-#         print("🔍 Converting image to text using Tesseract OCR...")
-#         q = Terminal().run(f"cd ~/AppData/Local/Tesseract-OCR; pytesseract '{img_path}'", shell="pwsh").capture().op
-#         print("📝 Extracted Text:")
-#         print("-" * 50)
-#         print(q)
-#         print("-" * 50 + "\n")
-#     else:
-#         print("📂 Image saved successfully. No text extraction requested.\n")
-
-# if __name__ == '__main__':
-#     main()