rigma 0.1.0__py3-none-any.whl

rigma/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

rigma/cli.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import platform
+
+import typer
+
+from .probe import probe_hardware
+from .registry import Registry
+from .resolve import resolve
+
+app = typer.Typer(no_args_is_help=True, add_completion=False)
+
+
+def _profile(reg: Registry):
+    return probe_hardware(reg.gpus)
+
+
+@app.command()
+def doctor():
+    """Print detected hardware and registry status."""
+    reg = Registry.load()
+    p = _profile(reg)
+    typer.echo(p.model_dump_json(indent=2))
+    typer.echo(f"fingerprint: {p.fingerprint}")
+    typer.echo(f"registry: {len(reg.models)} models, {len(reg.combos)} combos")
+
+
+@app.command()
+def plan(use_case: str = typer.Option("general", "--use-case"),
+         model: str = typer.Option(None, "--model"),
+         explain: bool = typer.Option(False, "--explain")):
+    """Show what `rigma up` would run, and why."""
+    reg = Registry.load()
+    rp = resolve(_profile(reg), reg, use_case=use_case, model_override=model)
+    typer.echo(f"model:   {rp.model_slug} ({rp.gguf.quant}, "
+               f"{rp.gguf.bytes / 2**30:.1f} GB)")
+    typer.echo(f"backend: {rp.backend}   origin: {rp.origin}")
+    typer.echo(f"flags:   {rp.flags.model_dump()}")
+    if explain:
+        for line in rp.explain:
+            typer.echo(f"  {line}")
+
+
+@app.command()
+def models():
+    """List registry models and whether they fit this machine."""
+    reg = Registry.load()
+    p = _profile(reg)
+    for slug, spec in sorted(reg.models.items()):
+        try:
+            rp = resolve(p, reg, model_override=slug)
+            fit = (f"fits as {rp.gguf.quant} (n_cpu_moe={rp.flags.n_cpu_moe})"
+                   if rp.model_slug == slug else "does not fit")
+        except Exception:
+            fit = "does not fit"
+        typer.echo(f"{slug:24} {spec.kind:5} {fit}")
+
+
+@app.command()
+def up(use_case: str = typer.Option("general", "--use-case"),
+       model: str = typer.Option(None, "--model"),
+       yes: bool = typer.Option(False, "--yes", "-y"),
+       dry_run: bool = typer.Option(False, "--dry-run"),
+       port: int = typer.Option(11500, "--port"),
+       turbo: bool = typer.Option(False, "--turbo",
+                                  help="Max-speed download (may saturate your connection)")):
+    """Probe -> resolve -> download -> serve."""
+    import os
+
+    from . import runtime  # local import: keeps --dry-run path light
+
+    if turbo:
+        os.environ["HF_HUB_DISABLE_XET"] = "0"
+        os.environ["HF_XET_NUM_CONCURRENT_RANGE_GETS"] = "16"
+
+    reg = Registry.load()
+    p = _profile(reg)
+    rp = resolve(p, reg, use_case=use_case, model_override=model)
+    os_name = {"Windows": "windows", "Linux": "linux",
+               "Darwin": "darwin"}[platform.system()]
+    argv_preview = rp.server_args("<model>", port)
+    typer.echo(f"plan: {rp.model_slug} {rp.gguf.quant} on {rp.backend} "
+               f"({rp.origin})")
+    typer.echo("argv: llama-server " + " ".join(argv_preview))
+    if dry_run:
+        raise typer.Exit(0)
+    if not yes:
+        typer.confirm(
+            f"download engine + model ({rp.gguf.bytes / 2**30:.1f} GB)?", abort=True)
+    exe = runtime.ensure_engine(rp.backend, os_name)
+    model_path = runtime.ensure_model(rp.gguf)
+    typer.echo("starting llama-server (first load can take minutes)...")
+    sp = runtime.launch_server(exe, rp, model_path, port=port)
+    typer.echo(f"ready: OpenAI-compatible endpoint at {sp.url}/v1")
+    typer.echo("Ctrl+C to stop.")
+    try:
+        sp.proc.wait()
+    except KeyboardInterrupt:
+        sp.stop()

rigma/data/engines.json

@@ -0,0 +1,15 @@
+{
+  "version": "b9867",
+  "url_base": "https://github.com/ggml-org/llama.cpp/releases/download/b9867/",
+  "assets": {
+    "windows/vulkan": "llama-b9867-bin-win-vulkan-x64.zip",
+    "windows/cuda": "llama-b9867-bin-win-cuda-12.4-x64.zip",
+    "windows/rocm": "llama-b9867-bin-win-hip-radeon-x64.zip",
+    "windows/cpu": "llama-b9867-bin-win-cpu-x64.zip",
+    "linux/vulkan": "llama-b9867-bin-ubuntu-vulkan-x64.tar.gz",
+    "linux/cpu": "llama-b9867-bin-ubuntu-x64.tar.gz"
+  },
+  "extra_assets": {
+    "windows/cuda": ["cudart-llama-bin-win-cuda-12.4-x64.zip"]
+  }
+}

rigma/data/registry/combos/_class/vram-16/ram-16/general.json

@@ -0,0 +1,7 @@
+{
+  "model": "qwen3.6-35b-a3b", "quant": "UD-Q3_K_XL", "backend": "vulkan",
+  "flags": {"ctx": 16384, "ngl": 99, "n_cpu_moe": 12, "flash_attn": true,
+            "cache_type_k": "q8_0", "cache_type_v": "q8_0"},
+  "notes": "Conservative class fallback for unknown 16GB cards with 16GB RAM; unverified.",
+  "sources": ["https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF"]
+}

rigma/data/registry/combos/amd/amd-radeon-rx-9070-xt-16g/ram-16/coding.json

@@ -0,0 +1,12 @@
+{
+  "model": "qwen3.6-35b-a3b", "quant": "UD-Q3_K_XL", "backend": "vulkan",
+  "flags": {"ctx": 32768, "ngl": 99, "n_cpu_moe": 10, "flash_attn": true,
+            "cache_type_k": "q8_0", "cache_type_v": "q8_0"},
+  "budget": {"vram_mb": 15200, "ram_mb": 5500},
+  "expected": {"tg_tps": [40, 60], "pp_tps": [400, 700]},
+  "verified": {"by": "IxMxAMAR", "date": "2026-07-06", "llamacpp": "b9867",
+               "measured": {"tg_tps": 57.1, "pp_tps": 689, "prompt_tokens": 4020}},
+  "notes": "Vulkan ~20-29% faster than ROCm on RDNA4; TurboQuant forks excluded (crash >65K ctx on this card).",
+  "sources": ["https://digtvbg.com/blog/llama-server-vulkan-rdna4-vllm-rocm-benchmark/",
+              "https://github.com/ggml-org/llama.cpp/issues/23098"]
+}

rigma/data/registry/combos/amd/amd-radeon-rx-9070-xt-16g/ram-16/general.json

@@ -0,0 +1,10 @@
+{
+  "model": "qwen3.6-35b-a3b", "quant": "UD-Q3_K_XL", "backend": "vulkan",
+  "flags": {"ctx": 16384, "ngl": 99, "n_cpu_moe": 8, "flash_attn": true,
+            "cache_type_k": "q8_0", "cache_type_v": "q8_0"},
+  "budget": {"vram_mb": 15200, "ram_mb": 4500},
+  "expected": {"tg_tps": [22, 32], "pp_tps": [150, 400]},
+  "verified": {"by": "IxMxAMAR", "date": "2026-07-03"},
+  "notes": "Smaller ctx than the coding combo keeps more experts on-GPU for faster general chat.",
+  "sources": ["https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF"]
+}

rigma/data/registry/gpus.json

@@ -0,0 +1,16 @@
+[
+  {"match": "RX 9070", "vendor": "amd", "arch": "rdna4",
+   "backends_windows": ["vulkan", "rocm"], "backends_linux": ["vulkan", "rocm"]},
+  {"match": "RX 7900", "vendor": "amd", "arch": "rdna3",
+   "backends_windows": ["vulkan", "rocm"], "backends_linux": ["vulkan", "rocm"]},
+  {"match": "RX 6", "vendor": "amd", "arch": "rdna2",
+   "backends_windows": ["vulkan"], "backends_linux": ["vulkan", "rocm"]},
+  {"match": "RTX 50", "vendor": "nvidia", "arch": "blackwell",
+   "backends_windows": ["cuda", "vulkan"], "backends_linux": ["cuda", "vulkan"]},
+  {"match": "RTX 40", "vendor": "nvidia", "arch": "ada",
+   "backends_windows": ["cuda", "vulkan"], "backends_linux": ["cuda", "vulkan"]},
+  {"match": "RTX 30", "vendor": "nvidia", "arch": "ampere",
+   "backends_windows": ["cuda", "vulkan"], "backends_linux": ["cuda", "vulkan"]},
+  {"match": "GTX 10", "vendor": "nvidia", "arch": "pascal",
+   "backends_windows": ["cuda", "vulkan"], "backends_linux": ["cuda", "vulkan"]}
+]

rigma/data/registry/models/qwen3-0.6b.json

@@ -0,0 +1,9 @@
+{
+  "slug": "qwen3-0.6b", "family": "qwen3", "kind": "dense",
+  "n_layers": 28, "full_attn_layers": 28, "kv_heads": 8, "head_dim": 128,
+  "native_ctx": 32768,
+  "ggufs": [{"repo": "unsloth/Qwen3-0.6B-GGUF", "file": "Qwen3-0.6B-Q8_0.gguf",
+             "bytes": 639447744, "quant": "Q8_0"}],
+  "license": "apache-2.0", "use_cases": ["general"],
+  "sources": ["https://huggingface.co/unsloth/Qwen3-0.6B-GGUF"]
+}

rigma/data/registry/models/qwen3.6-35b-a3b.json

@@ -0,0 +1,19 @@
+{
+  "slug": "qwen3.6-35b-a3b", "family": "qwen3.6", "kind": "moe",
+  "n_layers": 40, "full_attn_layers": 10, "kv_heads": 2, "head_dim": 256,
+  "native_ctx": 262144,
+  "moe": {"total_b": 35, "active_b": 3, "expert_weight_fraction": 0.85},
+  "cache_type_policy": {"k": "q8_0", "v": "q8_0",
+    "reason": "DeltaNet recurrent state desyncs with q4 K-cache on long contexts"},
+  "ggufs": [
+    {"repo": "unsloth/Qwen3.6-35B-A3B-GGUF", "file": "Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf",
+     "bytes": 22360456160, "quant": "UD-Q4_K_XL"},
+    {"repo": "unsloth/Qwen3.6-35B-A3B-GGUF", "file": "Qwen3.6-35B-A3B-UD-Q3_K_XL.gguf",
+     "bytes": 16845511648, "quant": "UD-Q3_K_XL"},
+    {"repo": "unsloth/Qwen3.6-35B-A3B-GGUF", "file": "Qwen3.6-35B-A3B-UD-Q2_K_XL.gguf",
+     "bytes": 12290628576, "quant": "UD-Q2_K_XL"}
+  ],
+  "license": "apache-2.0", "use_cases": ["coding", "general", "agentic"],
+  "sources": ["https://huggingface.co/Qwen/Qwen3.6-35B-A3B",
+              "https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF"]
+}

rigma/models.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+STANDARD_GB = [4, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256]
+
+
+def ram_tier(mb: int) -> int:
+    gb = mb / 1024
+    return min(STANDARD_GB, key=lambda s: abs(s - gb))
+
+
+class GpuInfo(BaseModel):
+    vendor: str
+    name: str
+    vram_mb: int
+    arch: str = "unknown"
+    slug: str = "unknown"
+    backends: list[str] = Field(default_factory=list)
+
+
+class CpuInfo(BaseModel):
+    cores: int
+    name: str = ""
+
+
+class HardwareProfile(BaseModel):
+    gpus: list[GpuInfo]
+    ram_mb: int
+    ram_free_mb: int
+    cpu: CpuInfo
+    os: str  # "windows" | "linux" | "darwin"
+    disk_free_gb: float
+
+    @property
+    def primary_gpu(self) -> GpuInfo | None:
+        return max(self.gpus, key=lambda g: g.vram_mb) if self.gpus else None
+
+    @property
+    def ram_tier_gb(self) -> int:
+        return ram_tier(self.ram_mb)
+
+    @property
+    def fingerprint(self) -> str:
+        gpu = self.primary_gpu
+        head = f"{gpu.vendor}-{gpu.slug}" if gpu else "cpu-only"
+        return f"{head}/ram-{self.ram_tier_gb}/{self.os}"
+
+
+class MoESpec(BaseModel):
+    total_b: float
+    active_b: float
+    expert_weight_fraction: float
+
+
+class CachePolicy(BaseModel):
+    k: str = "f16"
+    v: str = "f16"
+    reason: str = ""
+
+
+class GgufFile(BaseModel):
+    repo: str
+    file: str
+    bytes: int
+    quant: str
+    sha256: str | None = None
+
+
+class ModelSpec(BaseModel):
+    slug: str
+    family: str
+    kind: str  # "dense" | "moe"
+    n_layers: int
+    full_attn_layers: int
+    kv_heads: int
+    head_dim: int
+    native_ctx: int
+    ggufs: list[GgufFile]
+    moe: MoESpec | None = None
+    cache_type_policy: CachePolicy = CachePolicy()
+    license: str = ""
+    use_cases: list[str] = Field(default_factory=list)
+    sources: list[str] = Field(default_factory=list)
+
+
+class ComboFlags(BaseModel):
+    ctx: int
+    ngl: int = 99
+    n_cpu_moe: int = 0
+    flash_attn: bool = True
+    cache_type_k: str = "f16"
+    cache_type_v: str = "f16"
+
+
+class Budget(BaseModel):
+    vram_mb: int
+    ram_mb: int
+
+
+class Combo(BaseModel):
+    model: str
+    quant: str
+    backend: str
+    flags: ComboFlags
+    budget: Budget | None = None
+    expected: dict | None = None
+    verified: dict | None = None
+    notes: str = ""
+    sources: list[str] = Field(default_factory=list)
+
+
+class RunPlan(BaseModel):
+    model_slug: str
+    gguf: GgufFile
+    backend: str
+    flags: ComboFlags
+    origin: str  # "combo:<path>" | "class:<path>" | "calculator"
+    explain: list[str] = Field(default_factory=list)
+
+    def server_args(self, model_path: str, port: int) -> list[str]:
+        args = ["-m", model_path, "--port", str(port), "--host", "127.0.0.1",
+                "-ngl", str(self.flags.ngl), "-c", str(self.flags.ctx)]
+        if self.flags.n_cpu_moe > 0:
+            args += ["--n-cpu-moe", str(self.flags.n_cpu_moe)]
+        if self.flags.flash_attn:
+            args += ["-fa", "on"]
+        args += ["--cache-type-k", self.flags.cache_type_k,
+                 "--cache-type-v", self.flags.cache_type_v]
+        return args

rigma/probe.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import ctypes
+import os
+import platform
+import re
+import shutil
+
+import psutil
+
+from .models import CpuInfo, GpuInfo, HardwareProfile
+
+VENDOR_IDS = {0x1002: "amd", 0x10DE: "nvidia", 0x8086: "intel", 0x106B: "apple"}
+
+
+def _os_name() -> str:
+    return {"Windows": "windows", "Linux": "linux", "Darwin": "darwin"}.get(
+        platform.system(), "linux")
+
+
+def _slugify(name: str, vram_mb: int) -> str:
+    s = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    return f"{s}-{round(vram_mb / 1024)}g"
+
+
+def classify_gpu(raw: dict, gpu_table: list[dict], os_name: str) -> GpuInfo:
+    vendor = VENDOR_IDS.get(raw["vendor_id"], "unknown")
+    name, vram = raw["name"], raw["vram_mb"]
+    for row in gpu_table:
+        if row["match"].lower() in name.lower():
+            backends = row.get(f"backends_{os_name}",
+                               row.get("backends_windows", ["vulkan"]))
+            return GpuInfo(vendor=row["vendor"], name=name, vram_mb=vram,
+                           arch=row["arch"], slug=_slugify(name, vram),
+                           backends=backends)
+    return GpuInfo(vendor=vendor, name=name, vram_mb=vram,
+                   slug=_slugify(name, vram), backends=["vulkan"])
+
+
+# --- Vulkan enumeration (ctypes; no SDK needed, the ICD ships with GPU drivers) ---
+
+_VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x1
+
+
+class _VkAppInfo(ctypes.Structure):
+    _fields_ = [("sType", ctypes.c_int), ("pNext", ctypes.c_void_p),
+                ("pApplicationName", ctypes.c_char_p),
+                ("applicationVersion", ctypes.c_uint32),
+                ("pEngineName", ctypes.c_char_p), ("engineVersion", ctypes.c_uint32),
+                ("apiVersion", ctypes.c_uint32)]
+
+
+class _VkInstanceCreateInfo(ctypes.Structure):
+    _fields_ = [("sType", ctypes.c_int), ("pNext", ctypes.c_void_p),
+                ("flags", ctypes.c_uint32), ("pApplicationInfo", ctypes.c_void_p),
+                ("enabledLayerCount", ctypes.c_uint32),
+                ("ppEnabledLayerNames", ctypes.c_void_p),
+                ("enabledExtensionCount", ctypes.c_uint32),
+                ("ppEnabledExtensionNames", ctypes.c_void_p)]
+
+
+class _VkPhysicalDeviceProperties(ctypes.Structure):
+    _fields_ = [("apiVersion", ctypes.c_uint32), ("driverVersion", ctypes.c_uint32),
+                ("vendorID", ctypes.c_uint32), ("deviceID", ctypes.c_uint32),
+                ("deviceType", ctypes.c_int), ("deviceName", ctypes.c_char * 256),
+                ("pipelineCacheUUID", ctypes.c_uint8 * 16),
+                ("limits", ctypes.c_uint8 * 504),
+                ("sparseProperties", ctypes.c_uint8 * 20)]
+
+
+class _VkMemoryHeap(ctypes.Structure):
+    _fields_ = [("size", ctypes.c_uint64), ("flags", ctypes.c_uint32)]
+
+
+class _VkMemoryType(ctypes.Structure):
+    _fields_ = [("propertyFlags", ctypes.c_uint32), ("heapIndex", ctypes.c_uint32)]
+
+
+class _VkPhysicalDeviceMemoryProperties(ctypes.Structure):
+    _fields_ = [("memoryTypeCount", ctypes.c_uint32),
+                ("memoryTypes", _VkMemoryType * 32),
+                ("memoryHeapCount", ctypes.c_uint32),
+                ("memoryHeaps", _VkMemoryHeap * 16)]
+
+
+def enumerate_vulkan() -> list[dict]:
+    """Enumerate GPUs via the Vulkan loader. Returns [] on any failure."""
+    try:
+        lib = ctypes.CDLL("vulkan-1" if _os_name() == "windows" else
+                          ("libvulkan.dylib" if _os_name() == "darwin"
+                           else "libvulkan.so.1"))
+        app = _VkAppInfo(sType=0, pApplicationName=b"rigma", apiVersion=(1 << 22))
+        info = _VkInstanceCreateInfo(sType=1, pApplicationInfo=ctypes.cast(
+            ctypes.pointer(app), ctypes.c_void_p))
+        inst = ctypes.c_void_p()
+        if lib.vkCreateInstance(ctypes.byref(info), None, ctypes.byref(inst)) != 0:
+            return []
+        try:
+            n = ctypes.c_uint32(0)
+            lib.vkEnumeratePhysicalDevices(inst, ctypes.byref(n), None)
+            devs = (ctypes.c_void_p * n.value)()
+            lib.vkEnumeratePhysicalDevices(inst, ctypes.byref(n), devs)
+            out = []
+            for d in devs:
+                props = _VkPhysicalDeviceProperties()
+                lib.vkGetPhysicalDeviceProperties(ctypes.c_void_p(d),
+                                                  ctypes.byref(props))
+                mem = _VkPhysicalDeviceMemoryProperties()
+                lib.vkGetPhysicalDeviceMemoryProperties(ctypes.c_void_p(d),
+                                                        ctypes.byref(mem))
+                local = [mem.memoryHeaps[i].size for i in range(mem.memoryHeapCount)
+                         if mem.memoryHeaps[i].flags & _VK_MEMORY_HEAP_DEVICE_LOCAL_BIT]
+                if props.deviceType == 4:  # VK_PHYSICAL_DEVICE_TYPE_CPU
+                    continue
+                out.append({"vendor_id": props.vendorID,
+                            "name": props.deviceName.decode(errors="replace"),
+                            "vram_mb": int(max(local, default=0) / (1024 * 1024))})
+            return out
+        finally:
+            lib.vkDestroyInstance(inst, None)
+    except Exception:
+        return []
+
+
+def _nvml_gpus() -> list[dict]:
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        out = []
+        for i in range(pynvml.nvmlDeviceGetCount()):
+            h = pynvml.nvmlDeviceGetHandleByIndex(i)
+            name = pynvml.nvmlDeviceGetName(h)
+            if isinstance(name, bytes):
+                name = name.decode()
+            out.append({"vendor_id": 0x10DE, "name": name,
+                        "vram_mb": int(pynvml.nvmlDeviceGetMemoryInfo(h).total / 2**20)})
+        pynvml.nvmlShutdown()
+        return out
+    except Exception:
+        return []
+
+
+def probe_hardware(gpu_table: list[dict],
+                   raw_gpus: list[dict] | None = None) -> HardwareProfile:
+    os_name = _os_name()
+    raw = raw_gpus if raw_gpus is not None else (enumerate_vulkan() or _nvml_gpus())
+    vm = psutil.virtual_memory()
+    return HardwareProfile(
+        gpus=[classify_gpu(r, gpu_table, os_name) for r in raw],
+        ram_mb=int(vm.total / 2**20),
+        ram_free_mb=int(vm.available / 2**20),
+        cpu=CpuInfo(cores=os.cpu_count() or 1, name=platform.processor() or ""),
+        os=os_name,
+        disk_free_gb=shutil.disk_usage(os.path.expanduser("~")).free / 2**30,
+    )

rigma/registry.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+import os
+from importlib import resources
+from pathlib import Path
+
+from .models import Combo, ModelSpec
+
+
+class Registry:
+    def __init__(self, gpus: list[dict], models: dict[str, ModelSpec],
+                 combos: dict[str, Combo]):
+        self.gpus, self.models, self.combos = gpus, models, combos
+
+    @classmethod
+    def load(cls, path: Path | None = None) -> "Registry":
+        if path is None and os.environ.get("RIGMA_REGISTRY_DIR"):
+            path = Path(os.environ["RIGMA_REGISTRY_DIR"])
+        if path is None:
+            path = Path(str(resources.files("rigma").joinpath("data/registry")))
+        gpus = json.loads((path / "gpus.json").read_text(encoding="utf-8"))
+        models = {}
+        for f in sorted((path / "models").glob("*.json")):
+            spec = ModelSpec.model_validate_json(f.read_text(encoding="utf-8"))
+            models[spec.slug] = spec
+        combos = {}
+        for f in sorted((path / "combos").rglob("*.json")):
+            rel = f.relative_to(path / "combos").as_posix()
+            combos[rel] = Combo.model_validate_json(f.read_text(encoding="utf-8"))
+        return cls(gpus, models, combos)
+
+    def find_combo(self, vendor: str, gpu_slug: str, vram_gb: int, ram_gb: int,
+                   use_case: str) -> tuple[Combo, str] | None:
+        candidates = [
+            f"{vendor}/{gpu_slug}/ram-{ram_gb}/{use_case}.json",
+            f"{vendor}/{gpu_slug}/ram-{ram_gb}/general.json",
+            f"_class/vram-{vram_gb}/ram-{ram_gb}/{use_case}.json",
+            f"_class/vram-{vram_gb}/ram-{ram_gb}/general.json",
+        ]
+        for rel in candidates:
+            if rel in self.combos:
+                return self.combos[rel], rel
+        return None

rigma/resolve.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import math
+
+from .models import ComboFlags, GgufFile, HardwareProfile, ModelSpec, RunPlan
+from .registry import Registry
+
+VRAM_RESERVE_MB = {"windows": 1200, "linux": 400, "darwin": 0}
+RAM_RESERVE_MB = 2048
+COMPUTE_BUFFER_MB = 900
+CACHE_BYTES = {"f16": 2.0, "q8_0": 1.0625, "q4_0": 0.5625}
+CTX_DEFAULT = {"coding": 32768}
+CTX_FLOOR = 8192
+
+
+class ResolveError(RuntimeError):
+    pass
+
+
+def kv_bytes_per_token(spec: ModelSpec, k: str, v: str) -> float:
+    per_side = spec.full_attn_layers * spec.kv_heads * spec.head_dim
+    return per_side * CACHE_BYTES[k] + per_side * CACHE_BYTES[v]
+
+
+def _budgets(profile: HardwareProfile) -> tuple[float, float]:
+    gpu = profile.primary_gpu
+    vram = (gpu.vram_mb if gpu else 0) - VRAM_RESERVE_MB[profile.os] - COMPUTE_BUFFER_MB
+    return max(vram, 0), max(profile.ram_free_mb - RAM_RESERVE_MB, 0)
+
+
+def fit_gguf(spec: ModelSpec, gguf: GgufFile, profile: HardwareProfile,
+             ctx: int, explain: list[str]) -> ComboFlags | None:
+    usable_vram, usable_ram = _budgets(profile)
+    k, v = spec.cache_type_policy.k, spec.cache_type_policy.v
+    file_mb = gguf.bytes / 2**20
+    kv_mb = ctx * kv_bytes_per_token(spec, k, v) / 2**20
+    explain.append(f"{gguf.quant}@ctx{ctx}: file={file_mb:.0f}MB kv={kv_mb:.0f}MB "
+                   f"vs vram={usable_vram:.0f}MB ram={usable_ram:.0f}MB")
+    if spec.moe is None:
+        if file_mb + kv_mb <= usable_vram:
+            return ComboFlags(ctx=ctx, cache_type_k=k, cache_type_v=v)
+        return None
+    expert_mb = file_mb * spec.moe.expert_weight_fraction
+    per_layer = expert_mb / spec.n_layers
+    need_off = max(0.0, file_mb + kv_mb - usable_vram)
+    n_off = math.ceil(need_off / per_layer) if need_off else 0
+    if n_off <= spec.n_layers and n_off * per_layer <= usable_ram:
+        return ComboFlags(ctx=ctx, n_cpu_moe=n_off, cache_type_k=k, cache_type_v=v)
+    return None
+
+
+def _backend(profile: HardwareProfile) -> str:
+    gpu = profile.primary_gpu
+    return gpu.backends[0] if gpu and gpu.backends else "cpu"
+
+
+def _calculate(profile: HardwareProfile, registry: Registry,
+               use_case: str) -> RunPlan | None:
+    explain: list[str] = []
+    pool = [m for m in registry.models.values() if use_case in m.use_cases] or \
+        list(registry.models.values())
+
+    def total_b(m: ModelSpec) -> float:
+        return m.moe.total_b if m.moe else m.n_layers
+
+    for spec in sorted(pool, key=total_b, reverse=True):
+        for gguf in spec.ggufs:  # registry order: largest quant first
+            ctx = min(CTX_DEFAULT.get(use_case, 16384), spec.native_ctx)
+            while ctx >= CTX_FLOOR:
+                flags = fit_gguf(spec, gguf, profile, ctx, explain)
+                if flags:
+                    return RunPlan(model_slug=spec.slug, gguf=gguf,
+                                   backend=_backend(profile), flags=flags,
+                                   origin="calculator", explain=explain)
+                ctx //= 2
+    return None
+
+
+def resolve(profile: HardwareProfile, registry: Registry,
+            use_case: str = "general", model_override: str | None = None) -> RunPlan:
+    if not registry.models:
+        raise ResolveError("registry has no models")
+    gpu = profile.primary_gpu
+    if gpu and model_override is None:
+        hit = registry.find_combo(gpu.vendor, gpu.slug, round(gpu.vram_mb / 1024),
+                                  profile.ram_tier_gb, use_case)
+        if hit:
+            combo, rel = hit
+            spec = registry.models[combo.model]
+            gguf = next(g for g in spec.ggufs if g.quant == combo.quant)
+            kind = "class" if rel.startswith("_class/") else "combo"
+            return RunPlan(model_slug=combo.model, gguf=gguf, backend=combo.backend,
+                           flags=combo.flags, origin=f"{kind}:{rel}",
+                           explain=[f"registry match: {rel}"] + combo.sources)
+    if model_override:
+        registry = Registry(registry.gpus,
+                            {model_override: registry.models[model_override]},
+                            registry.combos)
+    plan = _calculate(profile, registry, use_case)
+    if plan:
+        return plan
+    # absolute floor: smallest model, smallest quant, CPU
+    spec = min(registry.models.values(), key=lambda m: m.ggufs[-1].bytes)
+    return RunPlan(model_slug=spec.slug, gguf=spec.ggufs[-1], backend="cpu",
+                   flags=ComboFlags(ctx=CTX_FLOOR, ngl=0), origin="calculator",
+                   explain=["floor: nothing larger fits"])

rigma/runtime.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import tarfile
+import time
+import zipfile
+from importlib import resources
+from pathlib import Path
+
+import httpx
+from huggingface_hub import hf_hub_download
+
+from .models import GgufFile, RunPlan
+
+
+def rigma_home() -> Path:
+    return Path(os.environ.get("RIGMA_HOME", str(Path.home() / ".rigma")))
+
+
+def _engines_manifest() -> dict:
+    return json.loads(resources.files("rigma").joinpath("data/engines.json")
+                      .read_text(encoding="utf-8"))
+
+
+def _fetch(url: str, dest: Path) -> None:
+    with httpx.stream("GET", url, follow_redirects=True, timeout=600) as r:
+        r.raise_for_status()
+        with open(dest, "wb") as f:
+            for chunk in r.iter_bytes(1 << 20):
+                f.write(chunk)
+
+
+def _extract(archive: Path, dest: Path) -> None:
+    if archive.name.endswith(".zip"):
+        with zipfile.ZipFile(archive) as z:
+            z.extractall(dest)
+    else:
+        with tarfile.open(archive) as t:
+            t.extractall(dest, filter="data")
+
+
+def ensure_engine(backend: str, os_name: str) -> Path:
+    man = _engines_manifest()
+    key = f"{os_name}/{backend}"
+    if key not in man["assets"]:
+        raise RuntimeError(f"no pinned engine build for {key}")
+    root = rigma_home() / "engines" / man["version"] / backend
+    exe = root / ("llama-server.exe" if os_name == "windows" else "llama-server")
+    if exe.exists():
+        return exe
+    found = next(root.rglob(exe.name), None) if root.exists() else None
+    if found:
+        return found
+    root.mkdir(parents=True, exist_ok=True)
+    lock_path = rigma_home() / "engines" / "lock.json"
+    lock = json.loads(lock_path.read_text()) if lock_path.exists() else {}
+    assets = [man["assets"][key]] + man.get("extra_assets", {}).get(key, [])
+    for asset in assets:
+        archive = root / asset
+        _fetch(man["url_base"] + asset, archive)
+        digest = hashlib.sha256(archive.read_bytes()).hexdigest()
+        lock_key = f"{key}:{asset}" if asset != man["assets"][key] else key
+        if lock_key in lock and lock[lock_key]["sha256"] != digest:
+            archive.unlink()
+            raise RuntimeError(f"checksum mismatch for {asset}: expected "
+                               f"{lock[lock_key]['sha256']}, got {digest}")
+        lock[lock_key] = {"asset": asset, "sha256": digest,
+                          "version": man["version"]}
+        _extract(archive, root)
+        archive.unlink()
+    lock_path.write_text(json.dumps(lock, indent=2))
+    if exe.exists():
+        return exe
+    found = next(root.rglob(exe.name), None)  # some archives nest under build/bin/
+    if not found:
+        raise RuntimeError(f"{exe.name} not found in downloaded engine assets")
+    return found
+
+
+def ensure_model(gguf: GgufFile) -> Path:
+    # Polite + robust by default: HF's xet backend opens ~16 parallel range
+    # requests (saturates home connections) and was observed to hang and lose
+    # resume state after interrupted runs (2026-07-06). The classic downloader
+    # is single-stream and resumes deterministically. `rigma up --turbo`
+    # re-enables xet at full concurrency.
+    os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+    os.environ.setdefault("HF_XET_NUM_CONCURRENT_RANGE_GETS", "4")
+    local_dir = rigma_home() / "models"
+    local_dir.mkdir(parents=True, exist_ok=True)
+    return Path(hf_hub_download(repo_id=gguf.repo, filename=gguf.file,
+                                local_dir=str(local_dir)))
+
+
+class ServerProcess:
+    def __init__(self, proc: subprocess.Popen, port: int, log_path: Path):
+        self.proc, self.port, self.log_path = proc, port, log_path
+
+    @property
+    def url(self) -> str:
+        return f"http://127.0.0.1:{self.port}"
+
+    def is_healthy(self) -> bool:
+        try:
+            return httpx.get(f"{self.url}/health", timeout=3).status_code == 200
+        except Exception:
+            return False
+
+    def stop(self) -> None:
+        self.proc.terminate()
+        try:
+            self.proc.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            self.proc.kill()
+
+
+def launch_server(exe: Path, plan: RunPlan, model_path: Path, port: int = 11500,
+                  timeout: float = 300.0,
+                  extra_args: list[str] | None = None) -> ServerProcess:
+    logs = rigma_home() / "logs"
+    sessions = rigma_home() / "sessions"
+    logs.mkdir(parents=True, exist_ok=True)
+    sessions.mkdir(parents=True, exist_ok=True)
+    log_path = logs / f"server-{port}.log"
+    argv = [str(exe), *(extra_args or []),
+            *plan.server_args(str(model_path), port),
+            "--slot-save-path", str(sessions)]
+    with open(log_path, "w", encoding="utf-8", errors="replace") as log_f:
+        proc = subprocess.Popen(argv, stdout=log_f, stderr=subprocess.STDOUT)
+    sp = ServerProcess(proc, port, log_path)
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            break
+        if sp.is_healthy():
+            return sp
+        time.sleep(0.5)
+    sp.stop()
+    tail = "".join(log_path.read_text(encoding="utf-8",
+                                      errors="replace").splitlines(True)[-40:])
+    raise RuntimeError(f"llama-server failed to become healthy on :{port}\n{tail}")

rigma-0.1.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: rigma
+Version: 0.1.0
+Summary: Hardware-aware local LLM deployment: probe, resolve, run.
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: psutil>=5.9
+Requires-Dist: pydantic>=2.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: nvidia
+Requires-Dist: pynvml>=11.5; extra == 'nvidia'
+Description-Content-Type: text/markdown
+
+# Rigma
+
+Hardware-aware local LLM deployment for consumer machines: `rigma up` probes your GPU/RAM,
+picks the community-verified best model + quant + flag combo for your exact hardware,
+downloads a pinned llama.cpp build and the model, and serves an OpenAI-compatible endpoint —
+no knob-mashing required.
+
+Unlike generic runners, Rigma applies the tuning that actually matters per machine:
+MoE expert offload (`--n-cpu-moe`) sized to your RAM, architecture-aware KV-cache policies
+(e.g. `q8_0` K-cache floor on DeltaNet-family models), backend selection per GPU generation
+(e.g. Vulkan over ROCm on RDNA4), flash attention, and session persistence
+(`--slot-save-path`) on by default. Every decision is auditable: `rigma plan --explain`
+shows the arithmetic and sources.
+
+## Quickstart (pre-alpha)
+
+```powershell
+git clone https://github.com/IxMxAMAR/rigma && cd rigma
+pip install -e .
+rigma up            # probe -> resolve -> download -> serve at http://127.0.0.1:11500/v1
+```
+
+Commands: `rigma doctor` (what Rigma sees), `rigma plan --explain` (what it would run and why),
+`rigma models` (what fits your machine), `rigma up --use-case coding` (serve).
+
+## Status
+
+Pre-alpha (M1). Verified combos:
+
+| Hardware | Model | Backend | Result |
+|---|---|---|---|
+| RX 9070 XT 16GB + 16GB RAM (Windows) | Qwen3.6-35B-A3B UD-Q3_K_XL, ctx 32K, n_cpu_moe 10 | Vulkan (llama.cpp b9867) | **verified 2026-07-06**: 57.1 t/s gen, 689 t/s prefill @ 4K prompt |
+
+Design: `docs/superpowers/specs/2026-07-03-rigma-design.md`. License: Apache-2.0.
+RAG integration (via [Raggity](https://github.com/IxMxAMAR/raggity), AGPL-3.0, separate process) lands in M4.

rigma-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+rigma/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+rigma/cli.py,sha256=e_Qohd-C5uF4xNI2aAJD2Vn4aJkN3ExVQ-FZV66B6fw,3503
+rigma/models.py,sha256=pYtXUuoT92UZm0yLW2NsVwNBvQEmq6WZe5phZG55-do,3091
+rigma/probe.py,sha256=u1wxdBQkIscxlwIDCTr-MqxSP_pZttGeMkBAUQGBXWs,6321
+rigma/registry.py,sha256=dkyj5F2Pp_3FPg4pczi7YQhKWx4-Wz17Oa89uPi8aF0,1762
+rigma/resolve.py,sha256=lyf7I7R-cMxz0uelnfTbNR2HARYKjDo1WeyvvSXDKBQ,4539
+rigma/runtime.py,sha256=L41gZwaz03wYpo5wE8e1ZnhVHRmwcNxWnEAymmQUh3o,5334
+rigma/data/engines.json,sha256=HaQIU55L33poCmwwlvnVFK7gXY710unhs0M9mZiIhc4,566
+rigma/data/registry/gpus.json,sha256=-RYx7WZV3Mjizv3uB_TLcNpO3StcaqwglFbKTJM6SvU,977
+rigma/data/registry/combos/_class/vram-16/ram-16/general.json,sha256=Z6rAneTSHyPOmZjlEFxxmhLCoz2eWIrT6fErdvF6I4Q,374
+rigma/data/registry/combos/amd/amd-radeon-rx-9070-xt-16g/ram-16/coding.json,sha256=Yo8wI5nbz5xoyO0MUGH2l1bogEIEOgPhsVR8X5ypnI8,749
+rigma/data/registry/combos/amd/amd-radeon-rx-9070-xt-16g/ram-16/general.json,sha256=2WDinapPnq7vE7Bzi9mopfdj05nG10wsG3g_onqCOMk,542
+rigma/data/registry/models/qwen3-0.6b.json,sha256=zJIkoA5cB1V7Lqk6ePb3B0kuaRiu0SB3e99nCWOstfw,410
+rigma/data/registry/models/qwen3.6-35b-a3b.json,sha256=5ZdhlsVlzWL1s_9pBtuyudUkv6YzZaQRnhP3kuNvmMY,1012
+rigma-0.1.0.dist-info/METADATA,sha256=ROj42G-e5deQJKBzqNt5M3X0cFdCXUquVJQkFUqfa0Q,2195
+rigma-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+rigma-0.1.0.dist-info/entry_points.txt,sha256=BKJ-KRvuElfowivFjws8v0UEcTrCEoPtKYETCfe3bEs,40
+rigma-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+rigma-0.1.0.dist-info/RECORD,,

rigma-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

rigma-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rigma = rigma.cli:app

rigma-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.