provably-sdk 0.1.0__tar.gz

provably_sdk-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/provably-sdk
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

provably_sdk-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

provably_sdk-0.1.0/LICENSE.md

@@ -0,0 +1,101 @@
+# License
+
+Business Source License 1.1
+
+Copyright © 2026 Provably Technologies LTD
+
+Use Limitation:  You may not offer the Software as a commercial hosted
+service without purchasing a commercial license from Provably Technologies Ltd.
+
+Change Date:     2029-05-07
+Change License:  GPL-3.0-or-later
+
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+
+1. Definitions
+   The "Licensed Work" is the software and documentation made available
+   under this License.
+   The "Licensor" is the entity offering the Licensed Work under this
+   License.
+   "You" refers to the licensee of the Licensed Work.
+   "Use Limitation" means the restrictions (if any) placed on your use of
+   the Licensed Work before the Change Date, as listed in the license
+   parameters at the top of this License.
+   "Additional Use Grant" means additional rights (if any) the Licensor
+   grants to you before the Change Date, as listed in the license parameters
+   at the top of this License.
+   The "Change License" is the license selected by the Licensor to replace
+   this License, as listed in the license parameters at the top of this
+   License.
+   The "Change Date" is the date when the license automatically changes
+   from this License to the Change License, as listed in the license
+   parameters at the top of this License.
+   "Distribution" and "Use" have the same meaning as under copyright law.
+
+
+2. License Grant
+   From the Effective Date until the Change Date, the Licensor hereby grants
+   you the following rights:
+   a)  The right to copy, modify, create derivative works, redistribute, and
+       make non-production Use of the Licensed Work, solely in compliance
+       with the Use Limitation and Additional Use Grant.
+   b)  The right to sublicense the foregoing rights to third parties acting
+       on your behalf (for example, cloud service providers or contractors),
+       subject to the same Use Limitation.
+
+   All other rights are expressly reserved by the Licensor.
+
+
+3. Change Date
+   On the Change Date, the rights granted in Section 2 terminate, and you
+   may thereafter exercise the rights granted to you under the Change
+   License.  The Licensor will publish the Change License in the same
+   repository or source as the Licensed Work or in any successor location.
+
+
+4. Compliance and Termination
+   Any Use of the Licensed Work not expressly permitted under this License
+   (including violating the Use Limitation) is **prohibited**.
+
+   If you violate this License, your rights will terminate automatically,
+   and you must cease all Use and Distribution of the Licensed Work as soon
+   as possible.  Your licenses from anyone else remain in force.
+
+
+5. Disclaimer of Warranty
+   THE LICENSED WORK IS PROVIDED "AS IS". TO THE MAXIMUM EXTENT PERMITTED
+   BY APPLICABLE LAW, THE LICENSOR DISCLAIMS ALL WARRANTIES, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+   NON-INFRINGEMENT.
+
+
+6. Limitation of Liability
+   TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL THE
+   LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
+   CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION WITH THE LICENSED
+   WORK OR THIS LICENSE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+
+7. Trademarks
+   This License does not grant permission to use the Licensor's trademarks
+   or trade names, except to the extent required for reasonable and
+   customary use in describing the origin of the Licensed Work.
+
+
+8. Severability
+   If any provision of this License is held unenforceable or invalid under
+   applicable law, such provision shall be interpreted to accomplish the
+   objectives of such provision to the greatest extent possible and the
+   remaining provisions shall continue in full force and effect.
+
+
+9. Governing Law
+   This License shall be governed by and construed in accordance with the
+   laws of the jurisdiction specified by the Licensor, excluding its
+   conflicts-of-law principles.  If no jurisdiction is specified, the laws
+   of Finland apply (excluding conflict-of-law rules).

provably_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.5
+Name: provably-sdk
+Version: 0.1.0
+Summary: Python SDK for the Provably API: OAuth sign-in, sandboxes, collections, queries and proofs.
+Project-URL: Homepage, https://provably.ai
+Project-URL: Repository, https://github.com/ProvablyAI/provably-sdk-python
+Author: Provably Technologies Ltd
+License: Business Source License 1.1
+License-File: LICENSE.md
+Keywords: oauth,proofs,provably,sdk,verifiable
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.26
+Requires-Dist: msgspec>=0.18.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: structlog>=24.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# provably-sdk
+
+Python SDK for the Provably API: OAuth browser sign-in, sandboxes, middlewares,
+databases, collections, preprocessing, queries and proofs.
+
+```bash
+pip install provably-sdk
+```
+
+## Configure
+
+The SDK reads nothing from the environment or disk. Tell it where the API is,
+which organisation to act for and where to keep the session:
+
+```python
+import uuid
+
+import provably
+from provably import MemoryTokenStore, ProvablyConfig
+
+provably.configure(
+    config=ProvablyConfig(org_id=uuid.UUID("...")),  # api_url / app_url default to production
+    tokens=MemoryTokenStore(),
+)
+```
+
+- `config` may be a callable, read whenever a client is built, for apps whose
+  settings change at runtime. It must not raise before sign-in; leave `org_id`
+  unset and org-scoped calls raise `ProvablyConfigError`.
+- `tokens` is any object with `load()`, `save(tokens)` and
+  `clear_refresh_token()` (see `provably.TokenStore`). Rotated tokens are written
+  back to it, together with the OAuth client they were issued to.
+- `egress` is an optional context manager every HTTP call runs inside, for apps
+  that intercept their own outbound traffic.
+
+## Sign in
+
+Each app signs in as its own registered OAuth client, on its own loopback port:
+
+```python
+tokens = await provably.browser_login(client_id="my-app", port=8911)
+store.save(tokens)
+```
+
+## Use
+
+```python
+from provably import service
+
+sandbox = await service.get_sandbox()
+query_id = await service.run_query(middleware_id, collection_id, "SELECT 1")
+await service.wait_for_proof_computation(query_id)
+```
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```

provably_sdk-0.1.0/README.md

@@ -0,0 +1,62 @@
+# provably-sdk
+
+Python SDK for the Provably API: OAuth browser sign-in, sandboxes, middlewares,
+databases, collections, preprocessing, queries and proofs.
+
+```bash
+pip install provably-sdk
+```
+
+## Configure
+
+The SDK reads nothing from the environment or disk. Tell it where the API is,
+which organisation to act for and where to keep the session:
+
+```python
+import uuid
+
+import provably
+from provably import MemoryTokenStore, ProvablyConfig
+
+provably.configure(
+    config=ProvablyConfig(org_id=uuid.UUID("...")),  # api_url / app_url default to production
+    tokens=MemoryTokenStore(),
+)
+```
+
+- `config` may be a callable, read whenever a client is built, for apps whose
+  settings change at runtime. It must not raise before sign-in; leave `org_id`
+  unset and org-scoped calls raise `ProvablyConfigError`.
+- `tokens` is any object with `load()`, `save(tokens)` and
+  `clear_refresh_token()` (see `provably.TokenStore`). Rotated tokens are written
+  back to it, together with the OAuth client they were issued to.
+- `egress` is an optional context manager every HTTP call runs inside, for apps
+  that intercept their own outbound traffic.
+
+## Sign in
+
+Each app signs in as its own registered OAuth client, on its own loopback port:
+
+```python
+tokens = await provably.browser_login(client_id="my-app", port=8911)
+store.save(tokens)
+```
+
+## Use
+
+```python
+from provably import service
+
+sandbox = await service.get_sandbox()
+query_id = await service.run_query(middleware_id, collection_id, "SELECT 1")
+await service.wait_for_proof_computation(query_id)
+```
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```

provably_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "provably-sdk"
+version = "0.1.0"
+description = "Python SDK for the Provably API: OAuth sign-in, sandboxes, collections, queries and proofs."
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.12"
+license = { text = "Business Source License 1.1" }
+authors = [{ name = "Provably Technologies Ltd" }]
+keywords = ["provably", "sdk", "verifiable", "proofs", "oauth"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.26",
+    "msgspec>=0.18.0",
+    "pydantic>=2.6",
+    "structlog>=24.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "ruff>=0.3",
+    "mypy>=1.10",
+]
+
+[project.urls]
+Homepage = "https://provably.ai"
+Repository = "https://github.com/ProvablyAI/provably-sdk-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/provably"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "W"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["provably"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "."]
+asyncio_mode = "auto"
+
+[tool.mypy]
+python_version = "3.12"
+mypy_path = "src"
+files = ["src", "tests"]
+strict = true
+warn_unreachable = true
+plugins = ["pydantic.mypy"]

provably_sdk-0.1.0/src/provably/__init__.py

@@ -0,0 +1,55 @@
+"""Python SDK for the Provably API."""
+
+from provably._answer_model import AggregateAnswer, QueryAnswer, ResultsetAnswer, TabularData
+from provably._auth_api import Organization, OrganizationType
+from provably._config import (
+    MemoryTokenStore,
+    OAuthTokens,
+    ProvablyConfig,
+    ProvablyConfigError,
+    TokenStore,
+    configure,
+)
+from provably._errors import (
+    ProvablyAPIError,
+    ProvablyAuthError,
+    ProvablyConnectionError,
+    ProvablyDataError,
+    ProvablyError,
+    ProvablyNotFoundError,
+    ProvablyResourceAlreadyExistsError,
+    ProvablyUnauthorizedError,
+)
+from provably.auth_service import ProvablyAuthService, auth_service
+from provably.connection import ConnectionInfo
+from provably.oauth_login import browser_login
+from provably.service import ProvablyService, service
+
+__all__ = [
+    "AggregateAnswer",
+    "ConnectionInfo",
+    "MemoryTokenStore",
+    "OAuthTokens",
+    "Organization",
+    "OrganizationType",
+    "ProvablyAPIError",
+    "ProvablyAuthError",
+    "ProvablyAuthService",
+    "ProvablyConfig",
+    "ProvablyConfigError",
+    "ProvablyConnectionError",
+    "ProvablyDataError",
+    "ProvablyError",
+    "ProvablyNotFoundError",
+    "ProvablyResourceAlreadyExistsError",
+    "ProvablyService",
+    "ProvablyUnauthorizedError",
+    "QueryAnswer",
+    "ResultsetAnswer",
+    "TabularData",
+    "TokenStore",
+    "auth_service",
+    "browser_login",
+    "configure",
+    "service",
+]

provably_sdk-0.1.0/src/provably/_answer_model.py

@@ -0,0 +1,78 @@
+"""Data validation and serialization contracts for the Rust API layers."""
+
+from typing import Any, Literal
+
+import msgspec
+import structlog
+from pydantic import BaseModel, Field, model_validator
+
+_log = structlog.get_logger(__name__)
+
+__all__ = ["QueryAnswer", "TabularData", "AggregateAnswer", "ResultsetAnswer"]
+
+
+def _safe_deserialize(cell: Any) -> Any:
+    """Helper to cleanly parse stringified JSON containers using high-speed C decoding."""
+    if isinstance(cell, str) and cell.strip().startswith(("{", "[")):
+        try:
+            return msgspec.json.decode(cell)
+        except Exception as e:
+            _log.debug("safe_deserialize_fallback", error=str(e))
+            return cell
+    return cell
+
+
+class TabularData(BaseModel):
+    columns: list[dict[str, Any]] = Field(default_factory=list)
+    rows: list[list[Any]] = Field(default_factory=list)
+
+    def extract_value(self) -> Any:
+        """Unpacks tabular results down to the core target payload."""
+        if not self.rows:
+            return {"columns": self.columns, "rows": self.rows}
+
+        row0 = self.rows[0]
+        # Extracted column names are normalized to lowercase
+        col_names = [str(c.get("name") or "").lower() for c in self.columns]
+
+        # Target 1: Extract intercept record payloads cleanly if present
+        if "raw_response" in col_names:
+            return _safe_deserialize(row0[col_names.index("raw_response")])
+
+        # Target 2: Single cell scalar
+        if len(col_names) == 1 and len(row0) == 1:
+            return _safe_deserialize(row0[0])
+
+        return {"columns": self.columns, "rows": self.rows}
+
+
+class AggregateAnswer(BaseModel):
+    type: Literal["aggregate"]
+    value: str
+
+    def extract_value(self) -> Any:
+        return _safe_deserialize(self.value)
+
+
+class ResultsetAnswer(BaseModel):
+    type: Literal["resultset"]
+    value: TabularData
+
+    def extract_value(self) -> Any:
+        return self.value.extract_value()
+
+
+class QueryAnswer(BaseModel):
+    """Wrapper mapping the structure of QueryAnswer enum."""
+
+    root: AggregateAnswer | ResultsetAnswer = Field(..., discriminator="type")
+
+    @model_validator(mode="before")
+    @classmethod
+    def wrap_root(cls, data: Any) -> Any:
+        if isinstance(data, dict) and "root" not in data:
+            return {"root": data}
+        return data
+
+    def flatten(self) -> Any:
+        return self.root.extract_value()