inferlet 0.3.0__py3-none-any.whl

inferlet/__init__.py

@@ -0,0 +1,150 @@
+"""
+Pie Inferlet SDK — Python bindings for the Pie runtime.
+
+Quickstart::
+
+    from inferlet import Context, Model, Sampler, runtime
+
+    model = Model.load(runtime.models()[0])
+    ctx = Context(model)
+
+    ctx.system("You are helpful.").user("What is 2 + 2?")
+    text = await ctx.generate(Sampler.argmax(), max_tokens=64).collect_text()
+
+Three-layer surface:
+
+* :class:`Context` — KV cache + chat fillers + ``forward()`` / ``generate()``.
+* :class:`Forward` (``ctx.forward()``) — single forward-pass primitive
+  with auto page management. For prefill / scoring / custom loops.
+* :class:`Generator` (``ctx.generate()``) — multi-step state machine
+  over Forward. Iterate with ``async for step in gen``, or use
+  ``await gen.collect_text() / .collect_tokens() / .collect_json()``.
+
+Streaming decoders for chat / reasoning / tools live as independent
+modules — compose by hand, no implicit suppression::
+
+    from inferlet import chat, reasoning, tools
+
+    chat_dec = chat.Decoder(model)
+    async for step in gen:
+        out = await step.execute()
+        match chat_dec.feed(out.tokens):
+            case chat.Event.Delta(text=t): print(t, end="")
+            case chat.Event.Done(text=full): break
+            case _: pass
+
+Constraint specs (:class:`JsonSchema`, :class:`AnyJson`, :class:`Regex`,
+:class:`Ebnf`) implement the :class:`Schema` protocol — duck-typed, so
+your own grammar source class plugs in by adding a ``build_constraint``
+method. No inheritance required.
+"""
+
+from __future__ import annotations
+
+# --- Core ---
+from .model import Model, Tokenizer
+from .sample import (
+    Distribution,
+    Entropy,
+    Logits,
+    Logprob,
+    Logprobs,
+    Sampler,
+)
+from .forward import Forward, Output, ProbeHandle, SampleHandle
+from .generation import GenStep, Generator
+from .context import Context
+
+# --- Decoders + tools (sub-modules; users import as `inferlet.chat`, etc.) ---
+from . import chat
+from . import reasoning
+from . import tools
+
+# --- Constraint surface ---
+from .grammar import (
+    AnyJson,
+    Constraint,
+    Ebnf,
+    Grammar,
+    GrammarConstraint,
+    JsonSchema,
+    Matcher,
+    Regex,
+    Schema,
+)
+
+# --- Speculation ---
+from .spec import Speculator
+
+# --- Runtime / IO ---
+from . import runtime
+from . import scheduling
+from . import messaging
+from . import session
+from . import mcp
+from . import zo
+
+# --- Adapter ---
+from .adapter import Adapter
+
+
+__all__ = [
+    # Core
+    "Context",
+    "Model",
+    "Tokenizer",
+    "Adapter",
+    # Forward primitive
+    "Forward",
+    "Output",
+    "SampleHandle",
+    "ProbeHandle",
+    # Generator
+    "Generator",
+    "GenStep",
+    # Sampler / Probe
+    "Sampler",
+    "Logits",
+    "Distribution",
+    "Logprob",
+    "Logprobs",
+    "Entropy",
+    # Decoders + tools
+    "chat",
+    "reasoning",
+    "tools",
+    # Constraints
+    "Schema",
+    "JsonSchema",
+    "AnyJson",
+    "Regex",
+    "Ebnf",
+    "Constraint",
+    "GrammarConstraint",
+    "Grammar",
+    "Matcher",
+    # Speculation
+    "Speculator",
+    # Runtime / IO
+    "runtime",
+    "scheduling",
+    "messaging",
+    "session",
+    "mcp",
+    "zo",
+]
+
+
+# --- Internal: return value plumbing for bakery wrapper ---
+_return_value: str | None = None
+
+
+def set_return(value: str) -> None:
+    """Set the return value for the inferlet (internal use by bakery wrapper)."""
+    global _return_value
+    _return_value = value
+
+
+def get_return_value() -> str | None:
+    """Get the return value for the inferlet (internal use by bakery wrapper)."""
+    return _return_value

inferlet/_async.py

@@ -0,0 +1,37 @@
+"""
+Internal async utilities for WASI pollable futures.
+"""
+
+import asyncio
+from typing import Protocol, TypeVar, runtime_checkable
+
+from wit_world.imports.poll import Pollable
+
+T = TypeVar("T")
+
+
+@runtime_checkable
+class WasiFuture(Protocol[T]):
+    """Generic interface for WASI async operations."""
+
+    def pollable(self) -> Pollable: ...
+    def get(self) -> T | None: ...
+
+
+async def await_future(future: WasiFuture[T], error_message: str) -> T:
+    """Await a WASI future cooperatively.
+
+    Registers the future's pollable with the asyncio event loop and
+    yields control until it becomes ready, allowing other coroutines
+    to make progress concurrently.
+    """
+    pollable = future.pollable()
+    loop = asyncio.get_event_loop()
+    waker: asyncio.Future[None] = loop.create_future()
+    loop.wakers.append((pollable, waker))  # type: ignore[attr-defined]
+    await waker
+
+    result = future.get()
+    if result is None:
+        raise RuntimeError(error_message)
+    return result

inferlet/adapter.py

@@ -0,0 +1,64 @@
+"""
+Adapter resource wrapper for ``pie:core/adapter``.
+
+Supports loading, saving, cloning, and locking model adapters (e.g. LoRA).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wit_world.imports import adapter as _adapter
+
+if TYPE_CHECKING:
+    from .model import Model
+
+
+class Adapter:
+    """Wraps the WIT adapter resource.
+
+    Usage::
+
+        adapter = Adapter.create(model, "my-adapter")
+        adapter.load("/path/to/weights")
+        adapter.save("/path/to/output")
+    """
+
+    __slots__ = ("_handle",)
+
+    def __init__(self, handle: _adapter.Adapter) -> None:
+        self._handle = handle
+
+    @staticmethod
+    def create(model: Model, name: str) -> Adapter:
+        """Create a new adapter for a model."""
+        return Adapter(_adapter.Adapter.create(model._handle, name))
+
+    @staticmethod
+    def open(model: Model, name: str) -> Adapter | None:
+        """Open an existing adapter by name."""
+        raw = _adapter.Adapter.open(model._handle, name)
+        if raw is None:
+            return None
+        return Adapter(raw)
+
+    def fork(self, new_name: str) -> Adapter:
+        """Fork this adapter with a new name."""
+        return Adapter(self._handle.fork(new_name))
+
+    def load(self, path: str) -> None:
+        """Load adapter weights from a file path."""
+        self._handle.load(path)
+
+    def save(self, path: str) -> None:
+        """Save adapter weights to a file path."""
+        self._handle.save(path)
+
+    def __enter__(self) -> Adapter:
+        return self
+
+    def __exit__(self, *args) -> None:
+        pass
+
+    def __repr__(self) -> str:
+        return f"Adapter({id(self._handle):#x})"

inferlet/bindings/__init__.py

@@ -0,0 +1 @@
+# WIT-generated bindings and runtime support.