statebase 0.1.0__tar.gz

statebase-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: statebase
+Version: 0.1.0
+Summary: The Reliability Layer for Production AI Agents
+Home-page: https://github.com/StateBase/statebase-python
+Author: StateBase Team
+Author-email: hello@statebase.org
+Project-URL: Bug Reports, https://github.com/StateBase/statebase-python/issues
+Project-URL: Source, https://github.com/StateBase/statebase-python
+Keywords: ai,agents,memory,state,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# StateBase SDKs
+
+This repository contains the official SDKs for StateBase API.
+
+## 📦 Python SDK
+
+### Installation
+```bash
+cd state-base-api-client
+pip install -e .
+```
+
+### Usage
+```python
+from state_base_api_client import Client
+from state_base_api_client.api.sessions import create_session_v1_sessions_post
+from state_base_api_client.models import SessionCreateRequest
+
+# Initialize client
+client = Client(base_url="https://api.statebase.org")
+client = client.with_headers({"X-API-Key": "your-api-key"})
+
+# Create a session
+request = SessionCreateRequest(
+    agent_id="my-agent",
+    initial_state={"user_name": "Alice"}
+)
+session = create_session_v1_sessions_post.sync(client=client, body=request)
+
+print(f"Created session: {session.id}")
+```
+
+**Features:**
+- ✅ Auto-generated from OpenAPI spec (always in sync)
+- ✅ Full type hints with Pydantic
+- ✅ Sync and async support
+- ✅ Complete API coverage
+
+## 📦 TypeScript SDK
+
+### Installation
+```bash
+cd ../statebase-ts-sdk
+npm install
+npm run build
+```
+
+### Usage
+```typescript
+import StateBase from './src/index';
+
+// Initialize client
+const client = new StateBase('your-api-key', 'http://api.statebase.org');
+
+// Create a session
+const session = await client.createSession({
+  agent_id: 'my-agent',
+  initial_state: { user_name: 'Alice' }
+});
+
+console.log(`Created session: ${session.id}`);
+```
+
+**Features:**
+- ✅ Auto-generated TypeScript types from OpenAPI
+- ✅ Clean, intuitive API
+- ✅ Full type safety
+- ✅ Promise-based async
+
+## 🔄 Regenerating SDKs
+
+When the API changes, regenerate the SDKs:
+
+### TypeScript Types
+```bash
+cd statebase-ts-sdk
+npx openapi-typescript ../statebase/openapi.json -o src/schema.ts
+```
+
+### Python Client
+```bash
+cd statebase-py-sdk
+python -m openapi_python_client generate --path ../statebase/openapi.json
+```
+
+## 📚 Documentation
+
+- API Docs: http://api.statebase.org/docs
+- Full Documentation: https://docs.statebase.org
+
+## License
+
+MIT

statebase-0.1.0/README.md

@@ -0,0 +1,93 @@
+# StateBase SDKs
+
+This repository contains the official SDKs for StateBase API.
+
+## 📦 Python SDK
+
+### Installation
+```bash
+cd state-base-api-client
+pip install -e .
+```
+
+### Usage
+```python
+from state_base_api_client import Client
+from state_base_api_client.api.sessions import create_session_v1_sessions_post
+from state_base_api_client.models import SessionCreateRequest
+
+# Initialize client
+client = Client(base_url="https://api.statebase.org")
+client = client.with_headers({"X-API-Key": "your-api-key"})
+
+# Create a session
+request = SessionCreateRequest(
+    agent_id="my-agent",
+    initial_state={"user_name": "Alice"}
+)
+session = create_session_v1_sessions_post.sync(client=client, body=request)
+
+print(f"Created session: {session.id}")
+```
+
+**Features:**
+- ✅ Auto-generated from OpenAPI spec (always in sync)
+- ✅ Full type hints with Pydantic
+- ✅ Sync and async support
+- ✅ Complete API coverage
+
+## 📦 TypeScript SDK
+
+### Installation
+```bash
+cd ../statebase-ts-sdk
+npm install
+npm run build
+```
+
+### Usage
+```typescript
+import StateBase from './src/index';
+
+// Initialize client
+const client = new StateBase('your-api-key', 'http://api.statebase.org');
+
+// Create a session
+const session = await client.createSession({
+  agent_id: 'my-agent',
+  initial_state: { user_name: 'Alice' }
+});
+
+console.log(`Created session: ${session.id}`);
+```
+
+**Features:**
+- ✅ Auto-generated TypeScript types from OpenAPI
+- ✅ Clean, intuitive API
+- ✅ Full type safety
+- ✅ Promise-based async
+
+## 🔄 Regenerating SDKs
+
+When the API changes, regenerate the SDKs:
+
+### TypeScript Types
+```bash
+cd statebase-ts-sdk
+npx openapi-typescript ../statebase/openapi.json -o src/schema.ts
+```
+
+### Python Client
+```bash
+cd statebase-py-sdk
+python -m openapi_python_client generate --path ../statebase/openapi.json
+```
+
+## 📚 Documentation
+
+- API Docs: http://api.statebase.org/docs
+- Full Documentation: https://docs.statebase.org
+
+## License
+
+MIT

statebase-0.1.0/setup.cfg

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

statebase-0.1.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+import pathlib
+
+# Read the README
+here = pathlib.Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="statebase",
+    version="0.1.0",
+    description="The Reliability Layer for Production AI Agents",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/StateBase/statebase-python",
+    author="StateBase Team",
+    author_email="hello@statebase.org",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    keywords="ai, agents, memory, state, llm",
+    packages=find_packages(exclude=["tests"]),
+    python_requires=">=3.9",
+    install_requires=[
+        "httpx>=0.24.0",
+        "pydantic>=2.0.0",
+        "typing-extensions>=4.0.0"
+    ],
+    project_urls={
+        "Bug Reports": "https://github.com/StateBase/statebase-python/issues",
+        "Source": "https://github.com/StateBase/statebase-python",
+    },
+)

statebase-0.1.0/statebase/__init__.py

@@ -0,0 +1,4 @@
+from .client import StateBase
+from .async_client import AsyncStateBase
+
+__all__ = ["StateBase", "AsyncStateBase"]

statebase-0.1.0/statebase/async_client.py

@@ -0,0 +1,187 @@
+"""
+StateBase Python SDK - Async Client
+"""
+import httpx
+from typing import Optional, Dict, Any, List
+from .models import (
+    SessionResponse,
+    TurnResponse,
+    MemoryResponse,
+)
+
+
+class AsyncStateBase:
+    """Asynchronous client for StateBase API"""
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.statebase.org",
+        timeout: float = 30.0
+    ):
+        """
+        Initialize async StateBase client.
+        
+        Args:
+            api_key: Your StateBase API key
+            base_url: Base URL for the API
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+        self.client = httpx.AsyncClient(
+            headers={
+                "X-API-Key": api_key,
+                "Content-Type": "application/json"
+            },
+            timeout=timeout
+        )
+    
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, *args):
+        await self.close()
+    
+    async def close(self):
+        """Close the HTTP client"""
+        await self.client.aclose()
+    
+    # Sessions
+    async def create_session(
+        self,
+        agent_id: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        initial_state: Optional[Dict[str, Any]] = None,
+        ttl_seconds: Optional[int] = None
+    ) -> SessionResponse:
+        """Create a new session"""
+        response = await self.client.post(
+            f"{self.base_url}/v1/sessions",
+            json={
+                "agent_id": agent_id,
+                "metadata": metadata,
+                "initial_state": initial_state,
+                "ttl_seconds": ttl_seconds
+            }
+        )
+        response.raise_for_status()
+        return SessionResponse(**response.json())
+    
+    async def get_session(self, session_id: str) -> SessionResponse:
+        """Get session by ID"""
+        response = await self.client.get(f"{self.base_url}/v1/sessions/{session_id}")
+        response.raise_for_status()
+        return SessionResponse(**response.json())
+    
+    async def delete_session(self, session_id: str) -> None:
+        """Delete a session"""
+        response = await self.client.delete(f"{self.base_url}/v1/sessions/{session_id}")
+        response.raise_for_status()
+    
+    # Turns
+    async def create_turn(
+        self,
+        session_id: str,
+        input_content: str,
+        output_content: str,
+        input_type: str = "text",
+        output_type: str = "text",
+        metadata: Optional[Dict[str, Any]] = None,
+        reasoning: Optional[str] = None
+    ) -> TurnResponse:
+        """Create a new turn in a session"""
+        response = await self.client.post(
+            f"{self.base_url}/v1/sessions/{session_id}/turns",
+            json={
+                "input": {"type": input_type, "content": input_content},
+                "output": {"type": output_type, "content": output_content},
+                "metadata": metadata,
+                "reasoning": reasoning
+            }
+        )
+        response.raise_for_status()
+        return TurnResponse(**response.json())
+    
+    # State
+    async def get_state(self, session_id: str) -> Dict[str, Any]:
+        """Get current state of a session"""
+        response = await self.client.get(f"{self.base_url}/v1/sessions/{session_id}/state")
+        response.raise_for_status()
+        return response.json()
+    
+    async def update_state(
+        self,
+        session_id: str,
+        updates: Dict[str, Any],
+        reasoning: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Partially update session state"""
+        response = await self.client.patch(
+            f"{self.base_url}/v1/sessions/{session_id}/state",
+            json={"updates": updates, "reasoning": reasoning}
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    async def replace_state(
+        self,
+        session_id: str,
+        state: Dict[str, Any],
+        reasoning: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Replace entire session state"""
+        response = await self.client.put(
+            f"{self.base_url}/v1/sessions/{session_id}/state",
+            json={"state": state, "reasoning": reasoning}
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    # Memories
+    async def create_memory(
+        self,
+        content: str,
+        memory_type: str = "fact",
+        session_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> MemoryResponse:
+        """Create a new memory"""
+        response = await self.client.post(
+            f"{self.base_url}/v1/memories",
+            json={
+                "content": content,
+                "memory_type": memory_type,
+                "session_id": session_id,
+                "tags": tags,
+                "metadata": metadata
+            }
+        )
+        response.raise_for_status()
+        return MemoryResponse(**response.json())
+    
+    async def search_memories(
+        self,
+        query: str,
+        session_id: Optional[str] = None,
+        memory_type: Optional[str] = None,
+        limit: int = 10
+    ) -> List[MemoryResponse]:
+        """Search memories by semantic similarity"""
+        params = {"query": query, "limit": limit}
+        if session_id:
+            params["session_id"] = session_id
+        if memory_type:
+            params["type"] = memory_type
+        
+        response = await self.client.get(f"{self.base_url}/v1/memories/search", params=params)
+        response.raise_for_status()
+        return [MemoryResponse(**m) for m in response.json().get("data", [])]
+    
+    # Health
+    async def health(self) -> Dict[str, Any]:
+        """Check API health"""
+        response = await self.client.get(f"{self.base_url}/health")
+        response.raise_for_status()
+        return response.json()

statebase-0.1.0/statebase/client.py

@@ -0,0 +1,191 @@
+"""
+StateBase Python SDK - Synchronous Client
+"""
+import httpx
+from typing import Optional, Dict, Any, List
+from .models import (
+    SessionCreateRequest,
+    SessionResponse,
+    TurnCreateRequest,
+    TurnResponse,
+    MemoryCreateRequest,
+    MemoryResponse,
+    StateUpdateRequest,
+)
+
+
+class StateBase:
+    """Synchronous client for StateBase API"""
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.statebase.org",
+        timeout: float = 30.0
+    ):
+        """
+        Initialize StateBase client.
+        
+        Args:
+            api_key: Your StateBase API key
+            base_url: Base URL for the API (default: production)
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+        self.client = httpx.Client(
+            headers={
+                "X-API-Key": api_key,
+                "Content-Type": "application/json"
+            },
+            timeout=timeout
+        )
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, *args):
+        self.close()
+    
+    def close(self):
+        """Close the HTTP client"""
+        self.client.close()
+    
+    # Sessions
+    def create_session(
+        self,
+        agent_id: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        initial_state: Optional[Dict[str, Any]] = None,
+        ttl_seconds: Optional[int] = None
+    ) -> SessionResponse:
+        """Create a new session"""
+        response = self.client.post(
+            f"{self.base_url}/v1/sessions",
+            json={
+                "agent_id": agent_id,
+                "metadata": metadata,
+                "initial_state": initial_state,
+                "ttl_seconds": ttl_seconds
+            }
+        )
+        response.raise_for_status()
+        return SessionResponse(**response.json())
+    
+    def get_session(self, session_id: str) -> SessionResponse:
+        """Get session by ID"""
+        response = self.client.get(f"{self.base_url}/v1/sessions/{session_id}")
+        response.raise_for_status()
+        return SessionResponse(**response.json())
+    
+    def delete_session(self, session_id: str) -> None:
+        """Delete a session"""
+        response = self.client.delete(f"{self.base_url}/v1/sessions/{session_id}")
+        response.raise_for_status()
+    
+    # Turns
+    def create_turn(
+        self,
+        session_id: str,
+        input_content: str,
+        output_content: str,
+        input_type: str = "text",
+        output_type: str = "text",
+        metadata: Optional[Dict[str, Any]] = None,
+        reasoning: Optional[str] = None
+    ) -> TurnResponse:
+        """Create a new turn in a session"""
+        response = self.client.post(
+            f"{self.base_url}/v1/sessions/{session_id}/turns",
+            json={
+                "input": {"type": input_type, "content": input_content},
+                "output": {"type": output_type, "content": output_content},
+                "metadata": metadata,
+                "reasoning": reasoning
+            }
+        )
+        response.raise_for_status()
+        return TurnResponse(**response.json())
+    
+    # State
+    def get_state(self, session_id: str) -> Dict[str, Any]:
+        """Get current state of a session"""
+        response = self.client.get(f"{self.base_url}/v1/sessions/{session_id}/state")
+        response.raise_for_status()
+        return response.json()
+    
+    def update_state(
+        self,
+        session_id: str,
+        updates: Dict[str, Any],
+        reasoning: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Partially update session state"""
+        response = self.client.patch(
+            f"{self.base_url}/v1/sessions/{session_id}/state",
+            json={"state": updates, "reasoning": reasoning}
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def replace_state(
+        self,
+        session_id: str,
+        state: Dict[str, Any],
+        reasoning: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Replace entire session state"""
+        response = self.client.put(
+            f"{self.base_url}/v1/sessions/{session_id}/state",
+            json={"state": state, "reasoning": reasoning}
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    # Memories
+    def create_memory(
+        self,
+        content: str,
+        memory_type: str = "fact",
+        session_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> MemoryResponse:
+        """Create a new memory"""
+        response = self.client.post(
+            f"{self.base_url}/v1/memories",
+            json={
+                "content": content,
+                "type": memory_type,
+                "session_id": session_id,
+                "tags": tags,
+                "metadata": metadata
+            }
+        )
+        response.raise_for_status()
+        return MemoryResponse(**response.json())
+    
+    def search_memories(
+        self,
+        query: str,
+        session_id: Optional[str] = None,
+        memory_type: Optional[str] = None,
+        limit: int = 10
+    ) -> List[MemoryResponse]:
+        """Search memories by semantic similarity"""
+        params = {"query": query, "limit": limit}
+        if session_id:
+            params["session_id"] = session_id
+        if memory_type:
+            params["types"] = memory_type
+        
+        response = self.client.get(f"{self.base_url}/v1/memories/search", params=params)
+        response.raise_for_status()
+        return [MemoryResponse(**m) for m in response.json().get("data", [])]
+    
+    # Health
+    def health(self) -> Dict[str, Any]:
+        """Check API health"""
+        response = self.client.get(f"{self.base_url}/health")
+        response.raise_for_status()
+        return response.json()

statebase-0.1.0/statebase/models.py

@@ -0,0 +1,86 @@
+"""
+StateBase SDK Models
+"""
+from typing import Optional, Dict, Any, List
+from pydantic import BaseModel, Field
+
+
+class SessionCreateRequest(BaseModel):
+    agent_id: str
+    metadata: Optional[Dict[str, Any]] = None
+    initial_state: Optional[Dict[str, Any]] = None
+    ttl_seconds: Optional[int] = None
+
+
+class SessionResponse(BaseModel):
+    object: str = "session"
+    id: str
+    agent_id: str
+    created_at: str
+    updated_at: str
+    metadata: Optional[Dict[str, Any]] = None
+    state: Dict[str, Any]
+    memory_count: int
+    turn_count: int
+    ttl_expires_at: Optional[str] = None
+
+
+class TurnInput(BaseModel):
+    type: str
+    content: str
+
+
+class TurnOutput(BaseModel):
+    type: str
+    content: str
+
+
+class TurnCreateRequest(BaseModel):
+    input: TurnInput
+    output: TurnOutput
+    metadata: Optional[Dict[str, Any]] = None
+    reasoning: Optional[str] = None
+
+
+class TurnResponse(BaseModel):
+    object: str = "turn"
+    id: str
+    session_id: str
+    turn_number: int
+    input: TurnInput
+    output: TurnOutput
+    metadata: Optional[Dict[str, Any]] = None
+    reasoning: Optional[str] = None
+    state_before: Dict[str, Any]
+    state_after: Dict[str, Any]
+    created_at: str
+
+
+class MemoryCreateRequest(BaseModel):
+    content: str
+    memory_type: str = "fact"
+    session_id: Optional[str] = None
+    tags: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class MemoryResponse(BaseModel):
+    object: str = "memory"
+    id: str
+    content: str
+    memory_type: str
+    session_id: Optional[str] = None
+    tags: List[str] = []
+    metadata: Optional[Dict[str, Any]] = None
+    created_at: str
+    updated_at: str
+
+
+class StateUpdateRequest(BaseModel):
+    updates: Dict[str, Any]
+    reasoning: Optional[str] = None
+
+
+class StateReplaceRequest(BaseModel):
+    state: Dict[str, Any]
+    reasoning: Optional[str] = None

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

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: statebase
+Version: 0.1.0
+Summary: The Reliability Layer for Production AI Agents
+Home-page: https://github.com/StateBase/statebase-python
+Author: StateBase Team
+Author-email: hello@statebase.org
+Project-URL: Bug Reports, https://github.com/StateBase/statebase-python/issues
+Project-URL: Source, https://github.com/StateBase/statebase-python
+Keywords: ai,agents,memory,state,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# StateBase SDKs
+
+This repository contains the official SDKs for StateBase API.
+
+## 📦 Python SDK
+
+### Installation
+```bash
+cd state-base-api-client
+pip install -e .
+```
+
+### Usage
+```python
+from state_base_api_client import Client
+from state_base_api_client.api.sessions import create_session_v1_sessions_post
+from state_base_api_client.models import SessionCreateRequest
+
+# Initialize client
+client = Client(base_url="https://api.statebase.org")
+client = client.with_headers({"X-API-Key": "your-api-key"})
+
+# Create a session
+request = SessionCreateRequest(
+    agent_id="my-agent",
+    initial_state={"user_name": "Alice"}
+)
+session = create_session_v1_sessions_post.sync(client=client, body=request)
+
+print(f"Created session: {session.id}")
+```
+
+**Features:**
+- ✅ Auto-generated from OpenAPI spec (always in sync)
+- ✅ Full type hints with Pydantic
+- ✅ Sync and async support
+- ✅ Complete API coverage
+
+## 📦 TypeScript SDK
+
+### Installation
+```bash
+cd ../statebase-ts-sdk
+npm install
+npm run build
+```
+
+### Usage
+```typescript
+import StateBase from './src/index';
+
+// Initialize client
+const client = new StateBase('your-api-key', 'http://api.statebase.org');
+
+// Create a session
+const session = await client.createSession({
+  agent_id: 'my-agent',
+  initial_state: { user_name: 'Alice' }
+});
+
+console.log(`Created session: ${session.id}`);
+```
+
+**Features:**
+- ✅ Auto-generated TypeScript types from OpenAPI
+- ✅ Clean, intuitive API
+- ✅ Full type safety
+- ✅ Promise-based async
+
+## 🔄 Regenerating SDKs
+
+When the API changes, regenerate the SDKs:
+
+### TypeScript Types
+```bash
+cd statebase-ts-sdk
+npx openapi-typescript ../statebase/openapi.json -o src/schema.ts
+```
+
+### Python Client
+```bash
+cd statebase-py-sdk
+python -m openapi_python_client generate --path ../statebase/openapi.json
+```
+
+## 📚 Documentation
+
+- API Docs: http://api.statebase.org/docs
+- Full Documentation: https://docs.statebase.org
+
+## License
+
+MIT

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

@@ -0,0 +1,11 @@
+README.md
+setup.py
+statebase/__init__.py
+statebase/async_client.py
+statebase/client.py
+statebase/models.py
+statebase.egg-info/PKG-INFO
+statebase.egg-info/SOURCES.txt
+statebase.egg-info/dependency_links.txt
+statebase.egg-info/requires.txt
+statebase.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

statebase-0.1.0/statebase.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx>=0.24.0
+pydantic>=2.0.0
+typing-extensions>=4.0.0

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

@@ -0,0 +1 @@
+statebase