verilore 0.11.0__py3-none-any.whl

verilore/__init__.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Raunak Dey
+
+"""Top-level ``verilore`` package.
+
+The wheel ships exactly one importable namespace, ``verilore`` (plus the two
+one-release shims ``verilore_sdk`` and ``verilore_errors``). The public surface
+lives in the submodules -- ``verilore.sdk``, ``verilore.errors``, ``verilore.api``,
+``verilore.cli``, ``verilore.mcp_server``, ``verilore.pack``, ``verilore.proof``,
+``verilore.proof_cli``, ``verilore.receipt``, ``verilore.runtime`` -- and the
+names below are re-exported lazily so that ``import verilore`` itself pulls in
+none of httpx, fastapi, sqlalchemy, onnxruntime, or the api/cli surfaces.
+
+    from verilore import Verilore
+
+is the documented import. The top-level ``verilore_sdk`` and ``verilore_errors``
+modules remain as deprecated shims for v0.11.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+import sys
+
+try:  # The distribution is installed (editable or wheel) in every real environment.
+    __version__ = importlib.metadata.version("verilore")
+except importlib.metadata.PackageNotFoundError:  # pragma: no cover - source tree without install
+    __version__ = "0.11.0"
+
+#: Lazy public names -> the submodule that defines them. Imported on first access.
+_LAZY = {
+    # From verilore.sdk.
+    "DEFAULT_CORPUS": "verilore.sdk",
+    "CorpusNotFoundError": "verilore.sdk",
+    "DatabaseUnavailableError": "verilore.sdk",
+    "MemoryClient": "verilore.sdk",
+    "MemoryClientError": "verilore.sdk",
+    "MemoryResult": "verilore.sdk",
+    "Verilore": "verilore.sdk",
+    "VeriloreAuthenticationError": "verilore.sdk",
+    "VeriloreConflictError": "verilore.sdk",
+    "VeriloreError": "verilore.sdk",
+    "VeriloreInternalError": "verilore.sdk",
+    "VeriloreNotFoundError": "verilore.sdk",
+    "VeriloreTransportError": "verilore.sdk",
+    "VeriloreUnauthorizedError": "verilore.sdk",
+    "VeriloreValidationError": "verilore.sdk",
+    "ProviderAuthenticationError": "verilore.sdk",
+    "ProviderError": "verilore.sdk",
+    "ProviderIncompatibleModelError": "verilore.sdk",
+    "ProviderMalformedResponseError": "verilore.sdk",
+    "ProviderRateLimitError": "verilore.sdk",
+    "ProviderRefusedError": "verilore.sdk",
+    "ProviderTimeoutError": "verilore.sdk",
+    "ProviderUnavailableError": "verilore.sdk",
+    "ReceiptError": "verilore.sdk",
+    "SyncSummary": "verilore.sdk",
+    "verify_receipt": "verilore.sdk",
+    "verify_response_receipt": "verilore.sdk",
+    "verify_trust": "verilore.sdk",
+    # From verilore.errors.
+    "COMPONENTS": "verilore.errors",
+    "AuthenticationError": "verilore.errors",
+    "ConflictError": "verilore.errors",
+    "DatabaseSchemaError": "verilore.errors",
+    "InternalError": "verilore.errors",
+    "NotFoundError": "verilore.errors",
+    "RequestId": "verilore.errors",
+    "TransportError": "verilore.errors",
+    "UnauthorizedError": "verilore.errors",
+    "ValidationError": "verilore.errors",
+    "classify_provider_error": "verilore.errors",
+    "envelope": "verilore.errors",
+    "new_request_id": "verilore.errors",
+}
+
+
+def __getattr__(name: str):
+    """Lazy attribute access: import a submodule only when one of its names is used."""
+    submodule = _LAZY.get(name)
+    if submodule is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module = sys.modules.get(submodule)
+    if module is None:
+        module = __import__(submodule, fromlist=[name])
+    value = getattr(module, name)
+    # Cache on the package so subsequent lookups skip the import.
+    setattr(sys.modules[__name__], name, value)
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals()) + list(_LAZY))

verilore/api/dependencies.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Raunak Dey
+
+"""Request-scoped authentication for the HTTP surface.
+
+Authentication is a middleware, not a per-route dependency, and that is a
+deliberate choice. A dependency runs only for routes that declare it, so the
+next route added without it would be an unauthenticated route -- and nothing
+would say so until it leaked. A middleware runs for every request the process
+serves, so forgetting to protect a new endpoint is not possible.
+
+The middleware also owns the teardown. A principal left in a `ContextVar` would
+be inherited by the next request served on the same task, so request N+1 would
+be scoped to request N's credential. Exiting the scope in a `finally` is what
+makes "one request, one identity" true rather than merely intended;
+`tests/test_tenant_isolation.py` asserts it by interleaving two identities
+through one client.
+"""
+
+from __future__ import annotations
+
+from verilore.api.services.authz import Principal
+from verilore.api.services.db import current_principal
+
+
+def request_principal(request) -> Principal:
+    """The identity resolved for this request.
+
+    Reads the `ContextVar` rather than request state so that a route handler, a
+    service several layers down, and a background task started from the handler
+    all see the same identity, and all of them see the same one.
+    """
+    return current_principal()

verilore/api/errors.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Raunak Dey
+
+"""The one place that explains a dead database.
+
+Both `verilore init` and the per-command failure text need to say the same
+thing, so the guidance lives here and is imported rather than restated. The
+underlying exception is never the only thing a developer sees, and never the
+first: it is appended for debugging, after the reason and the command to run.
+"""
+
+from __future__ import annotations
+
+
+def database_hint() -> str:
+    """Where Verilore believes the database is, named for this process.
+
+    Read from the environment rather than hardcoded, so the advice names the
+    database this command would actually use. Never raises: advice that fails is
+    worse than no advice.
+    """
+    url = _url()
+    try:
+        from sqlalchemy.engine import make_url
+
+        parsed = make_url(url)
+        return f"{parsed.host or 'localhost'}:{parsed.port or 5432}"
+    except Exception:  # noqa: BLE001 - a malformed URL must not break the message
+        return url
+
+
+def _url() -> str:
+    import os
+
+    return os.getenv("DATABASE_URL", "postgresql://mpadmin:secret@localhost:5432/verilore")
+
+
+def storage_unavailable(exc: Exception | None = None) -> str:
+    """The full explanation of a database that cannot be reached.
+
+    WHAT happened, WHY, and the exact commands to run.
+    """
+    detail = f"\n\n{type(exc).__name__}: {exc}" if exc is not None else ""
+    return (
+        "Verilore needs persistent storage, and it could not reach it.\n"
+        "\n"
+        f"Why: it could not connect to PostgreSQL at {database_hint()}.\n"
+        "\n"
+        "What to do:\n"
+        "  verilore init     starts the local database, or says why it cannot\n"
+        "  verilore doctor   finds the cause if that does not fix it" + detail
+    )