zeroproof 0.1.0__py3-none-any.whl

zeroproof/__init__.py

@@ -0,0 +1,12 @@
+"""
+ZeroProof Python SDK
+
+A minimal SDK for the ZeroProof AI verification API.
+Secure your agentic e-commerce ecosystem with zero-knowledge proofs.
+"""
+
+__version__ = "0.1.0"
+
+from .client import ZeroProof, ZeroProofError, Challenge, VerificationResult
+
+__all__ = ["ZeroProof", "ZeroProofError", "Challenge", "VerificationResult"]

zeroproof/client.py

@@ -0,0 +1,275 @@
+"""
+ZeroProof Client Module
+
+Provides the main ZeroProof class for interacting with the API.
+"""
+
+import json
+from typing import Any, Dict, Optional
+from dataclasses import dataclass
+from datetime import datetime
+
+try:
+    import requests
+except ImportError:
+    raise ImportError(
+        "The 'requests' library is required. Install it with: pip install requests"
+    )
+
+
+@dataclass
+class Challenge:
+    """Represents a verification challenge from the API."""
+    
+    challenge_id: str
+    nonce: str
+    expires_in: int
+    timestamp: int
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Challenge":
+        """Create a Challenge from API response data."""
+        return cls(
+            challenge_id=data["challenge_id"],
+            nonce=data["nonce"],
+            expires_in=data["expires_in"],
+            timestamp=data["timestamp"],
+        )
+
+
+@dataclass
+class VerificationResult:
+    """Represents the result of a proof verification."""
+    
+    verified: bool
+    agent_id: str
+    action: str
+    confidence: float
+    timestamp: str
+    session_id: str
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "VerificationResult":
+        """Create a VerificationResult from API response data."""
+        return cls(
+            verified=data["verified"],
+            agent_id=data["agent_id"],
+            action=data["action"],
+            confidence=data["confidence"],
+            timestamp=data["timestamp"],
+            session_id=data["session_id"],
+        )
+
+
+class ZeroProofError(Exception):
+    """Base exception for ZeroProof SDK errors."""
+    
+    def __init__(self, message: str, status_code: Optional[int] = None, response: Optional[Dict] = None):
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(self.message)
+
+
+class ZeroProof:
+    """
+    ZeroProof API Client
+    
+    A simple client for interacting with the ZeroProof verification API.
+    
+    Example:
+        >>> from zeroproof import ZeroProof
+        >>> client = ZeroProof(api_key="zkp_your_key_here")
+        >>> challenge = client.create_challenge("shopping-bot", "add_to_cart")
+        >>> result = client.verify_proof(challenge.challenge_id, "proof_data")
+    """
+    
+    DEFAULT_BASE_URL = "https://api.zeroproofai.com/v1"
+    
+    def __init__(self, api_key: str, base_url: Optional[str] = None):
+        """
+        Initialize the ZeroProof client.
+        
+        Args:
+            api_key: Your ZeroProof API key (starts with 'zkp_')
+            base_url: Optional custom API base URL (defaults to production)
+        """
+        if not api_key:
+            raise ValueError("API key is required")
+        
+        if not api_key.startswith("zkp_"):
+            raise ValueError("Invalid API key format. API key should start with 'zkp_'")
+        
+        self.api_key = api_key
+        self.base_url = base_url or self.DEFAULT_BASE_URL
+        self.session = requests.Session()
+        self.session.headers.update({
+            "X-Api-Key": self.api_key,
+            "Content-Type": "application/json",
+        })
+    
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a request to the API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint path
+            data: Optional request body data
+            params: Optional query parameters
+            
+        Returns:
+            Parsed JSON response
+            
+        Raises:
+            ZeroProofError: If the request fails
+        """
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                json=data,
+                params=params,
+                timeout=30,
+            )
+            
+            # Try to parse JSON response
+            try:
+                response_data = response.json()
+            except json.JSONDecodeError:
+                response_data = {"raw_response": response.text}
+            
+            # Check for errors
+            if response.status_code >= 400:
+                error_message = response_data.get("error", "Unknown error")
+                if "message" in response_data:
+                    error_message = f"{error_message}: {response_data['message']}"
+                
+                raise ZeroProofError(
+                    message=error_message,
+                    status_code=response.status_code,
+                    response=response_data,
+                )
+            
+            return response_data
+            
+        except requests.RequestException as e:
+            raise ZeroProofError(f"Request failed: {str(e)}") from e
+    
+    def create_challenge(
+        self,
+        agent_id: str,
+        action: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Challenge:
+        """
+        Create a new verification challenge.
+        
+        Args:
+            agent_id: Unique identifier for the AI agent
+            action: The action the agent wants to perform (e.g., "add_to_cart")
+            context: Optional additional context for the action
+            
+        Returns:
+            Challenge object containing the challenge details
+            
+        Raises:
+            ZeroProofError: If the request fails
+            
+        Example:
+            >>> challenge = client.create_challenge(
+            ...     agent_id="shopping-assistant-v1",
+            ...     action="add_to_cart",
+            ...     context={"item_id": "laptop-123", "price": 999.99}
+            ... )
+        """
+        data = {
+            "agent_id": agent_id,
+            "action": action,
+        }
+        
+        if context is not None:
+            data["context"] = context
+        
+        response = self._make_request("POST", "/verify/challenge", data=data)
+        return Challenge.from_dict(response)
+    
+    def verify_proof(
+        self,
+        challenge_id: str,
+        proof: str,
+        agent_signature: Optional[str] = None,
+    ) -> VerificationResult:
+        """
+        Verify a proof for a given challenge.
+        
+        Args:
+            challenge_id: The challenge ID from create_challenge()
+            proof: The cryptographic proof data
+            agent_signature: Optional agent signature for additional verification
+            
+        Returns:
+            VerificationResult object with verification details
+            
+        Raises:
+            ZeroProofError: If verification fails or request fails
+            
+        Example:
+            >>> result = client.verify_proof(
+            ...     challenge_id=challenge.challenge_id,
+            ...     proof="proof_data_here",
+            ...     agent_signature="signature_here"
+            ... )
+            >>> if result.verified:
+            ...     print(f"Verified with {result.confidence * 100}% confidence")
+        """
+        data = {
+            "challenge_id": challenge_id,
+            "proof": proof,
+        }
+        
+        if agent_signature is not None:
+            data["agent_signature"] = agent_signature
+        
+        response = self._make_request("POST", "/verify/proof", data=data)
+        return VerificationResult.from_dict(response)
+    
+    def get_status(self, session_id: str) -> Dict[str, Any]:
+        """
+        Get the status of a verification session.
+        
+        Args:
+            session_id: The session/challenge ID to check
+            
+        Returns:
+            Dictionary with session status details
+            
+        Raises:
+            ZeroProofError: If the request fails
+            
+        Example:
+            >>> status = client.get_status(challenge.challenge_id)
+            >>> print(f"Status: {status['status']}")
+        """
+        response = self._make_request("GET", f"/verify/status/{session_id}")
+        return response
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - close the session."""
+        self.session.close()
+    
+    def close(self):
+        """Close the underlying HTTP session."""
+        self.session.close()

zeroproof-0.1.0.dist-info/METADATA

@@ -0,0 +1,361 @@
+Metadata-Version: 2.4
+Name: zeroproof
+Version: 0.1.0
+Summary: Python SDK for ZeroProof AI verification API - Secure your agentic e-commerce ecosystem
+Home-page: https://github.com/jacobweiss2305/zeroproof
+Author: ZeroProof AI
+Author-email: ZeroProof AI <support@zeroproofai.com>
+Maintainer-email: ZeroProof AI <support@zeroproofai.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jacobweiss2305/zeroproof
+Project-URL: Documentation, https://docs.zeroproofai.com
+Project-URL: Repository, https://github.com/jacobweiss2305/zeroproof
+Project-URL: Bug Tracker, https://github.com/jacobweiss2305/zeroproof/issues
+Keywords: zeroproof,ai,verification,zkp,zero-knowledge-proof,agent,security,ecommerce
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security :: Cryptography
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# ZeroProof Python SDK
+
+[![PyPI version](https://badge.fury.io/py/zeroproof.svg)](https://badge.fury.io/py/zeroproof)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Python SDK for the ZeroProof AI verification API. Secure your agentic e-commerce ecosystem with zero-knowledge proofs.
+
+## Installation
+
+```bash
+pip install zeroproof
+```
+
+## Quick Start
+
+```python
+from zeroproof import ZeroProof
+
+# Initialize the client with your API key
+client = ZeroProof(api_key="zkp_your_api_key_here")
+
+# Create a verification challenge
+challenge = client.create_challenge(
+    agent_id="shopping-assistant-v1",
+    action="add_to_cart",
+    context={"item_id": "laptop-123", "price": 999.99}
+)
+
+print(f"Challenge ID: {challenge.challenge_id}")
+print(f"Nonce: {challenge.nonce}")
+print(f"Expires in: {challenge.expires_in} seconds")
+
+# Verify the proof (in production, this would be generated by your agent)
+result = client.verify_proof(
+    challenge_id=challenge.challenge_id,
+    proof="your_cryptographic_proof_here",
+    agent_signature="optional_signature_here"
+)
+
+if result.verified:
+    print(f"✅ Verification successful!")
+    print(f"   Agent: {result.agent_id}")
+    print(f"   Action: {result.action}")
+    print(f"   Confidence: {result.confidence * 100}%")
+    # Now execute the actual e-commerce action
+else:
+    print("❌ Verification failed")
+```
+
+## Use Cases
+
+### E-Commerce Agent Authorization
+
+```python
+from zeroproof import ZeroProof
+
+client = ZeroProof(api_key="zkp_...")
+
+# Before allowing an agent to make a purchase
+challenge = client.create_challenge(
+    agent_id="checkout-agent-v2",
+    action="initiate_purchase",
+    context={
+        "amount": 1499.99,
+        "merchant": "TechStore",
+        "items": ["laptop", "mouse", "keyboard"]
+    }
+)
+
+# Agent generates proof
+proof = your_agent.generate_proof(challenge)
+
+# Verify before processing payment
+result = client.verify_proof(challenge.challenge_id, proof)
+
+if result.verified and result.confidence > 0.95:
+    process_payment(1499.99)
+else:
+    log_security_incident(result)
+```
+
+### Refund Authorization
+
+```python
+# Verify agent before approving refund
+challenge = client.create_challenge(
+    agent_id="refund-processor",
+    action="approve_refund",
+    context={"order_id": "ORD-12345", "amount": 299.99}
+)
+
+result = client.verify_proof(challenge.challenge_id, proof)
+
+if result.verified:
+    approve_refund(order_id="ORD-12345")
+```
+
+### Inventory Management
+
+```python
+# Verify agent before updating inventory
+challenge = client.create_challenge(
+    agent_id="inventory-manager",
+    action="update_stock",
+    context={"product_id": "PROD-789", "quantity_change": -50}
+)
+
+result = client.verify_proof(challenge.challenge_id, proof)
+
+if result.verified:
+    update_inventory("PROD-789", quantity=-50)
+```
+
+## API Reference
+
+### ZeroProof
+
+The main client class for interacting with the API.
+
+#### `__init__(api_key: str, base_url: Optional[str] = None)`
+
+Initialize the ZeroProof client.
+
+**Parameters:**
+- `api_key` (str): Your ZeroProof API key (starts with 'zkp_')
+- `base_url` (str, optional): Custom API base URL (defaults to production)
+
+**Raises:**
+- `ValueError`: If API key is invalid or missing
+
+#### `create_challenge(agent_id: str, action: str, context: Optional[Dict] = None) -> Challenge`
+
+Create a new verification challenge.
+
+**Parameters:**
+- `agent_id` (str): Unique identifier for the AI agent
+- `action` (str): The action the agent wants to perform
+- `context` (dict, optional): Additional context for the action
+
+**Returns:**
+- `Challenge`: Object containing challenge_id, nonce, expires_in, timestamp
+
+**Raises:**
+- `ZeroProofError`: If the request fails
+
+#### `verify_proof(challenge_id: str, proof: str, agent_signature: Optional[str] = None) -> VerificationResult`
+
+Verify a proof for a given challenge.
+
+**Parameters:**
+- `challenge_id` (str): The challenge ID from create_challenge()
+- `proof` (str): The cryptographic proof data
+- `agent_signature` (str, optional): Optional agent signature
+
+**Returns:**
+- `VerificationResult`: Object containing verification details
+
+**Raises:**
+- `ZeroProofError`: If verification fails
+
+#### `get_status(session_id: str) -> Dict`
+
+Get the status of a verification session.
+
+**Parameters:**
+- `session_id` (str): The session/challenge ID to check
+
+**Returns:**
+- `dict`: Session status details
+
+**Raises:**
+- `ZeroProofError`: If the request fails
+
+### Data Classes
+
+#### Challenge
+
+Represents a verification challenge.
+
+**Attributes:**
+- `challenge_id` (str): Unique challenge identifier
+- `nonce` (str): Random nonce for this challenge
+- `expires_in` (int): Time until expiration in seconds
+- `timestamp` (int): Challenge creation timestamp
+
+#### VerificationResult
+
+Represents the result of proof verification.
+
+**Attributes:**
+- `verified` (bool): Whether the proof was verified
+- `agent_id` (str): The agent that was verified
+- `action` (str): The action that was authorized
+- `confidence` (float): Confidence score (0.0 to 1.0)
+- `timestamp` (str): Verification timestamp
+- `session_id` (str): Session identifier
+
+### Exceptions
+
+#### ZeroProofError
+
+Base exception for SDK errors.
+
+**Attributes:**
+- `message` (str): Error message
+- `status_code` (int, optional): HTTP status code
+- `response` (dict, optional): Full API response
+
+## Context Manager Support
+
+The SDK supports context managers for automatic resource cleanup:
+
+```python
+with ZeroProof(api_key="zkp_...") as client:
+    challenge = client.create_challenge("agent-1", "purchase")
+    result = client.verify_proof(challenge.challenge_id, proof)
+# Session is automatically closed
+```
+
+## Error Handling
+
+```python
+from zeroproof import ZeroProof, ZeroProofError
+
+client = ZeroProof(api_key="zkp_...")
+
+try:
+    challenge = client.create_challenge("agent", "action")
+    result = client.verify_proof(challenge.challenge_id, "invalid_proof")
+except ZeroProofError as e:
+    print(f"Error: {e.message}")
+    print(f"Status Code: {e.status_code}")
+    print(f"Response: {e.response}")
+```
+
+## Configuration
+
+### Custom API Endpoint
+
+For testing or self-hosted deployments:
+
+```python
+client = ZeroProof(
+    api_key="zkp_...",
+    base_url="https://api.custom-domain.com/v1"
+)
+```
+
+### Environment Variables
+
+You can set your API key via environment variable:
+
+```python
+import os
+from zeroproof import ZeroProof
+
+api_key = os.getenv("ZEROPROOF_API_KEY")
+client = ZeroProof(api_key=api_key)
+```
+
+## Requirements
+
+- Python 3.8+
+- requests >= 2.25.0
+
+## Getting an API Key
+
+1. Sign up at [https://zeroproofai.com](https://zeroproofai.com)
+2. Navigate to your dashboard
+3. Generate a new API key
+4. Copy the key (starts with `zkp_`)
+
+## Development
+
+### Installing for Development
+
+```bash
+git clone https://github.com/jacobweiss2305/zeroproof.git
+cd zeroproof/python-sdk
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Formatting
+
+```bash
+black zeroproof/
+flake8 zeroproof/
+mypy zeroproof/
+```
+
+## Support
+
+- **Documentation**: [https://docs.zeroproofai.com](https://docs.zeroproofai.com)
+- **Issues**: [GitHub Issues](https://github.com/jacobweiss2305/zeroproof/issues)
+- **Email**: support@zeroproofai.com
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Changelog
+
+### 0.1.0 (2025-01-10)
+
+- Initial release
+- Basic challenge/proof verification flow
+- Context manager support
+- Comprehensive error handling
+- Full type hints

zeroproof-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+zeroproof/__init__.py,sha256=qDAFhOILuf-uqSxvZXQKTn6p8iV6Sos4zvx-jZpAkJc,343
+zeroproof/client.py,sha256=mv2_vpnoKRgjeoWIEksNSFrp2GlydjxtwhYmNCrQwK4,8690
+zeroproof-0.1.0.dist-info/licenses/LICENSE,sha256=syJjKqAU8RC7zNCXS1Njm5_2Ch3UK49meh3dNA6txPM,1090
+zeroproof-0.1.0.dist-info/METADATA,sha256=bK2FzqpQdVmqRJzvXxpHI-mma0rx3_MFneFRSjlBhws,9768
+zeroproof-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zeroproof-0.1.0.dist-info/top_level.txt,sha256=3On0JLPOLYjabAf4QQEUYg9Kelox-ouOWHCiE0-7XGU,10
+zeroproof-0.1.0.dist-info/RECORD,,

zeroproof-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zeroproof-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZeroProof AI
+
+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.

zeroproof-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+zeroproof