subnoto-api-client 0.0.99__py3-none-manylinux2014_x86_64.whl

subnoto_api_client/transport.py

@@ -0,0 +1,156 @@
+# Copyright 2025 Subnoto
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Simplified transport using pure httpx with signature generation
+"""
+
+from typing import TYPE_CHECKING
+import httpx
+
+from .middleware.signature_utils import sign_request_headers
+from .types import SubnotoError
+
+if TYPE_CHECKING:
+    from .session import SessionManager
+
+
+class TunnelTransport(httpx.AsyncHTTPTransport):
+    """Custom transport using httpx for tunnel encryption and signatures"""
+    
+    def __init__(self, session_manager: "SessionManager", access_key: str, secret_key: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.session_manager = session_manager
+        self.access_key = access_key
+        self.secret_key = secret_key
+    
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        """Handle request with encryption and signature"""
+        url = str(request.url)
+        path = request.url.path
+        
+        # Skip all processing for handshake requests
+        if path == "/tunnel/session":
+            return await super().handle_async_request(request)
+        
+        # For local testing, skip encryption but still sign
+        is_local = "localhost" in str(request.url.host) or "127.0.0.1" in str(request.url.host)
+        
+        # Check if this request needs tunnel encryption
+        needs_encryption = not is_local and (
+            path.startswith("/tunnel/") or (path.startswith("/public/") and request.method != "GET")
+        )
+        
+        if needs_encryption:
+            # Ensure session is established
+            await self.session_manager.ensure_session()
+            
+            # Read original content
+            await request.aread()
+            original_content = request.content
+            
+            # Encrypt the content
+            encrypted_content = self.session_manager.encrypt_request(original_content)
+            
+            # Get session ID
+            session_id = self.session_manager.get_session_id()
+            if not session_id:
+                raise SubnotoError("Session ID not available")
+            
+            # Generate signature headers for ENCRYPTED content
+            signature_headers = sign_request_headers(
+                url=url,
+                method=request.method,
+                body_content=encrypted_content,
+                access_key=self.access_key,
+                secret_key=self.secret_key,
+                existing_headers={"content-type": "application/octet-stream"}
+            )
+            
+            # Build new headers without duplicates
+            new_headers = dict(signature_headers)
+            new_headers["X-Session-Id"] = session_id
+            
+            # Add cookies
+            cookies = self.session_manager._get_cookies_for_request(url)
+            if cookies:
+                new_headers["Cookie"] = cookies
+            
+            # Create new request with encrypted content and signature headers
+            new_request = httpx.Request(
+                method=request.method,
+                url=request.url,
+                headers=new_headers,
+                content=encrypted_content,
+                extensions=request.extensions
+            )
+            
+            # Send via parent transport
+            response = await super().handle_async_request(new_request)
+            
+            # Decrypt if needed
+            if response.headers.get("x-subnoto-encrypted-response") == "true":
+                response_content = await response.aread()
+                decrypted_content = self.session_manager.decrypt_response(response_content)
+                response = httpx.Response(
+                    status_code=response.status_code,
+                    headers=response.headers,
+                    content=decrypted_content,
+                    request=request,
+                )
+            
+            # Store cookies
+            self.session_manager._store_cookies(response, url)
+            
+            return response
+        else:
+            # No encryption needed, but still sign
+            await request.aread()
+            body_content = request.content if request.content else b""
+            
+            # Generate signature headers
+            signature_headers = sign_request_headers(
+                url=url,
+                method=request.method,
+                body_content=body_content,
+                access_key=self.access_key,
+                secret_key=self.secret_key,
+                existing_headers=dict(request.headers)
+            )
+            
+            # Build new headers without duplicates
+            new_headers = dict(signature_headers)
+            
+            # Add cookies
+            cookies = self.session_manager._get_cookies_for_request(url)
+            if cookies:
+                new_headers["Cookie"] = cookies
+            
+            # Create new request with signature headers
+            new_request = httpx.Request(
+                method=request.method,
+                url=request.url,
+                headers=new_headers,
+                content=body_content,
+                extensions=request.extensions
+            )
+            
+            # Send via parent transport
+            response = await super().handle_async_request(new_request)
+            
+            # Store cookies
+            self.session_manager._store_cookies(response, url)
+            
+            return response

subnoto_api_client/types.py

@@ -0,0 +1,43 @@
+# Copyright 2025 Subnoto
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SubnotoConfig:
+    """Configuration for the Subnoto API client"""
+    
+    api_base_url: str
+    access_key: str
+    secret_key: str
+    unattested: bool = False
+    attester_key: Optional[bytes] = None
+
+
+class SubnotoError(Exception):
+    """Base exception for Subnoto API client errors"""
+    
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+    
+    def __str__(self) -> str:
+        if self.status_code:
+            return f"SubnotoError({self.status_code}): {self.message}"
+        return f"SubnotoError: {self.message}"
+

subnoto_api_client-0.0.99.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: subnoto-api-client
+Author: Subnoto
+Author-email: support@subnoto.com
+Home-page: https://subnoto.com
+License: Apache-2.0
+Description-Content-Type: text/markdown
+Summary: Python client for the Subnoto Public API
+Project-URL: Documentation, https://subnoto.com/documentation/developers/sdks/python
+Project-URL: Homepage, https://subnoto.com
+Project-URL: Repository, https://gitlab.com/subnoto/subnoto-monorepo-public
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software 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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.8
+Requires-Dist: httpx
+Requires-Dist: attrs
+Requires-Dist: http-message-signatures
+Version: 0.0.99
+
+# Subnoto Python SDK
+
+Python client for the Subnoto Public API
+
+Note: the SDK is only available on the linux/amd64 platform for now
+
+## Installation
+
+```bash
+pip install subnoto-api-client
+```
+
+## Usage
+
+### Basic Example
+
+```python
+import asyncio
+from subnoto_api_client import SubnotoClient, SubnotoConfig
+
+async def main():
+    # Create client with configuration
+    config = SubnotoConfig(
+        api_base_url="https://enclave.subnoto.com",
+        access_key="your-access-key",
+        secret_key="your-secret-key-hex"
+    )
+
+    async with SubnotoClient(config) as client:
+        # List workspaces
+        response = await client.post("/public/workspace/list", json={})
+        workspaces = response.json()
+        print(f"Workspaces: {workspaces}")
+
+        # Get current user info
+        response = await client.post("/public/utils/whoami", json={})
+        user_info = response.json()
+        print(f"User: {user_info}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Configuration
+
+| Option         | Type  | Required | Description                                            |
+| -------------- | ----- | -------- | ------------------------------------------------------ |
+| `api_base_url` | str   | Yes      | API base URL (e.g., `https://enclave.subnoto.com`)     |
+| `access_key`   | str   | Yes      | API access key from your team settings                 |
+| `secret_key`   | str   | Yes      | API secret key (hex-encoded) from your team settings   |
+| `unattested`   | bool  | No       | Use unattested mode for development (default: `False`) |
+| `attester_key` | bytes | No       | Public key for attestation verification                |
+