outerproduct 0.3.0__tar.gz → 0.3.2__tar.gz

outerproduct-0.3.2/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+uv.lock
+.pytest_cache/
+.ruff_cache/

{outerproduct-0.3.0 → outerproduct-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: outerproduct
-Version: 0.3.0
+Version: 0.3.2
 Summary: Python SDK for the OuterProduct API
 Project-URL: Documentation, https://docs.outerproduct.com
 Project-URL: Homepage, https://outerproduct.com
@@ -23,17 +23,15 @@ Requires-Python: >=3.12
 Requires-Dist: httpx~=0.27
 Requires-Dist: narwhals>=1.13
 Requires-Dist: numpy~=1.23
-Requires-Dist: outerproduct-http-types
+Requires-Dist: outerproduct-http-types>=0.7.3
 Requires-Dist: pandas~=2.0
 Requires-Dist: polars<=1.41.0
+Requires-Dist: pyarrow>=14.0
 Requires-Dist: pydantic<3,>=2.0
 Provides-Extra: dev
 Requires-Dist: anyio; extra == 'dev'
-Requires-Dist: pyarrow>=14.0; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: respx; extra == 'dev'
-Provides-Extra: parquet
-Requires-Dist: pyarrow>=14.0; extra == 'parquet'
 Description-Content-Type: text/markdown
 
 # outerproduct-sdk

{outerproduct-0.3.0 → outerproduct-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "outerproduct"
-version = "0.3.0"
+version = "0.3.2"
 description = "Python SDK for the OuterProduct API"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -27,9 +27,12 @@ dependencies = [
   "httpx~=0.27",
   "narwhals>=1.13",
   "numpy~=1.23",
-  "outerproduct-http-types",
+  # Joint Python package releases raise this floor to the http-types version
+  # published with the SDK; in-repo builds resolve it from the path source below.
+  "outerproduct-http-types>=0.7.3",
   "pandas~=2.0",
   "polars<=1.41.0",
+  "pyarrow>=14.0",
   "pydantic>=2.0,<3",
 ]
 
@@ -38,14 +41,12 @@ Documentation = "https://docs.outerproduct.com"
 Homepage = "https://outerproduct.com"
 
 [project.optional-dependencies]
-dev = ["anyio", "pytest", "respx", "pyarrow>=14.0"]
-parquet = ["pyarrow>=14.0"]
+dev = ["anyio", "pytest", "respx"]
 
 [dependency-groups]
 dev = [
   "anyio>=4.0",
   "prek>=0.3.11",
-  "pyarrow>=14.0",
   "pytest>=9.0.3",
   "respx>=0.23.1",
   "ruff>=0.15.12",
@@ -69,7 +70,7 @@ include = [
 ]
 
 [tool.hatch.envs.hatch-test]
-extra-dependencies = ["anyio", "respx", "pyarrow>=14.0"]
+extra-dependencies = ["anyio", "respx"]
 
 [[tool.hatch.envs.hatch-test.matrix]]
 python = ["3.12", "3.13", "3.14"]
@@ -111,18 +112,9 @@ exclude = [".agents/**", ".ruff_cache/**", ".venv/**"]
 [tool.ty.src]
 include = ["src"]
 
-# By default the SDK resolves outerproduct-http-types from PyPI, via the plain
-# `outerproduct-http-types` entry in [project].dependencies above — pure-PyPI,
-# nothing to configure and no token needed for `uv sync`.
-#
-# Co-developing http-types alongside the SDK? Uncomment [tool.uv.sources] and
-# ONE override below to resolve it from source instead. This is a uv-only
-# setting that is stripped at build time, so it never affects the published
-# wheel. NOTE: with the git form, check-main-pins.py requires `branch = "main"`
-# on merges to main — don't commit a non-main pin (or the local path) to main.
-#
-# [tool.uv.sources]
-# # tip of http-types' default branch (CI git-auth is set up for this private repo):
-# outerproduct-http-types = { git = "https://github.com/OuterProduct-ai/outerproduct-http-types.git", branch = "main" }
-# # ...or a local editable checkout for live co-editing:
-# outerproduct-http-types = { path = "../outerproduct-http-types", editable = true }
+# In the monorepo the wire-types package is a sibling under packages/. Resolve
+# it from source so the SDK and its consumers share one copy of http-types.
+# This [tool.uv.sources] override is uv-only and stripped at build time, so the
+# published wheel keeps the PyPI lower bound above.
+[tool.uv.sources]
+outerproduct-http-types = { path = "../http-types" }

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/__init__.py

@@ -34,8 +34,8 @@ Quickstart
 
     op.init(api_key="...")
     dataset = op.LocalDataset.from_csv("customers.csv").upload()
-    reasoning_model = op.reasoning.fit(dataset, task=op.BinclassConfig(label_column="churn"))
-    test_dataset = op.Dataset(X_new)
+    reasoning_model = op.reasoning.fit(dataset, task=op.Binclass(label_column="churn"))
+    test_dataset = op.LocalDataset.from_pandas(X_new).upload()
     predictions = reasoning_model.predict(test_dataset)
     reasoning = reasoning_model.explain(test_dataset)
 """
@@ -49,17 +49,19 @@ from importlib.metadata import version as _pkg_version
 from typing import TYPE_CHECKING, Generator
 
 from outerproduct_http_types import (
-    BinclassConfig,
+    Binclass,
     ConnectorType,
-    ForecastingConfig,
-    MulticlassConfig,
-    RegressionConfig,
-    SequenceConfig,
-    TaskConfig,
+    Forecasting,
+    Multiclass,
+    Regression,
+    SequenceBinclass,
+    SequenceMulticlass,
+    SequenceRegression,
+    Task,
     TaskKind,
 )
 
-from outerproduct import agentic
+from outerproduct import agentic, reasoning
 from outerproduct.connector import (
     Connector,
     DatabricksConnector,
@@ -73,7 +75,13 @@ from outerproduct.dataset import (
     LocalDataset,
 )
 from outerproduct.expr import Expr, col
-from outerproduct.job import Job, JobFailed, JobNotReady, ReasoningFitJob, TrainerJob
+from outerproduct.job import (
+    Job,
+    JobFailed,
+    JobNotReady,
+    ReasoningFitJob,
+    TrainerJob,
+)
 from outerproduct.job_result import JobResult
 from outerproduct.model import (
     DiffModel,
@@ -81,15 +89,14 @@ from outerproduct.model import (
     ReasoningModel,
     SequenceReasoningModel,
 )
-from outerproduct import reasoning
 from outerproduct.reasoning import (
     Change,
     Counterfactual,
     QueryResult,
     Reasoning,
     ScenarioResult,
+    pattern_tracker,  # noqa: F401 — makes op.reasoning.pattern_tracker accessible
 )
-from outerproduct.reasoning import pattern_tracker  # noqa: F401 — makes op.reasoning.pattern_tracker accessible
 from outerproduct.trainer import (
     Metric,
     Trainer,
@@ -251,7 +258,7 @@ def get_datasets() -> list[Dataset]:
     out: list[Dataset] = []
     for entry in response.datasets:
         dataset = Dataset(entry.connection_config, client, entry.columns)
-        dataset._stamp_id(entry.id)
+        dataset._set_id(entry.id)
         out.append(dataset)
     return out
 
@@ -272,7 +279,7 @@ def get_dataset(dataset_id: str) -> Dataset:
     client = _resolve_client()
     entry = client.datasets_api.get(dataset_id)
     dataset = Dataset(entry.connection_config, client, entry.columns)
-    dataset._stamp_id(entry.id)
+    dataset._set_id(entry.id)
     return dataset
 
 
@@ -343,14 +350,16 @@ __all__ = [
     # Trainer
     "Trainer",
     "Metric",
-    # Task config
-    "TaskConfig",
+    # Task
+    "Task",
     "TaskKind",
-    "RegressionConfig",
-    "BinclassConfig",
-    "MulticlassConfig",
-    "ForecastingConfig",
-    "SequenceConfig",
+    "Regression",
+    "Binclass",
+    "Multiclass",
+    "Forecasting",
+    "SequenceRegression",
+    "SequenceBinclass",
+    "SequenceMulticlass",
     # Connector
     "Connector",
     "ConnectorType",

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/agentic/documents.py

@@ -339,7 +339,7 @@ class DocumentDataset(Dataset):
             DatasetColumn(name=q.id, datatype=_ANSWER_TYPE_TO_DATATYPE[q.answer_type])
             for q in schema.questions
         ]
-        self._id = dataset_id  # ty: ignore[invalid-assignment]  # TODO: deferred DocumentDataset port
+        self._id = dataset_id  # TODO: deferred DocumentDataset port
         self._connection_config = None
         self._remote_only = True
         self._schema = schema
@@ -486,7 +486,7 @@ def induce_schema(
     submission = op.agentic_documents_api.induce_schema(
         InduceSchemaRequest(documents=refs, use_case=use_case, skill=skill)
     )
-    op.wait_for(submission.job_id)
+    op.wait_for(str(submission.job_id))
     result = op.agentic_documents_api.get_schema(submission.schema_id)
     return _schema_from_payload(result.schema_)
 
@@ -521,12 +521,12 @@ def tabularize(
             }
         )
     )
-    op.wait_for(submission.job_id)
-    result = op.agentic_documents_api.get_table(submission.dataset_id)
+    op.wait_for(str(submission.job_id))
+    result = op.agentic_documents_api.get_table(str(submission.dataset_id))
     return DocumentDataset(
         schema=_schema_from_payload(result.schema_),
         document_ids=list(result.document_ids),
-        dataset_id=result.dataset_id,
+        dataset_id=str(result.dataset_id),
         label_column=label_column,
     )
 

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/client/apis.py

@@ -9,8 +9,10 @@ ergonomic method names without duplicating any type machinery.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
 
+import httpx
+from pydantic import TypeAdapter
 from outerproduct_http_types import (
     CreateDatasetRequest,
     CreateDatasetResponse,
@@ -24,6 +26,8 @@ from outerproduct_http_types import (
     GlobalDriversResponse,
     InduceSchemaJobResponse,
     InduceSchemaRequest,
+    JobResultResponse,
+    JobResponse,
     ListDatasetEntry,
     ListDatasetsResponse,
     ListModelsResponse,
@@ -86,6 +90,91 @@ if TYPE_CHECKING:
     )
 
 
+INFERENCE_RESULT_DOWNLOAD_TIMEOUT_SECONDS = 60.0
+
+
+def inference_result_download_url(result: JobResultResponse) -> str:
+    data = result.result_data or {}
+    url = data.get("presigned_url")
+    if not isinstance(url, str) or not url:
+        raise RuntimeError(
+            f"Inference job {result.job_id} result did not include a presigned_url"
+        )
+    return url
+
+
+def parse_inference_payload(
+    job_id: str, payload: object, response_type: Any
+) -> Any:
+    if not isinstance(payload, dict):
+        raise RuntimeError(
+            f"Inference job {job_id} result payload was not a JSON object"
+        )
+    return TypeAdapter(response_type).validate_python(payload)
+
+
+def assert_inference_payload_object(job_id: str, payload: object) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        raise RuntimeError(
+            f"Inference job {job_id} result payload was not a JSON object"
+        )
+    return cast(dict[str, Any], payload)
+
+
+def download_inference_result(result: JobResultResponse) -> dict[str, Any]:
+    response = httpx.get(
+        inference_result_download_url(result),
+        timeout=INFERENCE_RESULT_DOWNLOAD_TIMEOUT_SECONDS,
+    )
+    response.raise_for_status()
+    return assert_inference_payload_object(str(result.job_id), response.json())
+
+
+async def async_download_inference_result(
+    result: JobResultResponse,
+) -> dict[str, Any]:
+    async with httpx.AsyncClient(
+        timeout=INFERENCE_RESULT_DOWNLOAD_TIMEOUT_SECONDS
+    ) as client:
+        response = await client.get(inference_result_download_url(result))
+    response.raise_for_status()
+    return assert_inference_payload_object(str(result.job_id), response.json())
+
+
+def submit_inference_job(
+    client: OuterProductClient,
+    endpoint: Any,
+    request: Any,
+    *,
+    model_id: str,
+    response_type: Any,
+) -> Any:
+    response = cast(JobResponse, client._post(endpoint, request, model_id=model_id))
+    job_id = str(response.job_id)
+    client.wait_for(job_id)
+    result = client.results(job_id)
+    payload = download_inference_result(result)
+    return TypeAdapter(response_type).validate_python(payload)
+
+
+async def async_submit_inference_job(
+    client: AsyncOuterProductClient,
+    endpoint: Any,
+    request: Any,
+    *,
+    model_id: str,
+    response_type: Any,
+) -> Any:
+    response = cast(
+        JobResponse, await client._post(endpoint, request, model_id=model_id)
+    )
+    job_id = str(response.job_id)
+    await client.wait_for(job_id)
+    result = await client.results(job_id)
+    payload = await async_download_inference_result(result)
+    return TypeAdapter(response_type).validate_python(payload)
+
+
 class UploadsAPI:
     """``POST /v1/uploads`` — request a presigned upload URL."""
 
@@ -178,7 +267,12 @@ class ModelsAPI:
 
 
 class InferenceAPI:
-    """Synchronous inference on ``/v1/models/{model_id}/...``."""
+    """Inference on ``/v1/models/{model_id}/...``.
+
+    The API runs inference as a job, but this SDK surface preserves the
+    synchronous inference contract: each method waits for the job and returns
+    the typed inference response.
+    """
 
     def __init__(self, client: OuterProductClient) -> None:
         self._client = client
@@ -186,11 +280,15 @@ class InferenceAPI:
     def predict(
         self, model_id: str, request: PredictRequest
     ) -> PredictResponse | SequencePredictResponse:
-        # cast: the PREDICT endpoint's response_type is this union, but ty
-        # can't bind the generic RespT through it; the cast keeps it ty-clean.
         return cast(
             "PredictResponse | SequencePredictResponse",
-            self._client._post(PREDICT, request, model_id=model_id),
+            submit_inference_job(
+                self._client,
+                PREDICT,
+                request,
+                model_id=model_id,
+                response_type=SequencePredictResponse | PredictResponse,
+            ),
         )
 
     def explain(
@@ -198,23 +296,54 @@ class InferenceAPI:
     ) -> ExplainResponse | SequenceExplainResponse:
         return cast(
             "ExplainResponse | SequenceExplainResponse",
-            self._client._post(EXPLAIN, request, model_id=model_id),
+            submit_inference_job(
+                self._client,
+                EXPLAIN,
+                request,
+                model_id=model_id,
+                response_type=SequenceExplainResponse | ExplainResponse,
+            ),
         )
 
     def predict_and_explain(
         self, model_id: str, request: PredictAndExplainRequest
     ) -> PredictAndExplainResponse:
-        return self._client._post(PREDICT_AND_EXPLAIN, request, model_id=model_id)
+        return cast(
+            "PredictAndExplainResponse",
+            submit_inference_job(
+                self._client,
+                PREDICT_AND_EXPLAIN,
+                request,
+                model_id=model_id,
+                response_type=PredictAndExplainResponse,
+            ),
+        )
 
     def get_global_drivers(
         self, model_id: str, request: GlobalDriversRequest | None = None
     ) -> GlobalDriversResponse:
-        return self._client._post(
-            GLOBAL_DRIVERS, request or GlobalDriversRequest(), model_id=model_id
+        return cast(
+            "GlobalDriversResponse",
+            submit_inference_job(
+                self._client,
+                GLOBAL_DRIVERS,
+                request or GlobalDriversRequest(),
+                model_id=model_id,
+                response_type=GlobalDriversResponse,
+            ),
         )
 
     def scenario(self, model_id: str, request: ScenarioRequest) -> ScenarioResponse:
-        return self._client._post(SCENARIO, request, model_id=model_id)
+        return cast(
+            "ScenarioResponse",
+            submit_inference_job(
+                self._client,
+                SCENARIO,
+                request,
+                model_id=model_id,
+                response_type=ScenarioResponse,
+            ),
+        )
 
 
 class PatternTrackerAPI:
@@ -369,7 +498,7 @@ class AsyncModelsAPI:
 
 
 class AsyncInferenceAPI:
-    """Synchronous-endpoint inference on ``/v1/models/{model_id}/...`` (async client)."""
+    """Inference on ``/v1/models/{model_id}/...`` for the async client."""
 
     def __init__(self, client: AsyncOuterProductClient) -> None:
         self._client = client
@@ -377,12 +506,15 @@ class AsyncInferenceAPI:
     async def predict(
         self, model_id: str, request: PredictRequest
     ) -> PredictResponse | SequencePredictResponse:
-        # cast: the PREDICT endpoint's response_type is this union, but ty
-        # can't bind the generic RespT through it (same limitation the sync
-        # InferenceAPI.predict hits); the cast keeps the async twin ty-clean.
         return cast(
             "PredictResponse | SequencePredictResponse",
-            await self._client._post(PREDICT, request, model_id=model_id),
+            await async_submit_inference_job(
+                self._client,
+                PREDICT,
+                request,
+                model_id=model_id,
+                response_type=SequencePredictResponse | PredictResponse,
+            ),
         )
 
     async def explain(
@@ -390,25 +522,56 @@ class AsyncInferenceAPI:
     ) -> ExplainResponse | SequenceExplainResponse:
         return cast(
             "ExplainResponse | SequenceExplainResponse",
-            await self._client._post(EXPLAIN, request, model_id=model_id),
+            await async_submit_inference_job(
+                self._client,
+                EXPLAIN,
+                request,
+                model_id=model_id,
+                response_type=SequenceExplainResponse | ExplainResponse,
+            ),
         )
 
     async def predict_and_explain(
         self, model_id: str, request: PredictAndExplainRequest
     ) -> PredictAndExplainResponse:
-        return await self._client._post(PREDICT_AND_EXPLAIN, request, model_id=model_id)
+        return cast(
+            "PredictAndExplainResponse",
+            await async_submit_inference_job(
+                self._client,
+                PREDICT_AND_EXPLAIN,
+                request,
+                model_id=model_id,
+                response_type=PredictAndExplainResponse,
+            ),
+        )
 
     async def get_global_drivers(
         self, model_id: str, request: GlobalDriversRequest | None = None
     ) -> GlobalDriversResponse:
-        return await self._client._post(
-            GLOBAL_DRIVERS, request or GlobalDriversRequest(), model_id=model_id
+        return cast(
+            "GlobalDriversResponse",
+            await async_submit_inference_job(
+                self._client,
+                GLOBAL_DRIVERS,
+                request or GlobalDriversRequest(),
+                model_id=model_id,
+                response_type=GlobalDriversResponse,
+            ),
         )
 
     async def scenario(
         self, model_id: str, request: ScenarioRequest
     ) -> ScenarioResponse:
-        return await self._client._post(SCENARIO, request, model_id=model_id)
+        return cast(
+            "ScenarioResponse",
+            await async_submit_inference_job(
+                self._client,
+                SCENARIO,
+                request,
+                model_id=model_id,
+                response_type=ScenarioResponse,
+            ),
+        )
 
 
 class AsyncPatternTrackerAPI:

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/dataset/__init__.py

@@ -24,7 +24,6 @@ from typing import TYPE_CHECKING, Any, cast
 from outerproduct_http_types import (
     ConnectionConfig,
     DatasetColumn,
-    FileUploadConnectionConfig,
 )
 from outerproduct_http_types import Dataset as CreateDatasetRequestBody
 from outerproduct_http_types import FilterExpr as WireFilterExpr
@@ -41,6 +40,7 @@ from outerproduct.dataset.datatypes import Datatype, coerce, from_narwhals_dtype
 if TYPE_CHECKING:
     import numpy as np
     import pandas as pd
+    import polars as pl
     from narwhals.stable.v1 import DataFrame as Frame
     from narwhals.stable.v1.typing import IntoDataFrame
 
@@ -82,7 +82,7 @@ class LocalDataset(BaseModel):
         return LocalDataset._from_data(df)
 
     @staticmethod
-    def from_polars(df: Any) -> LocalDataset:
+    def from_polars(df: pl.DataFrame) -> LocalDataset:
         return LocalDataset._from_data(df)
 
     @staticmethod
@@ -205,7 +205,15 @@ class LocalDataset(BaseModel):
     # ------------------------------------------------------------------
 
     def upload(self, client: OuterProductClient | None = None) -> Dataset:
-        """Serialize the rows to Parquet, PUT them, and return a :class:`Dataset`.
+        """Serialize the rows to Parquet, PUT them, register the dataset, and
+        return a fully-registered :class:`Dataset`.
+
+        Three server round-trips: ``POST /v1/uploads`` mints the upload's
+        connection-config row and presigned PUT, the bytes are PUT to S3, then
+        ``POST /v1/datasets`` registers the dataset over that config — which
+        HEAD-verifies the upload landed and mints the Postgres dataset id. The
+        returned handle is registered (``_id`` set), so downstream fit/predict
+        calls reuse it without re-registering.
 
         ``client`` defaults to the one configured via :func:`outerproduct.init`.
         This is the real implementation (the underlying client is synchronous);
@@ -225,16 +233,23 @@ class LocalDataset(BaseModel):
                 f"upload cap is {MAX_UPLOAD_BYTES / 1e9:.0f} GB. For larger datasets, "
                 "register an external connector (S3, Snowflake, Databricks) instead."
             )
-        upload = client.uploads_api.create(CreateUploadRequest(file_format="parquet"))
+        upload_response = client.uploads_api.create(
+            CreateUploadRequest(file_format="parquet")
+        )
         with httpx.Client() as http:
             put_resp = http.put(
-                upload.upload_url,
+                upload_response.upload_url,
                 content=body,
-                headers={"Content-Type": upload.content_type},
+                headers={"Content-Type": upload_response.content_type},
             )
             put_resp.raise_for_status()
-        config = FileUploadConnectionConfig(uri=upload.data_uri, file_format="parquet")
-        return Dataset(config, client, self.columns)
+        # The server minted the file_upload_connection_config row and returned
+        # it as ``connection_config`` (the upload URI is no longer the id).
+        # Register the dataset now so the Postgres-generated id is assigned and
+        # the upload is verified server-side before returning.
+        ds = Dataset(upload_response.connection_config, client, self.columns)
+        ds._ensure_registered()
+        return ds
 
     async def aupload(self, client: OuterProductClient | None = None) -> Dataset:
         """Async :meth:`upload`.
@@ -297,7 +312,7 @@ class Dataset(BaseModel):
             connection_config, _resolve_client(), columns if columns is not None else []
         )
 
-    def _stamp_id(self, dataset_id: ID) -> None:
+    def _set_id(self, dataset_id: ID) -> None:
         """Cache the server-assigned id from a fit/predict response."""
         self._id = dataset_id
 

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/job.py

@@ -30,7 +30,6 @@ from outerproduct.utils import _client
 if TYPE_CHECKING:
     from outerproduct.model import Model, ReasoningModel, SequenceReasoningModel
 
-
 class JobFailed(RuntimeError):
     """Raised by :meth:`Job.results` when the server reports status='failed'."""
 
@@ -90,7 +89,7 @@ class Job:
         if body.status == "failed":
             raise JobFailed(body.error_message or f"job {self._job_id} failed")
         return JobResult(
-            job_id=body.job_id,
+            job_id=str(body.job_id),
             result_uri=body.result_uri,
             completed_at=body.completed_at,
             raw=dict(body.result_data or {}),

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/model.py

@@ -15,8 +15,8 @@ End-to-end shape:
 
 import outerproduct as op
 dataset = op.LocalDataset.from_csv("data.csv").upload()
-reasoning_model = op.reasoning.fit(dataset, label_column="churn")
-test_dataset = op.Dataset(test_df)
+reasoning_model = op.reasoning.fit(dataset, task=op.Binclass(label_column="churn"))
+test_dataset = op.LocalDataset.from_pandas(test_df).upload()
 predictions = reasoning_model.predict(test_dataset)
 reasoning = reasoning_model.explain(test_dataset)
 """
@@ -31,6 +31,7 @@ if TYPE_CHECKING:
     import numpy as np
     from outerproduct_http_types import Dataset as WireDataset
     from outerproduct_http_types import ExplainResponse
+    from outerproduct_http_types import SequenceExplainResponse
 
     from outerproduct.dataset import Dataset, DatasetColumn
     from outerproduct.reasoning import Reasoning, ScenarioResult
@@ -209,9 +210,9 @@ class Model:
         Parameters
         ----------
         dataset : :class:`~outerproduct.dataset.Dataset`
-            Input features. Wrap a local ``pandas.DataFrame`` /
-            ``numpy.ndarray`` / list with :class:`~outerproduct.dataset.Dataset`
-            first — the SDK no longer accepts raw arrays.
+            Input features. Build one with
+            ``op.LocalDataset.from_*(...).upload()`` (or a connector) — the
+            SDK does not accept a raw DataFrame / ndarray.
 
         Returns
         -------
@@ -574,7 +575,8 @@ class SequenceReasoningModel(Model):
     """A sequence-task model: ``predict`` + per-entity ``explain`` only.
 
     Returned by :func:`~outerproduct.reasoning.fit` when the task is a
-    :class:`~outerproduct_http_types.SequenceConfig`. Inherits ``predict``
+    sequence variant (:class:`~outerproduct_http_types.SequenceBinclass` /
+    :class:`~outerproduct_http_types.SequenceMulticlass`). Inherits ``predict``
     (one prediction per entity). ``explain`` returns the per-entity attribution
     tensor. The flat-reasoning surfaces (``scenario``, ``get_global_drivers``,
     ``predict_and_explain``, and ``PatternTracker``) do not apply to sequence
@@ -597,7 +599,10 @@ class SequenceReasoningModel(Model):
 
         spec = _dataset_spec(dataset, "SequenceReasoningModel.explain")
         with _client() as c:
-            resp = c.inference_api.explain(self._id, ExplainRequest(dataset=spec))
+            resp = cast(
+                "SequenceExplainResponse",
+                c.inference_api.explain(self._id, ExplainRequest(dataset=spec)),
+            )
         return Reasoning(feature_names=[], attributions=np.asarray(resp.attributions))
 
     @staticmethod

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/reasoning/__init__.py

@@ -19,8 +19,8 @@ Examples
     import outerproduct as op
 
     dataset = op.LocalDataset.from_csv("data.csv").upload()
-    rm = op.reasoning.fit(dataset, task=op.BinclassConfig(label_column="churn"))
-    reasoning = rm.explain(op.Dataset(X))
+    rm = op.reasoning.fit(dataset, task=op.Binclass(label_column="churn"))
+    reasoning = rm.explain(op.LocalDataset.from_pandas(X).upload())
     reasoning.feature_names[:3]
 """
 
@@ -31,7 +31,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     import numpy as np
-    from outerproduct_http_types import TaskConfig
+    from outerproduct_http_types import Task
 
     from outerproduct.dataset import Dataset
     from outerproduct.job import ReasoningFitJob
@@ -155,7 +155,7 @@ class ScenarioResult:
 def fit(
     dataset: Dataset,
     *,
-    task: TaskConfig | None = None,
+    task: Task | None = None,
     teacher: Model | Predictor | None = None,
     model_types: list[str] | None = None,
     metric: Metric | list[Metric] | None = None,
@@ -188,7 +188,7 @@ def fit(
         dataset = op.LocalDataset.from_csv("customers.csv").upload()
 
         # Supervised: train against labels.
-        rm = op.reasoning.fit(dataset, task=op.BinclassConfig(label_column="churn")).wait()
+        rm = op.reasoning.fit(dataset, task=op.Binclass(label_column="churn")).wait()
 
         # Distill an external prediction API.
         teacher = op.model.Predictor(
@@ -199,7 +199,7 @@ def fit(
 
         # Distill an existing OuterProduct-trained model.
         trained = op.Trainer.configure(
-            dataset, task=op.BinclassConfig(label_column="churn")
+            dataset, task=op.Binclass(label_column="churn")
         ).run().wait()
         rm_wrapped = op.reasoning.fit(dataset, teacher=trained).wait()
 
@@ -207,9 +207,9 @@ def fit(
     ----------
     dataset : :class:`~outerproduct.dataset.Dataset`
         Training data.
-    task : :class:`~outerproduct_http_types.TaskConfig`, optional
+    task : :class:`~outerproduct_http_types.Task`, optional
         The learning task and its target columns (e.g.
-        ``op.RegressionConfig(label_column=...)``). Required for supervised
+        ``op.Regression(label_column=...)``). Required for supervised
         fits; ignored when ``teacher`` is set (the teacher provides the
         training target).
     teacher : :class:`~outerproduct.model.Model` or :class:`~outerproduct.model.Predictor`, optional
@@ -288,13 +288,19 @@ def fit(
 
     with _client() as client:
         resp = client.reasoning_api.fit(request)
-        dataset._stamp_id(resp.dataset_id)
+        dataset._set_id(resp.dataset_id)
 
-    from outerproduct_http_types import SequenceConfig
+    from outerproduct_http_types import (
+        SequenceBinclass,
+        SequenceMulticlass,
+        SequenceRegression,
+    )
 
     return ReasoningFitJob(
-        resp.job_id,
+        str(resp.job_id),
         feature_names=ds_feature_names,
         label_column=label_column,
-        is_sequence=isinstance(task, SequenceConfig),
+        is_sequence=isinstance(
+            task, (SequenceRegression, SequenceBinclass, SequenceMulticlass)
+        ),
     )

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/reasoning/pattern_tracker.py

@@ -10,7 +10,7 @@ Quickstart
 
     op.init(api_key="...")
     ds = op.LocalDataset.from_csv("data.csv").upload()
-    rm = op.reasoning.fit(ds, task=op.BinclassConfig(label_column="churn"))
+    rm = op.reasoning.fit(ds, task=op.Binclass(label_column="churn"))
     pt = op.reasoning.pattern_tracker.fit(rm, ds, target_range=(0.5, None))
 
     pt.patterns           # tuple[FilterPattern, ...]
@@ -254,7 +254,7 @@ def fit(
         resp = c.pattern_tracker_api.create_fit(reasoning_model.id, request)
 
     return PatternTrackerJob(
-        job_id=resp.job_id,
+        job_id=str(resp.job_id),
         model_id=reasoning_model.id,
         tracker_id=resp.tracker_id,
     )

{outerproduct-0.3.0 → outerproduct-0.3.2}/src/outerproduct/trainer.py

@@ -33,12 +33,12 @@ Examples
     dataset = op.LocalDataset.from_csv("data.csv").upload()
     trainer = op.Trainer.configure(
         dataset,
-        task=op.BinclassConfig(label_column="churn"),
+        task=op.Binclass(label_column="churn"),
         model_types=["tabm", "xgboost"],
     )
     job = trainer.run(strategy="optuna")
     model = job.wait()
-    predictions = model.predict(op.Dataset(X))
+    predictions = model.predict(op.LocalDataset.from_pandas(X).upload())
 """
 
 from __future__ import annotations
@@ -48,7 +48,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from outerproduct_http_types import TaskConfig, TrainerRunRequest
+    from outerproduct_http_types import Task, TrainerRunRequest
 
     from outerproduct.dataset import Dataset
     from outerproduct.job import TrainerJob
@@ -105,7 +105,7 @@ class Trainer:
         self,
         dataset: Dataset,
         *,
-        task: TaskConfig | None,
+        task: Task | None,
         model_types: list[str] | None,
         metric: Metric | list[Metric] | None,
         teacher: Model | Predictor | None,
@@ -121,7 +121,7 @@ class Trainer:
         cls,
         dataset: Dataset,
         *,
-        task: TaskConfig | None = None,
+        task: Task | None = None,
         model_types: list[str] | None = None,
         metric: Metric | list[Metric] | None = None,
         teacher: Model | Predictor | None = None,
@@ -132,13 +132,14 @@ class Trainer:
         ----------
         dataset : :class:`~outerproduct.dataset.Dataset`
             Training data.
-        task : :class:`~outerproduct_http_types.TaskConfig`, optional
+        task : :class:`~outerproduct_http_types.Task`, optional
             The learning task and its target columns — one of
-            ``RegressionConfig``, ``BinclassConfig``, ``MulticlassConfig``,
-            ``ForecastingConfig``, or ``SequenceConfig`` (each carries
-            ``label_column``; the time-series variants also carry
-            ``id_column`` / ``timestamp_column``). Required unless a
-            ``teacher`` is given (the teacher then supplies the target).
+            ``Regression``, ``Binclass``, ``Multiclass``, ``Forecasting``,
+            ``SequenceRegression``, ``SequenceBinclass``, or
+            ``SequenceMulticlass`` (each carries ``label_column``; the
+            time-series / sequence variants also carry ``id_column`` /
+            ``timestamp_column``). Required unless a ``teacher`` is given
+            (the teacher then supplies the target).
         model_types : list of str, optional
             Candidate model-family identifiers (e.g. ``["tabm",
             "xgboost"]``). Resolved server-side. Defaults to a curated
@@ -221,7 +222,7 @@ class Trainer:
 
         with _client() as client:
             resp = client.trainer_api.run(request)
-            self._dataset._stamp_id(resp.dataset_id)
+            self._dataset._set_id(resp.dataset_id)
 
         label_column = self._task.label_column if self._task is not None else None
 

outerproduct-0.3.0/.gitignore

@@ -1,16 +0,0 @@
-__pycache__/
-*.egg-info/
-.venv/
-.vscode/
-.pytest_cache/
-.ruff_cache/
-.claude/
-
-.DS_Store
-.agents/
-skills-lock.json
-dist/
-site/
-
-# Solve OUT-294
-uv.lock