mira-network 0.1.0__tar.gz → 0.1.1__tar.gz

mira_network-0.1.1/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.1
+Name: mira-network
+Version: 0.1.1
+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
+Description-Content-Type: text/markdown
+
+# Mira 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-sdk
+```
+
+## 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="mira/llama3.1",
+        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.1/README.md

@@ -0,0 +1,94 @@
+# Mira 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-sdk
+```
+
+## 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="mira/llama3.1",
+        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.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "mira-network"
+version = "0.1.1"
+description = "Python SDK for Mira Network API"
+authors = [
+    { name = "sarim2000", email = "sarimbleedblue@gmail.com" },
+]
+dependencies = [
+    "httpx>=0.28.1",
+    "pydantic>=2.10.4",
+    "typing-extensions>=4.8.0",
+    "requests>=2.32.3",
+]
+requires-python = "==3.10.*"
+readme = "README.md"
+
+[project.license]
+text = "MIT"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[dependency-groups]
+test = [
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.25.0",
+    "pytest-cov>=6.0.0",
+]

mira_network-0.1.1/src/mira_sdk/__init__.py

@@ -0,0 +1,21 @@
+from .client import MiraClient
+from .models import (
+    Message,
+    ModelProvider,
+    AiRequest,
+    FlowChatCompletion,
+    FlowRequest,
+    ApiTokenRequest,
+    AddCreditRequest,
+)
+
+__all__ = [
+    "MiraClient",
+    "Message",
+    "ModelProvider",
+    "AiRequest",
+    "FlowChatCompletion",
+    "FlowRequest",
+    "ApiTokenRequest",
+    "AddCreditRequest",
+]

mira_network-0.1.1/src/mira_sdk/client.py

@@ -0,0 +1,180 @@
+from typing import Optional, List, Dict, AsyncGenerator, Union
+import httpx
+from src.mira_sdk.models import (
+    Message,
+    ModelProvider,
+    AiRequest,
+    FlowChatCompletion,
+    FlowRequest,
+    ApiTokenRequest,
+    AddCreditRequest,
+)
+
+
+class MiraClient:
+    def __init__(self, base_url: str, 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, AsyncGenerator[str, None]]:
+        """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:
+
+            async def stream_response():
+                async for chunk in response.aiter_text():
+                    yield chunk
+
+            return stream_response()
+        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}/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}/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}/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}/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}/credits/history",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()

mira_network-0.1.1/src/mira_sdk/models.py

@@ -0,0 +1,67 @@
+from typing import Optional, List, Dict
+from pydantic import BaseModel, Field, field_validator
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+    @field_validator("role")
+    @classmethod
+    def validate_role(cls, v: str) -> str:
+        valid_roles = ["system", "user", "assistant"]
+        if v not in valid_roles:
+            raise ValueError(f"Invalid role. Must be one of: {valid_roles}")
+        return v
+
+
+class ModelProvider(BaseModel):
+    base_url: str
+    api_key: str
+
+
+class AiRequest(BaseModel):
+    model: str = Field("mira/llama3.1", title="Model")
+    model_provider: Optional[ModelProvider] = Field(None, title="Model Provider (optional)")
+    messages: List[Message] = Field([], title="Messages")
+    stream: Optional[bool] = Field(False, title="Stream")
+
+    @field_validator("messages")
+    @classmethod
+    def validate_messages(cls, v: List[Message]) -> List[Message]:
+        if not v:
+            raise ValueError("Messages list cannot be empty")
+        return v
+
+
+class FlowChatCompletion(BaseModel):
+    variables: Optional[Dict] = Field(None, title="Variables")
+
+
+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

mira_network-0.1.1/tests/test_client.py

@@ -0,0 +1,109 @@
+import pytest
+import httpx
+from src.mira_sdk.client import MiraClient
+from src.mira_sdk.models import (
+    Message,
+    AiRequest,
+    FlowRequest,
+    ApiTokenRequest,
+    AddCreditRequest,
+)
+
+
+@pytest.fixture
+def client():
+    return MiraClient(
+        base_url="https://mira-client-balancer.alts.dev",
+        api_token="sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc"
+    )
+
+
+@pytest.mark.asyncio
+async def test_list_models(client):
+    result = await client.list_models()
+    assert isinstance(result, list)
+    # assert len(result) > 0
+
+
+@pytest.mark.asyncio
+async def test_generate(client):
+    request = AiRequest(
+        model="mira/llama3.1",
+        messages=[Message(role="user", content="Hi Who are you!")],
+        stream=False,
+        model_provider=None
+    )
+    
+    result = await client.generate(request)
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+@pytest.mark.asyncio
+async def test_generate_stream(client):
+    request = AiRequest(
+        model="mira/llama3.1",
+        messages=[Message(role="user", content="Hi!")],
+        stream=True,
+        model_provider=None
+    )
+    
+    stream = await client.generate(request)
+    chunks = []
+    async for chunk in stream:
+        chunks.append(chunk)
+    assert len(chunks) > 0
+
+
+@pytest.mark.asyncio
+async def test_list_flows(client):
+    result = await client.list_flows()
+    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"
+    )
+    
+    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)
+
+
+@pytest.mark.asyncio
+async def test_create_api_token(client):
+    request = ApiTokenRequest(description="Test token")
+    result = await client.create_api_token(request)
+    assert "token" in result
+
+
+@pytest.mark.asyncio
+async def test_get_user_credits(client):
+    result = await client.get_user_credits()
+    assert "amount" in result
+
+
+@pytest.mark.asyncio
+async def test_error_handling(client):
+    with pytest.raises(httpx.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
+        )
+        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)

mira_network-0.1.1/tests/test_integration.py

@@ -0,0 +1,48 @@
+import pytest
+from src.mira_sdk.client import MiraClient
+from src.mira_sdk.models import Message, AiRequest, ModelProvider
+
+
+@pytest.mark.asyncio
+async def test_real_generate():
+    """This test makes a real API call to generate text."""
+    client = MiraClient(
+        base_url="https://mira-client-balancer.alts.dev",
+        api_token="sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc"
+    )
+
+    request = AiRequest(
+        model="mira/llama3.1",
+        messages=[Message(role="user", content="Hi Who are you!")],
+        stream=False,
+        model_provider=None
+    )
+
+    async with client:
+        result = await client.generate(request)
+        print("Real API Response:", result)
+        # assert len(result) > 0
+
+
+# @pytest.mark.asyncio
+# async def test_real_generate_stream():
+#     """This test makes a real API call with streaming enabled."""
+#     client = MiraClient(
+#         base_url="https://mira-client-balancer.alts.dev",
+#         api_token="sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc"
+#     )
+
+#     request = AiRequest(
+#         messages=[Message(role="user", content="Count from 1 to 5")],
+#         stream=True
+#     )
+
+#     async with client:
+#         stream = await client.generate(request)
+#         response = ""
+#         async for chunk in stream:
+#             print("Chunk:", chunk)
+#             response += chunk
+#         print("Final Response:", response)
+#         assert isinstance(response, str)
+#         assert len(response) > 0

mira_network-0.1.1/tests/test_models.py

@@ -0,0 +1,109 @@
+import pytest
+from src.mira_sdk.models import (
+    Message,
+    ModelProvider,
+    AiRequest,
+    FlowChatCompletion,
+    FlowRequest,
+    ApiTokenRequest,
+    AddCreditRequest,
+)
+
+
+def test_message_model():
+    message = Message(role="user", content="Hello!")
+    assert message.role == "user"
+    assert message.content == "Hello!"
+
+
+def test_model_provider():
+    provider = ModelProvider(base_url="https://mira-client-balancer.alts.dev", api_key="sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc")
+    assert provider.base_url == "https://mira-client-balancer.alts.dev"
+    assert provider.api_key == "sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc"
+
+
+def test_ai_request():
+    messages = [Message(role="user", content="Hello!")]
+    provider = ModelProvider(base_url="https://mira-client-balancer.alts.dev", api_key="sk-mira-8ac810228d32ff68fc93266fb9a0ba612724119ffab16dcc")
+    
+    # Test with default values
+    request = AiRequest(messages=messages)
+    assert request.model == "mira/llama3.1"
+    assert request.stream is False
+    assert request.model_provider is None
+    assert request.messages == messages
+    
+    # Test with custom values
+    request = AiRequest(
+        model="custom/model",
+        messages=messages,
+        model_provider=provider,
+        stream=True
+    )
+    assert request.model == "custom/model"
+    assert request.stream is True
+    assert request.model_provider == provider
+    assert request.messages == messages
+
+
+def test_flow_chat_completion():
+    # Test with no variables
+    completion = FlowChatCompletion()
+    assert completion.variables is None
+    
+    # Test with variables
+    variables = {"key": "value"}
+    completion = FlowChatCompletion(variables=variables)
+    assert completion.variables == variables
+
+
+def test_flow_request():
+    request = FlowRequest(
+        system_prompt="You are a helpful assistant",
+        name="test-flow"
+    )
+    assert request.system_prompt == "You are a helpful assistant"
+    assert request.name == "test-flow"
+
+
+def test_api_token_request():
+    # Test with no description
+    request = ApiTokenRequest()
+    assert request.description is None
+    
+    # Test with description
+    request = ApiTokenRequest(description="Test token")
+    assert request.description == "Test token"
+
+
+def test_add_credit_request():
+    # Test required fields
+    request = AddCreditRequest(user_id="user123", amount=100.0)
+    assert request.user_id == "user123"
+    assert request.amount == 100.0
+    assert request.description is None
+    
+    # Test with description
+    request = AddCreditRequest(
+        user_id="user123",
+        amount=100.0,
+        description="Test credit"
+    )
+    assert request.user_id == "user123"
+    assert request.amount == 100.0
+    assert request.description == "Test credit"
+
+
+def test_invalid_message():
+    with pytest.raises(ValueError):
+        Message(role="invalid", content="")  # Invalid role
+
+
+def test_invalid_ai_request():
+    with pytest.raises(ValueError):
+        AiRequest(messages=[])  # Empty messages list
+
+
+def test_invalid_add_credit_request():
+    with pytest.raises(ValueError):
+        AddCreditRequest(user_id="", amount=-100)  # Negative amount

mira_network-0.1.0/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.1
-Name: mira-network
-Version: 0.1.0
-Summary: Default template for PDM package
-Author-email: Hamid Raza <contact@hamidraza.com>
-License: MIT
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
-# mira-network

mira_network-0.1.0/README.md

@@ -1 +0,0 @@
-# mira-network

mira_network-0.1.0/pyproject.toml

@@ -1,19 +0,0 @@
-[project]
-name = "mira-network"
-version = "0.1.0"
-description = "Default template for PDM package"
-authors = [
-    {name = "Hamid Raza", email = "contact@hamidraza.com"},
-]
-dependencies = []
-requires-python = ">=3.11"
-readme = "README.md"
-license = {text = "MIT"}
-
-[build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"
-
-
-[tool.pdm]
-distribution = true

mira_network-0.1.0/setup.cfg

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

mira_network-0.1.0/src/mira_network/client.py

@@ -1,8 +0,0 @@
-class MiraNetwork:
-    def __init__(self, api_key: str) -> None:
-        self.api_key = api_key
-
-    def generate(self) -> dict:
-        # check if the api key is valid
-        if not self.api_key:
-            raise ValueError("API key is required")

mira_network-0.1.0/src/mira_network.egg-info/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.1
-Name: mira-network
-Version: 0.1.0
-Summary: Default template for PDM package
-Author-email: Hamid Raza <contact@hamidraza.com>
-License: MIT
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
-# mira-network

mira_network-0.1.0/src/mira_network.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-README.md
-pyproject.toml
-src/mira_network/__init__.py
-src/mira_network/client.py
-src/mira_network.egg-info/PKG-INFO
-src/mira_network.egg-info/SOURCES.txt
-src/mira_network.egg-info/dependency_links.txt
-src/mira_network.egg-info/top_level.txt
-tests/test_client.py

mira_network-0.1.0/src/mira_network.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

mira_network-0.1.0/src/mira_network.egg-info/top_level.txt

@@ -1 +0,0 @@
-mira_network

mira_network-0.1.0/tests/test_client.py

@@ -1,26 +0,0 @@
-import unittest
-from mira_network.client import MiraNetwork
-
-
-class TestMiraNetwork(unittest.TestCase):
-    def test_init(self):
-        api_key = "test_api_key"
-        client = MiraNetwork(api_key)
-        self.assertEqual(client.api_key, api_key)
-
-    def test_generate_with_valid_api_key(self):
-        api_key = "test_api_key"
-        client = MiraNetwork(api_key)
-        result = client.generate()
-        self.assertIsInstance(result, dict)
-
-    def test_generate_with_invalid_api_key(self):
-        client = MiraNetwork("")
-        with self.assertRaises(ValueError):
-            client.generate()
-
-
-if __name__ == "__main__":
-    unittest.main()
-
-# pypi-AgEIcHlwaS5vcmcCJGUzODI5NjhjLWQ4MTQtNDFhZi1iYjhlLTlmYWYyNDcyZjQ3ZgACKlszLCJjMzJhNWQ1NS1kYjYyLTRiYzEtOWZlMS0xNzEzNGIyZjVjNmQiXQAABiBQXeHWfLbWZOZA8Yw9XyZmDdyy_OonAp3XUeqCJTwBwA