machineconfig 7.50__py3-none-any.whl → 8.14__py3-none-any.whl

machineconfig/utils/code.py

@@ -1,10 +1,19 @@
 
-from typing import Any, Optional, Callable
+from typing import Any, Literal, Optional, Callable, cast
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.meta import lambda_to_python_script
 from pathlib import Path
 
 
+def get_uv_command(platform: str) -> str:
+    res = cast(Literal["Windows", "windows", "nt", "Linux", "linux", "Darwin", "darwin", "macos"], platform)
+    match res:
+        case "Windows" | "windows" | "nt":
+            return """& "$env:USERPROFILE/.local/bin/uv" """
+        case "Linux" | "linux" | "Darwin" | "darwin" | "macos":
+            return """$HOME/.local/bin/uv """
+        case _:
+            return """$HOME/.local/bin/uv """
+
 def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     import platform
     try:
@@ -26,28 +35,51 @@ def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
         print(f"--- End of {desc} ---")
 
 
-def get_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[str, Path]:
-    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
+def get_uv_command_executing_python_file(python_file: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str], 
+                                        prepend_print: bool = True, ) -> str:
+    # shell script
     if uv_with is not None and len(uv_with) > 0:
-        uv_with.append("rich")
+        if prepend_print: uv_with.append("rich")
         uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
     else:
-        uv_with_arg = "--with rich"
+        if prepend_print:
+            uv_with_arg = "--with rich"
+        else:
+            uv_with_arg = ""
     if uv_project_dir is not None:
         uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
     else:
         uv_project_dir_arg = ""
-    print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"), in_global=True, import_module=False)
-    python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
-    shell_script = f"""uv run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    import platform
+
+    uv_command = get_uv_command(platform=platform.system())
+    shell_script = f"""{uv_command} run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    return shell_script
+
+
+def get_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
+                                           prepend_print: bool = True, ) -> tuple[str, Path]:
+    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    if prepend_print:
+        from machineconfig.utils.meta import lambda_to_python_script
+        print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"),
+                                                    in_global=True, import_module=False)
+        python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
+    else:
+        python_file.write_text(python_script, encoding="utf-8")
+    shell_script = get_uv_command_executing_python_file(python_file=str(python_file), uv_with=uv_with, uv_project_dir=uv_project_dir, prepend_print=prepend_print)
     return shell_script, python_file
 
 
 def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
-    code = lambda_to_python_script(lmb, in_global=True, import_module=False)
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(lmb,
+                                            in_global=True, import_module=False)
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
     run_shell_script(uv_command)
+
+
 def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
     tmp_dir = Path.home().joinpath("tmp_results", "tmp_scripts", "marimo", randstr())
     tmp_dir.mkdir(parents=True, exist_ok=True)
@@ -67,35 +99,44 @@ uv run  {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
     exit_then_run_shell_script(fire_line)
 
 
-def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
-    import tempfile
+def run_shell_file(script_path: str, clean_env: bool):
     import platform
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
+    env = {} if clean_env else None
+    if platform.system() == "Windows":
+        import subprocess
+        proc = subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{script_path}"', check=True, shell=True, env=env)
+    elif platform.system() == "Linux" or platform.system() == "Darwin":
+        import subprocess
+        proc = subprocess.run(f"bash {str(script_path)}", check=True, shell=True, env=env)
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    return proc
 
+
+def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False) -> Any:
+
+    import platform
     if platform.system() == "Windows":
         suffix = ".ps1"
         lexer = "powershell"
     else:
         suffix = ".sh"
         lexer = "bash"
+
+    import tempfile
     with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False, encoding='utf-8') as temp_file:
         temp_file.write(script)
         temp_shell_script_path = Path(temp_file.name)
+
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    from rich.console import Console
     console = Console()
     if display_script:
         from rich.syntax import Syntax
         console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 shell script @ {temp_shell_script_path}", subtitle="shell script being executed"), style="bold red")
-    env = {} if clean_env else None
-    if platform.system() == "Windows":
-        import subprocess
-        proc = subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{temp_shell_script_path}"', check=True, shell=True, env=env)
-    elif platform.system() == "Linux" or platform.system() == "Darwin":
-        import subprocess
-        proc = subprocess.run(f"bash {str(temp_shell_script_path)}", check=True, shell=True, env=env)
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+
+    proc = run_shell_file(script_path=str(temp_shell_script_path), clean_env=clean_env)
     # console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_script_path}[/blue]")
     if proc.returncode != 0:
         console.print(f"❌  [red]Script execution failed with return code {proc.returncode}:[/red] [blue]{temp_shell_script_path}[/blue]")
@@ -103,6 +144,7 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
         console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_shell_script_path}[/blue]")
     else:
         console.print(f"⚠️  [yellow]Script executed with warnings (return code {proc.returncode}):[/yellow] [blue]{temp_shell_script_path}[/blue]")
+
     temp_shell_script_path.unlink(missing_ok=True)
     console.print(f"🗑️  [blue]Temporary script deleted:[/blue] [green]{temp_shell_script_path}[/green]")
     return proc
@@ -132,7 +174,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
             op_program_path = Path.home().joinpath("tmp_results", "tmp_scripts", "manual_run", f"manual_script_{randstr()}{suffix}")
             op_program_path.parent.mkdir(parents=True, exist_ok=True)
             op_program_path.write_text(script, encoding="utf-8")
-            print_code(script, lexer=lexer, desc="script to run manually")
+            print_code(code=script, lexer=lexer, desc="script to run manually")
             console.print("[bold yellow]⚠️  STRICT MODE:[/bold yellow] [cyan]Please run the script manually via your shell by executing:[/cyan]")
             console.print(f"[green]{str(op_program_path)}[/green]")
             console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set in strict mode.[/red]")
@@ -145,7 +187,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
         op_program_path.write_text(script, encoding="utf-8")
         console.print("[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH:[/cyan]")
         console.print(f"[bold green]{str(op_program_path)}[/bold green]")
-        print_code(script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
+        print_code(code=script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
     else:
         if op_program_path is not None and exists:
             console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")

machineconfig/utils/files/headers.py

@@ -25,7 +25,7 @@ def print_header():
     table.add_row("Virtual Environment", os.getenv('VIRTUAL_ENV', 'None'))
     table.add_row("Running @", str(Path.cwd()))
 
-    from machineconfig.utils.installer import get_machineconfig_version
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
 
     console.print(Panel(table, title=f"[bold blue]✨ 🐊 Machineconfig Shell {get_machineconfig_version()} ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
 def print_logo(logo: str):
@@ -44,7 +44,7 @@ def print_logo(logo: str):
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
-        from machineconfig.utils.installer_utils.installer_abc import is_executable_in_path
+        from machineconfig.utils.installer_utils.installer_locator_utils import is_executable_in_path
         avail_cowsay = is_executable_in_path("cowsay")
         avail_lolcat = is_executable_in_path("lolcat")
         avail_boxes = is_executable_in_path("boxes")

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -5,13 +5,40 @@ Extracts GitHub repository URLs and fetches latest release data with rate limiti
 """
 
 import json
-import time
-import subprocess
+import requests
 from pathlib import Path
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, Optional, Set, TypedDict
 from urllib.parse import urlparse
 
 
+class AssetInfo(TypedDict):
+    """Type definition for GitHub release asset information."""
+    name: str
+    size: int
+    download_count: int
+    content_type: str
+    created_at: str
+    updated_at: str
+    browser_download_url: str
+
+
+class ReleaseInfo(TypedDict):
+    """Type definition for GitHub release information."""
+    tag_name: str
+    name: str
+    published_at: str
+    assets: list[AssetInfo]
+    assets_count: int
+
+
+class OutputData(TypedDict):
+    """Type definition for the output JSON data structure."""
+    generated_at: str
+    total_repositories: int
+    successful_fetches: int
+    releases: Dict[str, Optional[ReleaseInfo]]
+
+
 def is_github_repo(url: str) -> bool:
     """Check if URL is a GitHub repository URL."""
     try:
@@ -19,170 +46,180 @@ def is_github_repo(url: str) -> bool:
         return parsed.netloc == "github.com" and len(parsed.path.split("/")) >= 3
     except Exception:
         return False
-
-
 def extract_github_repos_from_json(json_file_path: Path) -> Set[str]:
     """Extract GitHub repository URLs from installer JSON file."""
     github_repos: Set[str] = set()
-    
     try:
         with open(json_file_path, 'r', encoding='utf-8') as file:
             data = json.load(file)
-            
         for installer in data.get("installers", []):
             repo_url = installer.get("repoURL", "")
             if is_github_repo(repo_url):
                 github_repos.add(repo_url)
-                
     except (json.JSONDecodeError, FileNotFoundError) as e:
         print(f"Error reading {json_file_path}: {e}")
-        
     return github_repos
-
-
-def get_repo_name_from_url(repo_url: str) -> str:
-    """Extract owner/repo from GitHub URL."""
+def get_repo_name_from_url(repo_url: str) -> Optional[tuple[str, str]]:
+    """Extract owner/repo from GitHub URL as a tuple (username, repo_name)."""
     try:
         parsed = urlparse(repo_url)
         path_parts = parsed.path.strip("/").split("/")
-        return f"{path_parts[0]}/{path_parts[1]}"
+        return (path_parts[0], path_parts[1])
     except (IndexError, AttributeError):
-        return ""
+        return None
+
 
+def fetch_github_release_data(
+    username: str,
+    repo_name: str,
+    version: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Fetch GitHub release data for the latest or a specific tag."""
 
-def fetch_github_release_data(repo_name: str) -> Optional[Dict[str, Any]]:
-    """Fetch latest release data from GitHub API using curl."""
     try:
-        cmd = [
-            "curl", "-s",
-            f"https://api.github.com/repos/{repo_name}/releases/latest"
-        ]
-        
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30
-        )
-        
-        if result.returncode != 0:
-            print(f"❌ Failed to fetch data for {repo_name}: {result.stderr}")
+        requested_version = (version or "").strip()
+        if requested_version and requested_version.lower() != "latest":
+            url = f"https://api.github.com/repos/{username}/{repo_name}/releases/tags/{requested_version}"
+        else:
+            url = f"https://api.github.com/repos/{username}/{repo_name}/releases/latest"
+
+        response = requests.get(url, timeout=30)
+        if response.status_code != 200:
+            print(f"❌ Failed to fetch data for {username}/{repo_name}: HTTP {response.status_code}")
             return None
-            
-        response_data = json.loads(result.stdout)
-        
-        # Check if API returned an error
-        if "message" in response_data:
-            if "API rate limit exceeded" in response_data.get("message", ""):
-                print(f"🚫 Rate limit exceeded for {repo_name}")
+
+        response_data = response.json()
+        message = response_data.get("message")
+        if isinstance(message, str):
+            if "API rate limit exceeded" in message:
+                print(f"🚫 Rate limit exceeded for {username}/{repo_name}")
                 return None
-            elif "Not Found" in response_data.get("message", ""):
-                print(f"🔍 No releases found for {repo_name}")
+            if "Not Found" in message:
+                print(f"🔍 No releases found for {username}/{repo_name}")
                 return None
-                
+
         return response_data
-        
-    except (subprocess.TimeoutExpired, json.JSONDecodeError, subprocess.SubprocessError) as e:
-        print(f"❌ Error fetching {repo_name}: {e}")
+
+    except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as error:
+        print(f"❌ Error fetching {username}/{repo_name}: {error}")
         return None
 
 
-def extract_release_info(release_data: Dict[str, Any]) -> Dict[str, Any]:
+def get_release_info(
+    username: str,
+    repo_name: str,
+    version: Optional[str] = None,
+) -> Optional[ReleaseInfo]:
+    """Return sanitized release information for the requested repository."""
+    release_data = fetch_github_release_data(username, repo_name, version)
+    if not release_data:
+        return None
+    return extract_release_info(release_data)
+
+
+def extract_release_info(release_data: Dict[str, Any]) -> Optional[ReleaseInfo]:
     """Extract relevant information from GitHub release data."""
     if not release_data:
-        return {}
-        
-    asset_names = [asset["name"] for asset in release_data.get("assets", [])]
-    
+        return None
+    assets: list[AssetInfo] = []
+    for asset in release_data.get("assets", []):
+        asset_info: AssetInfo = {
+            "name": asset.get("name", ""),
+            "size": asset.get("size", 0),
+            "download_count": asset.get("download_count", 0),
+            "content_type": asset.get("content_type", ""),
+            "created_at": asset.get("created_at", ""),
+            "updated_at": asset.get("updated_at", ""),
+            "browser_download_url": asset.get("browser_download_url", "")
+        }
+        assets.append(asset_info)
     return {
         "tag_name": release_data.get("tag_name", ""),
         "name": release_data.get("name", ""),
         "published_at": release_data.get("published_at", ""),
-        "assets": asset_names,
-        "assets_count": len(asset_names)
+        "assets": assets,
+        "assets_count": len(assets)
     }
 
 
-def main() -> None:
-    """Main function to process installer JSON files and fetch GitHub release data."""
-    # Define paths
-    current_dir = Path(__file__).parent
-    installer_dir = current_dir.parent.parent / "jobs" / "installer"
+# def main() -> None:
+#     """Main function to process installer JSON files and fetch GitHub release data."""
+#     # Define paths
+#     current_dir = Path(__file__).parent
+#     installer_dir = current_dir.parent.parent / "jobs" / "installer"
     
-    standard_json = installer_dir / "installer_data.json"
-    output_json = current_dir / "github_releases.json"
+#     standard_json = installer_dir / "installer_data.json"
+#     output_json = current_dir / "github_releases.json"
     
-    print("🔍 Starting GitHub release data extraction...")
-    print(f"📁 Processing files from: {installer_dir}")
+#     print("🔍 Starting GitHub release data extraction...")
+#     print(f"📁 Processing files from: {installer_dir}")
     
-    # Extract GitHub repositories from both files
-    all_github_repos: Set[str] = set()
+#     # Extract GitHub repositories from both files
+#     all_github_repos: Set[str] = set()
     
-    if standard_json.exists():
-        print(f"📄 Reading {standard_json.name}...")
-        repos = extract_github_repos_from_json(standard_json)
-        all_github_repos.update(repos)
-        print(f"   Found {len(repos)} GitHub repos")
-    else:
-        print(f"⚠️  File not found: {standard_json}")    
-    print(f"🎯 Total unique GitHub repositories found: {len(all_github_repos)}")
+#     if standard_json.exists():
+#         print(f"📄 Reading {standard_json.name}...")
+#         repos = extract_github_repos_from_json(standard_json)
+#         all_github_repos.update(repos)
+#         print(f"   Found {len(repos)} GitHub repos")
+#     else:
+#         print(f"⚠️  File not found: {standard_json}")    
+#     print(f"🎯 Total unique GitHub repositories found: {len(all_github_repos)}")
     
-    if not all_github_repos:
-        print("❌ No GitHub repositories found. Exiting.")
-        return
+#     if not all_github_repos:
+#         print("❌ No GitHub repositories found. Exiting.")
+#         return
     
-    # Fetch release data with rate limiting
-    release_mapping: Dict[str, Any] = {}
-    total_repos = len(all_github_repos)
+#     # Fetch release data with rate limiting
+#     release_mapping: Dict[str, Optional[ReleaseInfo]] = {}
+#     total_repos = len(all_github_repos)
     
-    print(f"\n🚀 Fetching release data for {total_repos} repositories...")
-    print("⏰ Rate limiting: 5 seconds between requests")
-    print("-" * 60)
+#     print(f"\n🚀 Fetching release data for {total_repos} repositories...")
+#     print("⏰ Rate limiting: 5 seconds between requests")
+#     print("-" * 60)
     
-    for i, repo_url in enumerate(sorted(all_github_repos), 1):
-        repo_name = get_repo_name_from_url(repo_url)
+#     for i, repo_url in enumerate(sorted(all_github_repos), 1):
+#         repo_info = get_repo_name_from_url(repo_url)
         
-        if not repo_name:
-            print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
-            continue
-            
-        print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_name}", end=" ... ")
+#         if not repo_info:
+#             print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
+#             continue
         
-        release_data = fetch_github_release_data(repo_name)
+#         username, repo_name = repo_info
+#         repo_full_name = f"{username}/{repo_name}"
+            
+#         print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_full_name}", end=" ... ")
         
-        if release_data:
-            release_info = extract_release_info(release_data)
-            release_mapping[repo_url] = release_info
-            assets_count = release_info.get("assets_count", 0)
-            tag = release_info.get("tag_name", "unknown")
-            print(f"✅ {tag} ({assets_count} assets)")
-        else:
-            release_mapping[repo_url] = {}
-            print("❌ No data")
+#         release_info = get_release_info(username, repo_name)
+
+#         if release_info:
+#             release_mapping[repo_url] = release_info
+#             assets_count = release_info["assets_count"]
+#             tag = release_info["tag_name"]
+#             print(f"✅ {tag} ({assets_count} assets)")
+#         else:
+#             release_mapping[repo_url] = None
+#             print("❌ No data")
         
-        # Rate limiting - wait 5 seconds between requests (except for the last one)
-        if i < total_repos:
-            time.sleep(5)
+#         # Rate limiting - wait 5 seconds between requests (except for the last one)
+#         if i < total_repos:
+#             time.sleep(5)
     
-    # Save results
-    output_data = {
-        "generated_at": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
-        "total_repositories": len(all_github_repos),
-        "successful_fetches": len([v for v in release_mapping.values() if v]),
-        "releases": release_mapping
-    }
+#     # Save results
+#     output_data: OutputData = {
+#         "generated_at": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
+#         "total_repositories": len(all_github_repos),
+#         "successful_fetches": len([v for v in release_mapping.values() if v]),
+#         "releases": release_mapping
+#     }
     
-    with open(output_json, 'w', encoding='utf-8') as f:
-        json.dump(output_data, f, indent=2, ensure_ascii=False)
+#     with open(output_json, 'w', encoding='utf-8') as f:
+#         json.dump(output_data, f, indent=2, ensure_ascii=False)
     
-    successful = len([v for v in release_mapping.values() if v])
-    print("\n📊 Summary:")
-    print(f"   Total repositories processed: {len(all_github_repos)}")
-    print(f"   Successful fetches: {successful}")
-    print(f"   Failed fetches: {len(all_github_repos) - successful}")
-    print(f"   Output saved to: {output_json}")
-    print("✅ Done!")
-
-
-if __name__ == "__main__":
-    main()
+#     successful = len([v for v in release_mapping.values() if v])
+#     print("\n📊 Summary:")
+#     print(f"   Total repositories processed: {len(all_github_repos)}")
+#     print(f"   Successful fetches: {successful}")
+#     print(f"   Failed fetches: {len(all_github_repos) - successful}")
+#     print(f"   Output saved to: {output_json}")
+#     print("✅ Done!")