lmms 1.1.7__py3-none-any.whl

lmms-1.1.7.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: lmms
+Version: 1.1.7
+Summary: Builder, hardware profiler, and toolchain manager for the LMMs Ecosystem.
+Author: MarkanM
+Requires-Python: >=3.9
+Requires-Dist: psutil
+Requires-Dist: rich
+Requires-Dist: requests
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

lmms-1.1.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+lmms_builder/__init__.py,sha256=s4WXUCdtZenBWJdOJj8FZE-SsdNjqm_9x6igsTb_quM,52
+lmms_builder/cli.py,sha256=CLfuR3X_hVT6ryxMRH_oGBy9fgsV2xM1dKcHNlOVU0I,5575
+lmms_builder/hardware.py,sha256=R6d85tn3PCOQYgj2vMzmFE8iz7nCO9s_OzO8mBZnwSo,3092
+lmms_builder/installer.py,sha256=wqNT1BAEKx_hjlLmM05hErTLlYLmdkCF4SdUfT0bsBU,13779
+lmms_builder/reporter.py,sha256=AqYfzThEbDio_ftJ5Q2fo9isd_YFFjTsXckC-kLug4A,3898
+lmms-1.1.7.dist-info/METADATA,sha256=KMn5d-UaekkTc5up7nUzB9GgjU7G8acVYRou4i7x-d8,317
+lmms-1.1.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lmms-1.1.7.dist-info/entry_points.txt,sha256=BpRHTzaz0SeFuDpI_5OO1bB1IsREzlfY_mpXeHOSJok,141
+lmms-1.1.7.dist-info/top_level.txt,sha256=CvyaNnnSTryMQZoYWbnMFuzmbwXLwjS8KWanpLg0kl0,13
+lmms-1.1.7.dist-info/RECORD,,

lmms-1.1.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lmms-1.1.7.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+LMMs = lmms_builder.cli:unified_main
+LMMs-uninstall = lmms_builder.cli:uninstall_main
+lmms = lmms_builder.cli:unified_main

lmms-1.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+lmms_builder

lmms_builder/__init__.py

@@ -0,0 +1,3 @@
+"""
+LMMS Builder - Bootstrapper for the LMMs OS
+"""

lmms_builder/cli.py

@@ -0,0 +1,136 @@
+import argparse
+import sys
+import os
+import shutil
+import platform
+import subprocess
+import json
+from pathlib import Path
+
+from . import hardware
+from . import reporter
+from . import installer
+
+LMMS_CONFIG_DIR = Path(os.path.expanduser("~/.lmms"))
+LMMS_PROJECT_DIR = Path(os.path.expanduser("~/.lmms/app/src"))
+LMMS_APP_DIR = Path(os.path.expanduser("~/.lmms/app"))
+
+def print_help():
+    reporter.print_header()
+    print("\n[bold yellow]=== LMMs Complete Command List ===[/bold yellow]")
+    print("\n[bold cyan]1) Installer / Updater[/bold cyan]")
+    print("  LMMs -check                 : Automatically detects OS, hardware compatibility, and installed LMMs components.")
+    print("  LMMs install --all          : Downloads and installs the entire LMMs ecosystem.")
+    print("  LMMs update --all           : Forces a download of the latest code/binary version from GitHub Releases.")
+    
+    print("\n[bold cyan]2) Uninstall[/bold cyan]")
+    print("  LMMs-uninstall -all         : Deletes the LMMs source code but keeps Pip packages and User Data safe.")
+    print("  LMMs-uninstall -all --purge : Completely removes ALL LMMs code, pip environments, and user data (Factory Reset).")
+    
+    print("\n[bold cyan]3) Launch Options[/bold cyan]")
+    print("  LMMs --gui|--cli|--engine   : Directly runs the specified component overriding the default.")
+    print("  LMMs                        : Runs the default configured component.\n")
+
+
+def builder_main():
+    args_lower = [arg.lower() for arg in sys.argv]
+    if "-check" in args_lower:
+        reporter.print_step("Running LMMs System Check...")
+        hw = hardware.detect_all()
+        reporter.print_hardware_report(hw)
+        installed = installer.get_installed_components()
+        reporter.print_step("Installed Components:")
+        for k, v in installed.items():
+            if v:
+                print(f"  - {k.capitalize()}")
+        if not any(installed.values()):
+            print("  - None")
+        return
+
+    if "install" in args_lower or "update" in args_lower:
+        force_update = "update" in args_lower
+        if "--all" in args_lower:
+            installer.install_component("all", force=force_update)
+        else:
+            print("Usage: LMMs install --all")
+        return
+        
+    print_help()
+
+
+def uninstall_main():
+    install_dir = Path.home() / ".lmms" / "bin" if platform.system().lower() == "windows" else Path("/usr/local/bin")
+    fallback_dir = Path.home() / ".local" / "bin"
+    
+    args_lower = [arg.lower() for arg in sys.argv]
+    if "-all" not in args_lower:
+        print("Usage: LMMs-uninstall -all [--purge]")
+        return
+
+    if "--purge" in args_lower:
+        ans = input("WARNING: This will PURGE LMMs code, Python environments, and ALL user data (models, chats). Continue? [y/N]: ")
+        if ans.lower() == 'y':
+            shutil.rmtree(LMMS_APP_DIR, ignore_errors=True)
+            shutil.rmtree(LMMS_CONFIG_DIR, ignore_errors=True)
+            
+            # Remove global binaries
+            bin_name = "lmms.exe" if platform.system().lower() == "windows" else "lmms"
+            (install_dir / bin_name).unlink(missing_ok=True)
+            (fallback_dir / bin_name).unlink(missing_ok=True)
+            reporter.print_success("Purge complete. All LMMs files and data have been removed.")
+    else:
+        ans = input("INFO: This will delete the LMMs source code but KEEP your Python environment and User Data safe. Continue? [y/N]: ")
+        if ans.lower() == 'y':
+            src_dir = LMMS_APP_DIR / "src"
+            shutil.rmtree(src_dir, ignore_errors=True)
+            
+            # Mark uninstalled
+            installed = installer.get_installed_components()
+            installed["all"] = False
+            with open(installer.get_registry_path(), "w") as f:
+                json.dump(installed, f)
+            reporter.print_success("Code uninstalled. Pip packages and User Data remain safe.")
+
+
+def lmms_main():
+    args_lower = [arg.lower() for arg in sys.argv]
+    mode = None
+    if "--gui" in args_lower: mode = "gui"
+    elif "--cli" in args_lower: mode = "cli"
+    elif "--engine" in args_lower: mode = "engine"
+    else:
+        # Load default
+        config_path = LMMS_CONFIG_DIR / "config" / "config.json"
+        if config_path.exists():
+            with open(config_path, "r") as f:
+                try: mode = json.load(f).get("default_mode", "cli")
+                except: mode = "cli"
+        else:
+            mode = "cli"
+            
+    # Always use the launcher script through the VENV python
+    venv_python = LMMS_APP_DIR / "venv" / "Scripts" / "python.exe" if platform.system().lower() == "windows" else LMMS_APP_DIR / "venv" / "bin" / "python"
+    launcher_script = LMMS_PROJECT_DIR / "lmms_launcher.pyc"
+    if not launcher_script.exists():
+        launcher_script = LMMS_PROJECT_DIR / "lmms_launcher.py"
+
+    if launcher_script.exists():
+        cmd = [str(venv_python), str(launcher_script)]
+        if mode and mode != "cli":
+            cmd.append(mode)
+            
+        forward_args = [a for a in sys.argv[1:] if a not in ["--gui", "--cli", "--engine"]]
+        cmd.extend(forward_args)
+        
+        os.execvp(str(venv_python), cmd)
+    else:
+        print("LMMs launcher not found. Please run: LMMs install --all")
+
+
+def unified_main():
+    """Entry point for the 'LMMs' command."""
+    args_lower = [arg.lower() for arg in sys.argv]
+    if len(args_lower) > 1 and args_lower[1] in ["install", "update", "-check", "-help", "--help"]:
+        builder_main()
+    else:
+        lmms_main()

lmms_builder/hardware.py

@@ -0,0 +1,106 @@
+import os
+import platform
+import psutil
+import subprocess
+
+def detect_os():
+    return {
+        "system": platform.system(),
+        "release": platform.release(),
+        "architecture": platform.machine(),
+    }
+
+def detect_cpu():
+    return {
+        "cores": psutil.cpu_count(logical=False),
+        "threads": psutil.cpu_count(logical=True),
+    }
+
+def detect_ram():
+    mem = psutil.virtual_memory()
+    return {
+        "total_gb": round(mem.total / (1024**3), 2),
+        "available_gb": round(mem.available / (1024**3), 2)
+    }
+
+def detect_gpu():
+    try:
+        # Check nvidia-smi
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+            capture_output=True, text=True, check=True
+        )
+        lines = result.stdout.strip().split("\n")
+        if lines and lines[0]:
+            parts = lines[0].split(",")
+            name = parts[0].strip()
+            vram_str = parts[1].strip()
+            vram_mb = int(vram_str.replace(" MiB", ""))
+            return {
+                "detected": True,
+                "name": name,
+                "vram_gb": round(vram_mb / 1024, 2),
+                "type": "nvidia"
+            }
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+        
+    return {
+        "detected": False,
+        "name": "None",
+        "vram_gb": 0.0,
+        "type": "none"
+    }
+
+def detect_cuda():
+    try:
+        result = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, check=True)
+        for line in result.stdout.split("\n"):
+            if "release" in line:
+                version = line.split("release")[1].strip().split(",")[0]
+                return {"available": True, "version": version}
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+        
+    try:
+        result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, check=True)
+        if "CUDA Version: " in result.stdout:
+            version = result.stdout.split("CUDA Version: ")[1].split(" ")[0]
+            return {"available": True, "version": version}
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    return {"available": False, "version": None}
+
+def detect_python():
+    return {
+        "version": platform.python_version()
+    }
+
+import shutil
+from pathlib import Path
+
+def detect_tools():
+    system = platform.system().lower()
+    vscode = shutil.which("code") is not None
+    bt = False
+    if system == "windows":
+        bt_path = Path("C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools")
+        bt_path2 = Path("C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools")
+        bt = bt_path.exists() or bt_path2.exists()
+        
+    return {
+        "vscode": vscode,
+        "build_tools": bt
+    }
+
+def detect_all():
+    return {
+        "os": detect_os(),
+        "cpu": detect_cpu(),
+        "ram": detect_ram(),
+        "gpu": detect_gpu(),
+        "cuda": detect_cuda(),
+        "python": detect_python(),
+        "tools": detect_tools()
+    }

lmms_builder/installer.py

@@ -0,0 +1,341 @@
+import subprocess
+import sys
+import json
+import os
+import platform
+import shutil
+import zipfile
+import requests
+from pathlib import Path
+from rich.progress import Progress, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
+from . import reporter
+
+def check_python_version():
+    return sys.version_info >= (3, 9)
+
+def check_prerequisites():
+    system = platform.system().lower()
+    missing_tools = []
+    
+    reporter.print_step("Checking prerequisites...")
+    
+    # Check VS Code
+    if not shutil.which("code"):
+        missing_tools.append(("Visual Studio Code", "Microsoft.VisualStudioCode"))
+        
+    # Check Build Tools (Windows only)
+    if system == "windows":
+        bt_path = Path("C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools")
+        bt_path2 = Path("C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools")
+        if not bt_path.exists() and not bt_path2.exists():
+            missing_tools.append(("Visual Studio Build Tools (C++)", "Microsoft.VisualStudio.2022.BuildTools"))
+            
+    if missing_tools:
+        reporter.print_error("The following required tools are missing:")
+        for name, _ in missing_tools:
+            print(f"  - {name}")
+            
+        ans = input("Would you like to automatically install them now? [y/N]: ")
+        if ans.lower() == 'y':
+            for name, pkg_id in missing_tools:
+                reporter.print_step(f"Installing {name}...")
+                if system == "windows":
+                    try:
+                        subprocess.run(["winget", "install", "-e", "--id", pkg_id, "--accept-package-agreements", "--accept-source-agreements"], check=True)
+                        reporter.print_success(f"✓ {name} installed.")
+                    except:
+                        reporter.print_error(f"Failed to install {name} via winget. Please install it manually.")
+                else:
+                    reporter.print_error("Auto-install for this tool is only supported on Windows via winget.")
+        else:
+            reporter.print_error("Please install them manually to avoid issues.")
+    else:
+        reporter.print_success("✓ All prerequisites are installed.")
+    return True
+
+def get_registry_path():
+    p = Path(os.path.expanduser("~/.lmms/config/installed_components.json"))
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+def get_installed_components():
+    reg = get_registry_path()
+    if reg.exists():
+        try:
+            with open(reg, "r") as f:
+                return json.load(f)
+        except:
+            pass
+    return {}
+
+def mark_installed(component):
+    installed = get_installed_components()
+    installed[component] = True
+    with open(get_registry_path(), "w") as f:
+        json.dump(installed, f)
+
+def get_app_dir():
+    return Path.home() / ".lmms" / "app"
+
+def get_venv_python():
+    system = platform.system().lower()
+    app_dir = get_app_dir()
+    if system == "windows":
+        return app_dir / "venv" / "Scripts" / "python.exe"
+    return app_dir / "venv" / "bin" / "python"
+
+def install_python_os(system):
+    reporter.print_step("Attempting to auto-install Python...")
+    try:
+        if system == "linux":
+            reporter.print_step("Using apt to install Python 3.11... (You may be prompted for sudo password)")
+            subprocess.run(["sudo", "apt", "update"], check=True)
+            subprocess.run(["sudo", "apt", "install", "-y", "python3.11", "python3.11-venv"], check=True)
+            return True
+        elif system == "darwin":
+            reporter.print_step("Using brew to install Python 3.11...")
+            subprocess.run(["brew", "install", "python@3.11"], check=True)
+            return True
+        elif system == "windows":
+            reporter.print_step("Using winget to install Python 3.11...")
+            subprocess.run(["winget", "install", "-e", "--id", "Python.Python.3.11", "--accept-package-agreements", "--accept-source-agreements"], check=True)
+            return True
+    except subprocess.CalledProcessError as e:
+        reporter.print_error(f"Failed to auto-install Python: {e}")
+    return False
+
+def ensure_stable_python():
+    system = platform.system().lower()
+    # Check if a stable version (3.11 or 3.12) exists
+    for py_cmd in ["python3.11", "python3.12", "python3.10"]:
+        cmd_path = shutil.which(py_cmd)
+        if cmd_path:
+            reporter.print_success(f"✓ Found compatible stable Python at {cmd_path}")
+            return cmd_path
+            
+    # Fallback to general 'python3' or 'python' and check version
+    for py_cmd in ["python3", "python"]:
+        cmd_path = shutil.which(py_cmd)
+        if cmd_path:
+            try:
+                output = subprocess.check_output([cmd_path, "--version"], text=True, stderr=subprocess.STDOUT)
+                if "Python 3.11" in output or "Python 3.12" in output or "Python 3.10" in output:
+                    reporter.print_success(f"✓ Found compatible stable Python at {cmd_path}")
+                    return cmd_path
+            except Exception:
+                continue
+
+    # Not found!
+    reporter.print_error("Warning: A highly compatible Python version (3.11 or 3.12) was NOT found on your system!")
+    reporter.print_error("Llama-cpp-python and GPU acceleration run best on Python 3.11/3.12. Using Python 3.13 may cause build failures.")
+    try:
+        ans = input("Would you like me to attempt to auto-download and install Python 3.11 now? (y/n): ").strip().lower()
+    except EOFError:
+        ans = "n"
+        
+    if ans == "y":
+        if install_python_os(system):
+            # Check again
+            for py_cmd in ["python3.11", "python3.12"]:
+                cmd_path = shutil.which(py_cmd)
+                if cmd_path:
+                    reporter.print_success(f"✓ Successfully installed and found Python at {cmd_path}")
+                    return cmd_path
+            reporter.print_error("Python installation finished but executable not found in PATH. You may need to restart your terminal.")
+        else:
+            reporter.print_error("Auto-installation failed.")
+    
+    reporter.print_step("Falling back to current Python executable (this may be 3.13 and might cause issues)...")
+    return sys.executable
+
+def setup_venv(python_path):
+    app_dir = get_app_dir()
+    venv_dir = app_dir / "venv"
+    if not venv_dir.exists():
+        reporter.print_step(f"Creating isolated Virtual Environment at {venv_dir}...")
+        try:
+            subprocess.run([python_path, "-m", "venv", str(venv_dir)], check=True)
+            reporter.print_success("✓ Virtual Environment created successfully.")
+        except subprocess.CalledProcessError as e:
+            reporter.print_error(f"Failed to create VENV: {e}")
+            return False
+    else:
+        reporter.print_success("✓ Virtual Environment already exists.")
+        
+    if platform.system().lower() == "windows":
+        try:
+            subprocess.run(["attrib", "+h", str(app_dir.parent)], shell=True, check=False)
+        except: pass
+        
+    return True
+
+def download_source(component_name):
+    app_dir = get_app_dir()
+    src_dir = app_dir / "src"
+    
+    repo_url = "https://github.com/MarkanM-Official/LMMs/archive/refs/heads/main.zip"
+    zip_path = app_dir / "main.zip"
+    
+    app_dir.mkdir(parents=True, exist_ok=True)
+    
+    reporter.print_step("Downloading latest LMMs source code...")
+    try:
+        response = requests.get(repo_url, stream=True)
+        response.raise_for_status()
+        total_size = int(response.headers.get('content-length', 0))
+        
+        with Progress(
+            TextColumn("[bold cyan]{task.description}"),
+            BarColumn(bar_width=40),
+            "[progress.percentage]{task.percentage:>3.1f}%",
+            "•",
+            DownloadColumn(),
+            "•",
+            TransferSpeedColumn(),
+            "•",
+            TimeRemainingColumn(),
+            console=reporter.console
+        ) as progress:
+            task = progress.add_task("Downloading...", total=total_size if total_size > 0 else None)
+            with open(zip_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        file.write(chunk)
+                        progress.update(task, advance=len(chunk))
+        
+        reporter.print_step("Extracting source code...")
+        if src_dir.exists():
+            shutil.rmtree(src_dir)
+            
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(app_dir)
+            
+        # The zip extracts as "LMMs-main", rename it to "src"
+        extracted_dir = app_dir / "LMMs-main"
+        if extracted_dir.exists():
+            extracted_dir.rename(src_dir)
+            
+        zip_path.unlink()
+        reporter.print_success(f"✓ Source code installed to {src_dir}")
+        return True
+    except Exception as e:
+        reporter.print_error(f"Download/Extraction failed: {e}")
+        return False
+
+def create_global_wrapper(component_name):
+    system = platform.system().lower()
+    app_dir = get_app_dir()
+    venv_python = get_venv_python()
+    launcher_script = app_dir / "src" / "lmms_launcher.py"
+    
+    if system == "windows":
+        install_dir = Path.home() / ".lmms" / "bin"
+        install_path = install_dir / "lmms.bat"
+        wrapper_content = f'@echo off\n"{venv_python}" "{launcher_script}" %*'
+    else:
+        install_dir = Path("/usr/local/bin")
+        if not os.access(install_dir, os.W_OK):
+            install_dir = Path.home() / ".local" / "bin"
+        install_path = install_dir / "lmms"
+        wrapper_content = f'#!/bin/bash\n"{venv_python}" "{launcher_script}" "$@"'
+        
+    install_dir.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        with open(install_path, "w") as f:
+            f.write(wrapper_content)
+        
+        if system != "windows":
+            os.chmod(install_path, 0o755)
+            
+        reporter.print_success(f"✓ Global wrapper created at {install_path}")
+        return True
+    except Exception as e:
+        reporter.print_error(f"Failed to create wrapper: {e}")
+        return False
+
+def install_pip_requirements(component_name):
+    req_file = get_app_dir() / "src" / "requirements.txt"
+    if not req_file.exists():
+        reporter.print_error("requirements.txt not found in source code!")
+        return False
+        
+    reporter.print_step("Installing Pip Requirements...")
+    reporter.print_step("The following dependencies will be installed:")
+    try:
+        with open(req_file, "r") as f:
+            for line in f:
+                if line.strip() and not line.startswith("#"):
+                    print(f"  - {line.strip()}")
+    except: pass
+    
+    try:
+        venv_python = get_venv_python()
+        # Upgrade pip
+        subprocess.run([str(venv_python), "-m", "pip", "install", "--upgrade", "pip"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        
+        # Install requirements
+        cmd = [str(venv_python), "-m", "pip", "install", "-r", str(req_file)]
+        subprocess.run(cmd, check=True)
+        
+        # Check if playwright is in requirements and install browser binaries
+        with open(req_file, "r") as f:
+            reqs_text = f.read().lower()
+            if "playwright" in reqs_text:
+                reporter.print_step("Installing Playwright browser binaries...")
+                subprocess.run([str(venv_python), "-m", "playwright", "install", "chromium"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                
+        reporter.print_success("✓ Pip requirements installed successfully.")
+        return True
+    except subprocess.CalledProcessError as e:
+        reporter.print_error(f"Failed to install pip requirements: {e}")
+        return False
+
+def install_component(component_name, force=False):
+    installed = get_installed_components()
+    if installed.get(component_name) and not force:
+        reporter.print_success(f"✓ {component_name.capitalize()} is already installed. Skipping. (Use update to force)")
+        return True, ""
+
+    if force:
+        reporter.print_step(f"Updating {component_name.capitalize()} to the latest version...")
+        if component_name == "all":
+            try:
+                reporter.print_step("Checking for LMMs-builder updates...")
+                subprocess.run([sys.executable, "-m", "pip", "install", "--upgrade", "lmms-builder"], 
+                               check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except Exception:
+                pass
+    else:
+        reporter.print_step(f"Installing {component_name.capitalize()}...")
+    
+    if component_name in ["engine", "backend", "gui", "cli", "all"]:
+        # 0. Check Prerequisites
+        check_prerequisites()
+        
+        # 1. Check Python version
+        python_path = ensure_stable_python()
+        
+        # 2. Setup VENV
+        if not setup_venv(python_path):
+            return False, "VENV setup failed"
+            
+        # 3. Download Source
+        if not download_source(component_name):
+            return False, "Source download failed"
+            
+        # 4. Install Pip Requirements inside VENV
+        if not install_pip_requirements(component_name):
+            return False, "Pip installation failed"
+            
+        # 5. Create Global Wrapper
+        if not create_global_wrapper(component_name):
+            return False, "Wrapper creation failed"
+            
+        mark_installed(component_name)
+        return True, ""
+        
+    else:
+        reporter.print_error(f"Unknown component: {component_name}")
+        return False, "Unknown component"
+

lmms_builder/reporter.py

@@ -0,0 +1,101 @@
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+def print_header():
+    console.print(Panel("[bold cyan]LMMs Builder[/bold cyan]\n[bold yellow]Powered by MarkanM. For more details: Lmms.markanm.com[/bold yellow]\n[dim]Bootstrapper & Hardware Profiler[/dim]", border_style="cyan"))
+
+def print_hardware_report(hw):
+    table = Table(title="Hardware Detection Report", show_header=True, header_style="bold magenta")
+    table.add_column("Component", style="cyan")
+    table.add_column("Details", style="green")
+    
+    os_info = f"{hw['os']['system']} {hw['os']['release']} ({hw['os']['architecture']})"
+    table.add_row("OS", os_info)
+    
+    cpu_info = f"{hw['cpu']['cores']} Cores / {hw['cpu']['threads']} Threads"
+    table.add_row("CPU", cpu_info)
+    
+    ram_info = f"{hw['ram']['total_gb']} GB (Available: {hw['ram']['available_gb']} GB)"
+    table.add_row("RAM", ram_info)
+    
+    if hw['gpu']['detected']:
+        gpu_info = f"{hw['gpu']['name']} ({hw['gpu']['vram_gb']} GB VRAM)"
+    else:
+        gpu_info = "None Detected"
+    table.add_row("GPU", gpu_info)
+    
+    if hw['cuda']['available']:
+        cuda_info = f"Version {hw['cuda']['version']}"
+    else:
+        cuda_info = "Not Available"
+    table.add_row("CUDA", cuda_info)
+    
+    table.add_row("Python", hw['python']['version'])
+    
+    vscode_status = "[green]Installed[/green]" if hw['tools']['vscode'] else "[red]Not Installed[/red]"
+    table.add_row("VS Code", vscode_status)
+    
+    import platform
+    if platform.system().lower() == "windows":
+        bt_status = "[green]Installed[/green]" if hw['tools']['build_tools'] else "[red]Not Installed[/red]"
+        table.add_row("C++ Build Tools", bt_status)
+    
+    console.print(table)
+
+def print_compatibility_report(hw):
+    console.print("\n[bold magenta]========================[/bold magenta]")
+    console.print("[bold cyan]LMMS Compatibility[/bold cyan]\n")
+    
+    engine_comp = 100
+    cli_comp = 100
+    gui_comp = 100
+    air_comp = 100 if hw['ram']['total_gb'] >= 16 else 50
+    vllm_comp = 100 if hw['gpu']['detected'] and hw['gpu']['vram_gb'] >= 8 else 0
+    
+    console.print(f"Engine: {engine_comp}%")
+    console.print(f"CLI: {cli_comp}%")
+    console.print(f"GUI: {gui_comp}%")
+    console.print(f"Air Engine: {air_comp}%")
+    console.print(f"vLLM: {vllm_comp}%")
+    
+    overall = (engine_comp + cli_comp + gui_comp + air_comp + vllm_comp) // 5
+    console.print(f"\n[bold green]Overall: {overall}%[/bold green]")
+    console.print("[bold magenta]========================[/bold magenta]\n")
+
+def print_benchmark_estimate(hw):
+    console.print("\n[bold cyan]Hardware Benchmark (Estimated)[/bold cyan]")
+    
+    # Calculate an estimated TPS multiplier based on hardware
+    base = 5.0
+    if hw['gpu']['detected']:
+        base += hw['gpu']['vram_gb'] * 2
+    else:
+        base += hw['cpu']['cores'] * 1.5
+        
+    console.print("llama.cpp (7B): ~[green]{:.1f} tok/s[/green]".format(base))
+    console.print("ollama (7B): ~[green]{:.1f} tok/s[/green]".format(base * 0.95))
+    if hw['ram']['total_gb'] >= 16:
+        console.print("air (70B): ~[yellow]{:.1f} tok/s[/yellow]".format(max(1.0, base / 10)))
+    else:
+        console.print("air (70B): [red]Not Recommended (Insufficent RAM)[/red]")
+        
+def print_step(step_msg):
+    console.print(f"[bold blue]>[/bold blue] {step_msg}")
+
+def print_success(msg):
+    console.print(f"[bold green]✓[/bold green] {msg}")
+
+def print_error(msg):
+    console.print(f"[bold red]✗[/bold red] {msg}")
+
+def print_autoset_summary(mode, runtime):
+    console.print(Panel(
+        f"[bold green]AutoSet Complete![/bold green]\n\n"
+        f"[cyan]Default Mode:[/cyan] {mode}\n"
+        f"[cyan]Default Runtime:[/cyan] {runtime}\n\n"
+        "Run [bold magenta]lmms[/bold magenta] to launch.",
+        border_style="green"
+    ))