meshapi 0.1.0__py3-none-any.whl

meshapi/__init__.py

@@ -0,0 +1,251 @@
+"""MeshAPI Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._errors import MeshAPIError
+from ._http import AsyncHttpClient, MeshAPIConfig, SyncHttpClient
+from ._types import (
+    ApiErrorBody,
+    ApiErrorEnvelope,
+    ChatCompletionChunk,
+    ChatCompletionChunkChoice,
+    ChatCompletionChunkDelta,
+    ChatCompletionChoice,
+    ChatCompletionMessage,
+    ChatCompletionParams,
+    ChatCompletionResponse,
+    ChatMessage,
+    ChatRole,
+    CompareParams,
+    CompareResponse,
+    CompareStreamEvent,
+    ContentPart,
+    ContentPartAudio,
+    ContentPartImage,
+    ContentPartText,
+    CreateBatchParams,
+    CreateTemplateParams,
+    EmbeddingItem,
+    EmbeddingsParams,
+    EmbeddingsResponse,
+    EmbeddingsUsage,
+    FileObject,
+    ImageDetail,
+    ImageOptions,
+    InputAudio,
+    ListModelsParams,
+    ModelOverride,
+    ModelInfo,
+    ModelPricing,
+    BatchListResponse,
+    BatchObject,
+    BatchRequestItem,
+    ProviderPreferences,
+    ResponsesFunctionTool,
+    ResponsesParams,
+    ResponsesResponse,
+    ResponsesStreamEvent,
+    ResponsesUsage,
+    TemplateSummary,
+    TokenUsage,
+    Tool,
+    ToolCall,
+    ToolCallFunction,
+    ToolChoice,
+    ToolChoiceFunction,
+    ToolChoiceObject,
+    ToolFunction,
+    UploadBatchFileParams,
+    AudioOutputOptions,
+    BuiltinTool,
+    UpdateTemplateParams,
+    UsageInfo,
+)
+from .resources.batches import AsyncBatchesResource, BatchesResource
+from .resources.chat import AsyncChatResource, ChatResource
+from .resources.compare import AsyncCompareResource, CompareResource
+from .resources.embeddings import AsyncEmbeddingsResource, EmbeddingsResource
+from .resources.files import AsyncFilesResource, FilesResource
+from .resources.models import AsyncModelsResource, ModelsResource
+from .resources.responses import AsyncResponsesResource, ResponsesResource
+from .resources.templates import AsyncTemplatesResource, TemplatesResource
+
+__version__ = "0.1.0"
+__all__ = [
+    "__version__",
+    "MeshAPI",
+    "AsyncMeshAPI",
+    "MeshAPIConfig",
+    "MeshAPIError",
+    # types
+    "ChatRole",
+    "ChatMessage",
+    "ContentPart",
+    "ContentPartAudio",
+    "ContentPartText",
+    "ContentPartImage",
+    "ImageDetail",
+    "InputAudio",
+    "ImageOptions",
+    "AudioOutputOptions",
+    "ToolFunction",
+    "Tool",
+    "ToolCall",
+    "ToolCallFunction",
+    "ToolChoice",
+    "ToolChoiceFunction",
+    "ToolChoiceObject",
+    "ChatCompletionParams",
+    "ChatCompletionResponse",
+    "ChatCompletionChoice",
+    "ChatCompletionMessage",
+    "ChatCompletionChunk",
+    "ChatCompletionChunkChoice",
+    "ChatCompletionChunkDelta",
+    "UsageInfo",
+    "ModelPricing",
+    "ModelInfo",
+    "ListModelsParams",
+    "EmbeddingsParams",
+    "EmbeddingItem",
+    "EmbeddingsUsage",
+    "EmbeddingsResponse",
+    "ResponsesFunctionTool",
+    "BuiltinTool",
+    "ResponsesParams",
+    "ResponsesUsage",
+    "ResponsesResponse",
+    "ResponsesStreamEvent",
+    "ModelOverride",
+    "CompareParams",
+    "TokenUsage",
+    "CompareResponse",
+    "CompareStreamEvent",
+    "BatchRequestItem",
+    "UploadBatchFileParams",
+    "FileObject",
+    "CreateBatchParams",
+    "BatchObject",
+    "BatchListResponse",
+    "ProviderPreferences",
+    "CreateTemplateParams",
+    "UpdateTemplateParams",
+    "TemplateSummary",
+    "ApiErrorBody",
+    "ApiErrorEnvelope",
+]
+
+
+class MeshAPI:
+    """Synchronous MeshAPI client.
+
+    One instance = one auth realm. Use separate instances for different tokens
+    (e.g., ``rsk_`` key for inference, JWT for template management).
+
+    Example::
+
+        from meshapi import MeshAPI, ChatCompletionParams, ChatMessage
+
+        client = MeshAPI(base_url="http://localhost:8000", token="rsk_...")
+        resp = client.chat.completions.create(
+            ChatCompletionParams(
+                model="openai/gpt-4o-mini",
+                messages=[ChatMessage(role="user", content="Hello!")],
+            )
+        )
+        print(resp.choices[0].message.content)
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        token: str,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        httpx_client: Any = None,
+    ) -> None:
+        config = MeshAPIConfig(
+            base_url=base_url,
+            token=token,
+            timeout=timeout,
+            max_retries=max_retries,
+            httpx_client=httpx_client,
+        )
+        http = SyncHttpClient(config)
+        self.chat = ChatResource(http)
+        self.responses = ResponsesResource(http)
+        self.embeddings = EmbeddingsResource(http)
+        self.compare = CompareResource(http)
+        self.files = FilesResource(http)
+        self.batches = BatchesResource(http)
+        self.models = ModelsResource(http)
+        self.templates = TemplatesResource(http)
+        self._http = http
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "MeshAPI":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+
+class AsyncMeshAPI:
+    """Asynchronous MeshAPI client.
+
+    Example::
+
+        import asyncio
+        from meshapi import AsyncMeshAPI, ChatCompletionParams, ChatMessage
+
+        async def main():
+            async with AsyncMeshAPI(base_url="http://localhost:8000", token="rsk_...") as client:
+                resp = await client.chat.completions.create(
+                    ChatCompletionParams(
+                        model="openai/gpt-4o-mini",
+                        messages=[ChatMessage(role="user", content="Hello!")],
+                    )
+                )
+                print(resp.choices[0].message.content)
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        token: str,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        async_httpx_client: Any = None,
+    ) -> None:
+        config = MeshAPIConfig(
+            base_url=base_url,
+            token=token,
+            timeout=timeout,
+            max_retries=max_retries,
+            async_httpx_client=async_httpx_client,
+        )
+        http = AsyncHttpClient(config)
+        self.chat = AsyncChatResource(http)
+        self.responses = AsyncResponsesResource(http)
+        self.embeddings = AsyncEmbeddingsResource(http)
+        self.compare = AsyncCompareResource(http)
+        self.files = AsyncFilesResource(http)
+        self.batches = AsyncBatchesResource(http)
+        self.models = AsyncModelsResource(http)
+        self.templates = AsyncTemplatesResource(http)
+        self._http = http
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncMeshAPI":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.aclose()

meshapi/_errors.py

@@ -0,0 +1,94 @@
+"""MeshAPI API error type."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    import httpx
+
+
+class MeshAPIError(Exception):
+    """Raised when MeshAPI returns a non-2xx response or a mid-stream error."""
+
+    status: int
+    error_code: str
+    request_id: str
+    details: List[Any]
+    provider_error: Optional[Dict[str, Any]]
+    retry_after_seconds: Optional[int]
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        error_code: str,
+        request_id: str,
+        details: Optional[List[Any]] = None,
+        provider_error: Optional[Dict[str, Any]] = None,
+        retry_after_seconds: Optional[int] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.error_code = error_code
+        self.request_id = request_id
+        self.details = details or []
+        self.provider_error = provider_error
+        self.retry_after_seconds = retry_after_seconds
+
+    def __repr__(self) -> str:
+        return (
+            f"MeshAPIError(status={self.status!r}, "
+            f"error_code={self.error_code!r}, "
+            f"request_id={self.request_id!r}, "
+            f"message={str(self)!r})"
+        )
+
+    @classmethod
+    def from_response(cls, response: "httpx.Response") -> "MeshAPIError":
+        """Parse a MeshAPIError from an httpx Response."""
+        status = response.status_code
+        content_type = response.headers.get("content-type", "")
+        request_id = response.headers.get("x-request-id", "")
+
+        if "application/json" not in content_type:
+            raw = response.text[:500]
+            return cls(
+                raw or f"HTTP {status}",
+                status=status,
+                error_code="parse_error",
+                request_id=request_id,
+            )
+
+        try:
+            body = response.json()
+            error = body.get("error", {})
+            request_id = body.get("request_id", request_id)
+            return cls(
+                error.get("message", f"HTTP {status}"),
+                status=status,
+                error_code=error.get("code", "unknown_error"),
+                request_id=request_id,
+                details=error.get("details") or [],
+                provider_error=error.get("provider_error"),
+                retry_after_seconds=error.get("retry_after_seconds"),
+            )
+        except Exception:
+            raw = response.text[:500]
+            return cls(
+                raw or f"HTTP {status}",
+                status=status,
+                error_code="parse_error",
+                request_id=request_id,
+            )
+
+    @classmethod
+    def stream_interrupted(cls, cause: str) -> "MeshAPIError":
+        """Create an error representing a mid-stream connection failure."""
+        return cls(
+            f"Stream interrupted: {cause}",
+            status=0,
+            error_code="stream_interrupted",
+            request_id="",
+        )