outerproduct 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: outerproduct
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python SDK for the OuterProduct API
 Project-URL: Documentation, https://docs.outerproduct.com
 Project-URL: Homepage, https://outerproduct.com
@@ -118,7 +118,7 @@ reasoning = rm.explain(X)
 predictions, reasoning = rm.predict_and_explain(X)
 
 # Global feature importance
-reasoning = rm.interpret()
+reasoning = rm.get_global_drivers()
 
 # Counterfactual scenario search
 trace = rm.scenario(X, target_class=1, max_steps=10)

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

@@ -83,7 +83,7 @@ reasoning = rm.explain(X)
 predictions, reasoning = rm.predict_and_explain(X)
 
 # Global feature importance
-reasoning = rm.interpret()
+reasoning = rm.get_global_drivers()
 
 # Counterfactual scenario search
 trace = rm.scenario(X, target_class=1, max_steps=10)

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

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

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

@@ -15,7 +15,7 @@ core concepts:
   prediction endpoint, used to hand black-box models into
   :func:`~outerproduct.reasoning.fit` for distillation.
 - :class:`~outerproduct.model.ReasoningModel` — a :class:`~outerproduct.model.Model` that also supports
-  :meth:`~outerproduct.model.ReasoningModel.explain`, :meth:`~outerproduct.model.ReasoningModel.interpret`,
+  :meth:`~outerproduct.model.ReasoningModel.explain`, :meth:`~outerproduct.model.ReasoningModel.get_global_drivers`,
   and :meth:`~outerproduct.model.ReasoningModel.scenario`.
   Produced by :func:`~outerproduct.reasoning.fit`.
 - :class:`~outerproduct.reasoning.pattern_tracker.PatternTracker` —
@@ -33,10 +33,11 @@ Quickstart
 
     op.init(api_key="...")
     connector = op.FileUploadConnector()
-    dataset = connector.upload("customers.csv", label_column="churn")
-    reasoning_model = op.reasoning.fit(dataset)
-    predictions = reasoning_model.predict(X_new)
-    reasoning = reasoning_model.explain(X_new)
+    dataset = connector.upload("customers.csv")
+    reasoning_model = op.reasoning.fit(dataset, label_column="churn")
+    test_dataset = op.Dataset(X_new)
+    predictions = reasoning_model.predict(test_dataset)
+    reasoning = reasoning_model.explain(test_dataset)
 """
 
 from __future__ import annotations
@@ -124,9 +125,21 @@ def init(
     _state.hardware = hardware
 
 
+def get_datasets() -> list[Dataset]:
+    """List datasets owned by the configured API key."""
+    from outerproduct.client import OuterProductClient
+
+    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
+    ]
+
+
 __all__ = [
     # Bootstrap
     "init",
+    "get_datasets",
     "__version__",
     # Dataset
     "Dataset",

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

@@ -5,7 +5,7 @@ text) as a feature source: induce a frozen schema of survey questions
 for the use case, then have the agent extract every document against
 that schema. The tabularized rows live in object storage on the
 OuterProduct backend; the SDK returns a :class:`DocumentDataset` that
-references that remote table by ``model_id`` and slots into
+references that remote table by ``dataset_id`` and slots into
 :meth:`outerproduct.Trainer.configure` and
 :func:`outerproduct.reasoning.fit` exactly like any other uploaded
 :class:`~outerproduct.Dataset`.
@@ -16,7 +16,7 @@ Typical flow::
     refs = upload(docs)                                  # one-time upload
     schema = induce_schema(refs, use_case="audit", skill="invoice")
     ds = tabularize(refs, schema)                        # remote DocumentDataset
-    trainer.run(ds)                                      # uses data_uploaded=True
+    trainer.run(ds)                                      # sends dataset_id
 
 ``upload`` is explicit so the same documents can feed both
 :func:`induce_schema` and :func:`tabularize` without re-uploading.
@@ -288,13 +288,10 @@ class DocumentDataset(Dataset):
     """A remote-handle :class:`Dataset` whose rows are tabularized
     documents and columns are :class:`DocumentSchema` questions.
 
-    Holds no rows locally. The tabularized table lives on the
-    OuterProduct backend under ``model_id`` (the same path used by
-    pre-uploaded datasets), and the trainer/reasoning APIs fetch from
-    that location server-side via the standard ``data_uploaded=True``
-    wire mode.
+    Holds no rows locally. The tabularized table already exists on the
+    OuterProduct backend under ``dataset_id``.
 
-    Construct directly when you already have a tabularize ``model_id``,
+    Construct directly when you already have a tabularize ``dataset_id``,
     or — more commonly — let :func:`tabularize` build one for you.
     """
 
@@ -303,15 +300,22 @@ class DocumentDataset(Dataset):
         *,
         schema: DocumentSchema,
         document_ids: list[str],
-        model_id: str,
+        dataset_id: str,
         label_column: str | None = None,
         columns: list[Column] | None = None,
     ) -> None:
         import pandas as pd
 
         empty = pd.DataFrame(columns=pd.Index([q.id for q in schema.questions]))
-        super().__init__(empty, label_column=label_column, columns=columns)
-        self._upload_id = model_id
+        self._df = empty
+        self._label_column = label_column
+        self._explicit_columns = columns or [
+            Column(name=q.id) for q in schema.questions
+        ]
+        self._id = dataset_id
+        self._connector_id = None
+        self._table_name = None
+        self._remote_only = True
         self._schema = schema
         self._document_ids = list(document_ids)
 
@@ -324,10 +328,9 @@ class DocumentDataset(Dataset):
         return list(self._document_ids)
 
     @property
-    def model_id(self) -> str:
-        """The tabularize-job ``model_id`` that backs this dataset on the server."""
-        assert self._upload_id is not None
-        return self._upload_id
+    def dataset_id(self) -> str:
+        """The tabularize-job ``dataset_id`` that backs this dataset on the server."""
+        return self.id
 
     @property
     def n_samples(self) -> int:
@@ -476,7 +479,7 @@ def tabularize(
     The tabularized rows are written to object storage on the backend;
     the returned :class:`DocumentDataset` is a remote handle that
     :class:`~outerproduct.Trainer` and :func:`~outerproduct.reasoning.fit`
-    consume directly via the standard ``data_uploaded=True`` wire mode.
+    consume directly via the standard ``dataset_id`` wire mode.
     No rows are downloaded to the client.
     """
     op = _resolve_client(client)
@@ -496,7 +499,7 @@ def tabularize(
     return DocumentDataset(
         schema=_schema_from_payload(result.schema_),
         document_ids=list(result.document_ids),
-        model_id=result.model_id,
+        dataset_id=result.dataset_id,
         label_column=label_column,
     )
 

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

@@ -18,14 +18,17 @@ from outerproduct_http_types import (
     CreateDocumentUploadResponse,
     CreateUploadRequest,
     CreateUploadResponse,
+    Dataset,
+    DatasetResponse,
     DeleteConnectorResponse,
     ExplainRequest,
     ExplainResponse,
+    GlobalDriversRequest,
+    GlobalDriversResponse,
     InduceSchemaJobResponse,
     InduceSchemaRequest,
-    InterpretRequest,
-    InterpretResponse,
     ListConnectorsResponse,
+    ListDatasetsResponse,
     ListTablesRequest,
     ListTablesResponse,
     PatternTrackerApplyRequest,
@@ -54,16 +57,19 @@ from outerproduct_http_types import (
 
 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,
-    INTERPRET,
     LIST_CONNECTORS,
+    LIST_DATASETS,
     LIST_TABLES,
     PATTERN_TRACKER_DISTRIBUTION,
     PATTERN_TRACKER_FIT,
@@ -145,6 +151,25 @@ class ReasoningAPI:
         return self._client._post(REASONING_FIT, request)
 
 
+class DatasetsAPI:
+    """CRUD for first-class datasets."""
+
+    def __init__(self, client: OuterProductClient) -> None:
+        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,
+        )
+
+    def list(self) -> ListDatasetsResponse:
+        return self._client._get(LIST_DATASETS)
+
+    def get(self, dataset_id: str) -> DatasetResponse:
+        return self._client._get(GET_DATASET, dataset_id=dataset_id)
+
+
 class InferenceAPI:
     """Synchronous inference on ``/v1/models/{model_id}/...``."""
 
@@ -162,11 +187,11 @@ class InferenceAPI:
     ) -> PredictAndExplainResponse:
         return self._client._post(PREDICT_AND_EXPLAIN, request, model_id=model_id)
 
-    def interpret(
-        self, model_id: str, request: InterpretRequest | None = None
-    ) -> InterpretResponse:
+    def get_global_drivers(
+        self, model_id: str, request: GlobalDriversRequest | None = None
+    ) -> GlobalDriversResponse:
         return self._client._post(
-            INTERPRET, request or InterpretRequest(), model_id=model_id
+            GLOBAL_DRIVERS, request or GlobalDriversRequest(), model_id=model_id
         )
 
     def scenario(self, model_id: str, request: ScenarioRequest) -> ScenarioResponse:
@@ -285,6 +310,7 @@ class ConnectorsAPI:
 __all__ = [
     "AgenticDocumentsAPI",
     "ConnectorsAPI",
+    "DatasetsAPI",
     "InferenceAPI",
     "PatternTrackerAPI",
     "ReasoningAPI",

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

@@ -30,6 +30,7 @@ if TYPE_CHECKING:
     from outerproduct.client.apis import (
         AgenticDocumentsAPI,
         ConnectorsAPI,
+        DatasetsAPI,
         InferenceAPI,
         PatternTrackerAPI,
         ReasoningAPI,
@@ -180,6 +181,12 @@ class OuterProductClient:
 
         return ConnectorsAPI(self)
 
+    @property
+    def datasets_api(self) -> DatasetsAPI:
+        from outerproduct.client.apis import DatasetsAPI
+
+        return DatasetsAPI(self)
+
     @property
     def agentic_documents_api(self) -> AgenticDocumentsAPI:
         from outerproduct.client.apis import AgenticDocumentsAPI

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

@@ -24,14 +24,17 @@ from outerproduct_http_types import (
     CreateDocumentUploadResponse,
     CreateUploadRequest,
     CreateUploadResponse,
+    Dataset,
+    DatasetResponse,
     DeleteConnectorResponse,
     ExplainRequest,
     ExplainResponse,
+    GlobalDriversRequest,
+    GlobalDriversResponse,
     InduceSchemaJobResponse,
     InduceSchemaRequest,
-    InterpretRequest,
-    InterpretResponse,
     ListConnectorsResponse,
+    ListDatasetsResponse,
     ListTablesRequest,
     ListTablesResponse,
     PatternTrackerApplyRequest,
@@ -151,6 +154,24 @@ REASONING_FIT = PostEndpoint(
     response_type=ReasoningFitResponse,
 )
 
+# --------------------------------------------------------------------------- #
+# Datasets                                                                    #
+# --------------------------------------------------------------------------- #
+
+CREATE_DATASET = PostEndpoint(
+    path="datasets",
+    request_type=Dataset,  # ty: ignore[invalid-argument-type]
+    response_type=DatasetResponse,
+)
+LIST_DATASETS = GetEndpoint(
+    path="datasets",
+    response_type=ListDatasetsResponse,
+)
+GET_DATASET = GetEndpoint(
+    path="datasets/{dataset_id}",
+    response_type=DatasetResponse,
+)
+
 # --------------------------------------------------------------------------- #
 # Status (cross-cutting; covers fit / fit-distill / segment)                  #
 # --------------------------------------------------------------------------- #
@@ -179,10 +200,10 @@ PREDICT_AND_EXPLAIN = PostEndpoint(
     request_type=PredictAndExplainRequest,
     response_type=PredictAndExplainResponse,
 )
-INTERPRET = PostEndpoint(
-    path="models/{model_id}/interpret",
-    request_type=InterpretRequest,
-    response_type=InterpretResponse,
+GLOBAL_DRIVERS = PostEndpoint(
+    path="models/{model_id}/global_drivers",
+    request_type=GlobalDriversRequest,
+    response_type=GlobalDriversResponse,
 )
 SCENARIO = PostEndpoint(
     path="models/{model_id}/scenario",
@@ -257,18 +278,21 @@ VALIDATE_CONNECTOR = PostEndpoint(
 
 __all__ = [
     "CREATE_CONNECTOR",
+    "CREATE_DATASET",
     "CREATE_DOCUMENT_UPLOAD",
     "CREATE_UPLOAD",
     "DELETE_CONNECTOR",
     "DeleteEndpoint",
     "EXPLAIN",
     "GET_CONNECTOR",
+    "GET_DATASET",
     "GET_DOCUMENT_SCHEMA",
     "GET_DOCUMENT_TABLE",
+    "GLOBAL_DRIVERS",
     "GetEndpoint",
     "INDUCE_DOCUMENT_SCHEMA",
-    "INTERPRET",
     "LIST_CONNECTORS",
+    "LIST_DATASETS",
     "LIST_TABLES",
     "PATTERN_TRACKER_DISTRIBUTION",
     "PATTERN_TRACKER_FIT",

{outerproduct-0.2.0 → outerproduct-0.2.2}/src/outerproduct/connector.py

@@ -17,11 +17,11 @@ Examples
 
     # File upload (local files):
     connector = op.FileUploadConnector()
-    dataset = connector.upload("data.csv", label_column="churn")
+    dataset = connector.upload("data.csv")
 
     # S3 connector (registered with backend):
     s3 = op.S3Connector("my-s3", root_dir="s3://bucket/prefix")
-    dataset = s3.table("customers.csv", label_column="churn")
+    dataset = s3.table("customers.csv")
 
     # Snowflake connector:
     sf = op.SnowflakeConnector(
@@ -32,7 +32,7 @@ Examples
         schema_name="PUBLIC",
         credentials={"user": "admin", "password": "secret"},
     )
-    dataset = sf.table("customers", label_column="churn")
+    dataset = sf.table("customers")
 
     # Databricks connector:
     db = op.DatabricksConnector(
@@ -43,7 +43,7 @@ Examples
         schema="default",
         credentials={"access_token": "dapi-..."},
     )
-    dataset = db.table("customers", label_column="churn")
+    dataset = db.table("customers")
 
 Credentials handling
 --------------------
@@ -177,24 +177,18 @@ class Connector(ABC):
         """
         return name in self.table_names()
 
-    def table(self, name: str, *, label_column: str | None = None) -> Dataset:
-        """Return a :class:`~outerproduct.dataset.Dataset` referencing a table in this connector.
+    def table(self, name: str) -> Dataset:
+        """Build a connector-backed :class:`~outerproduct.dataset.Dataset` spec.
 
-        The returned dataset is *lazy* — it holds a connector reference rather
-        than local data. The backend reads the actual data at training time.
+        The dataset rides inline on fit/predict requests; the target
+        column is selected at fit time via the ``label_column`` parameter
+        on :func:`~outerproduct.reasoning.fit` /
+        :meth:`~outerproduct.trainer.Trainer.configure`, not on the dataset.
 
         Parameters
         ----------
         name : str
             Table name or object path within the connector.
-        label_column : str, optional
-            Name of the target column for supervised training.
-
-        Returns
-        -------
-        :class:`~outerproduct.dataset.Dataset`
-            A connector-backed dataset ready for :class:`~outerproduct.trainer.Trainer`
-            or :func:`~outerproduct.reasoning.fit`.
         """
         from outerproduct.dataset import Dataset
 
@@ -204,7 +198,6 @@ class Connector(ABC):
         return Dataset._from_connector_ref(
             connector_id=self._connector_id,
             table_name=name,
-            label_column=label_column,
         )
 
     def validate(self) -> bool:
@@ -352,7 +345,7 @@ class Connector(ABC):
 
 
 # ---------------------------------------------------------------------------
-# File upload connector (stateless, unchanged)
+# File upload connector (local file -> uploaded dataset)
 # ---------------------------------------------------------------------------
 
 
@@ -363,10 +356,11 @@ class FileUploadConnector:
 
     1. Request a presigned upload URL from the server.
     2. ``PUT`` the raw file bytes to that URL.
-    3. Return a :class:`~outerproduct.dataset.Dataset` referring to the uploaded data.
+    3. Register the uploaded object as a first-class dataset row.
+    4. Return a :class:`~outerproduct.dataset.Dataset` referring to that row.
 
-    This connector does *not* register with the backend — it is a stateless
-    upload helper. Use the other connectors for registered external data sources.
+    This connector itself does not create a persistent connector config; it is
+    a local-file helper that produces dataset rows.
 
     Examples
     --------
@@ -374,7 +368,7 @@ class FileUploadConnector:
 
         import outerproduct as op
         connector = op.FileUploadConnector()
-        dataset = connector.upload("data.csv", label_column="churn")
+        dataset = connector.upload("data.csv")
     """
 
     _FORMAT_MAP: dict[str, str] = {
@@ -389,7 +383,6 @@ class FileUploadConnector:
         self,
         path: str | Path,
         *,
-        label_column: str | None = None,
         name: str | None = None,
     ) -> Dataset:
         """Upload a local data file and return a :class:`~outerproduct.dataset.Dataset`.
@@ -399,8 +392,6 @@ class FileUploadConnector:
         path : str or pathlib.Path
             Path to a local file. Supported formats: ``.csv``,
             ``.parquet``, ``.pkl``.
-        label_column : str, optional
-            Name of the target column, if any.
         name : str, optional
             Caller-supplied label, retained for display.
 
@@ -488,6 +479,7 @@ class FileUploadConnector:
             put_resp.raise_for_status()
 
         # 4. Parse the same bytes into a DataFrame for the local Dataset.
+        # The spec rides inline on fit/predict requests; no POST /v1/datasets.
         if file_format == "csv":
             df = pd.read_csv(io.BytesIO(file_bytes))
         elif file_format == "parquet":
@@ -496,9 +488,14 @@ class FileUploadConnector:
             raw = pd.read_pickle(io.BytesIO(file_bytes))
             df = pd.DataFrame(raw) if not isinstance(raw, pd.DataFrame) else raw
 
-        dataset = Dataset(df, label_column=label_column)
-        dataset._upload_id = upload_resp.dataset_id
-        return dataset
+        wire_columns = Dataset._http_columns_from_dataframe(df)
+        return Dataset._from_registered_dataframe(
+            df,
+            dataset_id=None,
+            columns=Dataset._columns_from_http(wire_columns),
+            data_uri=upload_resp.data_uri,
+            file_format=file_format,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -530,7 +527,7 @@ class S3Connector(Connector):
         import outerproduct as op
         connector = op.S3Connector("my-s3", root_dir="s3://bucket/prefix")
         print(connector.table_names())
-        dataset = connector.table("customers.csv", label_column="churn")
+        dataset = connector.table("customers.csv")
 
     Parameters
     ----------
@@ -592,7 +589,7 @@ class SnowflakeConnector(Connector):
             credentials={"user": "admin", "password": "secret"},
         )
         print(connector.table_names())
-        dataset = connector.table("customers", label_column="churn")
+        dataset = connector.table("customers")
 
     Parameters
     ----------
@@ -682,7 +679,7 @@ class DatabricksConnector(Connector):
             http_path="/sql/1.0/warehouses/abc",
             credentials={"access_token": "dapi..."},
         )
-        dataset = connector.table("customers", label_column="churn")
+        dataset = connector.table("customers")
 
     Parameters
     ----------