acretix-verify-sdk 0.1.0__tar.gz

acretix_verify_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Acretix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

acretix_verify_sdk-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+exclude test_acretix_verify.py

acretix_verify_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: acretix-verify-sdk
+Version: 0.1.0
+Summary: Python client for the AI Verify API - rubric-based verdicts with signed, re-verifiable proofs.
+License: MIT
+Project-URL: Documentation, https://api.acretix.io/docs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# acretix-verify-sdk
+
+Python client for the [AI Verify API](https://api.acretix.io/docs) — submit work against a rubric
+and receive a scored, explained verdict with an Ed25519-signed, independently re-verifiable proof.
+
+```python
+import os
+from acretix_verify import AcretixVerify
+
+client = AcretixVerify(api_key=os.environ["VERIFY_API_KEY"])
+
+rubric = client.compile_rubric({
+    "name": "invoice-check",
+    "criteria": [
+        {"key": "total_present", "type": "must_have", "primitive": "regex_match@1",
+         "config": {"pattern": r"Total: \$[0-9]+"}},
+    ],
+})
+
+verdict = client.submit_verification(
+    rubric_id=rubric["rubric_id"],
+    submission={"inline": "Invoice... Total: $420"},
+    wait_ms=30000,
+    idempotency_key="invoice-001",
+)
+# verdict["determination"]: "met" | "partial" | "not_met" — flagged=True means needs_review:
+# below the confidence threshold the engine abstains rather than asserting a verdict.
+
+report = client.reverify(verdict["verification_id"])
+# report["ok"] and report["chain_ok"] — the proof verifies against the published public key.
+```
+
+- Verdicts below the confidence threshold are **flagged `needs_review`** — the engine abstains
+  instead of guessing; your application decides what happens next.
+- Proofs are signed with Ed25519 and re-verifiable by any third party against the published
+  public key — see the [docs](https://api.acretix.io/docs) for the proof format.
+- Also available: `get_verification`, `wait_for_verification`, `get_proof`, `get_usage`, `submit_feedback`.
+- Usage is metered per verification by judge tier.
+
+Standard library only (urllib). Python 3.9+.
+
+License: MIT

acretix_verify_sdk-0.1.0/README.md

@@ -0,0 +1,42 @@
+# acretix-verify-sdk
+
+Python client for the [AI Verify API](https://api.acretix.io/docs) — submit work against a rubric
+and receive a scored, explained verdict with an Ed25519-signed, independently re-verifiable proof.
+
+```python
+import os
+from acretix_verify import AcretixVerify
+
+client = AcretixVerify(api_key=os.environ["VERIFY_API_KEY"])
+
+rubric = client.compile_rubric({
+    "name": "invoice-check",
+    "criteria": [
+        {"key": "total_present", "type": "must_have", "primitive": "regex_match@1",
+         "config": {"pattern": r"Total: \$[0-9]+"}},
+    ],
+})
+
+verdict = client.submit_verification(
+    rubric_id=rubric["rubric_id"],
+    submission={"inline": "Invoice... Total: $420"},
+    wait_ms=30000,
+    idempotency_key="invoice-001",
+)
+# verdict["determination"]: "met" | "partial" | "not_met" — flagged=True means needs_review:
+# below the confidence threshold the engine abstains rather than asserting a verdict.
+
+report = client.reverify(verdict["verification_id"])
+# report["ok"] and report["chain_ok"] — the proof verifies against the published public key.
+```
+
+- Verdicts below the confidence threshold are **flagged `needs_review`** — the engine abstains
+  instead of guessing; your application decides what happens next.
+- Proofs are signed with Ed25519 and re-verifiable by any third party against the published
+  public key — see the [docs](https://api.acretix.io/docs) for the proof format.
+- Also available: `get_verification`, `wait_for_verification`, `get_proof`, `get_usage`, `submit_feedback`.
+- Usage is metered per verification by judge tier.
+
+Standard library only (urllib). Python 3.9+.
+
+License: MIT

acretix_verify_sdk-0.1.0/acretix_verify.py

@@ -0,0 +1,123 @@
+"""AI Verify Python SDK — stdlib-only thin client (DRAFT, internal, never published).
+
+Mirrors sdks/typescript/src/client.ts. Uses urllib so no dependency is required;
+pass a custom ``transport`` callable for tests (signature: (method, url, headers, body) ->
+(status, body_text)).
+"""
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Optional
+
+Transport = Callable[[str, str, dict, Optional[bytes]], tuple]
+
+
+class AcretixVerifyError(Exception):
+    """problem+json error carrying status + RFC-7807 fields."""
+
+    def __init__(self, status: int, problem: dict):
+        super().__init__(f"{status} {problem.get('title', 'request failed')}")
+        self.status = status
+        self.problem = problem
+
+
+def _default_transport(method: str, url: str, headers: dict, body: Optional[bytes]) -> tuple:
+    request = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(request, timeout=70) as response:
+            return response.status, response.read().decode("utf-8")
+    except urllib.error.HTTPError as error:  # non-2xx still carries the problem body
+        return error.code, error.read().decode("utf-8")
+
+
+class AcretixVerify:
+    def __init__(self, api_key: str, base_url: str = "http://localhost:3000",
+                 transport: Transport = _default_transport):
+        if not api_key.startswith("avk_"):
+            raise ValueError("api_key must be an AI Verify key (avk_...)")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._transport = transport
+
+    # -- surface -----------------------------------------------------------------
+    def compile_rubric(self, spec: dict) -> dict:
+        return self._request("POST", "/api/v1/rubrics", spec)
+
+    def submit_verification(self, rubric_id: str, submission: dict,
+                            idempotency_key: Optional[str] = None,
+                            wait_ms: Optional[int] = None,
+                            max_judge_tier: Optional[int] = None,
+                            reference_set_id: Optional[str] = None,
+                            callback_url: Optional[str] = None) -> dict:
+        payload: dict[str, Any] = {"rubric_id": rubric_id, "submission": submission}
+        if reference_set_id is not None:
+            payload["reference_set_id"] = reference_set_id
+        if callback_url is not None:  # top-level contract field, NOT inside options
+            payload["callback_url"] = callback_url
+        options: dict[str, Any] = {}
+        if wait_ms is not None:
+            options["wait_ms"] = wait_ms
+        if max_judge_tier is not None:
+            options["max_judge_tier"] = max_judge_tier
+        if options:
+            payload["options"] = options
+        headers = {"idempotency-key": idempotency_key} if idempotency_key else {}
+        return self._request("POST", "/api/v1/verify", payload, headers)
+
+    def get_verification(self, verification_id: str) -> dict:
+        return self._request("GET", f"/api/v1/verifications/{verification_id}")
+
+    def wait_for_verification(self, verification_id: str, timeout_s: float = 120.0) -> dict:
+        started = time.monotonic()
+        delay = 0.5
+        while True:
+            row = self.get_verification(verification_id)
+            if row.get("status") in ("succeeded", "failed"):
+                return row
+            if time.monotonic() - started > timeout_s:
+                raise AcretixVerifyError(408, {"title": "timed out waiting for verification"})
+            time.sleep(delay)
+            delay = min(delay * 2, 2.0)
+
+    def get_proof(self, verification_id: str) -> dict:
+        return self._request("GET", f"/api/v1/verifications/{verification_id}/proof")
+
+    def reverify(self, verification_id: str) -> dict:
+        return self._request("POST", f"/api/v1/verifications/{verification_id}/reverify")
+
+    def get_usage(self, from_day: Optional[str] = None, to_day: Optional[str] = None) -> dict:
+        query = []
+        if from_day:
+            query.append(f"from={from_day}")
+        if to_day:
+            query.append(f"to={to_day}")
+        suffix = ("?" + "&".join(query)) if query else ""
+        return self._request("GET", f"/api/v1/usage{suffix}")
+
+    def submit_feedback(self, verification_id: str, outcome: str, note: Optional[str] = None) -> dict:
+        return self._request("POST", f"/api/v1/verifications/{verification_id}/feedback",
+                             {"outcome": outcome, "note": note})
+
+    # -- plumbing ----------------------------------------------------------------
+    def _request(self, method: str, path: str, body: Optional[dict] = None,
+                 extra_headers: Optional[dict] = None) -> dict:
+        headers = {"authorization": f"Bearer {self._api_key}", **(extra_headers or {})}
+        encoded = None
+        if body is not None:
+            headers["content-type"] = "application/json"
+            encoded = json.dumps(body).encode("utf-8")
+        status, text = self._transport(method, f"{self._base_url}{path}", headers, encoded)
+        try:
+            parsed = json.loads(text) if text else None
+        except json.JSONDecodeError:
+            parsed = {"title": "non-JSON response", "detail": text[:200]}
+        if status >= 400:
+            raise AcretixVerifyError(status, parsed or {"title": "request failed"})
+        return parsed or {}
+
+
+if __name__ == "__main__":
+    pass

acretix_verify_sdk-0.1.0/acretix_verify_sdk.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: acretix-verify-sdk
+Version: 0.1.0
+Summary: Python client for the AI Verify API - rubric-based verdicts with signed, re-verifiable proofs.
+License: MIT
+Project-URL: Documentation, https://api.acretix.io/docs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# acretix-verify-sdk
+
+Python client for the [AI Verify API](https://api.acretix.io/docs) — submit work against a rubric
+and receive a scored, explained verdict with an Ed25519-signed, independently re-verifiable proof.
+
+```python
+import os
+from acretix_verify import AcretixVerify
+
+client = AcretixVerify(api_key=os.environ["VERIFY_API_KEY"])
+
+rubric = client.compile_rubric({
+    "name": "invoice-check",
+    "criteria": [
+        {"key": "total_present", "type": "must_have", "primitive": "regex_match@1",
+         "config": {"pattern": r"Total: \$[0-9]+"}},
+    ],
+})
+
+verdict = client.submit_verification(
+    rubric_id=rubric["rubric_id"],
+    submission={"inline": "Invoice... Total: $420"},
+    wait_ms=30000,
+    idempotency_key="invoice-001",
+)
+# verdict["determination"]: "met" | "partial" | "not_met" — flagged=True means needs_review:
+# below the confidence threshold the engine abstains rather than asserting a verdict.
+
+report = client.reverify(verdict["verification_id"])
+# report["ok"] and report["chain_ok"] — the proof verifies against the published public key.
+```
+
+- Verdicts below the confidence threshold are **flagged `needs_review`** — the engine abstains
+  instead of guessing; your application decides what happens next.
+- Proofs are signed with Ed25519 and re-verifiable by any third party against the published
+  public key — see the [docs](https://api.acretix.io/docs) for the proof format.
+- Also available: `get_verification`, `wait_for_verification`, `get_proof`, `get_usage`, `submit_feedback`.
+- Usage is metered per verification by judge tier.
+
+Standard library only (urllib). Python 3.9+.
+
+License: MIT

acretix_verify_sdk-0.1.0/acretix_verify_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+MANIFEST.in
+README.md
+acretix_verify.py
+pyproject.toml
+acretix_verify_sdk.egg-info/PKG-INFO
+acretix_verify_sdk.egg-info/SOURCES.txt
+acretix_verify_sdk.egg-info/dependency_links.txt
+acretix_verify_sdk.egg-info/top_level.txt

acretix_verify_sdk-0.1.0/acretix_verify_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

acretix_verify_sdk-0.1.0/acretix_verify_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+acretix_verify

acretix_verify_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "acretix-verify-sdk"
+version = "0.1.0"
+description = "Python client for the AI Verify API - rubric-based verdicts with signed, re-verifiable proofs."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Documentation = "https://api.acretix.io/docs"
+
+[tool.setuptools]
+py-modules = ["acretix_verify"]

acretix_verify_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+