lorebase-inference 0.2.3__py3-none-any.whl

lorebase_inference/settings.py

@@ -0,0 +1,338 @@
+"""The `inference` settings section (design 16), registered with `lorebase_platform`.
+
+Environment aliases override the YAML values of the default chat model:
+`LLM_BASE_URL` (`inference.llm.base_url`), `LLM_MODEL` (`inference.llm.model`) and
+`LLM_API_KEY` (`inference.llm.api_key`, optional, handled as a secret).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Literal, Self
+
+from pydantic import Field, model_validator
+
+from lorebase_platform.secrets import SecretValue
+from lorebase_platform.settings import SectionModel, Settings, register_section
+
+SECTION = "inference"
+ENV_ALIASES = {
+    "LLM_BASE_URL": "llm.base_url",
+    "LLM_MODEL": "llm.model",
+    "LLM_API_KEY": "llm.api_key",
+}
+
+ChatProvider = Literal["openai_compatible", "fake"]
+EmbeddingProvider = Literal["fastembed", "openai_compatible", "fake"]
+SpanProvider = Literal["gliner", "fake"]
+RelationProvider = Literal["glirel", "cooccurrence", "fake"]
+
+RESERVED_HEADERS = frozenset({"authorization", "content-type", "accept", "content-length", "host"})
+"""Headers the client sets itself; `headers` cannot replace them."""
+RESERVED_BODY_FIELDS = frozenset({"model", "messages", "stream", "response_format"})
+"""Request fields the client sets itself; `extra_body` cannot replace them."""
+
+
+def _check_headers(headers: dict[str, Any] | None) -> None:
+    for name in headers or {}:
+        if not name.strip() or name.strip().lower() in RESERVED_HEADERS:
+            raise ValueError(f"header {name!r} cannot be set in `headers`")
+
+
+def _check_extra_body(extra: dict[str, Any] | None) -> None:
+    for name in extra or {}:
+        if name in RESERVED_BODY_FIELDS:
+            raise ValueError(f"field {name!r} cannot be set in `extra_body`")
+
+
+class RetrySettings(SectionModel):
+    """Retries of HTTP calls on 429, 5xx and connection errors, with exponential backoff.
+
+    A `Retry-After` header is honored (capped at `backoff_max_s`); otherwise the wait before
+    retry `n` (from 0) is `min(backoff_max_s, backoff_base_s * 2**n)` with full jitter.
+    """
+
+    max_retries: int = Field(default=3, ge=0, description="Retries after the first attempt.")
+    backoff_base_s: float = Field(default=0.5, gt=0)
+    backoff_max_s: float = Field(default=30, gt=0)
+
+
+class Price(SectionModel):
+    """Price per million tokens in the operator's currency; zero for local models."""
+
+    input: float = Field(default=0, ge=0)
+    output: float = Field(default=0, ge=0)
+
+
+class LlmTaskOverride(SectionModel):
+    """Per-task override of the chat model; unset fields inherit from `llm`."""
+
+    provider: ChatProvider | None = None
+    base_url: str | None = None
+    model: str | None = None
+    api_key: SecretValue | None = None
+    structured_output: Literal["json_schema", "json_mode"] | None = None
+    json_schema_strict: bool | None = None
+    temperature: float | None = Field(default=None, ge=0)
+    max_concurrency: int | None = Field(default=None, ge=1)
+    timeout_s: float | None = Field(default=None, gt=0)
+    trust_env: bool | None = None
+    price_per_million_tokens: Price | None = None
+    headers: dict[str, SecretValue] | None = None
+    extra_body: dict[str, Any] | None = None
+
+    @model_validator(mode="after")
+    def _check_request_options(self) -> Self:
+        _check_headers(self.headers)
+        _check_extra_body(self.extra_body)
+        return self
+
+
+class LlmSettings(SectionModel):
+    """Chat model (tier 2). Any OpenAI-compatible endpoint, local or hosted."""
+
+    provider: ChatProvider = Field(
+        default="openai_compatible", description="openai_compatible or fake (tests)."
+    )
+    base_url: str = Field(
+        default="http://localhost:11434/v1",
+        min_length=1,
+        description="OpenAI-compatible endpoint. Default: local Ollama. Hosted providers and "
+        "a LiteLLM proxy are selected by changing this value (alias LLM_BASE_URL).",
+    )
+    model: str = Field(
+        default="qwen2.5:7b-instruct",
+        min_length=1,
+        description="Model name served by the endpoint (alias LLM_MODEL).",
+    )
+    api_key: SecretValue | None = Field(
+        default=None,
+        description="Literal or secret reference; omitted for local servers (alias LLM_API_KEY).",
+    )
+    structured_output: Literal["json_schema", "json_mode"] = Field(
+        default="json_schema",
+        description="How the endpoint is asked for schema-valid JSON. json_schema sends the "
+        "schema as response_format and steps down to json_mode when the server rejects it; "
+        "json_mode asks for a JSON object with the schema in the prompt. Answers are always "
+        "validated against the schema, with up to `repair_attempts` repair retries.",
+    )
+    json_schema_strict: bool | None = Field(
+        default=None,
+        description="Value of response_format.json_schema.strict in json_schema mode; null "
+        "leaves it out. Some endpoints require true and then refuse schemas outside their "
+        "strict subset, which steps the client down like any other rejection.",
+    )
+    repair_attempts: int = Field(
+        default=1, ge=0, le=3, description="Repair retries after an invalid answer."
+    )
+    temperature: float | None = Field(
+        default=0,
+        ge=0,
+        description="Sampling temperature; null leaves it out of the request, for models that "
+        "refuse the parameter.",
+    )
+    max_tokens: int | None = Field(
+        default=None, ge=1, description="Completion token cap; unset leaves it to the server."
+    )
+    max_concurrency: int = Field(default=2, ge=1, description="Parallel requests per process.")
+    timeout_s: float = Field(default=120, gt=0)
+    trust_env: bool = Field(
+        default=False,
+        description="Honor HTTP_PROXY, HTTPS_PROXY and NO_PROXY (and other httpx environment "
+        "settings) for this endpoint; false ignores them and connects directly.",
+    )
+    retry: RetrySettings = Field(default_factory=RetrySettings)
+    price_per_million_tokens: Price = Field(default_factory=Price)
+    headers: dict[str, SecretValue] = Field(
+        default_factory=dict,
+        description="Extra HTTP headers sent with every request, for example a workspace or "
+        "organization id a hosted provider requires. Values accept secret references.",
+    )
+    extra_body: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Extra fields merged into every request body, for server-specific options "
+        'such as {"reasoning_effort": "none"}. model, messages, stream and response_format '
+        "are set by the client and cannot be overridden.",
+    )
+    tasks: dict[str, LlmTaskOverride] = Field(
+        default_factory=dict,
+        description="Optional overrides per task name, e.g. extraction, schema_discovery.",
+    )
+
+    @model_validator(mode="after")
+    def _check_request_options(self) -> Self:
+        _check_headers(self.headers)
+        _check_extra_body(self.extra_body)
+        return self
+
+    def for_task(self, task: str | None) -> Self:
+        """Effective settings for a task: this model with the task's overrides applied.
+
+        A task that names another `base_url` uses only its own `api_key` and `headers`: the main
+        key and headers are never sent to an endpoint they were not configured for.
+        """
+        override = self.tasks.get(task) if task else None
+        changes: dict[str, Any] = (
+            {
+                name: value
+                for name in type(override).model_fields
+                if (value := getattr(override, name)) is not None
+            }
+            if override
+            else {}
+        )
+        if override and override.temperature is None and "temperature" in override.model_fields_set:
+            changes["temperature"] = None  # an explicit null leaves the parameter out
+        if override and override.base_url not in (None, self.base_url):
+            changes["api_key"] = override.api_key
+            changes["headers"] = override.headers or {}
+        return self.model_copy(update={**changes, "tasks": {}})
+
+
+class EmbeddingSettings(SectionModel):
+    """Embedding model; its name and dimension define the vector index."""
+
+    provider: EmbeddingProvider = Field(
+        default="fastembed", description="fastembed (in-process), openai_compatible or fake."
+    )
+    model: str = Field(default="BAAI/bge-small-en-v1.5", min_length=1)
+    dims: int = Field(default=384, ge=1, description="Vector dimension produced by the model.")
+    base_url: str | None = Field(
+        default=None,
+        description="Endpoint for openai_compatible embeddings (Ollama or hosted); "
+        "for example http://localhost:11434/v1.",
+    )
+    api_key: SecretValue | None = None
+    batch_size: int = Field(default=32, ge=1, description="Texts per model call or request.")
+    query_prefix: str = Field(
+        default="",
+        description="Text put before a search query when it is embedded "
+        "(`lorebase-inference embed --query`); models such as E5 and BGE expect one, for "
+        'example "query: " or "Represent this sentence for searching relevant passages: ".',
+    )
+    document_prefix: str = Field(
+        default="",
+        description="Text put before every Record text Scribe embeds, for models that expect "
+        'one (E5: "passage: "). Part of the stored text hash and of the template fingerprint: '
+        "after changing it the next embedding pass embeds every text again.",
+    )
+    cache_dir: Path | None = Field(
+        default=None, description="fastembed: where model files are stored; unset: library default."
+    )
+    threads: int | None = Field(
+        default=None, ge=1, description="fastembed: CPU threads; unset: library default."
+    )
+    timeout_s: float = Field(default=60, gt=0, description="openai_compatible request timeout.")
+    trust_env: bool = Field(
+        default=False,
+        description="Honor HTTP_PROXY, HTTPS_PROXY and NO_PROXY (and other httpx environment "
+        "settings) for the openai_compatible endpoint; false ignores them and connects directly.",
+    )
+    retry: RetrySettings = Field(default_factory=RetrySettings)
+
+    @model_validator(mode="after")
+    def _endpoint_required(self) -> Self:
+        if self.provider == "openai_compatible" and not self.base_url:
+            raise ValueError("base_url is required when provider is openai_compatible")
+        return self
+
+
+class ExtractorSettings(SectionModel):
+    """One tier-1 local extractor."""
+
+    enabled: bool = True
+    model: str = Field(min_length=1, description="Checkpoint name; see the weight license note.")
+    threshold: float = Field(default=0.5, ge=0, le=1)
+    cache_dir: Path | None = Field(
+        default=None, description="Where checkpoints are stored; unset: library default."
+    )
+    window_chars: int = Field(
+        default=1500,
+        ge=100,
+        description="Longer texts are cut at whitespace into windows of at most this size, "
+        "because the models read a few hundred tokens at a time.",
+    )
+
+
+class SpacySettings(SectionModel):
+    """Optional spaCy pipeline."""
+
+    enabled: bool = False
+    pipeline: str = Field(default="en_core_web_sm", min_length=1)
+
+
+class CooccurrenceSettings(SectionModel):
+    """Limits of the deterministic relation fallback (`relation_provider: cooccurrence`)."""
+
+    max_pairs_per_sentence: int = Field(
+        default=200, ge=1, description="Candidate pairs kept per sentence, nearest first."
+    )
+
+
+class LocalExtractorSettings(SectionModel):
+    """Tier-1 extractors; check each checkpoint's weight license before enabling."""
+
+    provider: SpanProvider = Field(default="gliner", description="gliner or fake (tests).")
+    relation_provider: RelationProvider = Field(
+        default="glirel",
+        description="glirel, or cooccurrence (deterministic pairing of spans that share a "
+        "sentence, no model), or fake (same as cooccurrence, for tests; the default when "
+        "`provider` is fake).",
+    )
+    gliner: ExtractorSettings = ExtractorSettings(model="urchade/gliner_multi-v2.1")
+    glirel: ExtractorSettings = ExtractorSettings(model="jackboyla/glirel-large-v0")
+    cooccurrence: CooccurrenceSettings = Field(default_factory=CooccurrenceSettings)
+    spacy: SpacySettings = Field(default_factory=SpacySettings)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _fake_provider_implies_fake_relations(cls, data: Any) -> Any:
+        """`provider: fake` selects the offline relation provider too, unless one is named."""
+        if isinstance(data, dict) and data.get("provider") == "fake":
+            return {"relation_provider": "fake", **data}
+        return data
+
+
+class FakeSettings(SectionModel):
+    """Behavior of `provider: fake`, used by tests and offline demos."""
+
+    fixtures_dir: Path | None = Field(
+        default=None,
+        description="Directory of `<prompt-hash>.json` files holding canned chat answers.",
+    )
+    dictionary: dict[str, list[str]] = Field(
+        default_factory=dict,
+        description="Label name -> surface forms matched by the fake span extractor.",
+    )
+    max_schema_depth: int = Field(
+        default=6, ge=1, description="Nesting depth beyond which optional properties are omitted."
+    )
+
+
+class InferenceSettings(SectionModel):
+    """All model-related configuration. Used by Scribe only."""
+
+    llm: LlmSettings = Field(default_factory=LlmSettings)
+    embeddings: EmbeddingSettings = Field(default_factory=EmbeddingSettings)
+    local_extractors: LocalExtractorSettings = Field(default_factory=LocalExtractorSettings)
+    fake: FakeSettings = Field(default_factory=FakeSettings)
+    mode_memory_key: SecretValue | None = Field(
+        default=None,
+        description="Secret that keys the digests under which the structured output mode of "
+        "each chat endpoint is remembered across restarts, e.g. secret://env/LOREBASE_MODE_KEY; "
+        "without it the digests are keyed by a fixed label only. Changing it forgets the modes.",
+    )
+    mode_memory_ttl_s: float = Field(
+        default=7 * 24 * 3600,
+        gt=0,
+        description="Seconds a remembered structured output mode counts; after that the "
+        "endpoint is tried with the configured mode again.",
+    )
+
+
+register_section(SECTION, InferenceSettings, env_aliases=ENV_ALIASES)
+
+
+def inference_settings(settings: Settings) -> InferenceSettings:
+    """The validated `inference` section of loaded settings."""
+    return settings.section(SECTION, InferenceSettings)

lorebase_inference/transport.py

@@ -0,0 +1,233 @@
+"""HTTP client shared by the endpoint providers: timeouts, retries and backoff.
+
+Speaks JSON over plain HTTP with `httpx`; no vendor library is involved. Calls are retried on
+429, 500, 502, 503, 504 and on connection errors or timeouts, up to `retry.max_retries` times.
+A `Retry-After` header (seconds or HTTP date) sets the wait, capped at `retry.backoff_max_s`;
+otherwise the wait is exponential backoff with full jitter. Request and response bodies are
+never logged: they hold prompts and documents.
+
+Error text sent by the server is kept in `EndpointError` only after anything that looks like a
+credential is removed, and not at all for 401 and 403, where providers often echo the key.
+Proxy variables (`HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`) are ignored unless `trust_env` is set.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import math
+import random
+import re
+import time
+from collections.abc import Awaitable, Callable, Iterable, Mapping
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
+from types import TracebackType
+from typing import Any, Self
+
+import httpx
+from pydantic import SecretStr
+
+from lorebase_inference.errors import EndpointError
+from lorebase_inference.settings import RetrySettings
+
+logger = logging.getLogger("lorebase.inference")
+
+RETRYABLE_STATUS = frozenset({429, 500, 502, 503, 504})
+_DETAIL_LIMIT = 300
+_SCRUB_WINDOW = _DETAIL_LIMIT * 4
+CREDENTIAL_STATUS = frozenset({401, 403})
+REDACTED = "[redacted]"
+_MIN_SECRET_CHARS = 8
+_CREDENTIAL = re.compile(
+    r"\bbearer\s+[^\s\"',;]+"  # an echoed Authorization value
+    r"|(?<![A-Za-z0-9])(?:sk|pk|rk)[-_][A-Za-z0-9_\-*.]{6,}"  # sk-..., sk_live_..., masked too
+    # long base64, base64url or hex runs holding both letters and digits
+    r"|(?<![A-Za-z0-9+/_\-])(?=[A-Za-z0-9+/_\-]*\d)(?=[A-Za-z0-9+/_\-]*[A-Za-z])"
+    r"[A-Za-z0-9+/_\-]{32,}={0,2}",
+    re.IGNORECASE,
+)
+_CONNECT_TIMEOUT_S = 10.0
+
+Sleep = Callable[[float], Awaitable[None]]
+
+
+def parse_retry_after(
+    value: str | None, *, now: Callable[[], datetime] | None = None
+) -> float | None:
+    """Seconds to wait according to a `Retry-After` header value, or `None` when unusable."""
+    if not value:
+        return None
+    value = value.strip()
+    try:
+        seconds = float(value)
+    except ValueError:
+        try:
+            moment = parsedate_to_datetime(value)
+        except (TypeError, ValueError):
+            return None
+        if moment.tzinfo is None:
+            moment = moment.replace(tzinfo=UTC)
+        seconds = float((moment - (now or (lambda: datetime.now(UTC)))()).total_seconds())
+    return None if math.isnan(seconds) else max(seconds, 0.0)
+
+
+def scrub_credentials(text: str, *, secrets: Iterable[str] = ()) -> str:
+    """`text` with the given secrets and anything shaped like a credential replaced."""
+    for secret in secrets:
+        if len(secret) >= _MIN_SECRET_CHARS:
+            text = text.replace(secret, REDACTED)
+    return _CREDENTIAL.sub(REDACTED, text)
+
+
+def error_detail(response: httpx.Response, *, secrets: Iterable[str] = ()) -> str:
+    """Error text of a failed response: the API error message when present, else the body.
+
+    Whitespace is collapsed, credentials are scrubbed (see `scrub_credentials`) and the result
+    is cut to a bounded excerpt.
+    """
+    try:
+        body = response.json()
+    except ValueError:
+        text = response.text
+    else:
+        error = body.get("error") if isinstance(body, dict) else None
+        if isinstance(error, dict):
+            text = str(error.get("message") or error)
+        elif error is not None:
+            text = str(error)
+        else:
+            text = str(body)
+    excerpt = " ".join(text[: _SCRUB_WINDOW * 4].split())[:_SCRUB_WINDOW]
+    return scrub_credentials(excerpt, secrets=secrets)[:_DETAIL_LIMIT]
+
+
+class EndpointClient:
+    """JSON POST client for one HTTP endpoint with bounded concurrency and retries."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: SecretStr | None,
+        timeout_s: float,
+        retry: RetrySettings,
+        max_concurrency: int = 4,
+        trust_env: bool = False,
+        headers: Mapping[str, SecretStr] | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+        sleep: Sleep | None = None,
+        jitter: Callable[[], float] = random.random,
+    ) -> None:
+        if not base_url.startswith(("http://", "https://")):
+            raise ValueError(f"base_url must start with http:// or https://, got {base_url!r}")
+        self._base_url = base_url.rstrip("/")
+        self._key = api_key
+        self._headers = dict(headers or {})
+        self._timeout = httpx.Timeout(timeout_s, connect=min(_CONNECT_TIMEOUT_S, timeout_s))
+        self._retry = retry
+        self._slots = asyncio.Semaphore(max_concurrency)
+        self._trust_env = trust_env
+        self._transport = transport
+        self._sleep: Sleep = sleep or asyncio.sleep
+        self._jitter = jitter
+        self._client: httpx.AsyncClient | None = None
+
+    async def post(self, path: str, payload: dict[str, Any]) -> dict[str, Any]:
+        """POST `payload` as JSON to `path` under the base URL and return the JSON object."""
+        client = self._http()
+        headers = {name: value.get_secret_value() for name, value in self._headers.items()}
+        headers.update({"Content-Type": "application/json", "Accept": "application/json"})
+        if self._key is not None and self._key.get_secret_value():
+            headers["Authorization"] = f"Bearer {self._key.get_secret_value()}"
+        async with self._slots:
+            attempt = 0
+            while True:
+                started = time.monotonic()
+                retry_after: float | None = None
+                try:
+                    response = await client.post(
+                        self._base_url + path, json=payload, headers=headers
+                    )
+                except httpx.TransportError as exc:
+                    reason = type(exc).__name__
+                    failure = EndpointError(f"{path}: request failed ({reason})")
+                else:
+                    logger.debug(
+                        "POST %s -> %d in %.0f ms (attempt %d)",
+                        path,
+                        response.status_code,
+                        (time.monotonic() - started) * 1000,
+                        attempt + 1,
+                    )
+                    if response.status_code < 400:
+                        return _json_object(path, response)
+                    reason = f"HTTP {response.status_code}"
+                    failure = self._failure(path, response)
+                    if response.status_code not in RETRYABLE_STATUS:
+                        raise failure
+                    retry_after = parse_retry_after(response.headers.get("Retry-After"))
+                if attempt >= self._retry.max_retries:
+                    raise failure
+                delay = self._delay(attempt, retry_after)
+                logger.warning(
+                    "%s failed (%s); retry %d/%d in %.1f s",
+                    path,
+                    reason,
+                    attempt + 1,
+                    self._retry.max_retries,
+                    delay,
+                )
+                await self._sleep(delay)
+                attempt += 1
+
+    def _failure(self, path: str, response: httpx.Response) -> EndpointError:
+        status = response.status_code
+        if status in CREDENTIAL_STATUS:
+            return EndpointError(
+                f"{path}: HTTP {status}: credentials refused (server text omitted)", status=status
+            )
+        secrets = [self._key.get_secret_value()] if self._key is not None else []
+        secrets.extend(value.get_secret_value() for value in self._headers.values())
+        detail = error_detail(response, secrets=secrets)
+        return EndpointError(f"{path}: HTTP {status}: {detail}", status=status, detail=detail)
+
+    def _delay(self, attempt: int, retry_after: float | None) -> float:
+        cap = self._retry.backoff_max_s
+        if retry_after is not None:
+            return min(retry_after, cap)
+        return float(self._jitter() * min(cap, self._retry.backoff_base_s * 2**attempt))
+
+    def _http(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=self._timeout, transport=self._transport, trust_env=self._trust_env
+            )
+        return self._client
+
+    async def aclose(self) -> None:
+        """Release the connection pool."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+
+def _json_object(path: str, response: httpx.Response) -> dict[str, Any]:
+    try:
+        body = response.json()
+    except ValueError:
+        raise EndpointError(f"{path}: response is not JSON", status=response.status_code) from None
+    if not isinstance(body, dict):
+        raise EndpointError(f"{path}: response is not a JSON object", status=response.status_code)
+    return body

lorebase_inference-0.2.3.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: lorebase-inference
+Version: 0.2.3
+Summary: Lorebase inference: model-agnostic chat, embedding and span extraction providers
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: jsonschema>=4.22
+Requires-Dist: lorebase-platform<0.3,>=0.2
+Provides-Extra: fastembed
+Requires-Dist: fastembed>=0.4; extra == 'fastembed'
+Provides-Extra: local-extractors
+Requires-Dist: gliner>=0.2; extra == 'local-extractors'
+Requires-Dist: glirel>=1.0; extra == 'local-extractors'

lorebase_inference-0.2.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+lorebase_inference/__init__.py,sha256=p_yoFoAkIwPhTGPvLs8X3xicon53-M3mAmd9ln3cClE,1599
+lorebase_inference/__main__.py,sha256=AO0XYw-Tv6GbCrSj9hNnnlUhwp7YqmIryub8v30ikDA,146
+lorebase_inference/chat.py,sha256=UttGW97BalG1gJ1biEK7ngC3we5ww3nlQBcTubVzV8A,17312
+lorebase_inference/cli.py,sha256=sk7IZzkEpq1PzusVSbmTcRNkTZpxXUtUZwAIwLJkjLI,8512
+lorebase_inference/errors.py,sha256=MH4Rmc4wYSFdDOipWmqsFIkN2FjtGnkVOXjknCjZRLA,1828
+lorebase_inference/fake.py,sha256=O1I_w8XYyNwBUJHSwPe0eZKcQ8qyTYBMg652q9RdQ1g,12789
+lorebase_inference/interfaces.py,sha256=bpTxcFNN-Nf79ZcpNXa7mNg_GRn2Ey35V4a3OOsfCnM,4333
+lorebase_inference/local_embeddings.py,sha256=gtZ3cCzOuWZhW2p1xMyMEaBCoveCP8h5zAHIqxslIhM,2352
+lorebase_inference/local_relations.py,sha256=P_hiMBROZVHt264SA2y80PSF0Gl-kQSBFsSu2zLLqRs,7465
+lorebase_inference/local_spans.py,sha256=OkDiCMY0LDE3qT9AtaCMfX3y49ZOVN97My1Za0nBGyM,4035
+lorebase_inference/registry.py,sha256=hx-Jt47WHsQOf_q7TuNkVEBYdKMHdyHhimm1j7QlrqU,12340
+lorebase_inference/remote_embeddings.py,sha256=1_3v6txuKarJuGcuGwHbci-UhYlykyAjOBkRrmNGDNU,3936
+lorebase_inference/settings.py,sha256=dsSjItAgRCbRGB3DzW5Zx3dcovZf49dNadqjVA5PPdc,14507
+lorebase_inference/transport.py,sha256=89yOjzf4jnCuy4l_T4GDvj-7vdpT1jsY7tMi2dIzDqo,9331
+lorebase_inference-0.2.3.dist-info/METADATA,sha256=_qlKWaDQ1hgWtSTzDt4aHxfgsVwjdXHiBm63VF5r0VM,501
+lorebase_inference-0.2.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lorebase_inference-0.2.3.dist-info/entry_points.txt,sha256=tNQ5m5Coi1HOA-C6FV7194IRZkPy5xumhjIJrrfG-3A,67
+lorebase_inference-0.2.3.dist-info/RECORD,,

lorebase_inference-0.2.3.dist-info/WHEEL

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

lorebase_inference-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lorebase-inference = lorebase_inference.cli:main