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

machineconfig/utils/files/headers.py

@@ -6,7 +6,6 @@ import random
 from pathlib import Path
 from rich import pretty
 from rich.console import Console
-from typing import Optional
 
 
 def print_header():
@@ -26,8 +25,9 @@ def print_header():
     table.add_row("Virtual Environment", os.getenv('VIRTUAL_ENV', 'None'))
     table.add_row("Running @", str(Path.cwd()))
 
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
 
-    console.print(Panel(table, title="[bold blue]✨ 🐊 Crocodile Shell 14.5 ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
+    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):
     from machineconfig.utils.files.ascii_art import font_box_color, character_color, character_or_box_color
     if platform.system() == "Windows":
@@ -38,26 +38,23 @@ def print_logo(logo: str):
             if random.choice([True, True, False]): font_box_color(logo)
             else: character_color(logo)
         else:
-            print("\n" + "🚫 " + "-" * 70 + " 🚫")
-            print("🔍 Missing ASCII art dependencies. Install with: iwr bit.ly/cfgasciiartwindows | iex")
-            print("🚫 " + "-" * 70 + " 🚫\n")
+            # print("\n" + "🚫 " + "-" * 70 + " 🚫")
+            # print("🔍 Missing ASCII art dependencies. Install with: iwr bit.ly/cfgasciiartwindows | iex")
+            # print("🚫 " + "-" * 70 + " 🚫\n")
             _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
-        def is_executable_in_path(executable_name: str) -> Optional[str]:
-            path_dirs = os.environ['PATH'].split(os.pathsep)
-            for path_dir in path_dirs:
-                path_to_executable = os.path.join(path_dir, executable_name)
-                if os.path.isfile(path_to_executable) and os.access(path_to_executable, os.X_OK): return path_to_executable
-            return None
+        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")
         avail_figlet = is_executable_in_path("figlet")
         if avail_cowsay and avail_lolcat and avail_boxes and avail_figlet:
-            _dynamic_art = random.choice([True, True, True, True, False])
-            if _dynamic_art: character_or_box_color(logo=logo)
-            else: print(Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*"))))).read_text())
+            # _dynamic_art = random.choice([True, True, True, True, False])
+            # if _dynamic_art: character_or_box_color(logo=logo)
+            # else:
+            #     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"

machineconfig/utils/files/ouch/decompress.py

@@ -0,0 +1,45 @@
+
+
+from pathlib import Path
+from zipfile import ZipFile, BadZipFile
+from typing import Union
+
+
+def decompress_and_remove_zip(zip_path: Union[str, Path]) -> None:
+    """
+    Decompress a ZIP file and remove it after extraction.
+
+    Args:
+        zip_path (Union[str, Path]): Path to the ZIP file.
+
+    Raises:
+        FileNotFoundError: If the zip file does not exist.
+        BadZipFile: If the file is not a valid ZIP archive.
+        PermissionError: If the file cannot be deleted due to permission issues.
+        Exception: For other unexpected errors.
+    """
+    zip_path = Path(zip_path)
+
+    if not zip_path.exists():
+        raise FileNotFoundError(f"The file '{zip_path}' does not exist.")
+    
+    if not zip_path.is_file():
+        raise FileNotFoundError(f"The path '{zip_path}' is not a file.")
+
+    extract_dir = zip_path.parent
+
+    try:
+        with ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_dir)
+    except BadZipFile as e:
+        raise BadZipFile(f"The file '{zip_path}' is not a valid zip archive.") from e
+    except Exception as e:
+        raise Exception(f"Failed to extract '{zip_path}': {e}") from e
+
+    try:
+        zip_path.unlink()
+    except PermissionError as e:
+        raise PermissionError(f"Permission denied when deleting '{zip_path}'.") from e
+    except Exception as e:
+        raise Exception(f"Failed to delete '{zip_path}': {e}") from e
+

machineconfig/utils/files/read.py

@@ -12,18 +12,16 @@ class Read:
         suffix = Path(path).suffix[1:]
         if suffix == "": raise ValueError(f"File type could not be inferred from suffix. Suffix is empty. Path: {path}")
         if suffix in ("sqlite", "sqlite3", "db", "duckdb"):
-            # from crocodile.database import DBMS
-            # if suffix == "duckdb": pass
-            # res = DBMS.from_local_db(path=path)
-            # print(res.describe_db())
-            # return res
-            raise NotImplementedError("Reading database files is not implemented yet. Use `crocodile.database.DBMS` to connect to the database file.")
+            from machineconfig.utils.files.dbms import DBMS
+            res = DBMS.from_local_db(path=path)
+            print(res.describe_db())
+            return res
         try: return getattr(Read, suffix)(str(path), **kwargs)
         except AttributeError as err:
             if "type object 'Read' has no attribute" not in str(err): raise AttributeError(err) from err
             if suffix in ('eps', 'jpg', 'jpeg', 'pdf', 'pgf', 'png', 'ps', 'raw', 'rgba', 'svg', 'svgz', 'tif', 'tiff'):
                 import matplotlib.pyplot as pyplot
-                return pyplot.imread(path, **kwargs)  # from: plt.gcf().canvas.get_supported_filetypes().keys():
+                return pyplot.imread(str(path), **kwargs)  # from: plt.gcf().canvas.get_supported_filetypes().keys():
             if suffix == "parquet":
                 import polars as pl
                 return pl.read_parquet(path, **kwargs)
@@ -39,17 +37,11 @@ class Read:
                 raise ImportError(err) from err2
     @staticmethod
     def json(path: 'Path', r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
-        import json
-        try:
-            mydict = json.loads(Path(path).read_text(encoding='utf-8'), **kwargs)
-        except Exception:
-            import pyjson5
-            mydict = pyjson5.loads(Path(path).read_text(encoding='utf-8'), **kwargs)  # file has C-style comments.
-        _ = r
-        return mydict
+        from machineconfig.utils.io import read_json
+        return read_json(path, r=r, **kwargs)
     @staticmethod
     def yaml(path: 'Path', r: bool = False) -> Any:  # return could be list or dict etc
-        import yaml  # type: ignore
+        import yaml
         with open(str(path), "r", encoding="utf-8") as file:
             mydict = yaml.load(file, Loader=yaml.FullLoader)
         _ = r
@@ -63,8 +55,8 @@ class Read:
         return res
     @staticmethod
     def toml(path: 'Path'):
-        import toml
-        return toml.loads(Path(path).read_text(encoding='utf-8'))
+        import tomllib
+        return tomllib.loads(Path(path).read_text(encoding='utf-8'))
     @staticmethod
     def npy(path: 'Path', **kwargs: Any):
         import numpy as np

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!")