machineconfig 7.79__py3-none-any.whl → 7.83__py3-none-any.whl

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -6,12 +6,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,87 +47,99 @@ 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(repo_name: str) -> Optional[Dict[str, Any]]:
-    """Fetch latest release data from GitHub API using curl."""
+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."""
+
     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)
     }
 
 
@@ -132,7 +172,7 @@ def main() -> None:
         return
     
     # Fetch release data with rate limiting
-    release_mapping: Dict[str, Any] = {}
+    release_mapping: Dict[str, Optional[ReleaseInfo]] = {}
     total_repos = len(all_github_repos)
     
     print(f"\n🚀 Fetching release data for {total_repos} repositories...")
@@ -140,24 +180,26 @@ def main() -> None:
     print("-" * 60)
     
     for i, repo_url in enumerate(sorted(all_github_repos), 1):
-        repo_name = get_repo_name_from_url(repo_url)
+        repo_info = get_repo_name_from_url(repo_url)
         
-        if not repo_name:
+        if not repo_info:
             print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
             continue
-            
-        print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_name}", end=" ... ")
         
-        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_info = get_release_info(username, repo_name)
+
+        if release_info:
             release_mapping[repo_url] = release_info
-            assets_count = release_info.get("assets_count", 0)
-            tag = release_info.get("tag_name", "unknown")
+            assets_count = release_info["assets_count"]
+            tag = release_info["tag_name"]
             print(f"✅ {tag} ({assets_count} assets)")
         else:
-            release_mapping[repo_url] = {}
+            release_mapping[repo_url] = None
             print("❌ No data")
         
         # Rate limiting - wait 5 seconds between requests (except for the last one)
@@ -165,7 +207,7 @@ def main() -> None:
             time.sleep(5)
     
     # Save results
-    output_data = {
+    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]),

machineconfig/utils/installer_utils/install_from_url.py

@@ -4,46 +4,23 @@ import platform
 from urllib.parse import urlparse
 
 import typer
-from typing import Optional, TypeAlias, cast
+from typing import TYPE_CHECKING
 
-from machineconfig.utils.installer_utils.installer_class import install_deb_package
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package
 from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.installer_utils.github_release_bulk import (
+    get_repo_name_from_url,
+    fetch_github_release_data,
+    extract_release_info,
+    AssetInfo,
+)
 from machineconfig.utils.path_extended import DECOMPRESS_SUPPORTED_FORMATS, PathExtended
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
 
-SUPPORTED_GITHUB_HOSTS = {"github.com", "www.github.com"}
-
-GitHubAsset: TypeAlias = dict[str, object]
-GitHubRelease: TypeAlias = dict[str, object]
-
-
-def _extract_repo_name(github_url: str) -> str:
-    parsed = urlparse(github_url)
-    parts = [part for part in parsed.path.strip("/").split("/") if part]
-    if len(parts) < 2:
-        return ""
-    owner, repo = parts[0], parts[1]
-    if repo == "":
-        return ""
-    return f"{owner}/{repo}"
-
+if TYPE_CHECKING:
+    from rich.console import Console
 
-def _fetch_latest_release(repo_name: str) -> Optional[GitHubRelease]:
-    import json
-    import requests
-    try:
-        response = requests.get(f"https://api.github.com/repos/{repo_name}/releases/latest", timeout=30)
-    except requests.RequestException:
-        return None
-    if response.status_code != 200:
-        return None
-    try:
-        data = response.json()
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(data, dict):
-        return None
-    return cast(GitHubRelease, data)
+SUPPORTED_GITHUB_HOSTS = {"github.com", "www.github.com"}
 
 
 def _format_size(size_bytes: int) -> str:
@@ -71,74 +48,8 @@ def _derive_tool_name(repo_name: str, asset_name: str) -> str:
     return "githubapp"
 
 
-def install_from_github_url(github_url: str) -> None:
-    from machineconfig.utils.options import choose_from_options
-    from rich.console import Console
-    from rich.panel import Panel
-
-    console = Console()
-    repo_name = _extract_repo_name(github_url)
-    if repo_name == "":
-        console.print(Panel(f"Invalid GitHub URL: {github_url}", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    console.print(Panel(f"Fetching latest release for [green]{repo_name}[/green]", title="🌐 GitHub", border_style="blue"))
-    release_raw = _fetch_latest_release(repo_name)
-    if not release_raw:
-        console.print(Panel("No releases available for this repository.", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    release = release_raw
-    assets_value = release.get("assets", [])
-    assets: list[GitHubAsset] = []
-    if isinstance(assets_value, list):
-        for asset in assets_value:
-            if isinstance(asset, dict):
-                typed_asset: GitHubAsset = {}
-                name_value = asset.get("name")
-                url_value = asset.get("browser_download_url")
-                size_value = asset.get("size")
-                content_value = asset.get("content_type")
-                if isinstance(name_value, str):
-                    typed_asset["name"] = name_value
-                if isinstance(url_value, str):
-                    typed_asset["browser_download_url"] = url_value
-                if isinstance(size_value, int):
-                    typed_asset["size"] = size_value
-                if isinstance(content_value, str):
-                    typed_asset["content_type"] = content_value
-                assets.append(typed_asset)
-    if not assets:
-        console.print(Panel("No downloadable assets found in the latest release.", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    binary_assets = assets
-    selection_pool = binary_assets if binary_assets else assets
-    if not selection_pool:
-        console.print(Panel("No assets available for installation.", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    options_map: dict[str, GitHubAsset] = {}
-    for asset in selection_pool:
-        name = asset.get("name")
-        download_url = asset.get("browser_download_url")
-        if not isinstance(name, str) or not isinstance(download_url, str) or name == "" or download_url == "":
-            continue
-        size_value = asset.get("size")
-        size = size_value if isinstance(size_value, int) else 0
-        label = f"{name} [{_format_size(size)}]"
-        options_map[label] = asset
-    if not options_map:
-        console.print(Panel("Release assets lack download URLs.", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    selection_label = choose_from_options(options=list(options_map.keys()), msg="Select a release asset", multi=False, header="📦 GitHub Release Assets", fzf=True)
-    selected_asset = options_map[selection_label]
-    download_url_value = selected_asset.get("browser_download_url")
-    asset_name_value = selected_asset.get("name")
-    if not isinstance(download_url_value, str) or download_url_value == "":
-        console.print(Panel("Selected asset lacks a download URL.", title="❌ Error", border_style="red"))
-        raise typer.Exit(1)
-    asset_name = asset_name_value if isinstance(asset_name_value, str) else "github_binary"
-    version_value = release.get("tag_name")
-    version = version_value if isinstance(version_value, str) and version_value != "" else "latest"
-    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan]", title="⬇️ Download", border_style="magenta"))
-    archive_path = PathExtended(download_url_value).download(folder=INSTALL_TMP_DIR)
+def _download_and_prepare(download_url: str) -> PathExtended:
+    archive_path = PathExtended(download_url).download(folder=INSTALL_TMP_DIR)
     extracted_path = archive_path
     if extracted_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
         extracted_path = archive_path.decompress()
@@ -150,6 +61,12 @@ def install_from_github_url(github_url: str) -> None:
                 if nested_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
                     extracted_path = nested_path.decompress()
                     nested_path.delete(sure=True)
+    return extracted_path
+
+
+def _finalize_install(repo_name: str, asset_name: str, version: str, extracted_path: PathExtended, console: "Console") -> None:
+    from rich.panel import Panel
+
     if extracted_path.suffix == ".deb":
         install_deb_package(extracted_path)
         tool_name_deb = _derive_tool_name(repo_name, asset_name)
@@ -178,3 +95,106 @@ def install_from_github_url(github_url: str) -> None:
     INSTALL_VERSION_ROOT.joinpath(tool_name).parent.mkdir(parents=True, exist_ok=True)
     INSTALL_VERSION_ROOT.joinpath(tool_name).write_text(version, encoding="utf-8")
     console.print(Panel(f"Installed [green]{tool_name}[/green] to {installed_path}\nVersion: {version}", title="✅ Complete", border_style="green"))
+
+
+def install_from_github_url(github_url: str) -> None:
+    from machineconfig.utils.options import choose_from_options
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+    repo_info = get_repo_name_from_url(github_url)
+    if repo_info is None:
+        console.print(Panel(f"Invalid GitHub URL: {github_url}", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    owner, repo = repo_info
+    repo_name = f"{owner}/{repo}"
+    console.print(Panel(f"Fetching latest release for [green]{repo_name}[/green]", title="🌐 GitHub", border_style="blue"))
+    release_raw = fetch_github_release_data(owner, repo)
+    if not release_raw:
+        console.print(Panel("No releases available for this repository.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    
+    release_info = extract_release_info(release_raw)
+    if not release_info:
+        console.print(Panel("Failed to parse release information.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    
+    assets = release_info["assets"]
+    if not assets:
+        console.print(Panel("No downloadable assets found in the latest release.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    binary_assets = assets
+    selection_pool = binary_assets if binary_assets else assets
+    if not selection_pool:
+        console.print(Panel("No assets available for installation.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    
+    # First pass: collect all formatted data and calculate column widths
+    asset_data = []
+    for asset in selection_pool:
+        name = asset["name"]
+        download_url = asset["browser_download_url"]
+        if name == "" or download_url == "":
+            continue
+        size = asset["size"]
+        download_count = asset.get("download_count", 0)
+        created_at = asset.get("created_at", "")
+        
+        # Format each field
+        size_str = f"[{_format_size(size)}]"
+        downloads_str = f"{download_count:,}"
+        date_str = created_at.split("T")[0] if created_at else "N/A"
+        
+        asset_data.append({
+            "name": name,
+            "size_str": size_str,
+            "downloads_str": downloads_str,
+            "date_str": date_str,
+            "asset": asset
+        })
+    
+    # Calculate maximum widths for alignment
+    max_name_len = max(len(item["name"]) for item in asset_data) if asset_data else 0
+    max_size_len = max(len(item["size_str"]) for item in asset_data) if asset_data else 0
+    max_downloads_len = max(len(item["downloads_str"]) for item in asset_data) if asset_data else 0
+    
+    # Second pass: build aligned labels
+    options_map: dict[str, AssetInfo] = {}
+    for item in asset_data:
+        name_padded = item["name"].ljust(max_name_len)
+        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']}"
+        options_map[label] = item["asset"]
+    
+    if not options_map:
+        console.print(Panel("Release assets lack download URLs.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    selection_label = choose_from_options(options=list(options_map.keys()), msg="Select a release asset", multi=False, header="📦 GitHub Release Assets", fzf=True)
+    selected_asset = options_map[selection_label]
+    download_url_value = selected_asset["browser_download_url"]
+    asset_name_value = selected_asset["name"]
+    if download_url_value == "":
+        console.print(Panel("Selected asset lacks a download URL.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    asset_name = asset_name_value if asset_name_value != "" else "github_binary"
+    version = release_info["tag_name"] if release_info["tag_name"] != "" else "latest"
+    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan]", title="⬇️ Download", border_style="magenta"))
+    extracted_path = _download_and_prepare(download_url_value)
+    _finalize_install(repo_name=repo_name, asset_name=asset_name, version=version, extracted_path=extracted_path, console=console)
+
+
+def install_from_binary_url(binary_url: str) -> None:
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+    parsed = urlparse(binary_url)
+    asset_candidate = parsed.path.split("/")[-1] if parsed.path else ""
+    asset_name = asset_candidate if asset_candidate != "" else "binary_asset"
+    host = parsed.netloc if parsed.netloc != "" else "remote host"
+    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan] from [green]{host}[/green]", title="⬇️ Download", border_style="magenta"))
+    extracted_path = _download_and_prepare(binary_url)
+    _finalize_install(repo_name="", asset_name=asset_name, version="latest", extracted_path=extracted_path, console=console)

machineconfig/utils/installer_utils/installer_class.py

@@ -1,35 +1,16 @@
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package
 from machineconfig.utils.path_extended import PathExtended, DECOMPRESS_SUPPORTED_FORMATS
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
 from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows, check_tool_exists
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, get_os_name, get_normalized_arch
+from machineconfig.utils.installer_utils.github_release_bulk import (
+    get_repo_name_from_url,
+    get_release_info,
+)
 
 import platform
 import subprocess
-import json
-from typing import Optional, Any
-from urllib.parse import urlparse
-
-
-
-def install_deb_package(downloaded: PathExtended) -> None:
-    from rich import print as rprint
-    from rich.panel import Panel
-    print(f"📦 Installing .deb package: {downloaded}")
-    assert platform.system() == "Linux"
-    result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
-    success = result.returncode == 0 and result.stderr == ""
-    if not success:
-        from rich.console import Group
-        desc = "Installing .deb"
-        sub_panels = []
-        if result.stdout:
-            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
-        if result.stderr:
-            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"))
-    print("🗑️  Cleaning up .deb package...")
-    downloaded.delete(sure=True)
+from typing import Optional
 
 
 class Installer:
@@ -125,7 +106,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://"):  # its a url to be downloaded
+            elif installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://"):
                 # downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
                 from machineconfig.scripts.python.helpers_utils.download import download
                 downloaded_object = download(installer_arch_os, output_dir=str(INSTALL_TMP_DIR))
@@ -221,44 +202,6 @@ class Installer:
             if only_file_in.is_file() and only_file_in.suffix in DECOMPRESS_SUPPORTED_FORMATS:  # further decompress
                 downloaded = only_file_in.decompress()
         return downloaded, version_to_be_installed
-    @staticmethod
-    def _get_repo_name_from_url(repo_url: str) -> str:
-        """Extract owner/repo from GitHub URL."""
-        try:
-            parsed = urlparse(repo_url)
-            path_parts = parsed.path.strip("/").split("/")
-            return f"{path_parts[0]}/{path_parts[1]}"
-        except (IndexError, AttributeError):
-            return ""
-
-    @staticmethod
-    def _fetch_github_release_data(repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
-        """Fetch release data from GitHub API using requests."""
-        import requests
-        try:
-            if version and version.lower() != "latest":  # Fetch specific version
-                url = f"https://api.github.com/repos/{repo_name}/releases/tags/{version}"
-            else:   # Fetch latest release
-                url = f"https://api.github.com/repos/{repo_name}/releases/latest"
-            response = requests.get(url, timeout=30)
-            if response.status_code != 200:
-                print(f"❌ Failed to fetch data for {repo_name}: HTTP {response.status_code}")
-                return None
-            response_data = response.json()
-            # 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}")
-                    return None
-                elif "Not Found" in response_data.get("message", ""):
-                    print(f"🔍 No releases found for {repo_name}")
-                    return None
-                    
-            return response_data
-            
-        except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as e:
-            print(f"❌ Error fetching {repo_name}: {e}")
-            return None
 
     def get_github_release(self, repo_url: str, version: Optional[str]) -> tuple[Optional[str], Optional[str]]:
         """
@@ -270,20 +213,20 @@ class Installer:
         filename_pattern = self.installer_data["fileNamePattern"][arch][os_name]
         if filename_pattern is None:
             raise ValueError(f"No fileNamePattern for {self._get_exe_name()} on {os_name} {arch}")
-        repo_name = self._get_repo_name_from_url(repo_url)
-        if not repo_name:
+        repo_info = get_repo_name_from_url(repo_url)
+        if not repo_info:
             print(f"❌ Invalid repository URL: {repo_url}")
             return None, None
-        release_data = self._fetch_github_release_data(repo_name, version)
-        if not release_data:
+        username, repository = repo_info
+        release_info = get_release_info(username, repository, version)
+        if not release_info:
             return None, None        
-        # print(release_data)
-        actual_version = release_data.get("tag_name", "unknown")
+        actual_version = release_info.get("tag_name", "unknown") or "unknown"
         filename = filename_pattern.format(version=actual_version)
 
         available_filenames: list[str] = []
-        for asset in release_data.get("assets", []):
-            an_dl = asset.get("browser_download_url", "NA")
+        for asset in release_info["assets"]:
+            an_dl = asset["browser_download_url"]
             available_filenames.append(an_dl.split("/")[-1])
         if filename not in available_filenames:
             candidates = [