sigmashake 0.1.1__py3-none-any.whl

sigmashake/__init__.py

@@ -0,0 +1,25 @@
+"""SigmaShake Python SDK -- agent-first, async-native, type-safe."""
+
+from ._version import __version__
+from .client import SigmaShake
+from .exceptions import (
+    AuthenticationError,
+    AuthorizationError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    SigmaShakeError,
+    ValidationError,
+)
+
+__all__ = [
+    "__version__",
+    "SigmaShake",
+    "SigmaShakeError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "NotFoundError",
+    "ValidationError",
+    "RateLimitError",
+    "ServerError",
+]

sigmashake/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

sigmashake/accounts.py

@@ -0,0 +1,91 @@
+"""Account management operations."""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional, TYPE_CHECKING
+
+from .models import (
+    Account,
+    AddSeatBody,
+    Seat,
+    Subscription,
+    TenantUsage,
+    Tier,
+    UpdateSubscriptionBody,
+)
+
+if TYPE_CHECKING:
+    from .client import _HTTPTransport
+
+
+class AccountsResource:
+    """Account CRUD and subscription management."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    # -- accounts -------------------------------------------------------------
+
+    def create(self, name: str, tier: str = "free") -> Account:
+        body = {"name": name, "tier": tier}
+        data = self._t.request("POST", "/v1/accounts", json=body)
+        return Account.model_validate(data)
+
+    async def async_create(self, name: str, tier: str = "free") -> Account:
+        body = {"name": name, "tier": tier}
+        data = await self._t.async_request("POST", "/v1/accounts", json=body)
+        return Account.model_validate(data)
+
+    def get(self, account_id: str) -> Account:
+        data = self._t.request("GET", f"/v1/accounts/{account_id}")
+        return Account.model_validate(data)
+
+    async def async_get(self, account_id: str) -> Account:
+        data = await self._t.async_request("GET", f"/v1/accounts/{account_id}")
+        return Account.model_validate(data)
+
+    def get_usage(self, account_id: str) -> TenantUsage:
+        data = self._t.request("GET", f"/v1/accounts/{account_id}/usage")
+        return TenantUsage.model_validate(data)
+
+    async def async_get_usage(self, account_id: str) -> TenantUsage:
+        data = await self._t.async_request("GET", f"/v1/accounts/{account_id}/usage")
+        return TenantUsage.model_validate(data)
+
+    # -- subscriptions --------------------------------------------------------
+
+    def get_subscription(self, account_id: str) -> Subscription:
+        data = self._t.request("GET", f"/v1/accounts/{account_id}/subscription")
+        return Subscription.model_validate(data)
+
+    async def async_get_subscription(self, account_id: str) -> Subscription:
+        data = await self._t.async_request("GET", f"/v1/accounts/{account_id}/subscription")
+        return Subscription.model_validate(data)
+
+    def update_subscription(self, account_id: str, **kwargs: Any) -> Subscription:
+        data = self._t.request("PATCH", f"/v1/accounts/{account_id}/subscription", json=kwargs)
+        return Subscription.model_validate(data)
+
+    async def async_update_subscription(self, account_id: str, **kwargs: Any) -> Subscription:
+        data = await self._t.async_request("PATCH", f"/v1/accounts/{account_id}/subscription", json=kwargs)
+        return Subscription.model_validate(data)
+
+    # -- seats ----------------------------------------------------------------
+
+    def add_seat(self, account_id: str, user_email: str, role: str = "member") -> Seat:
+        body = {"user_email": user_email, "role": role}
+        data = self._t.request("POST", f"/v1/accounts/{account_id}/seats", json=body)
+        return Seat.model_validate(data)
+
+    async def async_add_seat(self, account_id: str, user_email: str, role: str = "member") -> Seat:
+        body = {"user_email": user_email, "role": role}
+        data = await self._t.async_request("POST", f"/v1/accounts/{account_id}/seats", json=body)
+        return Seat.model_validate(data)
+
+    def list_seats(self, account_id: str) -> List[Seat]:
+        data = self._t.request("GET", f"/v1/accounts/{account_id}/seats")
+        return [Seat.model_validate(s) for s in data.get("seats", data if isinstance(data, list) else [])]
+
+    async def async_list_seats(self, account_id: str) -> List[Seat]:
+        data = await self._t.async_request("GET", f"/v1/accounts/{account_id}/seats")
+        return [Seat.model_validate(s) for s in data.get("seats", data if isinstance(data, list) else [])]

sigmashake/agents.py

@@ -0,0 +1,47 @@
+"""Agent lifecycle operations."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import _HTTPTransport
+
+
+class AgentsResource:
+    """Agent registration and management."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    def register(
+        self,
+        agent_id: str,
+        agent_type: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        body = {"agent_id": agent_id, "agent_type": agent_type, "metadata": metadata or {}}
+        return self._t.request("POST", "/v1/agents", json=body)
+
+    async def async_register(
+        self,
+        agent_id: str,
+        agent_type: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        body = {"agent_id": agent_id, "agent_type": agent_type, "metadata": metadata or {}}
+        return await self._t.async_request("POST", "/v1/agents", json=body)
+
+    def get(self, agent_id: str) -> Dict[str, Any]:
+        return self._t.request("GET", f"/v1/agents/{agent_id}")
+
+    async def async_get(self, agent_id: str) -> Dict[str, Any]:
+        return await self._t.async_request("GET", f"/v1/agents/{agent_id}")
+
+    def list(self, limit: int = 100, offset: int = 0) -> List[Dict[str, Any]]:
+        data = self._t.request("GET", "/v1/agents", params={"limit": limit, "offset": offset})
+        return data.get("agents", []) if isinstance(data, dict) else data
+
+    async def async_list(self, limit: int = 100, offset: int = 0) -> List[Dict[str, Any]]:
+        data = await self._t.async_request("GET", "/v1/agents", params={"limit": limit, "offset": offset})
+        return data.get("agents", []) if isinstance(data, dict) else data

sigmashake/auth.py

@@ -0,0 +1,57 @@
+"""Auth and Identity token management."""
+
+from __future__ import annotations
+
+from typing import Any, List, TYPE_CHECKING
+
+from .models import (
+    IdentityTokenResponse,
+    TokenResponse,
+)
+
+if TYPE_CHECKING:
+    from .client import _HTTPTransport
+
+
+class AuthResource:
+    """Token creation and validation."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    def create_token(self, agent_id: str, scopes: List[str] | None = None) -> TokenResponse:
+        body = {"agent_id": agent_id, "scopes": scopes or []}
+        data = self._t.request("POST", "/v1/auth/token", json=body)
+        return TokenResponse.model_validate(data)
+
+    async def async_create_token(self, agent_id: str, scopes: List[str] | None = None) -> TokenResponse:
+        body = {"agent_id": agent_id, "scopes": scopes or []}
+        data = await self._t.async_request("POST", "/v1/auth/token", json=body)
+        return TokenResponse.model_validate(data)
+
+
+class IdentityResource:
+    """Agent identity issuance."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    def issue(
+        self,
+        agent_id: str,
+        capabilities: List[str] | None = None,
+        ttl_secs: int = 3600,
+    ) -> IdentityTokenResponse:
+        body = {"agent_id": agent_id, "capabilities": capabilities or [], "ttl_secs": ttl_secs}
+        data = self._t.request("POST", "/v1/identity/issue", json=body)
+        return IdentityTokenResponse.model_validate(data)
+
+    async def async_issue(
+        self,
+        agent_id: str,
+        capabilities: List[str] | None = None,
+        ttl_secs: int = 3600,
+    ) -> IdentityTokenResponse:
+        body = {"agent_id": agent_id, "capabilities": capabilities or [], "ttl_secs": ttl_secs}
+        data = await self._t.async_request("POST", "/v1/identity/issue", json=body)
+        return IdentityTokenResponse.model_validate(data)

sigmashake/client.py

@@ -0,0 +1,217 @@
+"""Main SigmaShake client -- sync and async HTTP transport."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .auth import AuthResource, IdentityResource
+from .accounts import AccountsResource
+from .agents import AgentsResource
+from .db import DBResource
+from .exceptions import raise_for_status
+from .fleet import FleetResource
+from .gateway import GatewayResource
+from .memory import MemoryResource
+from .shield import ShieldResource
+from .soc import SOCResource
+
+
+_DEFAULT_BASE_URL = "https://api.sigmashake.com"
+_DEFAULT_TIMEOUT = 30.0
+
+
+class _HTTPTransport:
+    """Thin wrapper around httpx providing sync and async request methods."""
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str,
+        timeout: float,
+        async_mode: bool,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._async_mode = async_mode
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "sigmashake-python/0.1.0",
+        }
+        if async_mode:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers=headers,
+                timeout=timeout,
+            )
+            self._sync_client = None
+        else:
+            self._sync_client = httpx.Client(
+                base_url=self._base_url,
+                headers=headers,
+                timeout=timeout,
+            )
+            self._async_client = None
+
+    # -- sync -----------------------------------------------------------------
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        assert self._sync_client is not None, "Use async_request in async_mode"
+        resp = self._sync_client.request(method, path, json=json, params=params)
+        body = resp.json() if resp.content else {}
+        raise_for_status(resp.status_code, body)
+        return body
+
+    # -- async ----------------------------------------------------------------
+
+    async def async_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        assert self._async_client is not None, "Use request in sync mode"
+        resp = await self._async_client.request(method, path, json=json, params=params)
+        body = resp.json() if resp.content else {}
+        raise_for_status(resp.status_code, body)
+        return body
+
+    # -- lifecycle ------------------------------------------------------------
+
+    def close(self) -> None:
+        if self._sync_client is not None:
+            self._sync_client.close()
+
+    async def aclose(self) -> None:
+        if self._async_client is not None:
+            await self._async_client.aclose()
+
+
+class SigmaShake:
+    """Top-level SigmaShake client.
+
+    Usage (sync)::
+
+        client = SigmaShake(api_key="sk-...")
+        token = client.auth.create_token(agent_id="a1", scopes=["read"])
+
+    Usage (async)::
+
+        async with SigmaShake(api_key="sk-...", async_mode=True) as client:
+            token = await client.auth.create_token(agent_id="a1", scopes=["read"])
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: float = _DEFAULT_TIMEOUT,
+        async_mode: bool = False,
+    ) -> None:
+        self._transport = _HTTPTransport(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            async_mode=async_mode,
+        )
+        self._async_mode = async_mode
+
+        # Resource namespaces
+        self.auth = AuthResource(self._transport)
+        self.identity = IdentityResource(self._transport)
+        self.accounts = AccountsResource(self._transport)
+        self.agents = AgentsResource(self._transport)
+        self.shield = ShieldResource(self._transport)
+        self.documents = AgentsResource(self._transport)  # alias kept for back-compat
+        self.soc = SOCResource(self._transport)
+        self.gateway = GatewayResource(self._transport)
+        self.db = DBResource(self._transport)
+        self.memory = MemoryResource(self._transport)
+        self.fleet = FleetResource(self._transport)
+        # documents uses its own resource
+        self.documents = _DocumentsResource(self._transport)
+
+    # -- context managers -----------------------------------------------------
+
+    def __enter__(self) -> "SigmaShake":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+    async def __aenter__(self) -> "SigmaShake":
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        await self.aclose()
+
+    def close(self) -> None:
+        self._transport.close()
+
+    async def aclose(self) -> None:
+        await self._transport.aclose()
+
+
+class _DocumentsResource:
+    """Document mutation and search operations."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    def create(
+        self,
+        resource: str,
+        action: str,
+        payload: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        from .models import MutationResponse
+        body = {"resource": resource, "action": action, "payload": payload or {}}
+        data = self._t.request("POST", "/v1/documents", json=body)
+        return MutationResponse.model_validate(data)
+
+    async def async_create(
+        self,
+        resource: str,
+        action: str,
+        payload: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        from .models import MutationResponse
+        body = {"resource": resource, "action": action, "payload": payload or {}}
+        data = await self._t.async_request("POST", "/v1/documents", json=body)
+        return MutationResponse.model_validate(data)
+
+    def search(
+        self,
+        query: str,
+        limit: int = 10,
+        offset: int = 0,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        from .models import SearchResponse
+        body = {"query": query, "limit": limit, "offset": offset, "filters": filters or {}}
+        data = self._t.request("POST", "/v1/documents/search", json=body)
+        return SearchResponse.model_validate(data)
+
+    async def async_search(
+        self,
+        query: str,
+        limit: int = 10,
+        offset: int = 0,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        from .models import SearchResponse
+        body = {"query": query, "limit": limit, "offset": offset, "filters": filters or {}}
+        data = await self._t.async_request("POST", "/v1/documents/search", json=body)
+        return SearchResponse.model_validate(data)

sigmashake/db.py

@@ -0,0 +1,213 @@
+"""Database operations."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+from .models import (
+    ClusterStatusResponse,
+    QueryResponse,
+    ScrollQueryResponse,
+)
+
+if TYPE_CHECKING:
+    from .client import _HTTPTransport
+
+
+class DBResource:
+    """SigmaShake database operations."""
+
+    def __init__(self, transport: _HTTPTransport) -> None:
+        self._t = transport
+
+    # -- tables ---------------------------------------------------------------
+
+    def create_table(
+        self,
+        table_name: str,
+        columns: List[Dict[str, str]],
+    ) -> Dict[str, Any]:
+        body = {"table_name": table_name, "columns": columns}
+        return self._t.request("POST", "/v1/db/tables", json=body)
+
+    async def async_create_table(
+        self,
+        table_name: str,
+        columns: List[Dict[str, str]],
+    ) -> Dict[str, Any]:
+        body = {"table_name": table_name, "columns": columns}
+        return await self._t.async_request("POST", "/v1/db/tables", json=body)
+
+    # -- insert ---------------------------------------------------------------
+
+    def insert(
+        self,
+        table_name: str,
+        columns: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        body = {"table_name": table_name, "columns": columns}
+        return self._t.request("POST", "/v1/db/insert", json=body)
+
+    async def async_insert(
+        self,
+        table_name: str,
+        columns: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        body = {"table_name": table_name, "columns": columns}
+        return await self._t.async_request("POST", "/v1/db/insert", json=body)
+
+    # -- query ----------------------------------------------------------------
+
+    def query(
+        self,
+        table_name: str,
+        filters: Optional[List[Dict[str, Any]]] = None,
+        columns: Optional[List[str]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> QueryResponse:
+        body: Dict[str, Any] = {"table_name": table_name}
+        if filters:
+            body["filters"] = filters
+        if columns:
+            body["columns"] = columns
+        if limit is not None:
+            body["limit"] = limit
+        if offset is not None:
+            body["offset"] = offset
+        data = self._t.request("POST", "/v1/db/query", json=body)
+        return QueryResponse.model_validate(data)
+
+    async def async_query(
+        self,
+        table_name: str,
+        filters: Optional[List[Dict[str, Any]]] = None,
+        columns: Optional[List[str]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> QueryResponse:
+        body: Dict[str, Any] = {"table_name": table_name}
+        if filters:
+            body["filters"] = filters
+        if columns:
+            body["columns"] = columns
+        if limit is not None:
+            body["limit"] = limit
+        if offset is not None:
+            body["offset"] = offset
+        data = await self._t.async_request("POST", "/v1/db/query", json=body)
+        return QueryResponse.model_validate(data)
+
+    # -- vector search --------------------------------------------------------
+
+    def vector_search(
+        self,
+        table_name: str,
+        column: str,
+        vector: List[float],
+        top_k: int = 10,
+        filters: Optional[List[Dict[str, Any]]] = None,
+    ) -> QueryResponse:
+        body: Dict[str, Any] = {
+            "table_name": table_name,
+            "column": column,
+            "vector": vector,
+            "top_k": top_k,
+        }
+        if filters:
+            body["filters"] = filters
+        data = self._t.request("POST", "/v1/db/vector-search", json=body)
+        return QueryResponse.model_validate(data)
+
+    async def async_vector_search(
+        self,
+        table_name: str,
+        column: str,
+        vector: List[float],
+        top_k: int = 10,
+        filters: Optional[List[Dict[str, Any]]] = None,
+    ) -> QueryResponse:
+        body: Dict[str, Any] = {
+            "table_name": table_name,
+            "column": column,
+            "vector": vector,
+            "top_k": top_k,
+        }
+        if filters:
+            body["filters"] = filters
+        data = await self._t.async_request("POST", "/v1/db/vector-search", json=body)
+        return QueryResponse.model_validate(data)
+
+    # -- scroll ---------------------------------------------------------------
+
+    def scroll(
+        self,
+        table_name: str,
+        batch_size: int = 100,
+        cursor: Optional[str] = None,
+        filters: Optional[List[Dict[str, Any]]] = None,
+    ) -> ScrollQueryResponse:
+        body: Dict[str, Any] = {"table_name": table_name, "batch_size": batch_size}
+        if cursor:
+            body["cursor"] = cursor
+        if filters:
+            body["filters"] = filters
+        data = self._t.request("POST", "/v1/db/scroll", json=body)
+        return ScrollQueryResponse.model_validate(data)
+
+    async def async_scroll(
+        self,
+        table_name: str,
+        batch_size: int = 100,
+        cursor: Optional[str] = None,
+        filters: Optional[List[Dict[str, Any]]] = None,
+    ) -> ScrollQueryResponse:
+        body: Dict[str, Any] = {"table_name": table_name, "batch_size": batch_size}
+        if cursor:
+            body["cursor"] = cursor
+        if filters:
+            body["filters"] = filters
+        data = await self._t.async_request("POST", "/v1/db/scroll", json=body)
+        return ScrollQueryResponse.model_validate(data)
+
+    # -- cluster --------------------------------------------------------------
+
+    def init_cluster(
+        self,
+        cluster_name: str,
+        node_count: int = 1,
+        replication_factor: int = 1,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> ClusterStatusResponse:
+        body = {
+            "cluster_name": cluster_name,
+            "node_count": node_count,
+            "replication_factor": replication_factor,
+            "config": config or {},
+        }
+        data = self._t.request("POST", "/v1/db/cluster/init", json=body)
+        return ClusterStatusResponse.model_validate(data)
+
+    async def async_init_cluster(
+        self,
+        cluster_name: str,
+        node_count: int = 1,
+        replication_factor: int = 1,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> ClusterStatusResponse:
+        body = {
+            "cluster_name": cluster_name,
+            "node_count": node_count,
+            "replication_factor": replication_factor,
+            "config": config or {},
+        }
+        data = await self._t.async_request("POST", "/v1/db/cluster/init", json=body)
+        return ClusterStatusResponse.model_validate(data)
+
+    def cluster_status(self, cluster_name: str) -> ClusterStatusResponse:
+        data = self._t.request("GET", f"/v1/db/cluster/{cluster_name}/status")
+        return ClusterStatusResponse.model_validate(data)
+
+    async def async_cluster_status(self, cluster_name: str) -> ClusterStatusResponse:
+        data = await self._t.async_request("GET", f"/v1/db/cluster/{cluster_name}/status")
+        return ClusterStatusResponse.model_validate(data)