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

machineconfig/utils/code.py

@@ -4,15 +4,15 @@ from machineconfig.utils.accessories import randstr
 from pathlib import Path
 
 
-def get_uv_run_command(platform: str) -> str:
+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" run"""
+            return """& "$env:USERPROFILE/.local/bin/uv" """
         case "Linux" | "linux" | "Darwin" | "darwin" | "macos":
-            return """$HOME/.local/bin/uv run"""
+            return """$HOME/.local/bin/uv """
         case _:
-            return """$HOME/.local/bin/uv run"""
+            return """$HOME/.local/bin/uv """
 
 def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     import platform
@@ -35,10 +35,10 @@ 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],
-                                           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)
+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:
         if prepend_print: uv_with.append("rich")
         uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
@@ -50,8 +50,18 @@ def get_uv_command_executing_python_script(python_script: str, uv_with: Optional
     if uv_project_dir is not None:
         uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
     else:
-        uv_project_dir_arg = ""
-    
+        uv_project_dir_arg = "--no-project"
+    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"),
@@ -59,18 +69,19 @@ def get_uv_command_executing_python_script(python_script: str, uv_with: Optional
         python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
     else:
         python_file.write_text(python_script, encoding="utf-8")
-    import platform
-    uv_run = get_uv_run_command(platform=platform.system())
-    shell_script = f"""{uv_run} {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    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:
+def get_shell_script_running_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[str, Path]:
     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)
+    uv_command, py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
+    return uv_command, py_file
+def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
+    uv_command, _py_file = get_shell_script_running_lambda_function(lmb=lmb, uv_with=uv_with, uv_project_dir=uv_project_dir)
+    run_shell_script(uv_command, display_script=True, clean_env=False)
 
 
 def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
@@ -92,35 +103,38 @@ 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
+    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, clean_env: bool):
     import platform
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
-
     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]")
@@ -136,7 +150,6 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
 def exit_then_run_shell_script(script: str, strict: bool = False):
     import os
     from rich.console import Console
-    
     console = Console()
     op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
     if op_program_path is not None:
@@ -176,6 +189,38 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
             console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")
         elif op_program_path is None:
             console.print("[cyan]ℹ️  OP_PROGRAM_PATH is not set.[/cyan] [yellow]Falling back to direct execution.[/yellow]")
-        run_shell_script(script)
+        run_shell_script(script, display_script=True, clean_env=False)
+    import sys
+    sys.exit(0)
+def exit_then_run_shell_file(script_path: str, strict: bool):
+    import os
+    from rich.console import Console
+    console = Console()
+    op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
+    if op_program_path is None or Path(op_program_path).exists():
+        if strict:
+            console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set or the file already exists in strict mode.[/red]")
+            import sys
+            sys.exit(1)
+    if op_program_path is None or Path(op_program_path).exists():
+        console.print("[cyan]ℹ️  OP_PROGRAM_PATH is not set.[/cyan] [yellow]Falling back to direct execution.[/yellow]")
+        run_shell_file(script_path=script_path, clean_env=False)
+        return
+    import platform
+    if platform.system() == "Windows":
+        suffix = ".ps1"
+        lexer = "powershell"
+        script = str(script_path)
+    elif platform.system() == "Linux" or platform.system() == "Darwin":
+        suffix = ".sh"
+        lexer = "bash"
+        script = f"source {str(script_path)}"
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    op_program_path = Path(op_program_path)
+    op_program_path.parent.mkdir(parents=True, exist_ok=True)
+    op_program_path.write_text(script, encoding="utf-8")
+    _ = suffix, lexer
+    console.print(f"[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH @ {str(op_program_path)}[/cyan]")
     import sys
     sys.exit(0)

machineconfig/utils/files/ascii_art.py

@@ -32,15 +32,11 @@ class BoxStyles:
 
 class CowStyles:
     eyes = ['-b', '-d', '-g', '-h', '-l', '-L', '-n', '-N', '-p', '-s', '-t', '-w', '-y']
-    # this one for the package installed with sudo apt install cowsay and is located at /usr/games/cowsay. See cowsay -l
-    figures = ['apt', 'bunny', 'cheese', 'cock', 'cower', 'daemon', 'default', 'dragon',
-               'dragon-and-cow', 'duck', 'elephant', 'elephant-in-snake', 'eyes', 'fox', 'ghostbusters',
-               'gnu', 'kangaroo', 'kiss', 'milk',
-               'moose', 'pony', 'pony-smaller', 'sheep', 'skeleton', 'snowman', 'stegosaurus',  # 'suse',
-               'three-eyes', 'turkey', 'turtle', 'tux', 'unipony', 'unipony-smaller', 'vader', 'vader']  # 'hellokitty' 'mech-and-cow'  # 'moofasa', 'stimpy', 'calvin', , 'ren', 'koala', 'flaming-sheep' , 'bud-frogs' , 'kosh' , 'luke-koala'
+    # Available characters from Python cowsay package (uv tool install cowsay)
+    figures = ['beavis', 'cheese', 'cow', 'daemon', 'dragon', 'fox', 'ghostbusters', 'kitty', 'meow', 'miki', 'milk', 'octopus', 'pig', 'stegosaurus', 'stimpy', 'trex', 'turkey', 'turtle', 'tux']
 
 
-FIGLET_FONTS = ['banner', 'big', 'standard']
+FIGLET_FONTS = ['Banner', 'Big', 'Standard']
 
 FIGJS_FONTS = ['3D Diagonal', '3D-ASCII', '4Max', '5 Line Oblique', 'Acrobatic', 'ANSI Regular', 'ANSI Shadow',
                'Avatar', 'Banner', 'Banner3-D', 'Banner4',
@@ -55,8 +51,8 @@ FIGJS_FONTS = ['3D Diagonal', '3D-ASCII', '4Max', '5 Line Oblique', 'Acrobatic',
 
 def get_art(comment: Optional[str] = None, artlib: Optional[BOX_OR_CHAR] = None, style: Optional[str] = None, super_style: str = 'scene', prefix: str = ' ', file: Optional[str] = None, verbose: bool = True):
     """ takes in a comment and does the following wrangling:
-    * text => figlet font => boxes => lolcat
-    * text => cowsay => lolcat
+    * text => figlet font => boxes => lolcatjs
+    * text => cowsay => lolcatjs
     """
     if comment is None:
         try:
@@ -68,10 +64,10 @@ def get_art(comment: Optional[str] = None, artlib: Optional[BOX_OR_CHAR] = None,
     if artlib == 'boxes':
         if style is None: style = random.choice(BoxStyles.__dict__[super_style or random.choice(['language', 'scene', 'character'])])
         fonting = f'figlet -f {random.choice(FIGLET_FONTS)}'
-        cmd = f"""echo "{comment}" | {fonting} | boxes -d {style} {to_file}"""
+        cmd = f"""{fonting} "{comment}" | boxes -d {style} {to_file}"""
     else:
         if style is None: style = random.choice(CowStyles.figures)
-        cmd = f"""echo "{comment}" | /usr/games/cowsay -f {style} {to_file}"""
+        cmd = f"""cowsay -c {style} -t "{comment}" {to_file}"""
     try:
         res = subprocess.run(cmd, text=True, capture_output=True, shell=True, check=True).stdout
     except subprocess.CalledProcessError as ex:
@@ -91,7 +87,7 @@ def font_box_color(logo: str):
     box_style = random.choice(['whirly', 'xes', 'columns', 'parchment', 'scroll', 'scroll-akn', 'diamonds', 'headline', 'nuke', 'spring', 'stark1'])
     _cmd = f'figlet -f "{font}" "{logo}" | boxes -d "{box_style}" | lolcatjs'
     # print(_cmd)
-    os.system(_cmd)  # | lolcat
+    os.system(_cmd)  # | lolcatjs
     # print("after")
 
 
@@ -100,7 +96,7 @@ def character_color(logo: str):
     with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
         f.write(ArtLib.cowsay(logo))
         _new_art = f.name
-    os.system(f'type {_new_art} | lolcatjs')  # | lolcat
+    os.system(f'type {_new_art} | lolcatjs')  # | lolcatjs
 
 
 def character_or_box_color(logo: str):
@@ -110,7 +106,7 @@ def character_or_box_color(logo: str):
     get_art(logo, artlib=None, file=_new_art, verbose=False)
     # Prefer bat on mac if available, fallback to cat
     pager = "bat" if (platform.system() == "Darwin" and any((Path(p).joinpath("bat").exists() for p in os.environ.get("PATH", "").split(os.pathsep)))) else "cat"
-    command = f"{pager} {_new_art} | lolcat"
+    command = f"{pager} {_new_art} | lolcatjs"
     os.system(command)
 
 

machineconfig/utils/files/headers.py

@@ -46,7 +46,7 @@ def print_logo(logo: str):
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
         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_lolcat = is_executable_in_path("lolcatjs")
         avail_boxes = is_executable_in_path("boxes")
         avail_figlet = is_executable_in_path("figlet")
         if avail_cowsay and avail_lolcat and avail_boxes and avail_figlet:
@@ -56,10 +56,8 @@ def print_logo(logo: str):
             #     print(Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*"))))).read_text())
             character_or_box_color(logo=logo)
         else:
-            print("\n" + "🚫 " + "-" * 70 + " 🚫")
-            install_cmd = "devops install --group TerminalEyeCandy" if platform.system() == "Linux" else "brew install cowsay lolcat boxes figlet"
-            print(f"🔍 Missing ASCII art dependencies. Install with: {install_cmd}")
-            print("🚫 " + "-" * 70 + " 🚫\n")
+            install_cmd = "devops install --group term-eye-candy "
+            print(f"🔍 Missing ASCII art dependencies. Install with: {install_cmd}  | {avail_boxes=} {avail_cowsay} {avail_figlet} {avail_lolcat=}")
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     else:

machineconfig/utils/files/read.py

@@ -14,7 +14,11 @@ class Read:
         if suffix in ("sqlite", "sqlite3", "db", "duckdb"):
             from machineconfig.utils.files.dbms import DBMS
             res = DBMS.from_local_db(path=path)
-            print(res.describe_db())
+            try:
+                print(res.describe_db())
+            except Exception:
+                print("💥 Could not describe the database.")
+                pass
             return res
         try: return getattr(Read, suffix)(str(path), **kwargs)
         except AttributeError as err:
@@ -28,6 +32,9 @@ class Read:
             elif suffix == "csv":
                 import polars as pl
                 return pl.read_csv(path, **kwargs)
+            elif suffix == "npz" or suffix == "npy":
+                import numpy as np
+                return np.load(str(path), **kwargs)
             try:
                 # guess = install_n_import('magic', 'python-magic').from_file(path)
                 guess = "IDKm"

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -10,6 +10,8 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Set, TypedDict
 from urllib.parse import urlparse
 
+from machineconfig.utils.installer_utils.github_release_scraper import scrape_github_release_page
+
 
 class AssetInfo(TypedDict):
     """Type definition for GitHub release asset information."""
@@ -74,7 +76,7 @@ def fetch_github_release_data(
     repo_name: str,
     version: Optional[str] = None,
 ) -> Optional[Dict[str, Any]]:
-    """Fetch GitHub release data for the latest or a specific tag."""
+    """Fetch GitHub release data for the latest or a specific tag. Falls back to HTML scraping if API fails."""
 
     try:
         requested_version = (version or "").strip()
@@ -85,24 +87,24 @@ def fetch_github_release_data(
 
         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
+            print(f"⚠️ API failed for {username}/{repo_name}: HTTP {response.status_code}, trying HTML scraper...")
+            return scrape_github_release_page(username, repo_name, version)
 
         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
+                print(f"🚫 Rate limit exceeded for {username}/{repo_name}, trying HTML scraper...")
+                return scrape_github_release_page(username, repo_name, version)
             if "Not Found" in message:
-                print(f"🔍 No releases found for {username}/{repo_name}")
-                return None
+                print(f"🔍 No releases found via API for {username}/{repo_name}, trying HTML scraper...")
+                return scrape_github_release_page(username, repo_name, version)
 
         return response_data
 
     except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as error:
-        print(f"❌ Error fetching {username}/{repo_name}: {error}")
-        return None
+        print(f"⚠️ API error for {username}/{repo_name}: {error}, trying HTML scraper...")
+        return scrape_github_release_page(username, repo_name, version)
 
 
 def get_release_info(
@@ -141,85 +143,3 @@ def extract_release_info(release_data: Dict[str, Any]) -> Optional[ReleaseInfo]:
         "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"
-    
-#     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}")
-    
-#     # 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 not all_github_repos:
-#         print("❌ No GitHub repositories found. Exiting.")
-#         return
-    
-#     # 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)
-    
-#     for i, repo_url in enumerate(sorted(all_github_repos), 1):
-#         repo_info = get_repo_name_from_url(repo_url)
-        
-#         if not repo_info:
-#             print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
-#             continue
-        
-#         username, repo_name = repo_info
-#         repo_full_name = f"{username}/{repo_name}"
-            
-#         print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_full_name}", end=" ... ")
-        
-#         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)
-    
-#     # 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)
-    
-#     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!")

machineconfig/utils/installer_utils/github_release_scraper.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""HTML scraper for GitHub release pages as fallback when API rate limit is exceeded."""
+
+import re
+from typing import Any, Optional
+import requests
+
+
+def extract_tag_from_html(html: str, owner: str, repo: str) -> str:
+    patterns = [
+        rf'/{re.escape(owner)}/{re.escape(repo)}/releases/tag/([^"\'<>\s]+)',
+        rf'/{re.escape(owner)}/{re.escape(repo)}/tree/([^"\'<>\s]+)',
+        r'<span[^>]*class="[^"]*ml-1[^"]*"[^>]*>([^<]+)</span>',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, html, re.IGNORECASE)
+        if match:
+            tag = match.group(1).strip()
+            if tag and not tag.startswith("http"):
+                return tag
+    return ""
+
+
+def extract_release_name(html: str) -> str:
+    patterns = [
+        r'<h1[^>]*class="[^"]*d-inline[^"]*"[^>]*>([^<]+)</h1>',
+        r'<bdi[^>]*class="[^"]*mr-2[^"]*"[^>]*>([^<]+)</bdi>',
+        r'<h1[^>]*>([^<]+)</h1>',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, html)
+        if match:
+            name = match.group(1).strip()
+            if name:
+                return name
+    return ""
+
+
+def extract_published_at(html: str) -> str:
+    pattern = r'<relative-time[^>]*datetime="([^"]+)"'
+    match = re.search(pattern, html)
+    if match:
+        return match.group(1)
+    return ""
+
+
+def fetch_expanded_assets(username: str, repo_name: str, tag_name: str, headers: dict[str, str]) -> list[dict[str, Any]]:
+    """Fetch assets from the expanded_assets endpoint which contains all downloadable files."""
+    assets: list[dict[str, Any]] = []
+    expanded_url = f"https://github.com/{username}/{repo_name}/releases/expanded_assets/{tag_name}"
+    try:
+        response = requests.get(expanded_url, timeout=30, headers=headers)
+        if response.status_code != 200:
+            print(f"⚠️ [Scraper] Could not fetch expanded assets for {username}/{repo_name}: HTTP {response.status_code}")
+            return assets
+        html = response.text
+        pattern = r'href="([^"]*?/releases/download/[^"]+)"[^>]*>.*?<span[^>]*class="[^"]*Truncate-text[^"]*text-bold[^"]*"[^>]*>([^<]+)</span>'
+        seen_urls: set[str] = set()
+        matches = re.findall(pattern, html, re.DOTALL)
+        for href, name in matches:
+            asset_name = name.strip()
+            if not asset_name or asset_name.isspace():
+                continue
+            download_url = f"https://github.com{href}" if href.startswith("/") else href
+            if download_url in seen_urls:
+                continue
+            seen_urls.add(download_url)
+            assets.append({"name": asset_name, "size": 0, "download_count": 0, "content_type": "", "created_at": "", "updated_at": "", "browser_download_url": download_url})
+    except requests.RequestException as error:
+        print(f"⚠️ [Scraper] Error fetching expanded assets for {username}/{repo_name}: {error}")
+    return assets
+
+
+def scrape_github_release_page(username: str, repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
+    """Scrape GitHub release page HTML to extract release information. Falls back to this when API rate limit is hit."""
+    try:
+        requested_version = (version or "").strip()
+        if requested_version and requested_version.lower() != "latest":
+            url = f"https://github.com/{username}/{repo_name}/releases/tag/{requested_version}"
+        else:
+            url = f"https://github.com/{username}/{repo_name}/releases/latest"
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"}
+        response = requests.get(url, timeout=30, headers=headers, allow_redirects=True)
+        if response.status_code != 200:
+            print(f"❌ [Scraper] Failed to fetch page for {username}/{repo_name}: HTTP {response.status_code}")
+            return None
+        html = response.text
+        tag_name = extract_tag_from_html(html, username, repo_name)
+        if not tag_name:
+            print(f"🔍 [Scraper] No tag found for {username}/{repo_name}")
+            return None
+        release_name = extract_release_name(html) or tag_name
+        published_at = extract_published_at(html)
+        assets = fetch_expanded_assets(username, repo_name, tag_name, headers)
+        print(f"✅ [Scraper] Found {len(assets)} assets for {username}/{repo_name} @ {tag_name}")
+        return {"tag_name": tag_name, "name": release_name, "published_at": published_at, "assets": assets}
+    except requests.RequestException as error:
+        print(f"❌ [Scraper] Error fetching {username}/{repo_name}: {error}")
+        return None

machineconfig/utils/installer_utils/install_from_url.py

@@ -150,7 +150,7 @@ def install_from_github_url(github_url: str) -> None:
         size_padded = item["size_str"].ljust(max_size_len)
         downloads_padded = item["downloads_str"].rjust(max_downloads_len)
         
-        label = f"{name_padded} {size_padded} | ⬇ {downloads_padded} | 📅 {item['date_str']}"
+        label = f"{name_padded} {size_padded} | #🔽 {downloads_padded} | 📅 {item['date_str']}"
         options_map[label] = item["asset"]
     
     if not options_map:

machineconfig/utils/installer_utils/installer_class.py

@@ -13,6 +13,9 @@ import subprocess
 from typing import Optional
 
 
+PACAKGE_MANAGERS = ["bun", "npm", "pip", "uv", "winget", "powershell", "irm", "brew", "curl", "sudo"]
+
+
 class Installer:
     def __init__(self, installer_data: InstallerData):
         self.installer_data: InstallerData = installer_data
@@ -62,8 +65,13 @@ class Installer:
         if installer_arch_os is None:
             raise ValueError(f"No installation pattern for {exe_name} on {os_name} {arch}")
         version_to_be_installed: str = "unknown"  # Initialize to ensure it's always bound
-        if repo_url == "CMD":
-            if any(pm in installer_arch_os for pm in ["npm ", "pip ", "winget ", "brew ", "curl "]):
+
+        package_manager_installer = any(pm in installer_arch_os.split(" ") for pm in PACAKGE_MANAGERS)
+        script_installer = installer_arch_os.endswith((".sh", ".py", ".ps1"))
+        binary_download_link = installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://")
+
+        if (repo_url == "CMD") or package_manager_installer or script_installer or binary_download_link:
+            if package_manager_installer:
                 from rich import print as rprint
                 from rich.panel import Panel
                 from rich.console import Group
@@ -81,7 +89,7 @@ class Installer:
                         sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
                     group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
                     rprint(Panel(group_content, title=desc, style="red"))
-            elif installer_arch_os.endswith((".sh", ".py", ".ps1")):
+            elif script_installer:
                 import machineconfig.jobs.installer as module
                 from pathlib import Path
                 search_root = Path(module.__file__).parent
@@ -106,7 +114,7 @@ class Installer:
                     import runpy
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
-            elif installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://"):
+            elif binary_download_link:
                 downloaded_object = download_and_prepare(installer_arch_os)
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":

machineconfig/utils/installer_utils/installer_cli.py

@@ -1,18 +1,5 @@
-"""Devops Devapps Install
-
-
-sudo apt update && sudo apt install -y \
-  git gcc g++ clang \
-  yasm nasm pkg-config \
-  meson ninja-build \
-  autoconf automake libtool \
-  libx11-dev libxext-dev libxrandr-dev libxrender-dev libxss-dev \
-  libvdpau-dev libgl1-mesa-dev libegl1-mesa-dev libxv-dev \
-  libasound2-dev libpulse-dev \
-  libfribidi-dev libfreetype-dev libfontconfig1-dev libharfbuzz-dev \
-  libjpeg-dev libssl-dev zlib1g-dev python3-pip
-
 
+"""Devops Devapps Install
 """
 
 from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
@@ -20,7 +7,6 @@ import typer
 from typing import Annotated, Optional
 
 
-
 def main_installer_cli(
     which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program/groups names to install (if --group flag is set).")] = None,
     group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,

machineconfig/utils/installer_utils/installer_helper.py

@@ -104,7 +104,7 @@ def install_deb_package(downloaded: Path) -> None:
 
 def download_and_prepare(download_url: str) -> PathExtended:
     # archive_path = PathExtended(download_url).download(folder=INSTALL_TMP_DIR)
-    from machineconfig.scripts.python.helpers_utils.download import download
+    from machineconfig.scripts.python.helpers.helpers_utils.download import download
     downloaded_object = download(download_url, output_dir=str(INSTALL_TMP_DIR))
     if downloaded_object is None:
         raise ValueError(f"Failed to download from URL: {download_url}")
@@ -121,7 +121,7 @@ def download_and_prepare(download_url: str) -> PathExtended:
                 if nested_path.is_file() and any(ex in nested_path.suffixes for ex in DECOMPRESS_SUPPORTED_FORMATS):
                     extracted_path = nested_path.decompress()
                     nested_path.delete(sure=True)
-    elif extracted_path.is_dir() and len(extracted_path.search("*", r=True)) == 1:
+    elif extracted_path.is_dir() and len([p for p in extracted_path.rglob("*") if not p.name.startswith(".")]) == 1:
         only_file_in = next(extracted_path.glob("*"))
         if only_file_in.is_file() and any(ext in str(only_file_in) for ext in DECOMPRESS_SUPPORTED_FORMATS):  # further decompress
             extracted_path = only_file_in.decompress()