hugpy-engine 0.3.2__tar.gz → 0.3.4__tar.gz

{hugpy_engine-0.3.2 → hugpy_engine-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hugpy-engine
-Version: 0.3.2
+Version: 0.3.4
 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.3.2 → hugpy_engine-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hugpy-engine"
-version = "0.3.2"
+version = "0.3.4"
 description = "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"
 readme = "README.md"
 requires-python = ">=3.10"

{hugpy_engine-0.3.2 → hugpy_engine-0.3.4}/src/hugpy_engine/categories.py

@@ -114,19 +114,10 @@ MEDIA_DEFAULTS: Dict[str, str] = {
     "video":    DEFAULT_WHISPER_MODEL,
 }
 
-TASK_DEFAULTS: Dict[str, str] = {
-    "text-generation":              DEFAULT_CHAT_MODEL,
-    "image-text-to-text":           DEFAULT_VISION_MODEL,
-    "automatic-speech-recognition": DEFAULT_WHISPER_MODEL,
-    "text-summarization":           DEFAULT_SUMMARIZE_MODEL,
-    "text2text-generation":         DEFAULT_SUMMARIZE_MODEL,
-    "feature-extraction":           DEFAULT_EMBED_MODEL,
-    "sentence-similarity":          DEFAULT_EMBED_MODEL,
-    "text-to-image":                DEFAULT_IMAGEGEN_MODEL,
-    "image-to-image":               DEFAULT_IMAGEGEN_MODEL,
-    "keyword-extraction":           DEFAULT_KEYWORDS_MODEL,
-    "depth-estimation":             DEFAULT_DEPTH_MODEL,
-    "object-detection":             DEFAULT_DETECT_MODEL,
-    "image-classification":         DEFAULT_IMG_CLASSIFY_MODEL,
-    "image-segmentation":           DEFAULT_SEGMENT_MODEL,
-}
+# TASK DEFAULTS ARE NOT CONSTANTS ANY MORE (operator ruling 2026-10-04: "each
+# task is BOUND to a designated model in the DB. No guessing, no constants").
+# The task -> model_key map now lives in the DB (settings_policies
+# "task_bindings") and is read live from hugpy_core's GET /prompt/tasks
+# ``defaults`` via config.models.models_config.task_bindings(). This name is
+# kept EMPTY only so a mid-rollout importer does not break; nothing populates it.
+TASK_DEFAULTS: Dict[str, str] = {}

{hugpy_engine-0.3.2 → hugpy_engine-0.3.4}/src/hugpy_engine/config/models/models_config.py

@@ -188,3 +188,46 @@ def get_model_registry(dict_return: bool = False, return_dict: bool = False):
     if dict_return or return_dict:
         return MODEL_REGISTRY_DICT
     return MODEL_REGISTRY
+
+
+# ---------------------------------------------------------------------------
+# Task bindings — the task -> model_key map, from the DB via hugpy_core.
+#
+# Operator ruling 2026-10-04: "each task is BOUND to a designated model in the
+# DB. No guessing, no constants." The bindings live in settings_policies
+# ("task_bindings") and hugpy_core exposes them as the ``defaults`` of
+# ``GET {core}/prompt/tasks``. The engine reads THAT (never a hardcoded
+# categories table): TTL-cached, fail-open to the last-known map (empty at
+# worst, which yields the honest "no model bound to task X" refusal).
+# ---------------------------------------------------------------------------
+_bindings: dict[str, str] = {}
+_bindings_at = 0.0
+
+
+def task_bindings(force: bool = False) -> dict:
+    """The live {task: model_key} bindings from hugpy_core's /prompt/tasks
+    ``defaults``. TTL-cached; a failed/empty read keeps the last-known map."""
+    global _bindings, _bindings_at
+    now = time.time()
+    if not force and _bindings and (now - _bindings_at) < _TTL_S:
+        return dict(_bindings)
+    url = _CORE_URL + "/prompt/tasks"
+    try:
+        req = urllib.request.Request(url, headers={"Accept": "application/json"})
+        with urllib.request.urlopen(req, timeout=_TIMEOUT_S) as r:
+            data = json.loads(r.read().decode("utf-8") or "null")
+    except Exception as exc:  # noqa: BLE001 — never raise on the resolve path
+        logger.warning("registry: could not read task bindings from %s (%s); "
+                       "keeping the last-known map (%d)", url, exc, len(_bindings))
+        _bindings_at = now
+        return dict(_bindings)
+    defaults = (data or {}).get("defaults") if isinstance(data, dict) else None
+    if isinstance(defaults, dict):
+        _bindings = {str(k): str(v) for k, v in defaults.items() if v}
+    _bindings_at = now
+    return dict(_bindings)
+
+
+def task_binding(task: str) -> "Optional[str]":
+    """The model_key bound to ``task``, or None (no binding)."""
+    return task_bindings().get(task)

{hugpy_engine-0.3.2 → hugpy_engine-0.3.4}/src/hugpy_engine/resolvers/model_resolver.py

@@ -26,13 +26,16 @@ from abstract_essentials import derive_media_type, safe_load_from_json
 from pydantic import BaseModel
 import logging
 logger = logging.getLogger(__name__)
-from hugpy_engine.categories import MEDIA_DEFAULTS, TASK_DEFAULTS
-from hugpy_engine.config.models.models_config import MODELS, MODEL_REGISTRY, refresh_registry
+from hugpy_engine.categories import MEDIA_DEFAULTS
+from hugpy_engine.config.models.models_config import (
+    MODELS, MODEL_REGISTRY, refresh_registry, task_bindings)
 from hugpy_engine.config.models.models_default import DEFAULT_CHAT_MODEL
 from hugpy_engine.schemas.task_schemas import Resolution
 from hugpy_engine.resolvers.categories.builders import MODEL_REQUEST_BUILDERS
 from hugpy_engine.resolvers.categories.frameworks import FRAMEWORK_RUNNERS, KNOWN_TASKS_REGISTRY
 from hugpy_engine.resolvers.assure_model_key import assure_model_key
+from hugpy_engine.task_endpoints import (
+    TASK_ROUTES, TaskEndpointRunner, build_endpoint_request)
 
 # ---------------------------------------------------------------------------
 # Unclassified / adapter rows — refuse by NAME, never by assumption (k61).
@@ -137,9 +140,9 @@ def resolve_model_key(
     explicit representation override — authoritative when choosing between the
     GGUF and Transformers rows of the same model (operator 2026-09-29).
     """
-    if task is not None and task not in KNOWN_TASKS_REGISTRY:
+    if task is not None and task not in KNOWN_TASKS_REGISTRY and task not in TASK_ROUTES:
         raise KeyError(
-            f"Unknown task={task!r}; known: {sorted(KNOWN_TASKS_REGISTRY)}"
+            f"Unknown task={task!r}; known: {sorted(set(KNOWN_TASKS_REGISTRY) | set(TASK_ROUTES))}"
         )
     fmt = (model_format or "auto").strip().lower() if model_format else "auto"
     if fmt not in _MODEL_FORMATS:
@@ -177,22 +180,25 @@ def resolve_model_key(
         return model_key
 
     if task is not None:
-        inferred = TASK_DEFAULTS.get(task)
+        # Task -> model is a DB BINDING (settings_policies "task_bindings"), read
+        # live from hugpy_core's /prompt/tasks defaults. No guessing, no constants.
+        inferred = task_bindings().get(task)
         if inferred is None:
             raise KeyError(
-                f"No default model for task={task!r}; "
-                f"tasks with defaults: {sorted(TASK_DEFAULTS)}"
+                f"no model bound to task {task!r}; bind one in Settings "
+                f"(task_bindings)"
             )
         if inferred not in MODEL_REGISTRY:
             raise KeyError(
-                f"Task default {inferred!r} for {task!r} not in MODEL_REGISTRY:{MODEL_REGISTRY}"
+                f"model {inferred!r} bound to task {task!r} is not in the registry "
+                f"— no online worker has it (see /models)"
             )
         if task not in MODEL_REGISTRY[inferred].tasks:
             raise ValueError(
-                f"Task default {inferred!r} for {task!r} does not list "
-                f"{task!r} in cfg.tasks={sorted(MODEL_REGISTRY[inferred].tasks)!r}"
+                f"model {inferred!r} bound to task {task!r} does not list it in its "
+                f"hugpy.json tasks={sorted(MODEL_REGISTRY[inferred].tasks)!r}"
             )
-        logger.debug("resolve_model_key: task=%s -> key=%s", task, inferred)
+        logger.debug("resolve_model_key: task=%s -> bound key=%s", task, inferred)
         return inferred
 
     if media_type is None and file is not None:
@@ -218,20 +224,21 @@ def resolve_model_key(
         logger.debug("resolve_model_key: media=%s -> key=%s", media_type, inferred)
         return inferred
 
-    # Bare chat default — no model_key, task, media or file given. TASK_DEFAULTS
-    # is healed IN PLACE from the live registry (reconcile_defaults), so it holds
-    # a real core id for "text-generation"; the module-level DEFAULT_CHAT_MODEL
-    # is only the import-time seed. No data at all -> a clean, honest refusal
-    # (fail-as-data), never a surprise.
-    chat_default = TASK_DEFAULTS.get("text-generation") or DEFAULT_CHAT_MODEL
+    # Bare chat default — no model_key, task, media or file given. The default
+    # is the DB BINDING for text-generation (hugpy_core /prompt/tasks), never a
+    # constant. No binding -> an honest refusal (fail-as-data), never a surprise.
+    chat_default = task_bindings().get("text-generation")
+    if not chat_default:
+        raise KeyError(
+            "no model bound to task 'text-generation'; bind one in Settings "
+            "(task_bindings), or pass an explicit model_key"
+        )
     if chat_default not in MODEL_REGISTRY:
         raise KeyError(
-            f"no chat default available: the registry has no text-generation "
-            f"model (configured seed {DEFAULT_CHAT_MODEL!r}, healed default "
-            f"{chat_default!r}). Pass an explicit model_key, or make sure a "
-            f"chat-capable model is online on a worker."
+            f"model {chat_default!r} bound to task 'text-generation' is not in the "
+            f"registry — no online worker has it (see /models)"
         )
-    logger.debug("resolve_model_key: fallback to chat default=%s", chat_default)
+    logger.debug("resolve_model_key: fallback to bound chat default=%s", chat_default)
     return chat_default
 
 
@@ -334,6 +341,27 @@ def resolve(prompt_kwargs: Dict[str, Any]) -> Resolution:
 
     key = (framework, task)
 
+    # NON-CHAT TASKS -> the dedicated front-door route (hugpy_next cut 3). These
+    # bypass the plugin runner table ON PURPOSE: the media/video engine-plugins
+    # register IN-PROCESS runners for these tasks, and nothing may load a model
+    # in core (one GPU owner per box = the wrapper). resolve() routes them
+    # straight to TaskEndpointRunner, which relays to hugpy_core's /v1/<route>;
+    # core picks the worker holding this model (the same pick() as chat).
+    _endpoint = TASK_ROUTES.get(task)
+    if _endpoint is not None:
+        _route, _output = _endpoint
+
+        def _builder(_kw, _mk, *, _t=task, _r=_route, _o=_output):
+            return build_endpoint_request(_kw, _mk, task=_t, route=_r, output=_o)
+
+        logger.debug("resolve: model=%s task=%s -> front-door %s",
+                     model_key, task, _route)
+        return Resolution(
+            model_key=model_key, framework=framework, task=task, cfg=cfg,
+            builder=_builder, runner_cls=TaskEndpointRunner,
+            cache_key=(model_key, task),
+        )
+
     builder = MODEL_REQUEST_BUILDERS.get(key)
     if builder is None:
         raise KeyError(

hugpy_engine-0.3.4/src/hugpy_engine/task_endpoints.py

@@ -0,0 +1,239 @@
+"""Non-chat task dispatch — one HTTP relay per task family through the front door.
+
+Chat (text-generation / image-text-to-text) rides FitevictChatRunner ->
+hugpy_core ``/v1/chat/completions``. Every OTHER served task (embeddings,
+summarize, keywords, ASR, TTS, image/video generation) has a dedicated
+front-door route; this module is the engine side of that:
+
+  * :data:`TASK_ROUTES` — the task -> (route, output) PROTOCOL table. It MIRRORS
+    the wrapper's RunnerSpec ``tasks``/``endpoint`` (fitevict/lifted/runners).
+    Routes are protocol, so they live in code; MODEL NAMES never do (bindings
+    come from the DB via hugpy_core, see config.models.models_config.task_bindings).
+  * :func:`build_endpoint_request` — maps execute_prompt kwargs onto each route's
+    JSON body using the hugpy-media / abstract-hugpy field names (text/texts/
+    prompt -> input, file -> file_path, summary_mode/top_n/... pass through).
+  * :class:`TaskEndpointRunner` — POSTs ``{HUGPY_CORE_URL}/v1/<route>`` with that
+    body (+ ``model``), and returns the response as a TaskResult. hugpy_core
+    picks the worker holding ``body.model`` (same pick() as chat); the box's
+    wrapper owns the load, serving and call_log. Nothing loads a model in core.
+
+``resolve()`` selects this runner for any task in :data:`TASK_ROUTES`, ahead of
+the plugin runner table — the media/video engine-plugins register in-process
+runners that must NOT run in core (one GPU owner per box = the wrapper).
+"""
+from __future__ import annotations
+
+import base64
+
+import asyncio
+import json
+import logging
+import os
+import urllib.error
+import urllib.request
+from typing import Optional
+
+from pydantic import ConfigDict
+
+from hugpy_engine.schemas.event_schemas import DoneEvent, ErrorEvent, TokenEvent
+from hugpy_engine.schemas.task_schemas import TaskRequest, TaskResult
+from hugpy_platform.utils import make_request_id
+
+logger = logging.getLogger(__name__)
+
+CORE_URL = (os.environ.get("HUGPY_CORE_URL")
+            or os.environ.get("HUGPY_FITEVICT_FRONT_DOOR")
+            or "http://127.0.0.1:7020").rstrip("/")
+_TIMEOUT_S = float(os.environ.get("HUGPY_TASK_ENDPOINT_TIMEOUT_S", "900"))
+
+
+# task -> (front-door route, output kind). Mirrors the wrapper RunnerSpecs:
+#   embed /v1/embeddings | summarize /v1/summarize | keywords /v1/keywords |
+#   asr /v1/audio/transcriptions | tts /v1/audio/speech |
+#   imagegen /v1/images/generations | videogen /v1/videos/generations
+# The HF pipeline-tag spellings a hugpy.json may carry are all mapped (the
+# wrapper's spec.tasks list the same aliases).
+TASK_ROUTES: dict[str, tuple[str, str]] = {
+    "feature-extraction":           ("/v1/embeddings", "json"),
+    "sentence-similarity":          ("/v1/embeddings", "json"),
+    "text-summarization":           ("/v1/summarize", "json"),
+    "summarization":                ("/v1/summarize", "json"),
+    "text2text-generation":         ("/v1/summarize", "json"),
+    "keyword-extraction":           ("/v1/keywords", "json"),
+    "automatic-speech-recognition": ("/v1/audio/transcriptions", "json"),
+    "text-to-speech":               ("/v1/audio/speech", "audio"),
+    "text-to-image":                ("/v1/images/generations", "image"),
+    "image-to-image":               ("/v1/images/generations", "image"),
+    "inpainting":                   ("/v1/images/generations", "image"),
+    "text-to-video":                ("/v1/videos/generations", "video"),
+    "image-to-video":               ("/v1/videos/generations", "video"),
+}
+
+
+def route_for_task(task: str) -> "Optional[tuple[str, str]]":
+    return TASK_ROUTES.get(task)
+
+
+# ── request-body mapping, per ROUTE (shared across the tasks on that route) ──
+# ``input_key``: where the primary payload lands; ``sources``: kwargs checked in
+# order for it; ``file_sources``: folded to ``file_path``; ``passthrough``:
+# body params copied verbatim when present. The hugpy-media / abstract-hugpy
+# field names, so the wrapper runners (copied from hugpy_media) read them 1:1.
+_BODY_SPECS: dict[str, dict] = {
+    "/v1/embeddings": {
+        "input_key": "input", "sources": ("input", "texts", "text", "prompt"),
+        "passthrough": ("other_texts", "normalize"),
+    },
+    "/v1/summarize": {
+        "input_key": "input", "sources": ("input", "text", "prompt"),
+        "passthrough": ("max_length", "min_length", "max_chunk_tokens",
+                        "summary_mode"),
+    },
+    "/v1/keywords": {
+        "input_key": "input", "sources": ("input", "text", "prompt"),
+        "passthrough": ("top_n", "diversity", "use_mmr", "stop_words",
+                        "keyphrase_ngram_range"),
+    },
+    "/v1/audio/transcriptions": {
+        "input_key": None,
+        "file_sources": ("file_path", "file", "path", "image_path"),
+        "passthrough": ("file_b64", "language", "translate", "prompt",
+                        "temperature", "response_format"),
+    },
+    "/v1/audio/speech": {
+        "input_key": "input", "sources": ("input", "text", "prompt"),
+        "passthrough": ("voice", "response_format", "format", "speed"),
+    },
+    "/v1/images/generations": {
+        "input_key": "prompt", "sources": ("prompt", "input", "text"),
+        "passthrough": ("n", "size", "steps", "num_inference_steps",
+                        "guidance_scale", "negative_prompt", "seed", "width",
+                        "height", "image", "mask", "strength", "_route"),
+    },
+    "/v1/videos/generations": {
+        "input_key": "prompt", "sources": ("prompt", "input", "text"),
+        "passthrough": ("num_frames", "fps", "seed", "width", "height", "steps",
+                        "num_inference_steps", "image", "negative_prompt"),
+    },
+}
+
+
+class EndpointRequest(TaskRequest):
+    """A built non-chat request: the resolved front-door ``route`` + JSON ``body``
+    (model-less; the runner adds ``model``). ``output`` is the artifact kind."""
+    model_config = ConfigDict(extra="forbid")
+    route: str
+    body: dict = {}
+    output: str = "json"
+    timeout_s: float = _TIMEOUT_S
+
+
+def build_endpoint_request(kwargs: dict, model_key: str, *, task: str,
+                           route: str, output: str = "json") -> EndpointRequest:
+    """execute_prompt kwargs -> the front-door JSON body for ``route``."""
+    spec = _BODY_SPECS.get(route, {"input_key": "input",
+                                   "sources": ("input", "text", "prompt"),
+                                   "passthrough": ()})
+    body: dict = {}
+    file_sources = spec.get("file_sources") or ()
+    for k in file_sources:
+        v = kwargs.get(k)
+        if v:
+            # The serving box is whichever core picks — it does not share this
+            # host's disk. A file readable HERE travels as bytes (file_b64, which
+            # every runner's input_file() accepts); anything else (a path only the
+            # box knows) is passed as-is.
+            if isinstance(v, str) and os.path.isfile(v):
+                with open(v, "rb") as fh:
+                    body["file_b64"] = base64.b64encode(fh.read()).decode("ascii")
+                body["filename"] = os.path.basename(v)
+            else:
+                body["file_path"] = v
+            break
+    input_key = spec.get("input_key")
+    if input_key:
+        for k in spec.get("sources", ()):
+            if kwargs.get(k) is not None:
+                body[input_key] = kwargs[k]
+                break
+    for k in spec.get("passthrough", ()):
+        if kwargs.get(k) is not None:
+            body[k] = kwargs[k]
+    rid = kwargs.get("request_id") or make_request_id()
+    return EndpointRequest(request_id=rid, model_key=model_key, route=route,
+                           body=body, output=output,
+                           pool=kwargs.get("pool"))
+
+
+class TaskEndpointRunner:
+    """Relays one non-chat request to hugpy_core's front-door route and returns
+    its response as a TaskResult. One class for every route — the route rides the
+    request (EndpointRequest.route), so dispatch's ``runner_cls(cfg)`` build is
+    uniform and the per-(model_key, task) instance cache still applies."""
+
+    request_type = EndpointRequest
+    result_type = TaskResult
+
+    def __init__(self, cfg, **runtime_kwargs):
+        self.cfg = cfg
+        self.model_key = getattr(cfg, "model_key", None)
+
+    def _post(self, url: str, body: dict, timeout: float) -> "tuple[int, dict]":
+        req = urllib.request.Request(url, data=json.dumps(body).encode("utf-8"),
+                                     headers={"Content-Type": "application/json"},
+                                     method="POST")
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                return r.status, json.loads(r.read().decode("utf-8") or "{}")
+        except urllib.error.HTTPError as exc:
+            try:
+                return exc.code, json.loads(exc.read().decode("utf-8") or "{}")
+            except Exception:  # noqa: BLE001
+                return exc.code, {"error": {"message": str(exc)}}
+
+    @staticmethod
+    def _error(status: int, payload) -> str:
+        err = payload.get("error") if isinstance(payload, dict) else None
+        msg = err.get("message") if isinstance(err, dict) else err
+        return f"front door {status}: {msg or payload}"
+
+    def _result(self, req: EndpointRequest, status: int, payload) -> TaskResult:
+        ok = status == 200
+        fields = dict(payload) if isinstance(payload, dict) else {"data": payload}
+        for k in ("request_id", "model_key", "ok", "error"):
+            fields.pop(k, None)
+        return TaskResult(request_id=req.request_id, model_key=req.model_key,
+                          ok=ok, error=(None if ok else self._error(status, payload)),
+                          **fields)
+
+    async def run(self, req) -> TaskResult:
+        if not isinstance(req, EndpointRequest):
+            raise TypeError("TaskEndpointRunner requires an EndpointRequest")
+        body = {**req.body, "model": req.model_key}
+        status, payload = await asyncio.to_thread(
+            self._post, CORE_URL + req.route, body, req.timeout_s)
+        return self._result(req, status, payload)
+
+    async def stream(self, req: EndpointRequest, cancel_event=None):
+        if cancel_event is not None and cancel_event.is_set():
+            yield DoneEvent(request_id=req.request_id, input_tokens=0,
+                            output_chunks=0, finish_reason="cancelled")
+            return
+        try:
+            res = await self.run(req)
+        except Exception as exc:  # noqa: BLE001 — a transport fault is an event
+            yield ErrorEvent(request_id=req.request_id,
+                             message=f"front door unreachable: {exc}")
+            return
+        if not res.ok:
+            yield ErrorEvent(request_id=req.request_id, message=res.error or "run failed")
+            return
+        text = getattr(res, "text", None)
+        if text:
+            yield TokenEvent(request_id=req.request_id, text=str(text))
+        yield DoneEvent(request_id=req.request_id, input_tokens=0, output_chunks=1,
+                        finish_reason="stop")
+
+
+__all__ = ["TASK_ROUTES", "route_for_task", "build_endpoint_request",
+           "EndpointRequest", "TaskEndpointRunner", "CORE_URL"]

{hugpy_engine-0.3.2 → hugpy_engine-0.3.4}/src/hugpy_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hugpy-engine
-Version: 0.3.2
+Version: 0.3.4
 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.3.2 → hugpy_engine-0.3.4}/src/hugpy_engine.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/hugpy_engine/name_match.py
 src/hugpy_engine/placement.py
 src/hugpy_engine/py.typed
 src/hugpy_engine/task_deps.py
+src/hugpy_engine/task_endpoints.py
 src/hugpy_engine/tasks.py
 src/hugpy_engine.egg-info/PKG-INFO
 src/hugpy_engine.egg-info/SOURCES.txt