hugpy-engine 0.2.4__tar.gz → 0.2.6__tar.gz

{hugpy_engine-0.2.4/src/hugpy_engine.egg-info → hugpy_engine-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hugpy-engine
-Version: 0.2.4
+Version: 0.2.6
 Summary: Hugpy engine: model discovery and classification, allocation and eviction, native llama.cpp and GGUF runners, and the prompt-to-reply inference path with task and placement seams
 Author-email: putkoff <support@hugpy.ai>
 License-Expression: LicenseRef-Proprietary

{hugpy_engine-0.2.4 → hugpy_engine-0.2.6}/src/hugpy_engine/catalog_bridge.py

@@ -52,7 +52,14 @@ class EngineCatalogSource:
     def canonical_key(self, model_key: str) -> Optional[str]:
         from hugpy_engine.resolvers.assure_model_key import assure_model_key
 
-        return assure_model_key(model_key)
+        # IDENTITY resolution only (operator rule 2026-09-29): this is the
+        # storage/provision seam a WORKER uses to re-resolve a key central
+        # already resolved (ensure_model_registered -> _assure_local_key). The
+        # shorthand fuzzy tier must never answer here — on ae it turned
+        # ``Qwen3.8-9B-GGUF`` into the resident ``Qwen3.8-9B-Distill-GGUF``
+        # (same file, different model) and served it (S3/F7). None means
+        # "learn the row from central", never "use the nearest sibling".
+        return assure_model_key(model_key, fuzzy=False)
 
     def resolve_dir(self, model_key: str) -> Optional[str]:
         from hugpy_engine.config.main import get_model_path

{hugpy_engine-0.2.4 → hugpy_engine-0.2.6}/src/hugpy_engine/config/main.py

@@ -50,6 +50,14 @@ def _resolve_model_key(model_key, registry, prefer=None):
     def _bare(k):  # name without the "owner~" qualifier
         return k.split("~", 1)[1] if "~" in k else k
     candidates = sorted(k for k in registry if _bare(k) == model_key)
+    if not candidates:
+        # FORMAT EQUIVALENCE (operator rule 2026-09-29): ``X`` and ``X-GGUF``
+        # are one key, so either spelling resolves to the row on record under
+        # the other. Nothing else is folded — ``X-Distill-GGUF`` is a different
+        # model and never answers for ``X-GGUF`` (S3/F7). Lazy import keeps the
+        # config module's import graph unchanged.
+        from hugpy_engine.fit.types import key_equivalent
+        candidates = sorted(k for k in registry if key_equivalent(_bare(k), model_key))
     if not candidates:
         return None
     if len(candidates) == 1:

{hugpy_engine-0.2.4 → hugpy_engine-0.2.6}/src/hugpy_engine/config/models/models_config.py

@@ -1618,14 +1618,34 @@ def record_worker_models(worker_id: str, rows: dict) -> list[str]:
                 clean[key]["worker_location"] = location
         old = (data.get(worker_id) or {}).get("models")
         changed = old != clean
-        if changed:
+        # DETACH STEP 2 (operator 2026-10-02): the catalog's home is the DB
+        # (model_worker_presence, source 'discovered'); the JSON is written only
+        # with HUGPY_WORKER_CATALOG_JSON=1 — or when the DB write did not land
+        # (no DB / DB down): the JSON is the no-DB fallback the reader uses, so
+        # a no-DB central must still persist its scan there (2026-10-02).
+        db_changed = False
+        db_ok = False
+        try:
+            from hugpy_engine.model_index import record_worker_presence
+            rows = []
+            for key, row in clean.items():
+                r = dict(row); r["model_key"] = key
+                if r.get("worker_location"):
+                    r["external_location"] = r["worker_location"]
+                rows.append(r)
+            st, det = record_worker_presence(worker_id, rows, source="discovered", complete=True)
+            db_ok = st == "ok"
+            db_changed = bool(db_ok and (det or {}).get("changed"))
+        except Exception:  # noqa: BLE001 — a DB miss never breaks a heartbeat
+            db_changed = False
+        if changed and (not db_ok or os.environ.get("HUGPY_WORKER_CATALOG_JSON", "0") == "1"):
             data[worker_id] = {"at": time.time(), "models": clean}
             tmp = path + f".{os.getpid()}.tmp"
             with open(tmp, "w", encoding="utf-8") as fh:
                 json.dump(data, fh)
             os.replace(tmp, path)
         fcntl.flock(lock, fcntl.LOCK_UN)
-    _apply_worker_catalog(force=changed)
+    _apply_worker_catalog(force=(changed or db_changed))
     # The canonical keys may differ from worker-local scan keys when central
     # already has a same-named model from another hub. Return those identities
     # so heartbeat placement uses the same keys as the shared model catalog.
@@ -1639,14 +1659,27 @@ def _apply_worker_catalog(force=False) -> None:
     registry_dict = globals().get("MODEL_REGISTRY_DICT")
     if registry is None or registry_dict is None:
         return  # import-time base build
+    data = None
+    # DB first (detach step 2): the discovered catalog lives in
+    # model_worker_presence; the JSON file is the no-DB fallback only.
     try:
-        stamp = os.stat(_WORKER_CATALOG_PATH).st_mtime_ns
+        from hugpy_engine.model_index import fetch_presence_catalog
+        data = fetch_presence_catalog()
+    except Exception:  # noqa: BLE001
+        data = None
+    if data is not None:
+        stamp = hash(json.dumps(data, sort_keys=True, default=str))
         if not force and stamp == _WORKER_CATALOG_SEEN:
             return
-        with open(_WORKER_CATALOG_PATH, encoding="utf-8") as fh:
-            data = json.load(fh)
-    except (OSError, ValueError):
-        return
+    else:
+        try:
+            stamp = os.stat(_WORKER_CATALOG_PATH).st_mtime_ns
+            if not force and stamp == _WORKER_CATALOG_SEEN:
+                return
+            with open(_WORKER_CATALOG_PATH, encoding="utf-8") as fh:
+                data = json.load(fh)
+        except (OSError, ValueError):
+            return
     locations: dict[str, dict[str, str]] = {}
     external_apis: dict[str, dict[str, dict]] = {}
     candidates: dict[str, dict] = {}

{hugpy_engine-0.2.4 → hugpy_engine-0.2.6}/src/hugpy_engine/dispatch/activity.py

@@ -95,6 +95,13 @@ def snapshot() -> list:
             "kind": d["kind"],
             "prompt": d.get("prompt") or "",
             "state": state,
+            # WHERE a processing call is (2026-09-29): "prefill" while the
+            # engine is still reading the prompt (n_past/n_prompt ride on
+            # progress/input_tokens), "" once tokens flow. Without this the
+            # queue read "answering, 0 tokens" for a 105 s legitimate prefill.
+            "stage": d.get("stage") or "",
+            "progress": d.get("progress"),
+            "input_tokens": d.get("input_tokens"),
             "elapsed": d["elapsed"],
             "wait": d["wait"],
             "tokens": d["tokens"],

{hugpy_engine-0.2.4 → hugpy_engine-0.2.6}/src/hugpy_engine/dispatch/dispatch.py

@@ -697,7 +697,25 @@ async def stream_runner(runner, req, cancel_event=None):
                         timings=getattr(result, "timings", None))
     else:
         yield ErrorEvent(request_id=req.request_id,
-                         message=getattr(result, "error", None) or "run failed")
+                         message=getattr(result, "error", None) or "run failed",
+                         load_failure=(getattr(result, "load_failure", None)
+                                       if isinstance(getattr(result, "load_failure", None), dict)
+                                       else None))
+
+
+def _rewrap_error_event(event, rid):
+    """The ONE re-wrap of an inner ErrorEvent under the outer request id
+    (S5, 2026-09-29). It used to rebuild the event from ``message`` alone, so
+    the worker's structured ``load_failure`` (class + fit_failure + refusal —
+    F3) and ``code`` were dropped HERE, on central, between the relay and the
+    /v1 envelope: the client saw ``type: api_error`` with no ``fit_failure``
+    although the worker had logged kind=vram_fit. Carry both."""
+    return ErrorEvent(request_id=rid,
+                      message=getattr(event, "message", None) or "run failed",
+                      load_failure=(getattr(event, "load_failure", None)
+                                    if isinstance(getattr(event, "load_failure", None), dict)
+                                    else None),
+                      code=(str(getattr(event, "code")) if getattr(event, "code", None) else None))
 
 
 async def execute_prompt_stream(*args, cancel_event=None, **kwargs):
@@ -948,8 +966,7 @@ async def execute_chat_stream(*args, cancel_event=None, **kwargs):
                                         output_chunks=1, finish_reason="stop",
                                         usage=usage_totals, timings=timings_last)
                     else:
-                        yield ErrorEvent(request_id=rid,
-                                         message=getattr(event, "message", None) or "run failed")
+                        yield _rewrap_error_event(event, rid)
                     errored = True
                     break
                 else:
@@ -1130,7 +1147,26 @@ def evict(model_key: str, task: Optional[str] = None) -> bool:
         heavy = evict_llama_runner(model_key)
     except Exception:
         heavy = False
-    return dropped or heavy
+    # TRANSFORMERS weights live in generate.coder.REGISTRY, not in the runner
+    # wrapper: drop them too, then reclaim so the freed VRAM is visible to the
+    # very next fit check (2026-10-02: an in-process eviction "freed 16 MB" of
+    # a 17 GB model and stranded the rest on the card).
+    tf = 0
+    try:
+        from hugpy_engine.generate.coder import REGISTRY as _TF_REGISTRY
+        tf = _TF_REGISTRY.evict_model(model_key)
+    except Exception:
+        tf = 0
+    if tf:
+        try:
+            import gc
+            gc.collect()
+            import torch
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+        except Exception:
+            pass
+    return dropped or heavy or bool(tf)
 
 
 def clear() -> None:
@@ -1142,6 +1178,14 @@ def clear() -> None:
         clear_llama_runners()
     except Exception:
         pass
+    try:
+        from hugpy_engine.generate.coder import REGISTRY as _TF_REGISTRY
+        for _k in {getattr(getattr(i, "cfg", None), "model_key", None) for i in list(_TF_REGISTRY._instances.values())}:
+            if _k:
+                _TF_REGISTRY.evict_model(_k)
+        _TF_REGISTRY.clear()
+    except Exception:
+        pass
 
 
 def supported_task_keys() -> List[Tuple[str, str]]:

hugpy_engine-0.2.6/src/hugpy_engine/fit/__init__.py

@@ -0,0 +1,28 @@
+"""``hugpy_engine.fit`` — the pure, deterministic evict-to-fit core.
+
+Standalone: imports only ``hugpy_engine`` siblings (``eviction``, ``spill``)
+and the standard library — no torch, no nvml, no fleet. See ``plan.py``.
+"""
+from __future__ import annotations
+
+from hugpy_engine.fit.flex import (  # noqa: F401
+    FlexPlan, PartialPlan, band_bounds, band_ceiling, band_floor,
+    ctx_band_bounds, flex_priority_key, kv_at_ctx_pct, leniency_floor_pct,
+    plan_explicit_offload, plan_flex, plan_partial_offload,
+)
+from hugpy_engine.fit.plan import evict_order, need_split, plan_fit  # noqa: F401
+from hugpy_engine.fit.types import (  # noqa: F401
+    FAILURE_KINDS, DeviceVram, Eviction, FitFailure, FitPlan, FitPolicy,
+    FitRequest, MoeSplit, Resident, ResourceSnapshot, VramSnapshot,
+    canonical_key, key_equivalent,
+)
+
+__all__ = [
+    "plan_fit", "evict_order", "need_split",
+    "ResourceSnapshot", "VramSnapshot", "DeviceVram", "FitPolicy", "Resident",
+    "FitRequest", "Eviction", "MoeSplit", "FitFailure", "FAILURE_KINDS", "FitPlan",
+    "canonical_key", "key_equivalent",
+    "FlexPlan", "PartialPlan", "band_bounds", "band_ceiling", "band_floor",
+    "ctx_band_bounds", "flex_priority_key", "kv_at_ctx_pct", "leniency_floor_pct",
+    "plan_explicit_offload", "plan_flex", "plan_partial_offload",
+]