machineconfig 3.83__py3-none-any.whl → 3.86__py3-none-any.whl

machineconfig/scripts/python/repos_helper_action.py

@@ -0,0 +1,335 @@
+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/scheduler.py

@@ -4,7 +4,6 @@
 # from machineconfig.utils.scheduling import PathExtended, Report, DEFAULT_CONFIG, read_task_from_dir, main
 
 # def main_parse():
-#     import argparse
 #     print("\n" + "=" * 50)
 #     print("📅 Welcome to the Scheduler CLI")
 #     print("=" * 50 + "\n")

machineconfig/scripts/python/share_terminal.py

@@ -0,0 +1,41 @@
+
+
+from pathlib import Path
+from typing import Optional
+# import typer
+
+
+"""
+reference:
+# https://github.com/tsl0922/ttyd/wiki/Serving-web-fonts
+# -t "fontFamily=CaskaydiaCove" bash
+# --terminal-type xterm-kitty
+
+"""
+
+
+def share_terminal(port: int, password: Optional[str]) -> None:
+    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.")
+
+    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()
+
+    print(f"\n🌐 Access your terminal at: http://{local_ip_v4}:{port}\n")
+
+    code = f"""
+#!/bin/bash
+uv run --python 3.13 --with machineconfig install -ttyd
+
+ttyd --writable -t enableSixel=true --port {port} --credential "$USER:{password}" -t 'theme={"background": "black"}' bash
+
+"""
+    import subprocess
+    subprocess.run(code, shell=True, check=True)

machineconfig/scripts/python/start_slidev.py

@@ -6,6 +6,8 @@ from machineconfig.utils.source_of_truth import CONFIG_PATH
 from machineconfig.utils.code import print_code
 from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.terminal import Terminal
+from typing import Annotated, Optional
+import typer
 import subprocess
 import platform
 
@@ -47,28 +49,24 @@ def jupyter_to_markdown(file: PathExtended):
     return op_dir
 
 
-def main() -> None:
-    import argparse
-
+def main(
+    directory: Annotated[Optional[str], typer.Option("-d", "--directory", help="📁 Directory of the report.")] = None,
+    jupyter_file: Annotated[Optional[str], typer.Option("-j", "--jupyter-file", help="📓 Jupyter notebook file to convert to slides. If not provided, slides.md is used.")] = None,
+) -> None:
     print("\n" + "=" * 50)
     print("🎥 Welcome to the Slidev Presentation Tool")
     print("=" * 50 + "\n")
 
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-d", "--directory", default=None, help="📁 Directory of the report.")
-    parser.add_argument("-j", "--jupyter-file", default=None, help="📓 Jupyter notebook file to convert to slides. If not provided, slides.md is used.")
-    args = parser.parse_args()
-
     port = PORT_DEFAULT
 
-    if args.jupyter_file is not None:
+    if jupyter_file is not None:
         print("📓 Jupyter file provided. Converting to markdown...")
-        report_dir = jupyter_to_markdown(PathExtended(args.jupyter_file))
+        report_dir = jupyter_to_markdown(PathExtended(jupyter_file))
     else:
-        if args.directory is None:
+        if directory is None:
             report_dir = PathExtended.cwd()
         else:
-            report_dir = PathExtended(args.directory)
+            report_dir = PathExtended(directory)
 
     assert report_dir.exists(), f"❌ Directory {report_dir} does not exist."
     assert report_dir.is_dir(), f"❌ {report_dir} is not a directory."
@@ -108,5 +106,9 @@ def main() -> None:
     print_code(code=program, lexer="bash", desc="Run the following command to start the presentation")
 
 
+def arg_parser() -> None:
+    typer.run(main)
+
+
 if __name__ == "__main__":
-    main()
+    arg_parser()

machineconfig/scripts/python/start_terminals.py

@@ -3,7 +3,8 @@
 from machineconfig.utils.options import choose_from_options, get_ssh_hosts
 import platform
 from itertools import cycle
-from typing import Literal
+from typing import Literal, Optional, Annotated
+import typer
 
 
 COLOR_SCHEMES = ["Campbell", "Campbell Powershell", "Solarized Dark", "Ubuntu-ColorScheme", "Retro"]
@@ -70,40 +71,35 @@ wt --window {window} --title {hosts[0]} powershell -Command "ssh {host_linux} {s
     return cmd
 
 
-def main():
-    import argparse
-
+def main(
+    panes: Annotated[Optional[int], typer.Option("--panes", "-p", help="🔲 The number of panes to open.")] = 4,
+    vertical: Annotated[bool, typer.Option("--vertical", "-V", help="↕️ Switch orientation to vertical from default horizontal.")] = False,
+    window: Annotated[int, typer.Option("--window", "-w", help="🪟 The window ID to use.")] = 0,
+    hosts: Annotated[Optional[list[str]], typer.Option("--hosts", "-H", help="🌐 The hosts to connect to.")] = None,
+) -> None:
     print("\n" + "=" * 50)
     print("🖥️ Welcome to the Terminal Starter Tool")
     print("=" * 50 + "\n")
 
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--panes", "-p", type=int, help="🔲 The number of panes to open.", default=4)
-    parser.add_argument("--vertical", "-V", action="store_true", help="↕️ Switch orientation to vertical from default horizontal.")
-    parser.add_argument("--window", "-w", type=int, help="🪟 The window ID to use.", default=0)  # 0 refers to this window.
-    parser.add_argument("--hosts", "-H", type=str, nargs="*", help="🌐 The hosts to connect to.", default=None)
-    args = parser.parse_args()
-
-    if args.panes:
+    if panes:
         print("🔲 Configuring panes...")
-        cmd = f"wt --window {args.window} --colorScheme '{next(THEMES_ITER)}' pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
+        cmd = f"wt --window {window} --colorScheme '{next(THEMES_ITER)}' pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
         cmd += f" `; new-tab --colorScheme '{next(THEMES_ITER)}' --profile pwsh --title 't2' --tabColor '#f59218' "
         cmd += f" `; new-tab --colorScheme '{next(THEMES_ITER)}' --profile pwsh --title 't3' --tabColor '#009999' "
-        for idx in range(args.panes):
+        for idx in range(panes):
             if idx % 2 == 0:
                 cmd += f" `; move-focus down split-pane --horizontal --size {next(SIZE_ITER)} --colorScheme '{next(THEMES_ITER)}'  pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
             else:
                 cmd += f" `; move-focus up split-pane --vertical --size {next(SIZE_ITER)} --colorScheme '{next(THEMES_ITER)}' pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
 
     else:
-        if args.hosts is None:
+        if hosts is None:
             print("🌐 No hosts provided. Displaying options...")
             hosts = choose_from_options(msg="Select hosts:", options=get_ssh_hosts() + [THIS_MACHINE], multi=True, fzf=True)
         else:
-            print("🌐 Using provided hosts:", args.hosts)
-            hosts = args.hosts
+            print("🌐 Using provided hosts:", hosts)
         assert isinstance(hosts, list)
-        cmd = main_windows_and_wsl(window=args.window, hosts=hosts, orientation="vertical" if args.vertical else "horizontal")
+        cmd = main_windows_and_wsl(window=window, hosts=hosts, orientation="vertical" if vertical else "horizontal")
 
     print("\n📋 Generated Command:")
     print("-" * 50)
@@ -117,5 +113,9 @@ def main():
     print("✅ Command saved successfully!\n")
 
 
+def arg_parser() -> None:
+    typer.run(main)
+
+
 if __name__ == "__main__":
-    main()
+    arg_parser()

machineconfig/scripts/python/t4.py

@@ -0,0 +1,17 @@
+
+import typer
+from typing import Annotated
+
+def func(name: str):
+    print(f"Hello, {name}! from func")
+
+def hello(*, name: Annotated[str, typer.Option(..., help="Name to greet")]):
+    print(f"Hello, {name}!")
+
+def main():
+    typer.run(hello)
+
+if __name__ == "__main__":
+    # typer.run(hello)
+    main()
+    pass

machineconfig/scripts/python/wifi_conn.py

@@ -28,7 +28,8 @@ Usage examples:
 
 """
 
-import argparse
+from typing import Annotated
+import typer
 import configparser
 from pathlib import Path
 import os
@@ -262,24 +263,21 @@ def manual_network_selection() -> bool:
         return False
 
 
-def main():
+def main(
+    ssid: Annotated[str, typer.Option("-n", "--ssid", help="🔗 SSID of WiFi (from config)")] = "MyPhoneHotSpot",
+    manual: Annotated[bool, typer.Option("-m", "--manual", help="🔍 Manual network selection mode")] = False,
+    list_: Annotated[bool, typer.Option("-l", "--list", help="📡 List available networks only")] = False,
+) -> None:
     """Main function with fallback network selection"""
     console.print(Panel("📶 Welcome to the WiFi Connector Tool", title="[bold blue]WiFi Connection[/bold blue]", border_style="blue"))
 
-    parser = argparse.ArgumentParser(description="WiFi Connector")
-    parser.add_argument("-n", "--ssid", help="🔗 SSID of WiFi (from config)", default="MyPhoneHotSpot")
-    parser.add_argument("-m", "--manual", action="store_true", help="🔍 Manual network selection mode")
-    parser.add_argument("-l", "--list", action="store_true", help="📡 List available networks only")
-
-    args = parser.parse_args()
-
     # If user just wants to list networks
-    if args.list:
+    if list_:
         display_available_networks()
         return
 
     # If user wants manual mode, skip config and go straight to selection
-    if args.manual:
+    if manual:
         console.print("[blue]🔍 Manual network selection mode[/blue]")
         if manual_network_selection():
             console.print("[green]🎉 Successfully connected![/green]")
@@ -288,9 +286,9 @@ def main():
         return
 
     # Try to connect using configuration first
-    console.print(f"[blue]🔍 Attempting to connect to configured network: {args.ssid}[/blue]")
+    console.print(f"[blue]🔍 Attempting to connect to configured network: {ssid}[/blue]")
 
-    if try_config_connection(args.ssid):
+    if try_config_connection(ssid):
         console.print("[green]🎉 Successfully connected using configuration![/green]")
         return
 
@@ -306,6 +304,10 @@ def main():
         console.print("[blue]👋 Goodbye![/blue]")
 
 
+def arg_parser() -> None:
+    typer.run(main)
+
+
 def get_current_wifi_name() -> str:
     """Get the name of the currently connected WiFi network"""
     console.print("\n[blue]🔍 Checking current WiFi connection...[/blue]")
@@ -413,4 +415,4 @@ def create_new_connection(name: str, ssid: str, password: str):
 
 
 if __name__ == "__main__":
-    main()
+    arg_parser()