mira-network 0.1.2__tar.gz → 0.1.4__tar.gz

mira_network-0.1.4/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.1
+Name: mira-network
+Version: 0.1.4
+Summary: Python SDK for Mira Network API
+Author-Email: sarim2000 <sarimbleedblue@gmail.com>
+License: MIT
+Requires-Python: ==3.10.*
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.10.4
+Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pytest-cov>=6.0.0
+Description-Content-Type: text/markdown
+
+# Mira Network SDK
+
+A Python SDK for interacting with the Mira Network API. This SDK provides both synchronous and asynchronous interfaces to access Mira API endpoints for model inference, API token management, and credit system operations.
+
+## Installation
+
+```bash
+pip install mira-network
+```
+
+## Quick Start
+
+### Synchronous Usage
+
+```python
+from mira_network.sync_client import MiraSyncClient
+from mira_network.models import AiRequest, Message
+
+# Using context manager (recommended)
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Example 1: Non-streaming response
+    request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Hello!")
+        ],
+        stream=False
+    )
+    response = client.generate(request)
+    print(response)
+    
+    # Example 2: Streaming response
+    stream_request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Tell me a story!")
+        ],
+        stream=True
+    )
+    for chunk in client.generate(stream_request):
+        print(chunk)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from mira_network.client import MiraClient
+from mira_network.models import AiRequest, Message
+
+async def main():
+    # Using async context manager (recommended)
+    async with MiraClient(api_token="your-api-token") as client:
+        # Example 1: Non-streaming response
+        request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Hello!")
+            ],
+            stream=False
+        )
+        response = await client.generate(request)
+        print(response)
+        
+        # Example 2: Streaming response
+        stream_request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Tell me a story!")
+            ],
+            stream=True
+        )
+        async for chunk in await client.generate(stream_request):
+            print(chunk)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## API Reference
+
+### Client Initialization
+
+The SDK provides two client classes:
+- `MiraSyncClient`: Synchronous client using `requests`
+- `MiraClient`: Asynchronous client using `httpx`
+
+Both clients support context managers for proper resource cleanup:
+
+```python
+# Synchronous
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Your sync code here
+
+# Asynchronous
+async with MiraClient(api_token="your-api-token") as client:
+    # Your async code here
+```
+
+### Models
+
+- `Message`: Represents a chat message
+  - `role`: String ("system", "user", or "assistant")
+  - `content`: String content of the message
+
+- `AiRequest`: Configuration for model inference
+  - `model`: Model identifier (default: "mira/llama3.1")
+  - `messages`: List of Message objects
+  - `stream`: Boolean to enable streaming responses (default: False)
+  - `model_provider`: Optional ModelProvider configuration
+
+- `ModelProvider`: Custom provider configuration
+  - `base_url`: Provider's base URL
+  - `api_key`: Provider's API key
+
+- `ApiTokenRequest`: Request for creating API tokens
+  - `description`: Optional description for the token
+
+### Available Methods
+
+Both sync and async clients provide the same methods with identical parameters. The only difference is that async methods must be awaited.
+
+#### Model Operations
+```python
+# Sync
+models = client.list_models()
+response = client.generate(AiRequest(messages=[...], stream=False))
+for chunk in client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+
+# Async
+models = await client.list_models()
+response = await client.generate(AiRequest(messages=[...], stream=False))
+async for chunk in await client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+```
+
+#### API Token Operations
+```python
+# Sync
+token = client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = client.list_api_tokens()
+client.delete_api_token("token-to-delete")
+
+# Async
+token = await client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = await client.list_api_tokens()
+await client.delete_api_token("token-to-delete")
+```
+
+#### Credit Operations
+```python
+# Sync
+credits = client.get_user_credits()
+history = client.get_credits_history()
+
+# Async
+credits = await client.get_user_credits()
+history = await client.get_credits_history()
+```
+
+## License
+
+MIT License

mira_network-0.1.4/README.md

@@ -0,0 +1,164 @@
+# Mira Network SDK
+
+A Python SDK for interacting with the Mira Network API. This SDK provides both synchronous and asynchronous interfaces to access Mira API endpoints for model inference, API token management, and credit system operations.
+
+## Installation
+
+```bash
+pip install mira-network
+```
+
+## Quick Start
+
+### Synchronous Usage
+
+```python
+from mira_network.sync_client import MiraSyncClient
+from mira_network.models import AiRequest, Message
+
+# Using context manager (recommended)
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Example 1: Non-streaming response
+    request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Hello!")
+        ],
+        stream=False
+    )
+    response = client.generate(request)
+    print(response)
+    
+    # Example 2: Streaming response
+    stream_request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Tell me a story!")
+        ],
+        stream=True
+    )
+    for chunk in client.generate(stream_request):
+        print(chunk)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from mira_network.client import MiraClient
+from mira_network.models import AiRequest, Message
+
+async def main():
+    # Using async context manager (recommended)
+    async with MiraClient(api_token="your-api-token") as client:
+        # Example 1: Non-streaming response
+        request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Hello!")
+            ],
+            stream=False
+        )
+        response = await client.generate(request)
+        print(response)
+        
+        # Example 2: Streaming response
+        stream_request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Tell me a story!")
+            ],
+            stream=True
+        )
+        async for chunk in await client.generate(stream_request):
+            print(chunk)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## API Reference
+
+### Client Initialization
+
+The SDK provides two client classes:
+- `MiraSyncClient`: Synchronous client using `requests`
+- `MiraClient`: Asynchronous client using `httpx`
+
+Both clients support context managers for proper resource cleanup:
+
+```python
+# Synchronous
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Your sync code here
+
+# Asynchronous
+async with MiraClient(api_token="your-api-token") as client:
+    # Your async code here
+```
+
+### Models
+
+- `Message`: Represents a chat message
+  - `role`: String ("system", "user", or "assistant")
+  - `content`: String content of the message
+
+- `AiRequest`: Configuration for model inference
+  - `model`: Model identifier (default: "mira/llama3.1")
+  - `messages`: List of Message objects
+  - `stream`: Boolean to enable streaming responses (default: False)
+  - `model_provider`: Optional ModelProvider configuration
+
+- `ModelProvider`: Custom provider configuration
+  - `base_url`: Provider's base URL
+  - `api_key`: Provider's API key
+
+- `ApiTokenRequest`: Request for creating API tokens
+  - `description`: Optional description for the token
+
+### Available Methods
+
+Both sync and async clients provide the same methods with identical parameters. The only difference is that async methods must be awaited.
+
+#### Model Operations
+```python
+# Sync
+models = client.list_models()
+response = client.generate(AiRequest(messages=[...], stream=False))
+for chunk in client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+
+# Async
+models = await client.list_models()
+response = await client.generate(AiRequest(messages=[...], stream=False))
+async for chunk in await client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+```
+
+#### API Token Operations
+```python
+# Sync
+token = client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = client.list_api_tokens()
+client.delete_api_token("token-to-delete")
+
+# Async
+token = await client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = await client.list_api_tokens()
+await client.delete_api_token("token-to-delete")
+```
+
+#### Credit Operations
+```python
+# Sync
+credits = client.get_user_credits()
+history = client.get_credits_history()
+
+# Async
+credits = await client.get_user_credits()
+history = await client.get_credits_history()
+```
+
+## License
+
+MIT License

{mira_network-0.1.2 → mira_network-0.1.4}/pyproject.toml

@@ -1,7 +1,4 @@
 [project]
-name = "mira-network"
-version = "0.1.2"
-description = "Python SDK for Mira Network API"
 authors = [
     { name = "sarim2000", email = "sarimbleedblue@gmail.com" },
 ]
@@ -10,18 +7,22 @@ dependencies = [
     "pydantic>=2.10.4",
     "typing-extensions>=4.8.0",
     "requests>=2.32.3",
+    "pytest-cov>=6.0.0",
 ]
-requires-python = "==3.10.*"
+description = "Python SDK for Mira Network API"
+name = "mira-network"
 readme = "README.md"
+requires-python = "==3.10.*"
+version = "0.1.4"
 
 [project.license]
 text = "MIT"
 
 [build-system]
+build-backend = "pdm.backend"
 requires = [
     "pdm-backend",
 ]
-build-backend = "pdm.backend"
 
 [tool.pdm]
 distribution = true

{mira_network-0.1.2/src/mira_sdk → mira_network-0.1.4/src/mira_network}/__init__.py

@@ -1,12 +1,10 @@
 from .client import MiraClient
+from .sync_client import MiraSyncClient
 from .models import (
     Message,
     ModelProvider,
     AiRequest,
-    FlowChatCompletion,
-    FlowRequest,
     ApiTokenRequest,
-    AddCreditRequest,
 )
 
 __all__ = [
@@ -14,8 +12,5 @@ __all__ = [
     "Message",
     "ModelProvider",
     "AiRequest",
-    "FlowChatCompletion",
-    "FlowRequest",
     "ApiTokenRequest",
-    "AddCreditRequest",
 ]

mira_network-0.1.4/src/mira_network/client.py

@@ -0,0 +1,173 @@
+from typing import AsyncIterator, Optional, List, Dict, AsyncGenerator, Union
+import httpx
+from .models import (
+    AiRequest,
+    ApiTokenRequest,
+)
+
+
+class MiraClient:
+
+    def __init__(
+        self,
+        base_url: str = "https://apis.mira.network/",
+        api_token: Optional[str] = None,
+    ):
+        """Initialize Mira client.
+
+        Args:
+            base_url: Base URL of the Mira API
+            api_token: Optional API token for authentication
+        """
+        self.base_url = base_url
+        self.api_token = api_token
+        self._client = httpx.AsyncClient()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._client.aclose()
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_token:
+            headers["Authorization"] = f"Bearer {self.api_token}"
+        return headers
+
+    async def list_models(self) -> List[str]:
+        """List available models."""
+        response = await self._client.get(
+            f"{self.base_url}/v1/models",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def generate(self, request: AiRequest) -> Union[str, AsyncIterator[str]]:
+        """Generate text using the specified model."""
+        response = await self._client.post(
+            f"{self.base_url}/v1/chat/completions",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+
+        response.raise_for_status()
+
+        if request.stream:
+            return response.aiter_lines()
+        else:
+            return response.json()
+
+    # async def generate_with_flow(
+    #     self, flow_id: str, request: FlowChatCompletion
+    # ) -> Union[str, AsyncGenerator[str, None]]:
+    #     """Generate text using a specific flow."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/v1/flows/{flow_id}/chat/completions",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def list_flows(self) -> List[Dict]:
+    #     """List all flows."""
+    #     response = await self._client.get(
+    #         f"{self.base_url}/flows",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def get_flow(self, flow_id: str) -> Dict:
+    #     """Get details of a specific flow."""
+    #     response = await self._client.get(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def create_flow(self, request: FlowRequest) -> Dict:
+    #     """Create a new flow."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/flows",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def update_flow(self, flow_id: str, request: FlowRequest) -> Dict:
+    #     """Update an existing flow."""
+    #     response = await self._client.put(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def delete_flow(self, flow_id: str) -> None:
+    #     """Delete a flow."""
+    #     response = await self._client.delete(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+
+    async def create_api_token(self, request: ApiTokenRequest) -> Dict:
+        """Create a new API token."""
+        response = await self._client.post(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def list_api_tokens(self) -> List[Dict]:
+        """List all API tokens."""
+        response = await self._client.get(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def delete_api_token(self, token: str) -> None:
+        """Delete an API token."""
+        response = await self._client.delete(
+            f"{self.base_url}/api-tokens/{token}",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+
+    async def get_user_credits(self) -> Dict:
+        """Get user credits information."""
+        response = await self._client.get(
+            f"{self.base_url}/user-credits",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    # async def add_credit(self, request: AddCreditRequest) -> Dict:
+    #     """Add credits to a user account."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/credits",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    async def get_credits_history(self) -> List[Dict]:
+        """Get user credits history."""
+        response = await self._client.get(
+            f"{self.base_url}/user-credits-history",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()

{mira_network-0.1.2/src/mira_sdk → mira_network-0.1.4/src/mira_network}/models.py

@@ -22,7 +22,9 @@ class ModelProvider(BaseModel):
 
 class AiRequest(BaseModel):
     model: str = Field("mira/llama3.1", title="Model")
-    model_provider: Optional[ModelProvider] = Field(None, title="Model Provider (optional)")
+    model_provider: Optional[ModelProvider] = Field(
+        None, title="Model Provider (optional)"
+    )
     messages: List[Message] = Field([], title="Messages")
     stream: Optional[bool] = Field(False, title="Stream")
 
@@ -34,34 +36,34 @@ class AiRequest(BaseModel):
         return v
 
 
-class FlowChatCompletion(BaseModel):
-    variables: Optional[Dict] = Field(None, title="Variables")
+# class FlowChatCompletion(BaseModel):
+#     variables: Optional[Dict] = Field(None, title="Variables")
 
 
-class FlowRequest(BaseModel):
-    system_prompt: str
-    name: str
+# class FlowRequest(BaseModel):
+#     system_prompt: str
+#     name: str
 
 
 class ApiTokenRequest(BaseModel):
     description: Optional[str] = None
 
 
-class AddCreditRequest(BaseModel):
-    user_id: str
-    amount: float
-    description: Optional[str] = None
-
-    @field_validator("amount")
-    @classmethod
-    def validate_amount(cls, v: float) -> float:
-        if v <= 0:
-            raise ValueError("Amount must be greater than 0")
-        return v
-
-    @field_validator("user_id")
-    @classmethod
-    def validate_user_id(cls, v: str) -> str:
-        if not v.strip():
-            raise ValueError("User ID cannot be empty")
-        return v
+# class AddCreditRequest(BaseModel):
+#     user_id: str
+#     amount: float
+#     description: Optional[str] = None
+
+#     @field_validator("amount")
+#     @classmethod
+#     def validate_amount(cls, v: float) -> float:
+#         if v <= 0:
+#             raise ValueError("Amount must be greater than 0")
+#         return v
+
+#     @field_validator("user_id")
+#     @classmethod
+#     def validate_user_id(cls, v: str) -> str:
+#         if not v.strip():
+#             raise ValueError("User ID cannot be empty")
+#         return v