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

__init__.py

@@ -0,0 +1,34 @@
+# 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.
+#
+
+"""Oak Python SDK for secure session management."""
+
+__version__ = "0.1.0"
+
+# Import client and server modules
+# These are native extensions built from Rust via pyo3
+try:
+    from . import oak_client
+    from . import oak_server
+except ImportError as e:
+    # Provide a helpful error message
+    import sys
+    print(f"Failed to import oak_py_sdk native modules: {e}", file=sys.stderr)
+    print("Make sure the native extensions are built:", file=sys.stderr)
+    print("  eval \"$(direnv export bash)\" && bazel build //libs/oak_py_sdk:oak_client //libs/oak_py_sdk:oak_server", file=sys.stderr)
+    raise
+
+__all__ = ["oak_client", "oak_server"]
+

subnoto_api_client/__init__.py

@@ -0,0 +1,23 @@
+# 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 .client import SubnotoClient
+from .types import SubnotoConfig, SubnotoError
+
+# Re-export generated API modules
+from .generated import api, models
+
+__all__ = ["SubnotoClient", "SubnotoConfig", "SubnotoError", "api", "models"]
+

subnoto_api_client/client.py

@@ -0,0 +1,155 @@
+# 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 typing import Any, Dict, Optional
+
+import httpx
+
+from .session import SessionManager
+from .transport import TunnelTransport
+from .types import SubnotoConfig
+from .generated.client import Client as GeneratedClient
+
+
+class GeneratedClientWrapper:
+    """Wrapper to make our httpx client compatible with generated client expectations"""
+    
+    def __init__(self, httpx_client: httpx.AsyncClient):
+        self._httpx_client = httpx_client
+        self.raise_on_unexpected_status = False
+    
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        return self._httpx_client
+    
+    def get_httpx_client(self) -> httpx.Client:
+        raise NotImplementedError("Synchronous client not supported")
+
+
+class SubnotoClient:
+    """
+    Subnoto API client with Oak tunnel encryption and HTTP signature authentication
+    
+    This is a wrapper around the generated OpenAPI client that adds:
+    - Oak tunnel encryption for secure communication
+    - HTTP signature authentication (RFC 9421)
+    - Session management with attestation support
+    
+    You can use the generated API functions directly:
+        from subnoto_api_client.api.utils import post_public_utils_whoami
+        response = await post_public_utils_whoami.asyncio(client=client, body={})
+    
+    Or use the lower-level httpx methods:
+        response = await client.get("/public/utils/whoami")
+    """
+    
+    def __init__(self, config: SubnotoConfig):
+        self.config = config
+        
+        # Create session manager first (without http_client)
+        self.session_manager = SessionManager(config)
+        
+        # Create custom transport with tunnel encryption and signatures
+        transport = TunnelTransport(
+            self.session_manager,
+            config.access_key,
+            config.secret_key
+        )
+        
+        # Create httpx client with custom transport
+        self._client = httpx.AsyncClient(
+            base_url=config.api_base_url,
+            transport=transport,
+            timeout=30.0
+        )
+        
+        # Now give the session manager our signed client for handshakes
+        self.session_manager.http_client = self._client
+        
+        # Create wrapper for generated client compatibility
+        self.generated = GeneratedClientWrapper(self._client)
+    
+    async def __aenter__(self):
+        """Async context manager entry"""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.close()
+    
+    async def close(self) -> None:
+        """Close the client and cleanup resources"""
+        await self._client.aclose()
+        self.session_manager.destroy()
+    
+    async def get(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        """Make a GET request"""
+        return await self._client.get(path, params=params, headers=headers)
+    
+    async def post(
+        self,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[bytes] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        """Make a POST request"""
+        return await self._client.post(path, json=json, content=data, headers=headers)
+    
+    async def put(
+        self,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[bytes] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        """Make a PUT request"""
+        return await self._client.put(path, json=json, content=data, headers=headers)
+    
+    async def delete(
+        self,
+        path: str,
+        *,
+        headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        """Make a DELETE request"""
+        return await self._client.delete(path, headers=headers)
+    
+    async def patch(
+        self,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[bytes] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        """Make a PATCH request"""
+        return await self._client.patch(path, json=json, content=data, headers=headers)
+    
+    def get_attestation_results(self) -> Optional[str]:
+        """Get attestation results as JSON string"""
+        return self.session_manager.get_attestation_results()
+    
+    def get_attestation_status(self) -> Optional[str]:
+        """Get attestation status as JSON string"""
+        return self.session_manager.get_attestation_status()
+

subnoto_api_client/generated/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Subnoto Public API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

subnoto_api_client/generated/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

subnoto_api_client/generated/api/contact/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

subnoto_api_client/generated/api/contact/post_public_contact_create.py

@@ -0,0 +1,241 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.post_public_contact_create_body import PostPublicContactCreateBody
+from ...models.post_public_contact_create_response_200 import (
+    PostPublicContactCreateResponse200,
+)
+from ...models.post_public_contact_create_response_400 import (
+    PostPublicContactCreateResponse400,
+)
+from ...models.post_public_contact_create_response_401 import (
+    PostPublicContactCreateResponse401,
+)
+from ...models.post_public_contact_create_response_403 import (
+    PostPublicContactCreateResponse403,
+)
+from ...models.post_public_contact_create_response_500 import (
+    PostPublicContactCreateResponse500,
+)
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: PostPublicContactCreateBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/public/contact/create",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> (
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+    | None
+):
+    if response.status_code == 200:
+        response_200 = PostPublicContactCreateResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = PostPublicContactCreateResponse400.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = PostPublicContactCreateResponse401.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = PostPublicContactCreateResponse403.from_dict(response.json())
+
+        return response_403
+
+    if response.status_code == 500:
+        response_500 = PostPublicContactCreateResponse500.from_dict(response.json())
+
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: PostPublicContactCreateBody,
+) -> Response[
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+]:
+    """create
+
+     Create a contact inside the workspace.
+
+    Args:
+        body (PostPublicContactCreateBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PostPublicContactCreateResponse200 | PostPublicContactCreateResponse400 | PostPublicContactCreateResponse401 | PostPublicContactCreateResponse403 | PostPublicContactCreateResponse500]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: PostPublicContactCreateBody,
+) -> (
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+    | None
+):
+    """create
+
+     Create a contact inside the workspace.
+
+    Args:
+        body (PostPublicContactCreateBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PostPublicContactCreateResponse200 | PostPublicContactCreateResponse400 | PostPublicContactCreateResponse401 | PostPublicContactCreateResponse403 | PostPublicContactCreateResponse500
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: PostPublicContactCreateBody,
+) -> Response[
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+]:
+    """create
+
+     Create a contact inside the workspace.
+
+    Args:
+        body (PostPublicContactCreateBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PostPublicContactCreateResponse200 | PostPublicContactCreateResponse400 | PostPublicContactCreateResponse401 | PostPublicContactCreateResponse403 | PostPublicContactCreateResponse500]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: PostPublicContactCreateBody,
+) -> (
+    PostPublicContactCreateResponse200
+    | PostPublicContactCreateResponse400
+    | PostPublicContactCreateResponse401
+    | PostPublicContactCreateResponse403
+    | PostPublicContactCreateResponse500
+    | None
+):
+    """create
+
+     Create a contact inside the workspace.
+
+    Args:
+        body (PostPublicContactCreateBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PostPublicContactCreateResponse200 | PostPublicContactCreateResponse400 | PostPublicContactCreateResponse401 | PostPublicContactCreateResponse403 | PostPublicContactCreateResponse500
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed