outerproduct 0.2.2__tar.gz → 0.2.4__tar.gz

{outerproduct-0.2.2 → outerproduct-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: outerproduct
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for the OuterProduct API
 Project-URL: Documentation, https://docs.outerproduct.com
 Project-URL: Homepage, https://outerproduct.com
@@ -80,6 +80,32 @@ df = pd.read_csv("credit.csv")
 dataset = op.Dataset.from_pandas(df, label_column="default")
 ```
 
+### Tabularize Documents into a Dataset
+
+```python
+from outerproduct.agentic import documents
+
+docs = documents.DocumentSet.from_directory("./invoices")
+refs = documents.upload(docs)
+schema = documents.induce_schema(refs, use_case="fraud audit", skill="invoice")
+dataset = documents.tabularize(refs, schema, label_column="is_fraud")
+```
+
+You can also hand-author the schema:
+
+```python
+from outerproduct.agentic.documents import DocumentSchema, DocumentQuestion, AnswerType
+
+schema = DocumentSchema(
+    skill="invoice",
+    use_case="fraud audit",
+    questions=[
+        DocumentQuestion(id="invoice_total", question="Total amount due?", answer_type=AnswerType.NUMBER, unit="USD"),
+        DocumentQuestion(id="payment_terms", question="Payment terms?", answer_type=AnswerType.ENUM, enum=("net_15", "net_30", "net_60")),
+    ],
+)
+```
+
 ### Train a Plain Model (No Explanations)
 
 ```python

{outerproduct-0.2.2 → outerproduct-0.2.4}/README.md

@@ -45,6 +45,32 @@ df = pd.read_csv("credit.csv")
 dataset = op.Dataset.from_pandas(df, label_column="default")
 ```
 
+### Tabularize Documents into a Dataset
+
+```python
+from outerproduct.agentic import documents
+
+docs = documents.DocumentSet.from_directory("./invoices")
+refs = documents.upload(docs)
+schema = documents.induce_schema(refs, use_case="fraud audit", skill="invoice")
+dataset = documents.tabularize(refs, schema, label_column="is_fraud")
+```
+
+You can also hand-author the schema:
+
+```python
+from outerproduct.agentic.documents import DocumentSchema, DocumentQuestion, AnswerType
+
+schema = DocumentSchema(
+    skill="invoice",
+    use_case="fraud audit",
+    questions=[
+        DocumentQuestion(id="invoice_total", question="Total amount due?", answer_type=AnswerType.NUMBER, unit="USD"),
+        DocumentQuestion(id="payment_terms", question="Payment terms?", answer_type=AnswerType.ENUM, enum=("net_15", "net_30", "net_60")),
+    ],
+)
+```
+
 ### Train a Plain Model (No Explanations)
 
 ```python

{outerproduct-0.2.2 → outerproduct-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "outerproduct"
-version = "0.2.2"
+version = "0.2.4"
 description = "Python SDK for the OuterProduct API"
 readme = "README.md"
 requires-python = ">=3.12"

{outerproduct-0.2.2 → outerproduct-0.2.4}/src/outerproduct/__init__.py

@@ -42,8 +42,11 @@ Quickstart
 
 from __future__ import annotations
 
+from contextlib import contextmanager
+from contextvars import ContextVar
 from dataclasses import dataclass, field
 from importlib.metadata import version as _pkg_version
+from typing import TYPE_CHECKING, Generator
 
 from outerproduct_http_types import ConnectorType
 
@@ -68,6 +71,9 @@ from outerproduct.trainer import (
     Trainer,
 )
 
+if TYPE_CHECKING:
+    from outerproduct.client import OuterProductClient
+
 try:
     __version__ = _pkg_version("outerproduct")
 except Exception:
@@ -87,6 +93,61 @@ class _GlobalState:
 _state = _GlobalState()
 
 
+# ---------------------------------------------------------------------
+# Per-request client override (contextvar)
+# ---------------------------------------------------------------------
+#
+# By default, every SDK HTTP call builds an :class:`OuterProductClient`
+# from ``_state`` — one shared bearer token for the whole process. That
+# works for single-user SDK consumers (notebooks, scripts).
+#
+# Multi-tenant SDK consumers (e.g. an MCP server serving many users)
+# need *per-request* credentials. The contextvar below lets a caller
+# enter a scope in which SDK HTTP helpers use a provided pre-built
+# client instead of the global state — without mutating the global
+# state and without changing every SDK class signature.
+
+_request_client: ContextVar["OuterProductClient | None"] = ContextVar(
+    "outerproduct_request_client", default=None
+)
+
+
+@contextmanager
+def use_client(
+    client: "OuterProductClient",
+) -> Generator[None, None, None]:
+    """Use ``client`` for every SDK HTTP call inside this block.
+
+    Inside the ``with`` block, the SDK's internal client helper yields
+    ``client`` rather than building one from ``op._state``. The caller
+    owns ``client``'s lifecycle — the SDK will not close it.
+
+    Designed for service-style consumers (e.g. an MCP server) that need
+    to thread per-request credentials through SDK calls without mutating
+    global state. Contextvars propagate across ``asyncio.to_thread`` and
+    ``asyncio.TaskGroup``, so this works inside async dispatch.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        from outerproduct.client import OuterProductClient
+        import outerproduct as op
+
+        # Mint a per-request bearer (e.g. a short-lived JWT) and use it
+        # for every SDK call inside the `with` block.
+        with OuterProductClient.from_credentials(base_url, per_request_token) as client:
+            with op.use_client(client):
+                model = op.ReasoningModel(id="mdl-1", feature_names=["a","b"])
+                preds = model.predict(X)
+    """
+    token = _request_client.set(client)
+    try:
+        yield
+    finally:
+        _request_client.reset(token)
+
+
 def init(
     api_key: str | None = None,
     *,
@@ -131,14 +192,28 @@ def get_datasets() -> list[Dataset]:
 
     with OuterProductClient.from_credentials(_state.base_url, _state.api_key) as client:
         response = client.datasets_api.list()
-    return [
-        Dataset._from_id(dataset.id, response=dataset) for dataset in response.datasets
-    ]
+    return [Dataset._from_response(record) for record in response.datasets]
+
+
+def get_dataset(dataset_id: str) -> Dataset:
+    """Fetch a single dataset by id; useful for cross-session reuse.
+
+    The returned Dataset has its ``_id`` and ``connection_config`` already
+    stamped, so subsequent fit/predict calls short-circuit the server-side
+    create.
+    """
+    from outerproduct.client import OuterProductClient
+
+    with OuterProductClient.from_credentials(_state.base_url, _state.api_key) as client:
+        record = client.datasets_api.get(dataset_id)
+    return Dataset._from_response(record)
 
 
 __all__ = [
     # Bootstrap
     "init",
+    "use_client",
+    "get_dataset",
     "get_datasets",
     "__version__",
     # Dataset

{outerproduct-0.2.2 → outerproduct-0.2.4}/src/outerproduct/agentic/documents.py

@@ -313,8 +313,7 @@ class DocumentDataset(Dataset):
             Column(name=q.id) for q in schema.questions
         ]
         self._id = dataset_id
-        self._connector_id = None
-        self._table_name = None
+        self._connection_config = None
         self._remote_only = True
         self._schema = schema
         self._document_ids = list(document_ids)
@@ -470,7 +469,6 @@ def tabularize(
     schema: DocumentSchema,
     *,
     web_augmentation: bool = False,
-    concurrency: int = 1,
     label_column: str | None = None,
     client: OuterProductClient | None = None,
 ) -> DocumentDataset:
@@ -481,6 +479,9 @@ def tabularize(
     :class:`~outerproduct.Trainer` and :func:`~outerproduct.reasoning.fit`
     consume directly via the standard ``dataset_id`` wire mode.
     No rows are downloaded to the client.
+
+    Fan-out concurrency is governed server-side by the API's Lambda
+    fleet; there is no client-side ``concurrency`` knob.
     """
     op = _resolve_client(client)
     refs = _coerce_to_refs(documents, op)
@@ -490,7 +491,6 @@ def tabularize(
                 "documents": [r.model_dump() for r in refs],
                 "schema": _schema_to_payload(schema).model_dump(),
                 "web_augmentation": web_augmentation,
-                "concurrency": concurrency,
             }
         )
     )

{outerproduct-0.2.2 → outerproduct-0.2.4}/src/outerproduct/client/apis.py

@@ -12,25 +12,19 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from outerproduct_http_types import (
-    ConnectorResponse,
-    CreateConnectorRequest,
     CreateDocumentUploadRequest,
     CreateDocumentUploadResponse,
     CreateUploadRequest,
     CreateUploadResponse,
     Dataset,
     DatasetResponse,
-    DeleteConnectorResponse,
     ExplainRequest,
     ExplainResponse,
     GlobalDriversRequest,
     GlobalDriversResponse,
     InduceSchemaJobResponse,
     InduceSchemaRequest,
-    ListConnectorsResponse,
     ListDatasetsResponse,
-    ListTablesRequest,
-    ListTablesResponse,
     PatternTrackerApplyRequest,
     PatternTrackerDistributionResponse,
     PatternTrackerFitRequest,
@@ -52,25 +46,21 @@ from outerproduct_http_types import (
     TabularizeResultResponse,
     TrainerRunRequest,
     TrainerRunResponse,
+    ValidateConnectorRequest,
     ValidateConnectorResponse,
 )
 
 from outerproduct.client.endpoints import (
-    CREATE_CONNECTOR,
     CREATE_DATASET,
     CREATE_DOCUMENT_UPLOAD,
     CREATE_UPLOAD,
-    DELETE_CONNECTOR,
     EXPLAIN,
-    GET_CONNECTOR,
     GET_DATASET,
     GET_DOCUMENT_SCHEMA,
     GET_DOCUMENT_TABLE,
     GLOBAL_DRIVERS,
     INDUCE_DOCUMENT_SCHEMA,
-    LIST_CONNECTORS,
     LIST_DATASETS,
-    LIST_TABLES,
     PATTERN_TRACKER_DISTRIBUTION,
     PATTERN_TRACKER_FIT,
     PATTERN_TRACKER_GET,
@@ -158,10 +148,7 @@ class DatasetsAPI:
         self._client = client
 
     def create(self, request: Dataset) -> DatasetResponse:
-        return self._client._post(  # ty: ignore[invalid-return-type]
-            CREATE_DATASET,  # ty: ignore[invalid-argument-type]
-            request,
-        )
+        return self._client._post(CREATE_DATASET, request)
 
     def list(self) -> ListDatasetsResponse:
         return self._client._get(LIST_DATASETS)
@@ -254,62 +241,27 @@ class PatternTrackerAPI:
         )
 
 
-class ConnectorsAPI:
-    """CRUD and discovery for registered data connectors.
+class ConnectorAPI:
+    """Connector-validation endpoint exposed to the SDK.
 
-    Endpoints:
-      - ``POST   /v1/connectors``                        → create
-      - ``GET    /v1/connectors``                         → list
-      - ``GET    /v1/connectors/{connector_id}``          → get
-      - ``DELETE /v1/connectors/{connector_id}``          → delete
-      - ``POST   /v1/connectors/{connector_id}/tables``   → list_tables
-      - ``POST   /v1/connectors/{connector_id}/validate`` → validate
+    Credential CRUD (``POST/GET/DELETE /v1/connector``) is managed by
+    console.op only — the SDK does not surface credential management.
+    The SDK only needs :meth:`validate` to test a ``ConnectionConfig``.
     """
 
     def __init__(self, client: OuterProductClient) -> None:
         self._client = client
 
-    def create(self, request: CreateConnectorRequest) -> ConnectorResponse:
-        """Register a new connector (or return existing if name matches)."""
-        # CreateConnectorRequest / ConnectorResponse are discriminated
-        # `Annotated[Union[...]]` aliases; runtime is fine via TypeAdapter,
-        # but ty can't narrow `RespT` to a union alias.
-        return self._client._post(  # ty: ignore[invalid-return-type]
-            CREATE_CONNECTOR,  # ty: ignore[invalid-argument-type]
-            request,
-        )
-
-    def list(self) -> ListConnectorsResponse:
-        """List all connectors for the authenticated org."""
-        return self._client._get(LIST_CONNECTORS)
-
-    def get(self, connector_id: str) -> ConnectorResponse:
-        """Get a single connector by ID."""
-        return self._client._get(  # ty: ignore[invalid-return-type]
-            GET_CONNECTOR,
-            connector_id=connector_id,
-        )
-
-    def delete(self, connector_id: str) -> DeleteConnectorResponse:
-        """Delete a connector."""
-        return self._client._delete(DELETE_CONNECTOR, connector_id=connector_id)
-
-    def list_tables(self, connector_id: str) -> ListTablesResponse:
-        """List tables/paths available through a connector."""
-        return self._client._post(
-            LIST_TABLES, ListTablesRequest(), connector_id=connector_id
-        )
-
-    def validate(self, connector_id: str) -> ValidateConnectorResponse:
-        """Test connectivity for a connector."""
-        return self._client._post(
-            VALIDATE_CONNECTOR, ListTablesRequest(), connector_id=connector_id
-        )
+    def validate(
+        self, request: ValidateConnectorRequest
+    ) -> ValidateConnectorResponse:
+        """Probe connectivity against an inline ``ConnectionConfig``."""
+        return self._client._post(VALIDATE_CONNECTOR, request)
 
 
 __all__ = [
     "AgenticDocumentsAPI",
-    "ConnectorsAPI",
+    "ConnectorAPI",
     "DatasetsAPI",
     "InferenceAPI",
     "PatternTrackerAPI",

{outerproduct-0.2.2 → outerproduct-0.2.4}/src/outerproduct/client/client.py

@@ -29,7 +29,7 @@ from outerproduct.client.exceptions import (
 if TYPE_CHECKING:
     from outerproduct.client.apis import (
         AgenticDocumentsAPI,
-        ConnectorsAPI,
+        ConnectorAPI,
         DatasetsAPI,
         InferenceAPI,
         PatternTrackerAPI,
@@ -176,10 +176,10 @@ class OuterProductClient:
         return PatternTrackerAPI(self)
 
     @property
-    def connectors_api(self) -> ConnectorsAPI:
-        from outerproduct.client.apis import ConnectorsAPI
+    def connector_api(self) -> ConnectorAPI:
+        from outerproduct.client.apis import ConnectorAPI
 
-        return ConnectorsAPI(self)
+        return ConnectorAPI(self)
 
     @property
     def datasets_api(self) -> DatasetsAPI:

{outerproduct-0.2.2 → outerproduct-0.2.4}/src/outerproduct/client/endpoints.py

@@ -18,25 +18,23 @@ from dataclasses import dataclass
 from typing import Generic, TypeVar
 
 from outerproduct_http_types import (
-    ConnectorResponse,
-    CreateConnectorRequest,
+    CreateCredentialRequest,
     CreateDocumentUploadRequest,
     CreateDocumentUploadResponse,
     CreateUploadRequest,
     CreateUploadResponse,
+    CredentialResponse,
     Dataset,
     DatasetResponse,
-    DeleteConnectorResponse,
+    DeleteCredentialResponse,
     ExplainRequest,
     ExplainResponse,
     GlobalDriversRequest,
     GlobalDriversResponse,
     InduceSchemaJobResponse,
     InduceSchemaRequest,
-    ListConnectorsResponse,
+    ListCredentialsResponse,
     ListDatasetsResponse,
-    ListTablesRequest,
-    ListTablesResponse,
     PatternTrackerApplyRequest,
     PatternTrackerDistributionResponse,
     PatternTrackerFitRequest,
@@ -59,6 +57,7 @@ from outerproduct_http_types import (
     TabularizeResultResponse,
     TrainerRunRequest,
     TrainerRunResponse,
+    ValidateConnectorRequest,
     ValidateConnectorResponse,
 )
 from pydantic import BaseModel
@@ -69,11 +68,7 @@ RespT = TypeVar("RespT", bound=BaseModel)
 
 @dataclass(frozen=True)
 class GetEndpoint(Generic[RespT]):
-    """A ``GET`` endpoint, parameterised by its response model.
-
-    ``path`` is a relative path (no leading slash) that may contain
-    ``{name}`` placeholders to be filled in at call time.
-    """
+    """A ``GET`` endpoint, parameterised by its response model."""
 
     path: str
     response_type: type[RespT]
@@ -160,7 +155,7 @@ REASONING_FIT = PostEndpoint(
 
 CREATE_DATASET = PostEndpoint(
     path="datasets",
-    request_type=Dataset,  # ty: ignore[invalid-argument-type]
+    request_type=Dataset,
     response_type=DatasetResponse,
 )
 LIST_DATASETS = GetEndpoint(
@@ -241,59 +236,45 @@ PATTERN_TRACKER_PARTITION = PostEndpoint(
 )
 
 # --------------------------------------------------------------------------- #
-# Connectors                                                                  #
+# Connector (credentials CRUD via console.op; validate is shared with SDK)    #
 # --------------------------------------------------------------------------- #
 
-CREATE_CONNECTOR = PostEndpoint(
-    path="connectors",
-    # CreateConnectorRequest / ConnectorResponse are `Annotated[Union[...]]`
-    # discriminated aliases — runtime usage routes through TypeAdapter, but
-    # ty sees them where a plain `type[BaseModel]` is expected.
-    request_type=CreateConnectorRequest,  # ty: ignore[invalid-argument-type]
-    response_type=ConnectorResponse,  # ty: ignore[invalid-argument-type]
-)
-LIST_CONNECTORS = GetEndpoint(
-    path="connectors",
-    response_type=ListConnectorsResponse,
-)
-GET_CONNECTOR = GetEndpoint(
-    path="connectors/{connector_id}",
-    response_type=ConnectorResponse,  # ty: ignore[invalid-argument-type]
+CREATE_CREDENTIAL = PostEndpoint(
+    path="connector",
+    request_type=CreateCredentialRequest,
+    response_type=CredentialResponse,
 )
-DELETE_CONNECTOR = DeleteEndpoint(
-    path="connectors/{connector_id}",
-    response_type=DeleteConnectorResponse,
+LIST_CREDENTIALS = GetEndpoint(
+    path="connector",
+    response_type=ListCredentialsResponse,
 )
-LIST_TABLES = PostEndpoint(
-    path="connectors/{connector_id}/tables",
-    request_type=ListTablesRequest,
-    response_type=ListTablesResponse,
+DELETE_CREDENTIAL = DeleteEndpoint(
+    path="connector/{credential_name}",
+    response_type=DeleteCredentialResponse,
 )
 VALIDATE_CONNECTOR = PostEndpoint(
-    path="connectors/{connector_id}/validate",
-    request_type=ListTablesRequest,  # empty body, reuse ListTablesRequest
+    path="connector/validate",
+    request_type=ValidateConnectorRequest,
     response_type=ValidateConnectorResponse,
 )
 
 
 __all__ = [
-    "CREATE_CONNECTOR",
+    "CREATE_CREDENTIAL",
     "CREATE_DATASET",
     "CREATE_DOCUMENT_UPLOAD",
     "CREATE_UPLOAD",
-    "DELETE_CONNECTOR",
+    "DELETE_CREDENTIAL",
     "DeleteEndpoint",
     "EXPLAIN",
-    "GET_CONNECTOR",
     "GET_DATASET",
     "GET_DOCUMENT_SCHEMA",
     "GET_DOCUMENT_TABLE",
     "GLOBAL_DRIVERS",
     "GetEndpoint",
     "INDUCE_DOCUMENT_SCHEMA",
-    "LIST_CONNECTORS",
+    "LIST_CREDENTIALS",
     "LIST_DATASETS",
-    "LIST_TABLES",
     "PATTERN_TRACKER_DISTRIBUTION",
     "PATTERN_TRACKER_FIT",
     "PATTERN_TRACKER_GET",