larpfetch 0.1.0__py3-none-any.whl

larpfetch/__init__.py

@@ -0,0 +1,3 @@
+"""larpfetch: LARP as any distro, hardware, or machine you want."""
+
+__version__ = "0.1.0"

larpfetch/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running larpfetch as a module: python -m larpfetch."""
+
+from larpfetch.cli import main
+
+if __name__ == "__main__":
+    main()

larpfetch/cli.py

@@ -0,0 +1,172 @@
+"""CLI entry point for larpfetch."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Sequence
+
+from larpfetch import __version__
+from larpfetch.collectors.common import collect_all
+from larpfetch.config import (
+    get_appearance,
+    get_default_profile,
+    get_named_profiles,
+    load_config,
+)
+from larpfetch.renderer import render
+from larpfetch.resolver import resolve
+
+
+def _parse_sets(sets: list[str]) -> dict[str, str]:
+    """Parse repeated --set key=value arguments."""
+    result: dict[str, str] = {}
+    for s in sets:
+        if "=" not in s:
+            print(f"Error: --set argument must be key=value, got: {s}", file=sys.stderr)
+            sys.exit(1)
+        key, _, value = s.partition("=")
+        key = key.strip()
+        if not key:
+            print(f"Error: --set key cannot be empty in: {s}", file=sys.stderr)
+            sys.exit(1)
+        result[key] = value
+    return result
+
+
+def _list_profiles(config: dict) -> None:
+    """Print available profiles."""
+    profiles = get_named_profiles(config)
+    if not profiles:
+        print("No profiles configured.")
+        return
+    print("Available profiles:")
+    for name in sorted(profiles.keys()):
+        fields = profiles[name]
+        desc = fields.get("os", fields.get("distro", "Custom identity"))
+        print(f"  {name:20s} {desc}")
+
+
+def _show_config(config: dict) -> None:
+    """Print the resolved configuration."""
+    default = get_default_profile(config)
+    profiles = get_named_profiles(config)
+    appearance = get_appearance(config)
+
+    print("Default profile:")
+    if default:
+        for k, v in sorted(default.items()):
+            print(f"  {k} = {v}")
+    else:
+        print("  (empty)")
+
+    print("\nProfiles:")
+    if profiles:
+        for name in sorted(profiles.keys()):
+            print(f"\n  [{name}]")
+            for k, v in sorted(profiles[name].items()):
+                print(f"    {k} = {v}")
+    else:
+        print("  (none)")
+
+    print("\nAppearance:")
+    if appearance:
+        for k, v in sorted(appearance.items()):
+            print(f"  {k} = {v}")
+    else:
+        print("  (defaults)")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="larpfetch",
+        description=(
+            "LARP as any distro, hardware, or machine you want."
+            " Because reality is optional until you pass --real-shit."
+        ),
+    )
+    parser.add_argument("-p", "--profile", help="Select a named profile")
+    parser.add_argument(
+        "--real-shit",
+        action="store_true",
+        help="Show real detected system information only",
+    )
+    parser.add_argument(
+        "--list-profiles", action="store_true", help="List available profiles and exit"
+    )
+    parser.add_argument(
+        "--show-config", action="store_true", help="Show current configuration and exit"
+    )
+    parser.add_argument("--config", help="Path to a custom config file")
+    parser.add_argument(
+        "--set",
+        action="append",
+        default=[],
+        metavar="KEY=VALUE",
+        help="Override a field (repeatable)",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"larpfetch {__version__}"
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Load config
+    try:
+        config = load_config(args.config)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error loading config: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # --list-profiles
+    if args.list_profiles:
+        _list_profiles(config)
+        return
+
+    # --show-config
+    if args.show_config:
+        _show_config(config)
+        return
+
+    # Collect real system info
+    real = collect_all()
+
+    # Resolve display identity
+    default_profile = get_default_profile(config)
+    selected_profile = None
+    if args.profile:
+        profiles = get_named_profiles(config)
+        if args.profile not in profiles:
+            avail = ", ".join(sorted(profiles.keys()))
+            print(
+                f"Error: profile '{args.profile}' not found. Available: {avail}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        selected_profile = profiles[args.profile]
+
+    cli_overrides = _parse_sets(args.set)
+    appearance = get_appearance(config)
+
+    resolved = resolve(
+        real=real,
+        default_profile=default_profile,
+        selected_profile=selected_profile,
+        cli_overrides=cli_overrides,
+        real_shit=args.real_shit,
+    )
+
+    # Render
+    output = render(resolved, real, args.real_shit, appearance)
+    print(output)
+
+
+if __name__ == "__main__":
+    main()

larpfetch/collectors/__init__.py

@@ -0,0 +1 @@
+"""Collectors package."""

larpfetch/collectors/common.py

@@ -0,0 +1,327 @@
+"""Cross-platform collectors using standard library and psutil."""
+
+from __future__ import annotations
+
+import getpass
+import os
+import platform
+import socket
+import time
+from collections import OrderedDict
+
+try:
+    import psutil
+except ImportError:
+    psutil = None  # type: ignore[assignment]
+
+from larpfetch.models import SystemInfo
+
+
+def _fmt_bytes(n: int) -> str:
+    """Format bytes to human-readable string."""
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB", "PiB"):
+        if abs(n) < 1024:
+            return f"{n:.1f} {unit}"
+        n = int(n / 1024)
+    return f"{n} EiB"
+
+
+def _fmt_uptime(seconds: float) -> str:
+    """Format seconds to a human-readable uptime string."""
+    days = int(seconds // 86400)
+    hours = int((seconds % 86400) // 3600)
+    minutes = int((seconds % 3600) // 60)
+    parts: list[str] = []
+    if days:
+        parts.append(f"{days}d")
+    if hours:
+        parts.append(f"{hours}h")
+    parts.append(f"{minutes}m")
+    return " ".join(parts)
+
+
+def collect_common() -> SystemInfo:
+    """Collect information common across all platforms."""
+    info = SystemInfo(fields=OrderedDict())
+
+    # Username
+    try:
+        info.set("username", getpass.getuser())
+    except Exception:
+        pass
+
+    # Hostname
+    try:
+        info.set("hostname", socket.gethostname())
+    except Exception:
+        pass
+
+    # Architecture
+    try:
+        info.set("architecture", platform.machine())
+    except Exception:
+        pass
+
+    # Uptime
+    try:
+        if psutil is not None:
+            boot = psutil.boot_time()
+            info.set("uptime", _fmt_uptime(time.time() - boot))
+    except Exception:
+        pass
+
+    # Memory
+    try:
+        if psutil is not None:
+            vm = psutil.virtual_memory()
+            info.set("memory", f"{_fmt_bytes(vm.used)} / {_fmt_bytes(vm.total)}")
+    except Exception:
+        pass
+
+    # Disk
+    try:
+        if psutil is not None:
+            du = psutil.disk_usage("/")
+            info.set("disk", f"{_fmt_bytes(du.used)} / {_fmt_bytes(du.total)}")
+    except Exception:
+        pass
+
+    # Battery
+    try:
+        if psutil is not None:
+            bat = psutil.sensors_battery()
+            if bat is not None:
+                info.set("battery", f"{bat.percent}%")
+    except Exception:
+        pass
+
+    # CPU model
+    try:
+        info.set("cpu", _detect_cpu())
+    except Exception:
+        pass
+
+    return info
+
+
+def _detect_cpu() -> str:
+    """Best-effort CPU name detection."""
+    # Linux: /proc/cpuinfo
+    try:
+        with open("/proc/cpuinfo") as f:
+            for line in f:
+                if line.startswith("model name"):
+                    return line.split(":", 1)[1].strip()
+    except OSError:
+        pass
+
+    # macOS: sysctl
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["sysctl", "-n", "machdep.cpu.brand_string"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+
+    # Windows: platform.processor()
+    proc = platform.processor()
+    if proc:
+        return proc
+
+    return "Unknown CPU"
+
+
+def collect_platform() -> SystemInfo:
+    """Collect platform-specific information."""
+    system = platform.system()
+    if system == "Linux":
+        return _collect_linux()
+    elif system == "Darwin":
+        return _collect_macos()
+    elif system == "Windows":
+        return _collect_windows()
+    return SystemInfo(fields=OrderedDict())
+
+
+def _collect_linux() -> SystemInfo:
+    info = SystemInfo(fields=OrderedDict())
+
+    # OS / distro from /etc/os-release
+    os_release: dict[str, str] = {}
+    try:
+        with open("/etc/os-release") as f:
+            for line in f:
+                line = line.strip()
+                if "=" in line:
+                    key, _, value = line.partition("=")
+                    os_release[key] = value.strip('"')
+    except OSError:
+        pass
+
+    if os_release.get("PRETTY_NAME"):
+        info.set("distro", os_release["PRETTY_NAME"])
+        info.set("os", os_release["PRETTY_NAME"])
+    elif os_release.get("NAME"):
+        info.set("distro", os_release["NAME"])
+        info.set("os", os_release["NAME"])
+
+    if os_release.get("VERSION"):
+        info.set("os_version", os_release["VERSION"])
+
+    # Kernel
+    try:
+        info.set("kernel", platform.release())
+    except Exception:
+        pass
+
+    # Shell
+    shell = os.environ.get("SHELL", "")
+    if shell:
+        info.set("shell", os.path.basename(shell))
+
+    # Desktop environment
+    de = os.environ.get("XDG_CURRENT_DESKTOP", "") or os.environ.get(
+        "DESKTOP_SESSION", ""
+    )
+    if de:
+        info.set("de", de)
+
+    # GPU via lspci (best-effort)
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["lspci"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0:
+            for line in result.stdout.splitlines():
+                lower = line.lower()
+                if "vga" in lower or "3d" in lower or "display" in lower:
+                    # Format: "XX:XX.X Class: vendor device"
+                    parts = line.split(": ", 2)
+                    if len(parts) >= 3:
+                        gpu_desc = parts[2]
+                        # Trim the trailing (rev xx) if present
+                        if " (" in gpu_desc:
+                            gpu_desc = gpu_desc[: gpu_desc.rfind(" (")]
+                        info.set("gpu", gpu_desc)
+                        break
+    except Exception:
+        pass
+
+    return info
+
+
+def _collect_macos() -> SystemInfo:
+    info = SystemInfo(fields=OrderedDict())
+
+    # macOS version
+    try:
+        mac_ver = platform.mac_ver()
+        if mac_ver and mac_ver[0]:
+            info.set("os", f"macOS {mac_ver[0]}")
+            info.set("distro", f"macOS {mac_ver[0]}")
+            info.set("os_version", mac_ver[0])
+    except Exception:
+        pass
+
+    # Kernel
+    try:
+        info.set("kernel", f"Darwin {platform.release()}")
+    except Exception:
+        pass
+
+    # Shell
+    shell = os.environ.get("SHELL", "")
+    if shell:
+        info.set("shell", os.path.basename(shell))
+
+    # Desktop environment (macOS = Aqua)
+    info.set("de", "Aqua")
+
+    # GPU via system_profiler (best-effort)
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["system_profiler", "SPDisplaysDataType"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            for line in result.stdout.splitlines():
+                if "Chipset Model:" in line or "Chip:" in line:
+                    gpu = line.split(":", 1)[1].strip()
+                    info.set("gpu", gpu)
+                    break
+    except Exception:
+        pass
+
+    return info
+
+
+def _collect_windows() -> SystemInfo:
+    info = SystemInfo(fields=OrderedDict())
+
+    # Windows version
+    try:
+        ver = platform.version()
+        release = platform.release()
+        info.set("os", f"Windows {release} {ver}")
+        info.set("os_version", f"{release} {ver}")
+    except Exception:
+        pass
+
+    # Kernel
+    try:
+        info.set("kernel", platform.platform())
+    except Exception:
+        pass
+
+    # Shell
+    info.set("shell", "powershell.exe")
+
+    # Desktop environment
+    info.set("de", "Desktop Window Manager")
+
+    # GPU via WMIC (best-effort)
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["wmic", "path", "win32_videocontroller", "get", "name"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            lines = [
+                line.strip()
+                for line in result.stdout.splitlines()
+                if line.strip() and line.strip() != "Name"
+            ]
+            if lines:
+                info.set("gpu", lines[0])
+    except Exception:
+        pass
+
+    return info
+
+
+def collect_all() -> SystemInfo:
+    """Collect all available system information."""
+    info = collect_common()
+    platform_info = collect_platform()
+    info.update_from(platform_info.to_dict())
+    return info

larpfetch/collectors/linux.py

@@ -0,0 +1,5 @@
+"""Linux-specific collector (imports from common)."""
+
+from larpfetch.collectors.common import _collect_linux as collect_linux
+
+__all__ = ["collect_linux"]

larpfetch/collectors/macos.py

@@ -0,0 +1,5 @@
+"""macOS-specific collector (imports from common)."""
+
+from larpfetch.collectors.common import _collect_macos as collect_macos
+
+__all__ = ["collect_macos"]

larpfetch/collectors/windows.py

@@ -0,0 +1,5 @@
+"""Windows-specific collector (imports from common)."""
+
+from larpfetch.collectors.common import _collect_windows as collect_windows
+
+__all__ = ["collect_windows"]

larpfetch/config.py

@@ -0,0 +1,74 @@
+"""TOML configuration loading and management."""
+
+from __future__ import annotations
+
+import os
+import sys
+import tomllib
+from pathlib import Path
+from typing import Any
+
+# Platform default config paths
+if sys.platform == "darwin":
+    _DEFAULT_CONFIG_DIR = Path.home() / "Library" / "Application Support" / "larpfetch"
+elif sys.platform == "win32":
+    _DEFAULT_CONFIG_DIR = Path(os.environ.get("APPDATA", "~")) / "larpfetch"
+else:
+    _xdg = Path(os.environ.get("XDG_CONFIG_HOME", ""))
+    if _xdg.is_absolute():
+        _DEFAULT_CONFIG_DIR = _xdg / "larpfetch"
+    else:
+        _DEFAULT_CONFIG_DIR = Path.home() / ".config" / "larpfetch"
+
+DEFAULT_CONFIG_PATH = _DEFAULT_CONFIG_DIR / "config.toml"
+
+
+def _resolve_config_path(explicit: str | None = None) -> Path | None:
+    """Return the config path to use, or None if no config exists."""
+    if explicit:
+        p = Path(explicit)
+        if not p.is_file():
+            raise FileNotFoundError(f"Config file not found: {explicit}")
+        return p
+    if DEFAULT_CONFIG_PATH.is_file():
+        return DEFAULT_CONFIG_PATH
+    return None
+
+
+def load_config(path: str | None = None) -> dict[str, Any]:
+    """Load and parse a TOML config file.
+
+    Returns a dict with keys: default, profiles, appearance.
+    Missing sections default to empty dicts.
+    Raises FileNotFoundError or tomllib.TOMLDecodeError on failure.
+    """
+    config_path = _resolve_config_path(path)
+    if config_path is None:
+        return {"default": {}, "profiles": {}, "appearance": {}}
+
+    with open(config_path, "rb") as f:
+        data = tomllib.load(f)
+
+    return {
+        "default": data.get("default", {}),
+        "profiles": data.get("profiles", {}),
+        "appearance": data.get("appearance", {}),
+    }
+
+
+def get_default_profile(config: dict[str, Any]) -> dict[str, str]:
+    """Extract the default profile as a flat string dict."""
+    return {k: str(v) for k, v in config.get("default", {}).items()}
+
+
+def get_named_profiles(config: dict[str, Any]) -> dict[str, dict[str, str]]:
+    """Extract all named profiles as flat string dicts."""
+    profiles: dict[str, dict[str, str]] = {}
+    for name, values in config.get("profiles", {}).items():
+        profiles[name] = {k: str(v) for k, v in values.items()}
+    return profiles
+
+
+def get_appearance(config: dict[str, Any]) -> dict[str, Any]:
+    """Extract appearance settings."""
+    return config.get("appearance", {})

larpfetch/easter_eggs.py

@@ -0,0 +1,92 @@
+"""Easter eggs and humor for larpfetch."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+from larpfetch.models import SystemInfo
+
+
+def _is_implausible_memory(mem: str) -> bool:
+    """Check if a memory string is absurdly large (> 1 TiB)."""
+    match = re.search(r"([\d.]+)\s*(GiB|TiB|PiB|EiB)", mem, re.IGNORECASE)
+    if not match:
+        return False
+    value = float(match.group(1))
+    unit = match.group(2).lower()
+    if unit == "pib":
+        return True
+    if unit == "eib":
+        return True
+    if unit == "tib" and value >= 1:
+        return True
+    return False
+
+
+def _compute_authenticity(real: SystemInfo, resolved: SystemInfo, real_shit: bool) -> int:
+    """Compute an authenticity percentage (0-100)."""
+    if real_shit:
+        return 100
+
+    real_d = real.to_dict()
+    resolved_d = resolved.to_dict()
+
+    if not real_d:
+        return 50
+
+    matches = sum(1 for k in real_d if k in resolved_d and real_d[k] == resolved_d[k])
+    total = max(len(real_d), 1)
+    pct = int((matches / total) * 100)
+    # In LARP mode, authenticity should be low if user is faking a lot
+    return max(0, min(100, pct))
+
+
+def get_authenticity_line(
+    real: SystemInfo, resolved: SystemInfo, real_shit: bool, easter_eggs: bool
+) -> str | None:
+    """Return the authenticity line, or None if disabled."""
+    if not easter_eggs:
+        return None
+    pct = _compute_authenticity(real, resolved, real_shit)
+    return f"Authenticity: {pct}%"
+
+
+def get_extra_lines(
+    resolved: SystemInfo, real: SystemInfo, real_shit: bool, easter_eggs: bool
+) -> list[str]:
+    """Return additional humorous or informational lines."""
+    if not easter_eggs:
+        return []
+
+    lines: list[str] = []
+
+    if real_shit:
+        lines.append("Source: reality (unfortunately)")
+        return lines
+
+    # Check for implausible memory
+    mem = resolved.get("memory", "")
+    if _is_implausible_memory(mem):
+        lines.append("Source: trust me bro")
+
+    # Check for absurdly high package count
+    pc = resolved.get("package_count", "")
+    if pc.isdigit() and int(pc) > 99999:
+        lines.append("Reality Leakage: 100.00%")
+
+    # Check if real hardware is better than LARP (out-LARP detection)
+    if not real_shit and real.fields:
+        # Conservative thresholds for "impressive" real hardware
+        real_mem = real.get("memory", "")
+        if _is_implausible_memory(real_mem):
+            lines.append("Reality has out-LARPed the LARP.")
+
+    # The allegations were true - deterministic based on username
+    username = resolved.get("username", "")
+    if username:
+        h = int(hashlib.md5(username.encode()).hexdigest()[:8], 16)
+        if h % 100 == 0:  # 1% chance
+            lines.append("The allegations were true.")
+
+    return lines