mineai 0.1.0__py3-none-any.whl

mineai/__init__.py

@@ -0,0 +1,22 @@
+from .client import MineAI, AsyncMineAI
+from .models import Models
+from .errors import (
+    MineAIError,
+    AuthenticationError,
+    BadRequestError,
+    RateLimitError,
+    InternalServerError,
+    APIConnectionError
+)
+
+__all__ = [
+    "MineAI",
+    "AsyncMineAI",
+    "Models",
+    "MineAIError",
+    "AuthenticationError",
+    "BadRequestError",
+    "RateLimitError",
+    "InternalServerError",
+    "APIConnectionError",
+]

mineai/client.py

@@ -0,0 +1,98 @@
+import httpx
+from typing import Optional, Dict, Any
+from .errors import (
+    AuthenticationError,
+    BadRequestError,
+    RateLimitError,
+    InternalServerError,
+    APIConnectionError,
+    MineAIError
+)
+
+class BaseClient:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.mineai.dev",
+        timeout: float = 60.0,
+    ):
+        if not api_key:
+            raise AuthenticationError("API key is required")
+        
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _get_headers(self, memory: bool = False, memory_path: Optional[str] = None) -> Dict[str, str]:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        if memory:
+            headers["Memory"] = "true"
+        if memory_path:
+            headers["Memory-Path"] = memory_path
+        return headers
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        if response.is_success:
+            try:
+                return response.json()
+            except Exception:
+                return response.text
+
+        status_code = response.status_code
+        try:
+            error_data = response.json()
+            message = error_data.get("error", response.text)
+        except Exception:
+            message = response.text
+
+        if status_code == 401:
+            raise AuthenticationError(message, status_code, response)
+        elif status_code == 400:
+            raise BadRequestError(message, status_code, response)
+        elif status_code == 429:
+            raise RateLimitError(message, status_code, response)
+        elif status_code >= 500:
+            raise InternalServerError(message, status_code, response)
+        else:
+            raise MineAIError(message, status_code, response)
+
+class MineAI(BaseClient):
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.mineai.dev",
+        timeout: float = 60.0,
+    ):
+        super().__init__(api_key, base_url, timeout)
+        self.client = httpx.Client(base_url=self.base_url, timeout=self.timeout)
+        
+        # Resources
+        from .resources.chat.completions import Completions
+        self.chat = Chat(self)
+
+class Chat:
+    def __init__(self, client: MineAI):
+        from .resources.chat.completions import Completions
+        self.completions = Completions(client)
+
+class AsyncMineAI(BaseClient):
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.mineai.dev",
+        timeout: float = 60.0,
+    ):
+        super().__init__(api_key, base_url, timeout)
+        self.client = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout)
+        
+        # Resources
+        from .resources.chat.completions import AsyncCompletions
+        self.chat = AsyncChat(self)
+
+class AsyncChat:
+    def __init__(self, client: AsyncMineAI):
+        from .resources.chat.completions import AsyncCompletions
+        self.completions = AsyncCompletions(client)

mineai/errors.py

@@ -0,0 +1,26 @@
+class MineAIError(Exception):
+    """Base class for all MineAI SDK errors."""
+    def __init__(self, message: str, status_code: int = None, response: any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+class AuthenticationError(MineAIError):
+    """Raised when the API key is invalid or missing."""
+    pass
+
+class BadRequestError(MineAIError):
+    """Raised when the request is invalid."""
+    pass
+
+class RateLimitError(MineAIError):
+    """Raised when the rate limit is exceeded."""
+    pass
+
+class InternalServerError(MineAIError):
+    """Raised when the server encounters an error."""
+    pass
+
+class APIConnectionError(MineAIError):
+    """Raised when there is a problem connecting to the API."""
+    pass

mineai/models.py

@@ -0,0 +1,6 @@
+class Models:
+    """Constants for supported MineAI models."""
+    
+    R3_RT_Y = "mine:r3-rt-y"
+    R3_RT_Z = "mine:r3-rt-z"
+    O1_FREE = "mine:o1-free"

mineai/resources/chat/completions.py

@@ -0,0 +1,116 @@
+import json
+from typing import List, Dict, Any, Optional, Union, Iterator, AsyncIterator
+import httpx
+from ...errors import APIConnectionError
+
+class Completions:
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        stream: bool = False,
+        memory: bool = False,
+        memory_path: Optional[str] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], Iterator[Dict[str, Any]]]:
+        """
+        Create a chat completion.
+        
+        Args:
+            model: The ID of the model to use.
+            messages: A list of messages comprising the conversation.
+            stream: If True, partial message deltas will be sent as SSE.
+            memory: If True, enables conversation memory.
+            memory_path: Optional path for file-based memory.
+            **kwargs: Additional parameters to pass to the API.
+        """
+        url = "/v1/chat/completions"
+        headers = self._client._get_headers(memory=memory, memory_path=memory_path)
+        data = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs
+        }
+
+        if stream:
+            return self._stream_request(url, headers, data)
+        
+        try:
+            response = self._client.client.post(url, headers=headers, json=data)
+            return self._client._handle_response(response)
+        except httpx.RequestError as e:
+            raise APIConnectionError(f"Error connecting to API: {str(e)}")
+
+    def _stream_request(self, url: str, headers: Dict[str, str], data: Dict[str, Any]) -> Iterator[Dict[str, Any]]:
+        try:
+            with self._client.client.stream("POST", url, headers=headers, json=data) as response:
+                if not response.is_success:
+                    self._client._handle_response(response)
+                
+                for line in response.iter_lines():
+                    if line.startswith("data: "):
+                        content = line[6:].strip()
+                        if content == "[DONE]":
+                            break
+                        try:
+                            yield json.loads(content)
+                        except json.JSONDecodeError:
+                            continue
+        except httpx.RequestError as e:
+            raise APIConnectionError(f"Error connecting to API: {str(e)}")
+
+class AsyncCompletions:
+    def __init__(self, client):
+        self._client = client
+
+    async def create(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        stream: bool = False,
+        memory: bool = False,
+        memory_path: Optional[str] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], AsyncIterator[Dict[str, Any]]]:
+        """
+        Create a chat completion asynchronously.
+        """
+        url = "/v1/chat/completions"
+        headers = self._client._get_headers(memory=memory, memory_path=memory_path)
+        data = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs
+        }
+
+        if stream:
+            return self._stream_request(url, headers, data)
+        
+        try:
+            response = await self._client.client.post(url, headers=headers, json=data)
+            return self._client._handle_response(response)
+        except httpx.RequestError as e:
+            raise APIConnectionError(f"Error connecting to API: {str(e)}")
+
+    async def _stream_request(self, url: str, headers: Dict[str, str], data: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]:
+        try:
+            async with self._client.client.stream("POST", url, headers=headers, json=data) as response:
+                if not response.is_success:
+                    self._client._handle_response(response)
+                
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        content = line[6:].strip()
+                        if content == "[DONE]":
+                            break
+                        try:
+                            yield json.loads(content)
+                        except json.JSONDecodeError:
+                            continue
+        except httpx.RequestError as e:
+            raise APIConnectionError(f"Error connecting to API: {str(e)}")

mineai-0.1.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: mineai
+Version: 0.1.0
+Summary: The official Python SDK for MineAI
+Author-email: MineAI Team <support@getmineai.site>
+Project-URL: Homepage, https://studio.getmineai.site
+Project-URL: Bug Tracker, https://github.com/OfficalMinecore/mineai-sdk-python/issues
+Project-URL: Repository, https://github.com/OfficalMinecore/mineai-sdk-python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.20.0
+
+# MineAI Python SDK
+
+The official Python SDK from [MineAI-Studio](https://studio.getmineai.site).
+
+Powered by [http://getmineai.site/](http://getmineai.site/)
+
+- [Github](https://github.com/OfficalMinecore/mineai-sdk)
+- [Discord Server](https://discord.gg/fbfdwpHctb) – Join the server for Support.
+
+### Integrations:
+
+- Go To [MineAI-Studio](https://studio.getmineai.site/) 
+
+## Installation
+
+```bash
+pip install mineai
+```
+
+## Quick Start
+
+### Sync Client
+
+```python
+from mineai import MineAI, Models
+
+client = MineAI(api_key="YOUR_API_KEY")
+
+response = client.chat.completions.create(
+    model=Models.R3_RT_Y,
+    messages=[
+        {"role": "user", "content": "Hello MineAI!"}
+    ]
+)
+
+print(response['choices'][0]['message']['content'])
+```
+
+### Async Client
+
+```python
+import asyncio
+from mineai import AsyncMineAI, Models
+
+async def main():
+    client = AsyncMineAI(api_key="YOUR_API_KEY")
+    
+    response = await client.chat.completions.create(
+        model=Models.R3_RT_Z,
+        messages=[
+            {"role": "user", "content": "Tell me a joke."}
+        ]
+    )
+    print(response['choices'][0]['message']['content'])
+
+asyncio.run(main())
+```
+
+### Streaming
+
+```python
+from mineai import MineAI, Models
+
+client = MineAI(api_key="YOUR_API_KEY")
+
+stream = client.chat.completions.create(
+    model=Models.O1_FREE,
+    messages=[
+        {"role": "user", "content": "Write a long story."}
+    ],
+    stream=True
+)
+
+for chunk in stream:
+    if 'choices' in chunk:
+        content = chunk['choices'][0].get('delta', {}).get('content', '')
+        print(content, end='', flush=True)
+```
+
+### Memory Support
+
+```python
+from mineai import MineAI, Models
+
+client = MineAI(api_key="YOUR_API_KEY")
+
+# Enable database-backed memory
+response = client.chat.completions.create(
+    model=Models.R3_RT_Y,
+    messages=[
+        {"role": "user", "content": "My name is John."}
+    ],
+    memory=True
+)
+```
+
+## Error Handling
+
+The SDK provides custom exception classes for different API error scenarios:
+
+```python
+from mineai import MineAI, AuthenticationError, RateLimitError
+
+try:
+    client = MineAI(api_key="INVALID_KEY")
+    client.chat.completions.create(...)
+except AuthenticationError:
+    print("Invalid API key provided.")
+except RateLimitError:
+    print("Rate limit exceeded.")
+```
+
+## Supported Models
+
+- `Models.R3_RT_Y` (`mine:r3-rt-y`)
+- `Models.R3_RT_Z` (`mine:r3-rt-z`)
+- `Models.O1_FREE` (`mine:o1-free`)

mineai-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+mineai/__init__.py,sha256=og9p8irF5zMOyhte8xQLPgQ3EegRKmfRgY7w46mh1Og,428
+mineai/client.py,sha256=kSpOw_ZyIYxAWS7Wa-EjLvRTIo5vlUnOxYYyXQTc5h4,3086
+mineai/errors.py,sha256=jVqSkAqdxNtGBOsSerBV9aoNZeiM1dL-m4ficKjoxIA,780
+mineai/models.py,sha256=DNo7r46t-nVqjDYmzuQp5MIz8XqID8UBLanIlHJ3P3g,155
+mineai/resources/chat/completions.py,sha256=5JCYWT7GrtB1MPhYkleEs8n82-r_foMWzc-FEozgbjU,4397
+mineai-0.1.0.dist-info/METADATA,sha256=MNRetIN_yujHyXDdOmHFndBSUQB4Q6Xfalf5GfVSpwE,3028
+mineai-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mineai-0.1.0.dist-info/top_level.txt,sha256=TCTINwTbVDu8CrOXaosKbf9l92X2vTRTbbfB0r-tVBw,7
+mineai-0.1.0.dist-info/RECORD,,

mineai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mineai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mineai