hypernix 0.72.6.post3__tar.gz → 0.72.6.post4__tar.gz

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypernix
-Version: 0.72.6.post3
+Version: 0.72.6.post4
 Summary: Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M). and train models with a massive ai toolkit 
 Home-page: https://github.com/trail-b1az3r/hypernix-pip
 Author: HyperNix contributors
@@ -82,7 +82,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <img alt="PyPI" src="https://img.shields.io/badge/PyPI-v0.72.6.post2-ff2d55?style=for-the-badge&logo=pypi&logoColor=white" />
+  <img alt="PyPI" src="https://img.shields.io/badge/PyPI-v0.72.6.post3-ff2d55?style=for-the-badge&logo=pypi&logoColor=white" />
   <img alt="Python" src="https://img.shields.io/badge/Python-3.10--3.14-00c9ff?style=for-the-badge&logo=python&logoColor=white" />
   <img alt="License" src="https://img.shields.io/badge/License-HOS%20/%20LLU-00c853?style=for-the-badge" />
 </p>

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/README.md

@@ -4,7 +4,7 @@
 </p>
 
 <p align="center">
-  <img alt="PyPI" src="https://img.shields.io/badge/PyPI-v0.72.6.post2-ff2d55?style=for-the-badge&logo=pypi&logoColor=white" />
+  <img alt="PyPI" src="https://img.shields.io/badge/PyPI-v0.72.6.post3-ff2d55?style=for-the-badge&logo=pypi&logoColor=white" />
   <img alt="Python" src="https://img.shields.io/badge/Python-3.10--3.14-00c9ff?style=for-the-badge&logo=python&logoColor=white" />
   <img alt="License" src="https://img.shields.io/badge/License-HOS%20/%20LLU-00c853?style=for-the-badge" />
 </p>

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/install-t1.sh

@@ -45,7 +45,7 @@ set -euo pipefail
 # below replaces them whenever the script is run from a clone, and
 # tests/repo/test_install_script.py fails if the fallback drifts from the
 # package again.
-VERSION="0.72.6.post3"
+VERSION="0.72.6.post4"
 T1_API_VERSION="1.1.26.9.0.0"
 
 # Replace the baked versions with the real ones, when they can be read.

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypernix"
-version = "0.72.6.post3"
+version = "0.72.6.post4"
 description = "Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M). and train models with a massive ai toolkit "
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "HOL-1.0" }

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = hypernix
-version = 0.72.6.post3
+version = 0.72.6.post4
 description = Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M).
 long_description = file: README.md
 long_description_content_type = text/markdown

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/__init__.py

@@ -63,7 +63,7 @@ import importlib.util
 import sys
 from typing import TYPE_CHECKING, Any
 
-__version__ = "0.72.6.post3"
+__version__ = "0.72.6.post4"
 DEFAULT_REPO_ID = "ray0rf1re/hyper-Nix.2"
 DEFAULT_MODEL = "qwen3.5-4b"  # New default model
 

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/hyperlink/managed.py

@@ -445,13 +445,17 @@ class ManagedRunner:
         if not model_path.is_file():
             raise ManagedError(f"No such model: {model_path}")
 
-        from ..quant.gguf import GGUFError
-        from ..quant.runtime_bridge import BridgeError, find_build, model_types, serve_argv
+        from ..quant.gguf import GGUFError, GGUFFile
+        from ..quant.runtime_bridge import BridgeError, find_build, serve_argv
 
         try:
-            types = model_types(model_path)
+            header = GGUFFile.read(model_path)
         except (GGUFError, OSError):
-            types = frozenset()     # llama-server says what is wrong with it
+            header = None           # llama-server says what is wrong with it
+        types = (frozenset(int(t.ggml_type) for t in header.tensors)
+                 if header is not None else frozenset())
+        if header is not None and header.metadata.get("general.architecture") == "hypernix":
+            raise ManagedError(_hypernix_architecture_message(model_path))
         try:
             build = find_build(need=types)
         except BridgeError as exc:
@@ -764,6 +768,22 @@ class ManagedPool:
         }
 
 
+def _hypernix_architecture_message(model: Path) -> str:
+    """Why a GGUF labelled `hypernix` will not load, and how to remake it."""
+    return (
+        f"{model.name} says its architecture is 'hypernix', which no llama.cpp "
+        f"knows -- the HyperNix patch adds number formats, not architectures, so "
+        f"a patched build refuses it too (\"unknown model architecture: "
+        f"'hypernix'\").\n"
+        f"It was written by the generic converter, which older versions also used "
+        f"for hyperNix0x-v2 models saved without a config.json. Export it again "
+        f"from the model folder -- it is now written as 'llama', as "
+        f"HyperNix.3-mini is:\n"
+        f"  hnx convert /path/to/model-folder -o {model.stem}.gguf\n"
+        f"or, for a training run's checkpoint: hnx brew gguf runs/<name>/checkpoints/latest.pt"
+    )
+
+
 def _unreadable_types_message(model: Path, build: Any, missing: list[int]) -> str:
     """Why *build* cannot open *model*, and the one command that fixes it."""
     from ..quant.ggufcheck import _type_name  # noqa: PLC2701

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/interfaces/cli.py

@@ -556,10 +556,26 @@ def _run_convert(raw: list[str]) -> int:
             arch_name=ns.arch, name=ns.name,
             n_head_hint=ns.n_head, context_length=ns.context_length,
         )
+    _note_architecture(out)
     print(out)
     return 0
 
 
+def _note_architecture(path) -> None:
+    """Say so when a GGUF was written under a name llama.cpp does not know."""
+    from hypernix.quant.gguf import GGUFFile
+
+    try:
+        arch = GGUFFile.read(path).metadata.get("general.architecture", "")
+    except Exception:  # noqa: BLE001 - a note, never a failure
+        return
+    if arch == "hypernix":
+        print("note: written as general.architecture=hypernix. HnxRun runs it; llama.cpp, "
+              "patched or not, does not know that architecture. A hyperNix0x-v2 (Brewer) "
+              "model is written as llama instead -- this one was not recognised as one.",
+              file=sys.stderr)
+
+
 def _run_convert_pipeline(ns: argparse.Namespace, source: str) -> int:
     """``convert -P``: safetensors -> GGUF -> hyprslug."""
     from hypernix.quant.convertq import ConvertQuantizeError, convert_and_quantize, source_kind

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/interfaces/hyped_basic.py

@@ -159,8 +159,7 @@ def discover_backend(config: Config, *, timeout: float = 2.0) -> Backend:
 
     local = _first_local_model(config)
     if local is not None:
-        return Backend("local", model=str(local),
-                       detail=f"local model {local.name}")
+        return local_backend(local)
 
     return Backend(
         "none",
@@ -178,14 +177,58 @@ def models_dir(config: Config) -> Path:
     return Path.home() / ".hypernix" / "models"
 
 
+def local_models(config: Config) -> list[Path]:
+    """Every model on this machine hyped can run, in the models folder.
+
+    GGUF files anywhere under it, through symlinked folders, and model
+    folders -- Hugging Face snapshots and hyperNix0x-v2 (Brewer) models,
+    HyperNix.3-mini's kind. It used to be ``rglob("*.gguf")``, which saw
+    no model folder at all and walked straight past a symlinked one.
+    """
+    from . import hyped_pro_core as core
+
+    paths = []
+    for model in core.local_models(models_dir(config)):
+        repo = Path(model.repo)
+        paths.append(repo / model.gguf_filename if model.format == "gguf" else repo)
+    return sorted(paths)
+
+
 def _first_local_model(config: Config) -> Path | None:
-    directory = models_dir(config)
-    if not directory.is_dir():
-        return None
-    found = sorted(directory.rglob("*.gguf"))
+    if config.model:
+        # A model the dots (or --model) name, when it is a file or folder
+        # here: that is the one asked for, not the first one found.
+        from . import hyped_pro_core as core
+
+        named = core.resolve_model(config.model, allow_remote=False)
+        if named is not None:
+            return _model_path(named)
+    found = local_models(config)
     return found[0] if found else None
 
 
+def _model_path(model) -> Path:
+    repo = Path(model.repo)
+    return repo / model.gguf_filename if model.format == "gguf" else repo
+
+
+def local_backend(path: Path | str) -> Backend:
+    """Talk to a model on this machine, run in this process."""
+    return Backend("local", model=str(path), detail=f"local model {Path(path).name}, run here")
+
+
+def is_local(model) -> bool:
+    from . import hyped_pro_core as core
+    return core.is_local_path(model)
+
+
+def _size(path: Path) -> int:
+    if path.is_file():
+        return path.stat().st_size
+    from hypernix.system.linkwalk import walk_files
+    return sum(f.stat().st_size for f in walk_files(path))
+
+
 # ---------------------------------------------------------------------------
 # Hugging Face
 # ---------------------------------------------------------------------------
@@ -410,21 +453,47 @@ class Session:
 
     def cmd_model(self, argument: str) -> None:
         if not argument:
-            self.say(self.config.model or "(whatever the server has loaded)")
+            if self.backend.kind == "local":
+                self.say(self.backend.model)
+            else:
+                self.say(self.config.model or "(whatever the server has loaded)")
+            return
+        from . import hyped_pro_core as core
+
+        # Anything runnable, not only what a server has registered: a
+        # path, a name in the models folder, or a Hugging Face repo id.
+        try:
+            model = core.get_model(argument)
+        except core.HypedProError as exc:
+            if self.backend.kind == "t1":
+                # Perhaps a name the server knows; it will say if not.
+                self.config.model = argument
+                self.say(self.paint.ok(f"model is now {argument} (on the server)"))
+                return
+            self.warn(exc.message)
+            return
+        if model.kind != "local" or model.vendor in ("t1", "t1api"):
+            self.warn(f"{argument} is a {model.vendor} model; hyped runs local models. "
+                      f"hyped-pro talks to cloud ones.")
             return
         self.config.model = argument
-        self.say(self.paint.ok(f"model is now {argument}"))
+        self.backend = local_backend(_model_path(model) if is_local(model) else argument)
+        self.messages.clear()
+        self.say(self.paint.ok(f"model is now {model.short}, run here"))
 
     def cmd_models(self, _argument: str = "") -> None:
         directory = models_dir(self.config)
-        found = sorted(directory.rglob("*.gguf")) if directory.is_dir() else []
+        found = local_models(self.config)
         if not found:
             self.say(self.paint.dim(f"nothing in {directory}"))
             self.say("Try /search qwen3 to find one.")
             return
         for path in found:
-            size = path.stat().st_size / 1e9
-            self.say(f"  {path.name}  {self.paint.dim(f'{size:.1f} GB')}")
+            size = _size(path) / 1e9
+            kind = "gguf" if path.suffix.lower() == ".gguf" else "folder"
+            self.say(f"  {path.name}  {self.paint.dim(f'{size:.1f} GB {kind}')}")
+        self.say()
+        self.say(self.paint.dim("/model <name> to use one"))
 
     def cmd_search(self, argument: str) -> None:
         if not argument:
@@ -525,12 +594,11 @@ class Session:
         return reply
 
     def _ask(self, settings: Settings) -> str:
+        if self.backend.kind == "local":
+            return self._ask_local(settings)
         if self.backend.kind != "t1":
-            raise RuntimeError(
-                "a local GGUF is present but this build cannot run it "
-                "directly — start a server with `hypernix-t1 start` and it "
-                "will be used"
-            )
+            raise RuntimeError(self.backend.detail or "nothing to talk to")
+        base = self._runner_url()
         body: dict[str, Any] = {
             "messages": (
                 ([{"role": "system", "content": settings.system}]
@@ -544,7 +612,7 @@ class Session:
             body["model"] = settings.model
 
         request = urllib.request.Request(
-            f"{self.backend.base_url}/v1/chat/completions",
+            f"{base}/v1/chat/completions",
             data=json.dumps(body).encode(),
             method="POST",
         )
@@ -558,6 +626,46 @@ class Session:
             raise RuntimeError("the server returned no reply")
         return str(choices[0].get("message", {}).get("content", ""))
 
+    def _runner_url(self) -> str:
+        """Where the T1 server's loaded model answers.
+
+        The T1 server has no ``/v1/chat/completions`` of its own -- this
+        posted there, and every reply was a 404. The model it serves is
+        the runner's (llama-server, or the PyTorch server for a Brewer
+        model), on the address ``/runner/status`` gives.
+        """
+        request = urllib.request.Request(f"{self.backend.base_url}/runner/status", method="GET")
+        if self.backend.token:
+            request.add_header("Authorization", f"Bearer {self.backend.token}")
+        try:
+            with safe_urlopen(request, timeout=10) as response:
+                status = json.loads(response.read() or b"{}")
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise RuntimeError(
+                    f"the T1 server at {self.backend.base_url} wants a key: set token "
+                    f"in your dots, or T1_KEY") from exc
+            raise
+        if not status.get("loaded"):
+            raise RuntimeError(
+                f"the T1 server at {self.backend.base_url} has no model loaded. Load one "
+                f"there (hnx-t1 runner load <model>), or /model <a model here> to run "
+                f"it in hyped")
+        return str(status.get("base_url") or "").rstrip("/") or self.backend.base_url
+
+    def _ask_local(self, settings: Settings) -> str:
+        """One turn against a model on this machine, with no tools."""
+        from . import hyped_pro_core as core
+
+        try:
+            model = core.get_model(self.backend.model)
+            return core.send_local(
+                model, list(self.messages), system=settings.system or None,
+                max_tokens=settings.max_tokens, temperature=settings.temperature,
+            )
+        except core.HypedProError as exc:
+            raise RuntimeError(exc.message) from exc
+
 
 # ---------------------------------------------------------------------------
 # The loop

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/interfaces/hyped_pro_app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyped-pro",
-  "version": "0.72.6-post3",
+  "version": "0.72.6-post4",
   "description": "hyped-pro: the HyperNix terminal client, built on OpenTUI",
   "private": true,
   "type": "module",

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/interfaces/hyped_pro_app/src/app.ts

@@ -38,7 +38,7 @@ import {
 } from "./session.ts"
 import { theme } from "./theme.ts"
 
-export const VERSION = "0.72.6-post3"
+export const VERSION = "0.72.6-post4"
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
 
@@ -523,12 +523,32 @@ export class App {
       return
     }
     const wanted = this.options.model ?? process.env.HYPED_PRO_MODEL ?? this.prefs.model
-    const found = wanted ? findModel(this.catalog.models, wanted).model : undefined
+    let found = wanted ? findModel(this.catalog.models, wanted).model : undefined
+    if (wanted && !found) found = await this.resolveModel(wanted, false)
     if (wanted && !found) this.note(`No model called "${wanted}" — using ${this.catalog.models[0]?.short}.`)
     this.model = found ?? this.catalog.models[0]
     this.refreshHeader()
   }
 
+  // A model the catalog does not list: a path to a .gguf or a model
+  // folder, a name in ~/.hypernix/models, or a Hugging Face repo id
+  // (org/name, or org/name:file.gguf). The Python side decides; this
+  // only remembers what it said, so the picker shows it from then on.
+  private async resolveModel(name: string, report: boolean): Promise<ModelInfo | undefined> {
+    if (!this.catalog) return undefined
+    try {
+      const model = await this.bridge.call<ModelInfo>("resolve", { model: name })
+      if (!this.catalog.models.some((m) => m.short === model.short)) this.catalog.models.push(model)
+      return model
+    } catch (e) {
+      if (report) {
+        const err = e as BridgeError
+        this.error(err.message, err.code)
+      }
+      return undefined
+    }
+  }
+
   private selectModel(model: ModelInfo): void {
     this.model = model
     this.prefs.model = model.short
@@ -595,7 +615,16 @@ export class App {
         const { model, matches } = findModel(this.catalog.models, rest)
         if (model) this.selectModel(model)
         else if (matches.length) this.error(`"${rest}" matches ${matches.map((m) => m.short).join(", ")}`)
-        else this.error(`No model called "${rest}". /models lists them.`)
+        else
+          // Not in the catalog is not "cannot run": a file, a folder or a
+          // Hugging Face repo runs too. The error, if any, says which of
+          // those it tried.
+          void this.resolveModel(rest, true).then((resolved) => {
+            if (resolved) {
+              this.selectModel(resolved)
+              this.note(`Model: ${modelLabel(resolved)} — ${resolved.notes ?? resolved.repo}`)
+            }
+          })
         return
       }
       case "new":

{hypernix-0.72.6.post3 → hypernix-0.72.6.post4}/src/hypernix/interfaces/hyped_pro_bridge.py

@@ -259,6 +259,12 @@ def dispatch(req: dict[str, Any], cancel: threading.Event | None = None) -> dict
         if cmd == "catalog":
             return _ok(id_, core.catalog_json())
 
+        if cmd == "resolve":
+            # A model the catalog does not name: a path, a name in the
+            # models folder, or a Hugging Face repo id. HPC-CFG-001 with
+            # what was tried when it is none of those.
+            return _ok(id_, core.model_json(core.get_model(str(req.get("model") or ""))))
+
         if cmd == "is_downloaded":
             model = core.get_model(req["model"])
             downloaded, path = core.is_downloaded(model)