vereefy-sdk 0.2.1__tar.gz

vereefy_sdk-0.2.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: vereefy-sdk
+Version: 0.2.1
+Summary: VEREEFY Python SDK — EU AI Act Compliance-Infrastruktur
+Author-email: VEREEFY <hello@vereefy.ai>
+License: MIT
+Project-URL: Homepage, https://vereefy.ai
+Project-URL: Documentation, https://docs.vereefy.ai
+Project-URL: Repository, https://github.com/vereefy-ai/vereefy-python
+Keywords: EU AI Act,compliance,KI,audit,vereefy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+
+# vereefy-sdk
+
+Python SDK for the VEREEFY EU AI Act compliance API.
+
+## Installation
+
+```bash
+pip install vereefy-sdk
+```
+
+## Quickstart
+
+```python
+from vereefy import Verefy, Hasher
+
+async with Verefy(api_key="vfy_...") as v:
+    evidence = await v.log_interaction(
+        provider="openai",
+        model_name="gpt-4o",
+        purpose="Kundenberatung",
+        sector="financial_services",
+        input_content="Was ist der Zins?",
+        output_content="Der aktuelle Zinssatz beträgt 3,5 %.",
+    )
+    print(evidence.compliance_score)
+```
+
+## Documentation
+
+See [vereefy.ai/docs](https://vereefy.ai/docs) for the full API reference.

vereefy_sdk-0.2.1/README.md

@@ -0,0 +1,30 @@
+# vereefy-sdk
+
+Python SDK for the VEREEFY EU AI Act compliance API.
+
+## Installation
+
+```bash
+pip install vereefy-sdk
+```
+
+## Quickstart
+
+```python
+from vereefy import Verefy, Hasher
+
+async with Verefy(api_key="vfy_...") as v:
+    evidence = await v.log_interaction(
+        provider="openai",
+        model_name="gpt-4o",
+        purpose="Kundenberatung",
+        sector="financial_services",
+        input_content="Was ist der Zins?",
+        output_content="Der aktuelle Zinssatz beträgt 3,5 %.",
+    )
+    print(evidence.compliance_score)
+```
+
+## Documentation
+
+See [vereefy.ai/docs](https://vereefy.ai/docs) for the full API reference.

vereefy_sdk-0.2.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vereefy-sdk"
+version = "0.2.1"
+description = "VEREEFY Python SDK — EU AI Act Compliance-Infrastruktur"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+  {name = "VEREEFY", email = "hello@vereefy.ai"},
+]
+keywords = ["EU AI Act", "compliance", "KI", "audit", "vereefy"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+  "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["vereefy*", "verefy*"]
+
+[project.urls]
+Homepage = "https://vereefy.ai"
+Documentation = "https://docs.vereefy.ai"
+Repository = "https://github.com/vereefy-ai/vereefy-python"

vereefy_sdk-0.2.1/setup.cfg

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

vereefy_sdk-0.2.1/tests/test_sdk.py

@@ -0,0 +1,127 @@
+"""SDK-Tests: Standard-URL, Hash-Determinismus, Deprecation-Shim, Staging-Integration."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import warnings
+
+import pytest
+import pytest_asyncio
+
+from vereefy import Verefy, Hasher, VEREEFY_API_URL
+
+
+# ─── Standard-URL ────────────────────────────────────────────────────────────
+
+def test_default_base_url():
+    v = Verefy("vfy_testkey")
+    assert v.base_url == "https://api.vereefy.ai"
+
+
+def test_custom_base_url():
+    v = Verefy("vfy_testkey", base_url="https://staging.api.vereefy.ai")
+    assert v.base_url == "https://staging.api.vereefy.ai"
+
+
+def test_base_url_trailing_slash_stripped():
+    v = Verefy("vfy_testkey", base_url="https://api.vereefy.ai/")
+    assert v.base_url == "https://api.vereefy.ai"
+
+
+def test_invalid_api_key_raises():
+    with pytest.raises(ValueError, match="vfy_"):
+        Verefy("sk-notakey")
+
+
+# ─── Kanonischer Hash ─────────────────────────────────────────────────────────
+
+def test_canonical_hash_string_deterministic():
+    h1 = Hasher.canonical_hash("Hallo Welt")
+    h2 = Hasher.canonical_hash("Hallo Welt")
+    assert h1 == h2
+    assert len(h1) == 64
+
+
+def test_canonical_hash_string_strips_whitespace():
+    h1 = Hasher.canonical_hash("Hallo")
+    h2 = Hasher.canonical_hash("  Hallo  ")
+    assert h1 == h2
+
+
+def test_canonical_hash_dict_key_order_independent():
+    h1 = Hasher.canonical_hash({"a": 1, "b": 2})
+    h2 = Hasher.canonical_hash({"b": 2, "a": 1})
+    assert h1 == h2
+
+
+def test_canonical_hash_matches_reference():
+    # Referenzwert: sha256 von '{"a":1,"b":2}' (sort_keys, no spaces)
+    expected = hashlib.sha256(
+        json.dumps({"a": 1, "b": 2}, sort_keys=True, ensure_ascii=True, separators=(',', ':')).encode("utf-8")
+    ).hexdigest()
+    assert Hasher.canonical_hash({"b": 2, "a": 1}) == expected
+
+
+def test_canonical_hash_bytes():
+    raw = b"\x00\x01\x02"
+    h = Hasher.canonical_hash(raw)
+    assert h == hashlib.sha256(raw).hexdigest()
+
+
+def test_canonical_hash_none():
+    assert Hasher.canonical_hash(None) == hashlib.sha256(b"null").hexdigest()
+
+
+def test_canonical_hash_is_64_hex_chars():
+    for value in ["text", {"k": "v"}, [1, 2], b"bytes", None]:
+        h = Hasher.canonical_hash(value)
+        assert len(h) == 64
+        assert all(c in "0123456789abcdef" for c in h)
+
+
+# ─── Deprecation-Shim ────────────────────────────────────────────────────────
+
+def test_import_verefy_emits_deprecation_warning():
+    # verefy-Paket bereits importiert — DeprecationWarning beim ersten Import
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        import importlib
+        import verefy  # noqa: F401
+        importlib.reload(verefy)
+        depr = [w for w in caught if issubclass(w.category, DeprecationWarning)]
+    assert len(depr) >= 1
+    assert "vereefy" in str(depr[0].message).lower()
+
+
+def test_verefy_shim_exports_verefy_class():
+    import verefy as _old
+    assert hasattr(_old, "Verefy")
+    assert hasattr(_old, "Hasher")
+
+
+def test_verefy_shim_backward_compat_constants():
+    import verefy as _old
+    assert _old.VEREFY_API_URL == VEREEFY_API_URL
+
+
+# ─── Staging-Integration (optional, nur wenn VEREEFY_STAGING_KEY gesetzt) ───
+
+STAGING_KEY = os.environ.get("VEREEFY_STAGING_KEY", "")
+STAGING_URL = "https://staging.api.vereefy.ai"
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(not STAGING_KEY, reason="VEREEFY_STAGING_KEY nicht gesetzt")
+async def test_staging_log_interaction_returns_201():
+    async with Verefy(api_key=STAGING_KEY, base_url=STAGING_URL) as v:
+        evidence = await v.log_interaction(
+            provider="openai",
+            model_name="gpt-4o",
+            purpose="SDK-Integrationstest",
+            sector="financial_services",
+            input_content="Was ist der Zins?",
+            output_content="Der aktuelle Zinssatz beträgt 3,5 %.",
+        )
+    assert evidence.interaction_id
+    assert len(evidence.chain_tip_hash) == 64
+    assert evidence.compliance_score >= 0

vereefy_sdk-0.2.1/vereefy/__init__.py

@@ -0,0 +1,221 @@
+"""
+VEREEFY Python SDK v0.2
+Verwendung:
+    from vereefy import Verefy, Hasher
+    async with Verefy(api_key="vfy_...") as v:
+        nachweis = await v.log_interaction(
+            provider="openai", model_name="gpt-4o",
+            purpose="Kundenberatung Retail-Banking",
+            sector="financial_services",
+            input_content=nachrichten,
+            output_content=antwort,
+        )
+"""
+import hashlib, json, asyncio
+import httpx
+from typing import Any, Optional, Dict, List
+from dataclasses import dataclass
+
+VEREEFY_API_URL = "https://api.vereefy.ai"
+SDK_VERSION = "0.2.1"
+
+@dataclass
+class ComplianceEvidence:
+    interaction_id: str
+    risk_class: str
+    article_matches: List[str]
+    required_actions: List[str]
+    required_disclosures: List[str]
+    regulatory_flags: List[str]
+    confidence: str
+    compliance_score: int
+    audit_entry_id: str
+    chain_tip_hash: str
+    timestamp: str
+    classification_version: str
+    policy_version: str
+
+    def is_high_risk(self) -> bool:
+        return self.risk_class in ("high", "unacceptable")
+
+    def summary(self) -> str:
+        return (f"Risiko: {self.risk_class.upper()} | Score: {self.compliance_score}/100 | "
+                f"Artikel: {', '.join(self.article_matches[:3])}")
+
+
+class Hasher:
+    """Client-seitiges Hashing. Rohinhalte verlassen nie Ihre Umgebung."""
+
+    @staticmethod
+    def canonical_hash(content: Any) -> str:
+        if content is None:
+            return hashlib.sha256(b"null").hexdigest()
+        if isinstance(content, bytes):
+            return hashlib.sha256(content).hexdigest()
+        if isinstance(content, str):
+            return hashlib.sha256(content.strip().encode("utf-8")).hexdigest()
+        if isinstance(content, (dict, list)):
+            c = json.dumps(content, sort_keys=True, ensure_ascii=True, separators=(',', ':'))
+            return hashlib.sha256(c.encode("utf-8")).hexdigest()
+        return hashlib.sha256(str(content).encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def hash_messages(messages: List[Dict]) -> str:
+        normalized = [{"role": m.get("role", ""), "content": m.get("content", "")} for m in messages]
+        return Hasher.canonical_hash(normalized)
+
+
+class Verefy:
+    def __init__(self, api_key: str, base_url: str = VEREEFY_API_URL,
+                 timeout: float = 15.0, max_retries: int = 3):
+        if not api_key.startswith("vfy_"):
+            raise ValueError("API-Schlüssel muss mit 'vfy_' beginnen.")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._client: Optional[httpx.AsyncClient] = None
+
+    def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={"X-API-Key": self.api_key,
+                         "Content-Type": "application/json",
+                         "X-SDK-Version": SDK_VERSION},
+                timeout=self.timeout,
+            )
+        return self._client
+
+    async def close(self):
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self): return self
+    async def __aexit__(self, *args): await self.close()
+
+    async def _request(self, method: str, path: str, **kwargs):
+        client = self._get_client()
+        last_err = None
+        for attempt in range(self.max_retries):
+            try:
+                r = await client.request(method, path, **kwargs)
+                if r.status_code < 500:
+                    return r
+                last_err = VereefyAPIError(r.status_code, r.text)
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(2 ** attempt)
+            except httpx.TransportError as e:
+                last_err = VereefyConnectionError(str(e))
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(2 ** attempt)
+        raise last_err
+
+    async def log_interaction(
+        self, *, provider: str, model_name: str, purpose: str, sector: str,
+        input_hash: Optional[str] = None, output_hash: Optional[str] = None,
+        input_content: Optional[Any] = None, output_content: Optional[Any] = None,
+        model_version: Optional[str] = None, interaction_type: str = "chat",
+        customer_facing: bool = True, automation_level: str = "assisted",
+        decision_impact: str = "low", user_role: Optional[str] = None,
+        jurisdiction: str = "EU", external_ref: Optional[str] = None,
+        response_time_ms: Optional[int] = None, extra_data: Optional[Dict] = None,
+    ) -> ComplianceEvidence:
+        if input_content is not None:
+            resolved_input = Hasher.canonical_hash(input_content)
+        elif input_hash is not None:
+            resolved_input = input_hash
+        else:
+            raise VereefyValidationError("input_content oder input_hash angeben.")
+
+        if output_content is not None:
+            resolved_output = Hasher.canonical_hash(output_content)
+        elif output_hash is not None:
+            resolved_output = output_hash
+        else:
+            raise VereefyValidationError("output_content oder output_hash angeben.")
+
+        payload = {k: v for k, v in {
+            "provider": provider, "model_name": model_name,
+            "model_version": model_version, "purpose": purpose,
+            "sector": sector, "interaction_type": interaction_type,
+            "customer_facing": customer_facing, "automation_level": automation_level,
+            "decision_impact": decision_impact, "user_role": user_role,
+            "jurisdiction": jurisdiction, "input_hash": resolved_input,
+            "output_hash": resolved_output, "external_ref": external_ref,
+            "response_time_ms": response_time_ms,
+            "extra_data": extra_data,
+        }.items() if v is not None}
+
+        r = await self._request("POST", "/v1/interactions", json=payload)
+        if r.status_code == 201:
+            return ComplianceEvidence(**r.json())
+        raise VereefyAPIError(r.status_code, r.json().get("detail", r.text))
+
+    async def get_interaction(self, iid: str) -> Dict:
+        r = await self._request("GET", f"/v1/interactions/{iid}")
+        if r.status_code == 200: return r.json()
+        raise VereefyAPIError(r.status_code, r.text)
+
+    async def verify_chain(self, iid: str) -> Dict:
+        r = await self._request("GET", f"/v1/audit/{iid}/chain")
+        if r.status_code == 200: return r.json()
+        raise VereefyAPIError(r.status_code, r.text)
+
+    async def request_report(self, report_type: str = "eu_ai_act",
+                              date_from=None, date_to=None,
+                              interaction_ids=None, format: str = "json") -> Dict:
+        payload = {k: v for k, v in {
+            "report_type": report_type, "format": format,
+            "date_from": date_from, "date_to": date_to,
+            "interaction_ids": interaction_ids,
+        }.items() if v is not None}
+        r = await self._request("POST", "/v1/reports", json=payload)
+        if r.status_code in (200, 202): return r.json()
+        raise VereefyAPIError(r.status_code, r.text)
+
+    async def get_report(self, rid: str) -> Dict:
+        r = await self._request("GET", f"/v1/reports/{rid}")
+        if r.status_code == 200: return r.json()
+        raise VereefyAPIError(r.status_code, r.text)
+
+class VereefySync:
+    """
+    Synchrone Wrapper-Klasse für Flask/Django/Skripte.
+
+    WARNUNG — in Umgebungen mit bereits laufendem Event Loop
+    (Jupyter, FastAPI, ASGI-Apps) kann dieser Wrapper zu Konflikten führen.
+    Für produktive Verwendung wird der async Verefy-Client empfohlen.
+    """
+    def __init__(self, **kwargs):
+        self._async = Verefy(**kwargs)
+        try:
+            asyncio.get_running_loop()
+            import warnings
+            warnings.warn(
+                "VereefySync wird in einem bereits laufenden Event Loop erstellt. "
+                "Verwende stattdessen 'async with Verefy(...)' für async-Umgebungen.",
+                RuntimeWarning, stacklevel=2
+            )
+        except RuntimeError:
+            pass
+        self._loop = asyncio.new_event_loop()
+
+    def _run(self, coro): return self._loop.run_until_complete(coro)
+    def log_interaction(self, **kw): return self._run(self._async.log_interaction(**kw))
+    def verify_chain(self, iid): return self._run(self._async.verify_chain(iid))
+    def close(self):
+        self._run(self._async.close())
+        self._loop.close()
+    def __enter__(self): return self
+    def __exit__(self, *a): self.close()
+
+
+class VereefyError(Exception): pass
+class VereefyAPIError(VereefyError):
+    def __init__(self, sc, detail):
+        self.status_code = sc; self.detail = detail
+        super().__init__(f"VEREEFY API {sc}: {detail}")
+class VereefyConnectionError(VereefyError): pass
+class VereefyValidationError(VereefyError): pass

vereefy_sdk-0.2.1/vereefy_sdk.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: vereefy-sdk
+Version: 0.2.1
+Summary: VEREEFY Python SDK — EU AI Act Compliance-Infrastruktur
+Author-email: VEREEFY <hello@vereefy.ai>
+License: MIT
+Project-URL: Homepage, https://vereefy.ai
+Project-URL: Documentation, https://docs.vereefy.ai
+Project-URL: Repository, https://github.com/vereefy-ai/vereefy-python
+Keywords: EU AI Act,compliance,KI,audit,vereefy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+
+# vereefy-sdk
+
+Python SDK for the VEREEFY EU AI Act compliance API.
+
+## Installation
+
+```bash
+pip install vereefy-sdk
+```
+
+## Quickstart
+
+```python
+from vereefy import Verefy, Hasher
+
+async with Verefy(api_key="vfy_...") as v:
+    evidence = await v.log_interaction(
+        provider="openai",
+        model_name="gpt-4o",
+        purpose="Kundenberatung",
+        sector="financial_services",
+        input_content="Was ist der Zins?",
+        output_content="Der aktuelle Zinssatz beträgt 3,5 %.",
+    )
+    print(evidence.compliance_score)
+```
+
+## Documentation
+
+See [vereefy.ai/docs](https://vereefy.ai/docs) for the full API reference.

vereefy_sdk-0.2.1/vereefy_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tests/test_sdk.py
+vereefy/__init__.py
+vereefy_sdk.egg-info/PKG-INFO
+vereefy_sdk.egg-info/SOURCES.txt
+vereefy_sdk.egg-info/dependency_links.txt
+vereefy_sdk.egg-info/requires.txt
+vereefy_sdk.egg-info/top_level.txt
+verefy/__init__.py

vereefy_sdk-0.2.1/vereefy_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vereefy_sdk-0.2.1/vereefy_sdk.egg-info/requires.txt

@@ -0,0 +1,5 @@
+httpx>=0.27.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.24

vereefy_sdk-0.2.1/vereefy_sdk.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+vereefy
+verefy

vereefy_sdk-0.2.1/verefy/__init__.py

@@ -0,0 +1,33 @@
+"""
+Deprecated: Dieses Paket heisst jetzt 'vereefy'.
+Bitte auf 'from vereefy import ...' umsteigen.
+"""
+import warnings
+
+warnings.warn(
+    "Das Paket 'verefy' ist veraltet. "
+    "Bitte 'from vereefy import Verefy, Hasher' verwenden.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from vereefy import (  # noqa: F401, E402
+    Verefy,
+    VereefySync,
+    Hasher,
+    ComplianceEvidence,
+    VereefyError,
+    VereefyAPIError,
+    VereefyConnectionError,
+    VereefyValidationError,
+    VEREEFY_API_URL,
+    SDK_VERSION,
+)
+
+# Rückwärtskompatible Aliase
+VerefySync = VereefySync
+VerefyError = VereefyError
+VerefyAPIError = VereefyAPIError
+VerefyConnectionError = VereefyConnectionError
+VerefyValidationError = VereefyValidationError
+VEREFY_API_URL = VEREEFY_API_URL