mira-network 0.1.3__tar.gz → 0.1.5__tar.gz

mira_network-0.1.5/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.1
+Name: mira-network
+Version: 0.1.5
+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:  # base_url defaults to https://apis.mira.network/
+    # 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:  # base_url defaults to https://apis.mira.network/
+        # Example 1: Non-streaming response
+        request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Hello!")
+            ],
+            model="gpt-4o",
+            model_provider=None,
+            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",
+    base_url="https://apis.mira.network/"  # Optional, this is the default
+) as client:
+    # Your sync code here
+
+# Asynchronous
+async with MiraClient(
+    api_token="your-api-token",
+    base_url="https://apis.mira.network/"  # Optional, this is the default
+) 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.5/README.md

@@ -0,0 +1,172 @@
+# 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:  # base_url defaults to https://apis.mira.network/
+    # 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:  # base_url defaults to https://apis.mira.network/
+        # Example 1: Non-streaming response
+        request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Hello!")
+            ],
+            model="gpt-4o",
+            model_provider=None,
+            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",
+    base_url="https://apis.mira.network/"  # Optional, this is the default
+) as client:
+    # Your sync code here
+
+# Asynchronous
+async with MiraClient(
+    api_token="your-api-token",
+    base_url="https://apis.mira.network/"  # Optional, this is the default
+) 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.3 → mira_network-0.1.5}/pyproject.toml

@@ -13,7 +13,7 @@ description = "Python SDK for Mira Network API"
 name = "mira-network"
 readme = "README.md"
 requires-python = "==3.10.*"
-version = "0.1.3"
+version = "0.1.5"
 
 [project.license]
 text = "MIT"

{mira_network-0.1.3/src/mira_sdk → mira_network-0.1.5/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.3/src/mira_sdk → mira_network-0.1.5/src/mira_network}/client.py

@@ -1,13 +1,8 @@
 from typing import AsyncIterator, Optional, List, Dict, AsyncGenerator, Union
 import httpx
 from .models import (
-    Message,
-    ModelProvider,
     AiRequest,
-    FlowChatCompletion,
-    FlowRequest,
     ApiTokenRequest,
-    AddCreditRequest,
 )
 
 
@@ -15,7 +10,7 @@ class MiraClient:
 
     def __init__(
         self,
-        base_url: str = "https://mira-network.alts.dev/",
+        base_url: str = "https://apis.mira.network",
         api_token: Optional[str] = None,
     ):
         """Initialize Mira client.
@@ -64,63 +59,63 @@ class MiraClient:
         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 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."""
@@ -135,7 +130,7 @@ class MiraClient:
     async def list_api_tokens(self) -> List[Dict]:
         """List all API tokens."""
         response = await self._client.get(
-            f"{self.base_url}/tokens",
+            f"{self.base_url}/api-tokens",
             headers=self._get_headers(),
         )
         response.raise_for_status()
@@ -144,7 +139,7 @@ class MiraClient:
     async def delete_api_token(self, token: str) -> None:
         """Delete an API token."""
         response = await self._client.delete(
-            f"{self.base_url}/tokens/{token}",
+            f"{self.base_url}/api-tokens/{token}",
             headers=self._get_headers(),
         )
         response.raise_for_status()
@@ -158,20 +153,20 @@ class MiraClient:
         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 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}/credits/history",
+            f"{self.base_url}/user-credits-history",
             headers=self._get_headers(),
         )
         response.raise_for_status()

{mira_network-0.1.3/src/mira_sdk → mira_network-0.1.5/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

mira_network-0.1.5/src/mira_network/sync_client.py

@@ -0,0 +1,111 @@
+from typing import Optional, List, Dict, Iterator, Union
+import requests
+from .models import (
+    AiRequest,
+    ApiTokenRequest,
+)
+
+
+class MiraSyncClient:
+    def __init__(
+        self,
+        base_url: str = "https://apis.mira.network",
+        api_token: Optional[str] = None,
+    ):
+        """Initialize Mira synchronous 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._session = requests.Session()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._session.close()
+
+    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
+
+    def list_models(self) -> List[str]:
+        """List available models."""
+        response = self._session.get(
+            f"{self.base_url}/v1/models",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def generate(self, request: AiRequest) -> Union[str, Iterator[str]]:
+        """Generate text using the specified model.
+
+        Args:
+            request: The AI request configuration
+
+        Returns:
+            Either a string response (when stream=False) or an iterator of string chunks (when stream=True)
+        """
+        response = self._session.post(
+            f"{self.base_url}/v1/chat/completions",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+            stream=request.stream,
+        )
+        response.raise_for_status()
+
+        if request.stream:
+            return response.iter_lines(decode_unicode=True)
+        else:
+            return response.json()
+
+    def create_api_token(self, request: ApiTokenRequest) -> Dict:
+        """Create a new API token."""
+        response = self._session.post(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def list_api_tokens(self) -> List[Dict]:
+        """List all API tokens."""
+        response = self._session.get(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def delete_api_token(self, token: str) -> None:
+        """Delete an API token."""
+        response = self._session.delete(
+            f"{self.base_url}/api-tokens/{token}",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+
+    def get_user_credits(self) -> Dict:
+        """Get user credits information."""
+        response = self._session.get(
+            f"{self.base_url}/user-credits",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_credits_history(self) -> List[Dict]:
+        """Get user credits history."""
+        response = self._session.get(
+            f"{self.base_url}/user-credits-history",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()

{mira_network-0.1.3 → mira_network-0.1.5}/tests/test_client.py

@@ -1,12 +1,10 @@
 import pytest
 import httpx
-from src.mira_sdk.client import MiraClient
-from src.mira_sdk.models import (
+from src.mira_network.client import MiraClient
+from src.mira_network.models import (
     Message,
     AiRequest,
-    FlowRequest,
     ApiTokenRequest,
-    AddCreditRequest,
 )
 
 
@@ -32,7 +30,7 @@ async def test_list_models(client):
 @pytest.mark.asyncio
 async def test_generate(client):
     request = AiRequest(
-        model="mira/llama3.1",
+        model="gpt-4o",
         messages=[Message(role="user", content="Hi Who are you!")],
         stream=False,
         model_provider=None,
@@ -70,17 +68,17 @@ async def test_list_flows(client):
     assert isinstance(result, list)
 
 
-@pytest.mark.asyncio
-async def test_create_and_delete_flow(client):
-    # Create flow
-    request = FlowRequest(system_prompt="You are a helpful assistant", name="test_flow")
+# @pytest.mark.asyncio
+# async def test_create_and_delete_flow(client):
+#     # Create flow
+#     request = FlowRequest(system_prompt="You are a helpful assistant", name="test_flow")
 
-    flow = await client.create_flow(request)
-    assert flow.get("name") == "test_flow"
+#     flow = await client.create_flow(request)
+#     assert flow.get("name") == "test_flow"
 
-    # Delete the created flow
-    flow_id = flow.get("id")
-    await client.delete_flow(flow_id)
+#     # Delete the created flow
+#     flow_id = flow.get("id")
+#     await client.delete_flow(flow_id)
 
 
 @pytest.mark.asyncio
@@ -109,7 +107,7 @@ async def test_error_handling(client):
         await client.generate(request)
 
 
-@pytest.mark.asyncio
-async def test_client_context_manager():
-    async with MiraClient("https://mira-client-balancer.alts.dev") as client:
-        assert isinstance(client._client, httpx.AsyncClient)
+# @pytest.mark.asyncio
+# async def test_client_context_manager():
+#     async with MiraClient("https://mira-client-balancer.alts.dev") as client:
+#         assert isinstance(client._client, httpx.AsyncClient)

mira_network-0.1.5/tests/test_sync_client.py

@@ -0,0 +1,100 @@
+import pytest
+import requests
+from src.mira_network.sync_client import MiraSyncClient
+from src.mira_network.models import (
+    Message,
+    AiRequest,
+    ApiTokenRequest,
+)
+
+
+@pytest.fixture
+def client():
+    return MiraSyncClient(
+        base_url="https://mira-network.alts.dev",
+        api_token="sk-mira-b9ecd5f43ef0363e691322df3295c2b98bebd1c1edb0b6d8",
+    )
+
+
+def test_list_models(client):
+    result = client.list_models()
+    assert isinstance(result, dict)
+    assert result["object"] == "list"
+    assert isinstance(result["data"], list)
+    assert len(result["data"]) > 0
+    assert all(isinstance(model, dict) for model in result["data"])
+    assert all("id" in model and "object" in model for model in result["data"])
+
+
+def test_generate(client):
+    request = AiRequest(
+        model="gpt-4o",
+        messages=[Message(role="user", content="Hi Who are you!")],
+        stream=False,
+        model_provider=None,
+    )
+
+    result = client.generate(request)
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+def test_generate_stream(client):
+    request = AiRequest(
+        model="gpt-4o",
+        messages=[Message(role="user", content="Hi!")],
+        stream=True,
+        model_provider=None,
+    )
+    print("Making generate request with streaming...")
+    response = client.generate(request=request)
+    chunks = []
+    print("Starting to receive stream chunks...")
+    for chunk in response:
+        print(f"Received chunk: {chunk}")
+        assert isinstance(chunk, str)
+        assert len(chunk) > 0
+        chunks.append(chunk)
+    print(f"Received {len(chunks)} total chunks")
+    assert len(chunks) > 0
+
+
+def test_create_api_token(client):
+    request = ApiTokenRequest(description="Test token")
+    result = client.create_api_token(request)
+    assert "token" in result
+
+
+def test_get_user_credits(client):
+    result = client.get_user_credits()
+    assert "amount" in result
+
+
+def test_error_handling(client):
+    with pytest.raises(requests.HTTPError):
+        # Test with invalid model name to trigger error
+        request = AiRequest(
+            model="invalid_model",
+            messages=[Message(role="user", content="Hi!")],
+            stream=False,
+            model_provider=None,
+        )
+        client.generate(request)
+
+
+def test_client_context_manager():
+    with MiraSyncClient("https://mira-network.alts.dev") as client:
+        assert isinstance(client._session, requests.Session)
+        # Make a test request to ensure session works
+        result = client.list_models()
+        assert isinstance(result, dict)
+
+
+def test_list_api_tokens(client):
+    tokens = client.list_api_tokens()
+    assert isinstance(tokens, list)
+
+
+def test_get_credits_history(client):
+    history = client.get_credits_history()
+    assert isinstance(history, list)

mira_network-0.1.3/PKG-INFO

@@ -1,108 +0,0 @@
-Metadata-Version: 2.1
-Name: mira-network
-Version: 0.1.3
-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 a simple interface to access all Mira API endpoints including model inference, flow management, and credit system.
-
-## Installation
-
-```bash
-pip install mira-network
-```
-
-## Quick Start
-
-```python
-import asyncio
-from mira_sdk import MiraClient, Message, AiRequest
-
-async def main():
-    # Initialize client
-    client = MiraClient(
-        base_url="https://api.mira.example.com",
-        api_token="your-api-token"
-    )
-    
-    # List available models
-    models = await client.list_models()
-    print("Available models:", models)
-    
-    # Generate text
-    request = AiRequest(
-        model="gpt-4o",
-        messages=[
-            Message(role="system", content="You are a helpful assistant."),
-            Message(role="user", content="Hello!")
-        ],
-        model_provider=None
-    )
-    
-    response = await client.generate(request)
-    print("Response:", response)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Features
-
-- Asynchronous API using `httpx`
-- Full type hints support
-- Pydantic models for request/response validation
-- Support for all Mira API endpoints:
-  - Model inference
-  - Flow management
-  - API token management
-  - Credit system
-
-## API Reference
-
-### Models
-
-- `Message`: Represents a chat message
-- `ModelProvider`: Configuration for custom model providers
-- `AiRequest`: Request for model inference
-- `FlowChatCompletion`: Request for flow-based chat completion
-- `FlowRequest`: Request for creating/updating flows
-- `ApiTokenRequest`: Request for creating API tokens
-- `AddCreditRequest`: Request for adding credits
-
-### Client Methods
-
-#### Model Operations
-- `list_models()`: List available models
-- `generate(request: AiRequest)`: Generate text using specified model
-
-#### Flow Operations
-- `list_flows()`: List all flows
-- `get_flow(flow_id: str)`: Get flow details
-- `create_flow(request: FlowRequest)`: Create new flow
-- `update_flow(flow_id: str, request: FlowRequest)`: Update flow
-- `delete_flow(flow_id: str)`: Delete flow
-- `generate_with_flow(flow_id: str, request: FlowChatCompletion)`: Generate using flow
-
-#### Token Operations
-- `create_api_token(request: ApiTokenRequest)`: Create API token
-- `list_api_tokens()`: List API tokens
-- `delete_api_token(token: str)`: Delete API token
-
-#### Credit Operations
-- `get_user_credits()`: Get credit information
-- `add_credit(request: AddCreditRequest)`: Add credits
-- `get_credits_history()`: Get credit history
-
-## License
-
-MIT License

mira_network-0.1.3/README.md

@@ -1,94 +0,0 @@
-# Mira Network SDK
-
-A Python SDK for interacting with the Mira Network API. This SDK provides a simple interface to access all Mira API endpoints including model inference, flow management, and credit system.
-
-## Installation
-
-```bash
-pip install mira-network
-```
-
-## Quick Start
-
-```python
-import asyncio
-from mira_sdk import MiraClient, Message, AiRequest
-
-async def main():
-    # Initialize client
-    client = MiraClient(
-        base_url="https://api.mira.example.com",
-        api_token="your-api-token"
-    )
-    
-    # List available models
-    models = await client.list_models()
-    print("Available models:", models)
-    
-    # Generate text
-    request = AiRequest(
-        model="gpt-4o",
-        messages=[
-            Message(role="system", content="You are a helpful assistant."),
-            Message(role="user", content="Hello!")
-        ],
-        model_provider=None
-    )
-    
-    response = await client.generate(request)
-    print("Response:", response)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Features
-
-- Asynchronous API using `httpx`
-- Full type hints support
-- Pydantic models for request/response validation
-- Support for all Mira API endpoints:
-  - Model inference
-  - Flow management
-  - API token management
-  - Credit system
-
-## API Reference
-
-### Models
-
-- `Message`: Represents a chat message
-- `ModelProvider`: Configuration for custom model providers
-- `AiRequest`: Request for model inference
-- `FlowChatCompletion`: Request for flow-based chat completion
-- `FlowRequest`: Request for creating/updating flows
-- `ApiTokenRequest`: Request for creating API tokens
-- `AddCreditRequest`: Request for adding credits
-
-### Client Methods
-
-#### Model Operations
-- `list_models()`: List available models
-- `generate(request: AiRequest)`: Generate text using specified model
-
-#### Flow Operations
-- `list_flows()`: List all flows
-- `get_flow(flow_id: str)`: Get flow details
-- `create_flow(request: FlowRequest)`: Create new flow
-- `update_flow(flow_id: str, request: FlowRequest)`: Update flow
-- `delete_flow(flow_id: str)`: Delete flow
-- `generate_with_flow(flow_id: str, request: FlowChatCompletion)`: Generate using flow
-
-#### Token Operations
-- `create_api_token(request: ApiTokenRequest)`: Create API token
-- `list_api_tokens()`: List API tokens
-- `delete_api_token(token: str)`: Delete API token
-
-#### Credit Operations
-- `get_user_credits()`: Get credit information
-- `add_credit(request: AddCreditRequest)`: Add credits
-- `get_credits_history()`: Get credit history
-
-## License
-
-MIT License