lorica-sdk 0.1.0__tar.gz

lorica_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lorica Labs, Inc.
+
+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.

lorica_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: lorica-sdk
+Version: 0.1.0
+Summary: Python SDK for the Lorica biometric verification API
+Author-email: Tristan Linardos <tristan@loricaapi.com>
+License: MIT
+Project-URL: Homepage, https://loricaapi.com
+Project-URL: Documentation, https://loricaapi.com/docs
+Project-URL: Repository, https://github.com/LeoMirren/lorica
+Project-URL: Demo, https://loricaapi.com/demo
+Keywords: biometric,verification,identity,liveness,jwt,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# lorica
+
+Python SDK for the [Lorica](https://loricaapi.com) biometric verification API.
+
+Prove a human did it. One API call before any high-risk action. 16 security layers. Under 2 seconds. $0.05.
+
+## Install
+
+```bash
+pip install lorica
+```
+
+## Quick Start
+
+```python
+from lorica import LoricaClient
+
+client = LoricaClient("lrca_live_...")
+
+# Enroll a user (once)
+client.enroll(user_id="usr_123", image=face_base64)
+
+# Verify before any high-risk action
+result = client.verify(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="wire_transfer_50k",
+    liveness_mode="passive"  # or "dual_frame" or "motion"
+)
+
+if result["match"]:
+    jwt = result["token"]  # signed proof of authorization
+    process_transfer(jwt)
+else:
+    block_action(result["rejection_reason"])
+```
+
+## Read Image from File
+
+```python
+image_b64 = LoricaClient.image_from_file("photo.jpg")
+client.verify(user_id="usr_123", image=image_b64, action_context="trade")
+```
+
+## Multi-Party Verification
+
+```python
+result = client.verify_multi(
+    verifications=[
+        {"user_id": "trader_001", "image": trader_face, "role": "trader"},
+        {"user_id": "risk_mgr", "image": manager_face, "role": "risk_manager"},
+    ],
+    action_context="otc_block_trade",
+    require_all=True
+)
+# result["all_verified"] == True, result["token"] = single JWT
+```
+
+## Pre-Action Identity Lock
+
+```python
+lock = client.create_lock(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="multi_venue_execution",
+    duration_seconds=120
+)
+# lock["session_id"], lock["expires_at"]
+
+client.lock_heartbeat(lock["session_id"])  # extend
+client.lock_revoke(lock["session_id"])     # revoke
+```
+
+## Analytics
+
+```python
+client.stats(period="30d")
+client.user_report(user_id="usr_123")
+client.billing_usage()
+client.thresholds()  # AI-recommended thresholds
+```
+
+## Error Handling
+
+```python
+from lorica import LoricaClient
+from lorica.client import LoricaError
+
+try:
+    result = client.verify(user_id="usr_123", image=face)
+except LoricaError as e:
+    print(e.status_code)  # 404
+    print(e.error_code)   # "user_not_enrolled"
+    print(e.message)      # "No enrollment found..."
+```
+
+## Links
+
+- [Documentation](https://loricaapi.com/docs)
+- [Live Demo](https://loricaapi.com/demo)
+- [Security](https://loricaapi.com/security)
+- [Blog](https://loricaapi.com/blog/)
+
+## License
+
+MIT

lorica_sdk-0.1.0/README.md

@@ -0,0 +1,106 @@
+# lorica
+
+Python SDK for the [Lorica](https://loricaapi.com) biometric verification API.
+
+Prove a human did it. One API call before any high-risk action. 16 security layers. Under 2 seconds. $0.05.
+
+## Install
+
+```bash
+pip install lorica
+```
+
+## Quick Start
+
+```python
+from lorica import LoricaClient
+
+client = LoricaClient("lrca_live_...")
+
+# Enroll a user (once)
+client.enroll(user_id="usr_123", image=face_base64)
+
+# Verify before any high-risk action
+result = client.verify(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="wire_transfer_50k",
+    liveness_mode="passive"  # or "dual_frame" or "motion"
+)
+
+if result["match"]:
+    jwt = result["token"]  # signed proof of authorization
+    process_transfer(jwt)
+else:
+    block_action(result["rejection_reason"])
+```
+
+## Read Image from File
+
+```python
+image_b64 = LoricaClient.image_from_file("photo.jpg")
+client.verify(user_id="usr_123", image=image_b64, action_context="trade")
+```
+
+## Multi-Party Verification
+
+```python
+result = client.verify_multi(
+    verifications=[
+        {"user_id": "trader_001", "image": trader_face, "role": "trader"},
+        {"user_id": "risk_mgr", "image": manager_face, "role": "risk_manager"},
+    ],
+    action_context="otc_block_trade",
+    require_all=True
+)
+# result["all_verified"] == True, result["token"] = single JWT
+```
+
+## Pre-Action Identity Lock
+
+```python
+lock = client.create_lock(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="multi_venue_execution",
+    duration_seconds=120
+)
+# lock["session_id"], lock["expires_at"]
+
+client.lock_heartbeat(lock["session_id"])  # extend
+client.lock_revoke(lock["session_id"])     # revoke
+```
+
+## Analytics
+
+```python
+client.stats(period="30d")
+client.user_report(user_id="usr_123")
+client.billing_usage()
+client.thresholds()  # AI-recommended thresholds
+```
+
+## Error Handling
+
+```python
+from lorica import LoricaClient
+from lorica.client import LoricaError
+
+try:
+    result = client.verify(user_id="usr_123", image=face)
+except LoricaError as e:
+    print(e.status_code)  # 404
+    print(e.error_code)   # "user_not_enrolled"
+    print(e.message)      # "No enrollment found..."
+```
+
+## Links
+
+- [Documentation](https://loricaapi.com/docs)
+- [Live Demo](https://loricaapi.com/demo)
+- [Security](https://loricaapi.com/security)
+- [Blog](https://loricaapi.com/blog/)
+
+## License
+
+MIT

lorica_sdk-0.1.0/lorica/__init__.py

@@ -0,0 +1,6 @@
+"""Lorica — Biometric step-up verification API."""
+
+from .client import LoricaClient
+
+__version__ = "0.1.0"
+__all__ = ["LoricaClient"]

lorica_sdk-0.1.0/lorica/client.py

@@ -0,0 +1,335 @@
+"""Lorica Python SDK client."""
+
+import json
+import base64
+import urllib.request
+import urllib.error
+from typing import Optional
+
+
+class LoricaError(Exception):
+    """Raised when the Lorica API returns an error."""
+    def __init__(self, status_code: int, error_code: str, message: str):
+        self.status_code = status_code
+        self.error_code = error_code
+        self.message = message
+        super().__init__(f"[{status_code}] {error_code}: {message}")
+
+
+class LoricaClient:
+    """
+    Client for the Lorica biometric verification API.
+
+    Usage:
+        from lorica import LoricaClient
+
+        client = LoricaClient("lrca_live_...")
+
+        # Enroll a user
+        result = client.enroll(user_id="usr_123", image=base64_face)
+
+        # Verify before a high-risk action
+        result = client.verify(
+            user_id="usr_123",
+            image=base64_face,
+            action_context="wire_transfer_50k"
+        )
+
+        if result["match"]:
+            jwt = result["token"]
+            # proceed with action
+    """
+
+    DEFAULT_URL = "https://lorica-production.up.railway.app"
+
+    def __init__(self, api_key: str, base_url: Optional[str] = None, timeout: int = 30):
+        """
+        Initialize the Lorica client.
+
+        Args:
+            api_key: Your Lorica API key (starts with lrca_ or lorica-)
+            base_url: API base URL (default: production)
+            timeout: Request timeout in seconds (default: 30)
+        """
+        self.api_key = api_key
+        self.base_url = (base_url or self.DEFAULT_URL).rstrip("/")
+        self.timeout = timeout
+
+    def _request(self, method: str, path: str, body: dict = None) -> dict:
+        """Make an HTTP request to the Lorica API."""
+        url = f"{self.base_url}{path}"
+        headers = {
+            "X-API-Key": self.api_key,
+            "Content-Type": "application/json",
+        }
+        data = json.dumps(body).encode() if body else None
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode())
+        except urllib.error.HTTPError as e:
+            try:
+                err_body = json.loads(e.read().decode())
+                error_code = err_body.get("error_code", "") or ""
+                if isinstance(err_body.get("detail"), dict):
+                    error_code = err_body["detail"].get("error_code", error_code)
+                    message = err_body["detail"].get("error_message", str(err_body))
+                else:
+                    message = err_body.get("error_message", str(err_body))
+            except Exception:
+                error_code = "unknown"
+                message = str(e)
+            raise LoricaError(e.code, error_code, message)
+        except urllib.error.URLError as e:
+            raise LoricaError(0, "connection_error", str(e.reason))
+
+    # ── Core ──────────────────────────────────
+
+    def health(self) -> dict:
+        """Check API health status."""
+        return self._request("GET", "/health")
+
+    def enroll(self, user_id: str, image: str, images: list = None) -> dict:
+        """
+        Enroll a user with a face image.
+
+        Args:
+            user_id: Unique user identifier
+            image: Base64-encoded face image (for single enrollment)
+            images: List of base64-encoded images (for multi-image enrollment, 2-5)
+
+        Returns:
+            {"success": True, "user_id": "..."}
+        """
+        body = {"user_id": user_id}
+        if images:
+            body["images"] = images
+        else:
+            body["image"] = image
+        return self._request("POST", "/enroll", body)
+
+    def verify(
+        self,
+        user_id: str,
+        image: str,
+        action_context: str = "high_risk_action",
+        liveness_mode: str = "passive",
+        policy_id: str = None,
+        token_ttl_seconds: int = None,
+    ) -> dict:
+        """
+        Verify a user before a high-risk action.
+
+        Args:
+            user_id: The enrolled user to verify
+            image: Base64-encoded face image
+            action_context: What action is being authorized (e.g. "wire_transfer_50k")
+            liveness_mode: "passive", "dual_frame", or "motion"
+            policy_id: Optional policy to apply
+            token_ttl_seconds: Optional JWT TTL override (30-86400)
+
+        Returns:
+            {
+                "match": True/False,
+                "confidence": 0.94,
+                "confidence_level": "high",
+                "liveness_score": 0.91,
+                "token": "eyJ...",
+                "verification_id": "...",
+                ...
+            }
+        """
+        body = {
+            "user_id": user_id,
+            "image": image,
+            "action_context": action_context,
+            "liveness_mode": liveness_mode,
+        }
+        if policy_id:
+            body["policy_id"] = policy_id
+        if token_ttl_seconds:
+            body["token_ttl_seconds"] = token_ttl_seconds
+        return self._request("POST", "/verify", body)
+
+    def verify_multi(
+        self,
+        verifications: list,
+        action_context: str = "high_risk_action",
+        require_all: bool = True,
+    ) -> dict:
+        """
+        Multi-party verification. Two or more people verify together.
+
+        Args:
+            verifications: List of {"user_id": "...", "image": "...", "role": "..."}
+            action_context: What action is being authorized
+            require_all: Whether all parties must pass (default: True)
+
+        Returns:
+            {"all_verified": True, "token": "eyJ...", "parties": [...]}
+        """
+        return self._request("POST", "/verify-multi", {
+            "verifications": verifications,
+            "action_context": action_context,
+            "require_all": require_all,
+        })
+
+    def verify_batch(self, verifications: list) -> dict:
+        """
+        Batch verification. Process 1-50 verifications at once.
+
+        Args:
+            verifications: List of {"user_id": "...", "image": "...", "action_context": "..."}
+
+        Returns:
+            {"batch_id": "...", "total": 5, "passed": 4, "failed": 1, "results": [...], "token": "eyJ..."}
+        """
+        return self._request("POST", "/verify/batch", {"verifications": verifications})
+
+    # ── Locks ─────────────────────────────────
+
+    def create_lock(
+        self,
+        user_id: str,
+        image: str,
+        action_context: str,
+        duration_seconds: int = 60,
+    ) -> dict:
+        """
+        Create a pre-action identity lock.
+
+        Args:
+            user_id: The enrolled user
+            image: Base64-encoded face image
+            action_context: What action the lock covers
+            duration_seconds: How long the lock lasts (default: 60)
+
+        Returns:
+            {"session_id": "...", "status": "active", "expires_at": "..."}
+        """
+        return self._request("POST", "/lock", {
+            "user_id": user_id,
+            "image": image,
+            "action_context": action_context,
+            "duration_seconds": duration_seconds,
+        })
+
+    def lock_status(self, session_id: str) -> dict:
+        """Check lock status."""
+        return self._request("GET", f"/lock/{session_id}")
+
+    def lock_heartbeat(self, session_id: str) -> dict:
+        """Extend a lock."""
+        return self._request("POST", f"/lock/{session_id}/heartbeat")
+
+    def lock_revoke(self, session_id: str, reason: str = None) -> dict:
+        """Revoke a lock."""
+        body = {}
+        if reason:
+            body["reason"] = reason
+        return self._request("POST", f"/lock/{session_id}/revoke", body or None)
+
+    # ── Chains ────────────────────────────────
+
+    def create_chain(self, action_context: str = None, max_verifications: int = 50) -> dict:
+        """Create a verification chain."""
+        body = {"max_verifications": max_verifications}
+        if action_context:
+            body["action_context"] = action_context
+        return self._request("POST", "/chains", body)
+
+    def get_chain(self, chain_id: str) -> dict:
+        """Get chain status."""
+        return self._request("GET", f"/chains/{chain_id}")
+
+    def close_chain(self, chain_id: str) -> dict:
+        """Close a chain and generate chain JWT."""
+        return self._request("POST", f"/chains/{chain_id}/close")
+
+    def chain_jwt(self, chain_id: str) -> dict:
+        """Get the JWT for a closed chain."""
+        return self._request("GET", f"/chains/{chain_id}/jwt")
+
+    # ── Analytics ─────────────────────────────
+
+    def stats(self, period: str = "7d") -> dict:
+        """Get aggregate verification stats."""
+        return self._request("GET", f"/stats?period={period}")
+
+    def verifications(self, limit: int = 50, user_id: str = None) -> dict:
+        """Get verification history."""
+        path = f"/verifications?limit={limit}"
+        if user_id:
+            path += f"&user_id={user_id}"
+        return self._request("GET", path)
+
+    def user_report(self, user_id: str) -> dict:
+        """Get comprehensive user verification report."""
+        return self._request("GET", f"/users/{user_id}/report")
+
+    def billing_usage(self, period: str = None) -> dict:
+        """Get billing usage for current or specified period."""
+        path = "/billing/usage"
+        if period:
+            path += f"?period={period}"
+        return self._request("GET", path)
+
+    def thresholds(self) -> dict:
+        """Get AI-recommended verification thresholds."""
+        return self._request("GET", "/thresholds/recommend")
+
+    # ── Policies ──────────────────────────────
+
+    def create_policy(self, policy_id: str, **kwargs) -> dict:
+        """Create a verification policy."""
+        body = {"policy_id": policy_id, **kwargs}
+        return self._request("POST", "/policies", body)
+
+    def get_policy(self, policy_id: str) -> dict:
+        """Get a policy."""
+        return self._request("GET", f"/policies/{policy_id}")
+
+    def update_policy(self, policy_id: str, **kwargs) -> dict:
+        """Update a policy."""
+        return self._request("PUT", f"/policies/{policy_id}", kwargs)
+
+    def delete_policy(self, policy_id: str) -> dict:
+        """Delete a policy."""
+        return self._request("DELETE", f"/policies/{policy_id}")
+
+    # ── Actions ───────────────────────────────
+
+    def create_action(self, action_id: str, **kwargs) -> dict:
+        """Register a custom action."""
+        body = {"action_id": action_id, **kwargs}
+        return self._request("POST", "/actions", body)
+
+    def list_actions(self) -> dict:
+        """List all registered actions."""
+        return self._request("GET", "/actions")
+
+    def delete_action(self, action_id: str) -> dict:
+        """Delete a custom action."""
+        return self._request("DELETE", f"/actions/{action_id}")
+
+    # ── Webhooks ──────────────────────────────
+
+    def create_webhook(self, url: str, events: list) -> dict:
+        """Register a webhook."""
+        return self._request("POST", "/webhooks", {"url": url, "events": events})
+
+    def list_webhooks(self) -> dict:
+        """List all webhooks."""
+        return self._request("GET", "/webhooks")
+
+    def delete_webhook(self, webhook_id: str) -> dict:
+        """Delete a webhook."""
+        return self._request("DELETE", f"/webhooks/{webhook_id}")
+
+    # ── Helpers ───────────────────────────────
+
+    @staticmethod
+    def image_from_file(path: str) -> str:
+        """Read an image file and return base64-encoded string."""
+        with open(path, "rb") as f:
+            return base64.b64encode(f.read()).decode()

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

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: lorica-sdk
+Version: 0.1.0
+Summary: Python SDK for the Lorica biometric verification API
+Author-email: Tristan Linardos <tristan@loricaapi.com>
+License: MIT
+Project-URL: Homepage, https://loricaapi.com
+Project-URL: Documentation, https://loricaapi.com/docs
+Project-URL: Repository, https://github.com/LeoMirren/lorica
+Project-URL: Demo, https://loricaapi.com/demo
+Keywords: biometric,verification,identity,liveness,jwt,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# lorica
+
+Python SDK for the [Lorica](https://loricaapi.com) biometric verification API.
+
+Prove a human did it. One API call before any high-risk action. 16 security layers. Under 2 seconds. $0.05.
+
+## Install
+
+```bash
+pip install lorica
+```
+
+## Quick Start
+
+```python
+from lorica import LoricaClient
+
+client = LoricaClient("lrca_live_...")
+
+# Enroll a user (once)
+client.enroll(user_id="usr_123", image=face_base64)
+
+# Verify before any high-risk action
+result = client.verify(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="wire_transfer_50k",
+    liveness_mode="passive"  # or "dual_frame" or "motion"
+)
+
+if result["match"]:
+    jwt = result["token"]  # signed proof of authorization
+    process_transfer(jwt)
+else:
+    block_action(result["rejection_reason"])
+```
+
+## Read Image from File
+
+```python
+image_b64 = LoricaClient.image_from_file("photo.jpg")
+client.verify(user_id="usr_123", image=image_b64, action_context="trade")
+```
+
+## Multi-Party Verification
+
+```python
+result = client.verify_multi(
+    verifications=[
+        {"user_id": "trader_001", "image": trader_face, "role": "trader"},
+        {"user_id": "risk_mgr", "image": manager_face, "role": "risk_manager"},
+    ],
+    action_context="otc_block_trade",
+    require_all=True
+)
+# result["all_verified"] == True, result["token"] = single JWT
+```
+
+## Pre-Action Identity Lock
+
+```python
+lock = client.create_lock(
+    user_id="usr_123",
+    image=face_base64,
+    action_context="multi_venue_execution",
+    duration_seconds=120
+)
+# lock["session_id"], lock["expires_at"]
+
+client.lock_heartbeat(lock["session_id"])  # extend
+client.lock_revoke(lock["session_id"])     # revoke
+```
+
+## Analytics
+
+```python
+client.stats(period="30d")
+client.user_report(user_id="usr_123")
+client.billing_usage()
+client.thresholds()  # AI-recommended thresholds
+```
+
+## Error Handling
+
+```python
+from lorica import LoricaClient
+from lorica.client import LoricaError
+
+try:
+    result = client.verify(user_id="usr_123", image=face)
+except LoricaError as e:
+    print(e.status_code)  # 404
+    print(e.error_code)   # "user_not_enrolled"
+    print(e.message)      # "No enrollment found..."
+```
+
+## Links
+
+- [Documentation](https://loricaapi.com/docs)
+- [Live Demo](https://loricaapi.com/demo)
+- [Security](https://loricaapi.com/security)
+- [Blog](https://loricaapi.com/blog/)
+
+## License
+
+MIT

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

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+lorica/__init__.py
+lorica/client.py
+lorica_sdk.egg-info/PKG-INFO
+lorica_sdk.egg-info/SOURCES.txt
+lorica_sdk.egg-info/dependency_links.txt
+lorica_sdk.egg-info/top_level.txt
+tests/test_client.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+lorica

lorica_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lorica-sdk"
+version = "0.1.0"
+description = "Python SDK for the Lorica biometric verification API"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "Tristan Linardos", email = "tristan@loricaapi.com"},
+]
+keywords = ["biometric", "verification", "identity", "liveness", "jwt", "api"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://loricaapi.com"
+Documentation = "https://loricaapi.com/docs"
+Repository = "https://github.com/LeoMirren/lorica"
+Demo = "https://loricaapi.com/demo"
+
+[tool.setuptools.packages.find]
+include = ["lorica*"]

lorica_sdk-0.1.0/setup.cfg

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

lorica_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,25 @@
+"""Basic tests for the Lorica Python SDK."""
+from lorica import LoricaClient
+
+def test_init():
+    c = LoricaClient("test-key")
+    assert c.api_key == "test-key"
+    assert c.base_url == LoricaClient.DEFAULT_URL
+    assert c.timeout == 30
+
+def test_custom_url():
+    c = LoricaClient("test-key", base_url="http://localhost:8000")
+    assert c.base_url == "http://localhost:8000"
+
+def test_health():
+    c = LoricaClient("lorica-dev-key-001")
+    h = c.health()
+    assert h["status"] == "ok"
+    assert "version" in h
+    print(f"Health: {h['status']} v{h['version']}")
+
+if __name__ == "__main__":
+    test_init()
+    test_custom_url()
+    test_health()
+    print("All tests passed!")