meibel 0.1.0b1__tar.gz

meibel-0.1.0b1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: meibel
+Version: 0.1.0b1
+Summary: The Meibel API provides document parsing, datasource management, and AI agent orchestration.
+License: MIT
+Project-URL: Homepage, https://docs.meibel.ai
+Project-URL: Repository, https://github.com/meibel-ai/meibel-python
+Project-URL: Documentation, https://docs.meibel.ai/sdk/python
+Project-URL: Bug Tracker, https://github.com/meibel-ai/meibel-python/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# Meibel Python SDK
+
+The official Python SDK for the [Meibel API](https://docs.meibel.ai). Provides document parsing, datasource management, and AI agent orchestration.
+
+## Installation
+
+```bash
+pip install meibel==0.1.0b1
+```
+
+## Quick Start
+
+```python
+from meibel import MeibelClient
+
+client = MeibelClient(
+    api_key="your-api-key",
+    base_url="https://api.meibel.ai/v2",
+)
+
+# Parse a document
+with open("document.pdf", "rb") as f:
+    result = client.documents.parse_document(file=f)
+    print(result.job_id)
+
+# Process a document synchronously (waits for completion)
+with open("document.pdf", "rb") as f:
+    result = client.documents.process_document(file=f)
+    print(result)
+
+# List datasources
+datasources = client.datasources.list_datasources()
+for ds in datasources.items:
+    print(ds.name)
+```
+
+## Async Usage
+
+```python
+from meibel import AsyncMeibelClient
+
+client = AsyncMeibelClient(
+    api_key="your-api-key",
+    base_url="https://api.meibel.ai/v2",
+)
+
+result = await client.documents.process_document(file=open("doc.pdf", "rb"))
+```
+
+## Documentation
+
+- [API Reference](https://docs.meibel.ai/api-reference/overview)
+- [SDK Guide](https://docs.meibel.ai/sdk/python)
+
+## License
+
+MIT

meibel-0.1.0b1/README.md

@@ -0,0 +1,57 @@
+# Meibel Python SDK
+
+The official Python SDK for the [Meibel API](https://docs.meibel.ai). Provides document parsing, datasource management, and AI agent orchestration.
+
+## Installation
+
+```bash
+pip install meibel==0.1.0b1
+```
+
+## Quick Start
+
+```python
+from meibel import MeibelClient
+
+client = MeibelClient(
+    api_key="your-api-key",
+    base_url="https://api.meibel.ai/v2",
+)
+
+# Parse a document
+with open("document.pdf", "rb") as f:
+    result = client.documents.parse_document(file=f)
+    print(result.job_id)
+
+# Process a document synchronously (waits for completion)
+with open("document.pdf", "rb") as f:
+    result = client.documents.process_document(file=f)
+    print(result)
+
+# List datasources
+datasources = client.datasources.list_datasources()
+for ds in datasources.items:
+    print(ds.name)
+```
+
+## Async Usage
+
+```python
+from meibel import AsyncMeibelClient
+
+client = AsyncMeibelClient(
+    api_key="your-api-key",
+    base_url="https://api.meibel.ai/v2",
+)
+
+result = await client.documents.process_document(file=open("doc.pdf", "rb"))
+```
+
+## Documentation
+
+- [API Reference](https://docs.meibel.ai/api-reference/overview)
+- [SDK Guide](https://docs.meibel.ai/sdk/python)
+
+## License
+
+MIT

meibel-0.1.0b1/meibel/__init__.py

@@ -0,0 +1,18 @@
+"""
+meibel - The Meibel API provides document parsing, datasource management, and AI agent orchestration.
+
+Generated by Forge SDK Generator.
+"""
+
+__version__ = "0.1.0-beta.1"
+
+from .client import MeibelClient
+from .client import AsyncMeibelClient
+from .models import *
+from .exceptions import *
+
+__all__ = [
+    "MeibelClient",
+    "AsyncMeibelClient",
+    "__version__",
+]

meibel-0.1.0b1/meibel/_http.py

@@ -0,0 +1,309 @@
+"""
+HTTP Client Module
+
+Provides sync and async HTTP clients using httpx.
+"""
+
+from __future__ import annotations
+
+import httpx
+from typing import Any, Dict, Optional, TypeVar, Type, Union
+from pydantic import BaseModel
+
+from .exceptions import ApiError, AuthenticationError, RateLimitError, NotFoundError
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class HttpClient:
+    """Synchronous HTTP client."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        timeout: float = 30.0,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._headers = headers or {}
+
+        if api_key:
+            self._headers["Meibel-API-Key"] = api_key
+        if bearer_token:
+            self._headers["Authorization"] = f"Bearer {bearer_token}"
+
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=timeout,
+            headers=self._headers,
+        )
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self) -> "HttpClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Make an HTTP request."""
+        # Filter out None values from params
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        # Merge headers
+        request_headers = {**self._headers}
+        if headers:
+            request_headers.update(headers)
+
+        response = self._client.request(
+            method=method,
+            url=path,
+            params=params,
+            json=self._serialize_body(json),
+            headers=request_headers,
+        )
+
+        return self._handle_response(response, response_model)
+
+    def upload(
+        self,
+        method: str,
+        path: str,
+        *,
+        file: Any,
+        file_name: str,
+        field_name: str = "file",
+        params: Optional[Dict[str, Any]] = None,
+        form_fields: Optional[Dict[str, str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Upload a file with streaming multipart/form-data."""
+        from ._upload import create_multipart_stream
+
+        content_stream, content_type = create_multipart_stream(
+            file, field_name=field_name, file_name=file_name, form_fields=form_fields,
+        )
+
+        request_headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        request_headers["Content-Type"] = content_type
+        if headers:
+            request_headers.update(headers)
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        response = self._client.request(
+            method=method, url=path, content=content_stream, params=params, headers=request_headers,
+        )
+        return self._handle_response(response, response_model)
+
+    def _serialize_body(self, body: Any) -> Any:
+        """Serialize request body, converting Pydantic models to dicts."""
+        if body is None:
+            return None
+        if isinstance(body, BaseModel):
+            return body.model_dump(mode="json", exclude_none=True)
+        if isinstance(body, list):
+            return [self._serialize_body(item) for item in body]
+        return body
+
+    def _handle_response(
+        self,
+        response: httpx.Response,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Handle HTTP response, raising errors or parsing data."""
+        if response.status_code == 204:
+            return None
+
+        if response.status_code >= 400:
+            self._raise_error(response)
+
+        if response_model:
+            return response_model.model_validate(response.json())
+
+        try:
+            return response.json()
+        except Exception:
+            return None
+
+    def _raise_error(self, response: httpx.Response) -> None:
+        """Raise appropriate error based on status code."""
+        try:
+            error_body = response.json()
+        except Exception:
+            error_body = {"message": response.text}
+
+        message = error_body.get("message", error_body.get("error", "Unknown error"))
+
+        if response.status_code == 401:
+            raise AuthenticationError(message, response.status_code, error_body)
+        elif response.status_code == 404:
+            raise NotFoundError(message, response.status_code, error_body)
+        elif response.status_code == 429:
+            raise RateLimitError(message, response.status_code, error_body)
+        else:
+            raise ApiError(message, response.status_code, error_body)
+
+
+class AsyncHttpClient:
+    """Asynchronous HTTP client."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        timeout: float = 30.0,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._headers = headers or {}
+
+        if api_key:
+            self._headers["Meibel-API-Key"] = api_key
+        if bearer_token:
+            self._headers["Authorization"] = f"Bearer {bearer_token}"
+
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=timeout,
+            headers=self._headers,
+        )
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self._client.aclose()
+
+    async def __aenter__(self) -> "AsyncHttpClient":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Make an HTTP request."""
+        # Filter out None values from params
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        # Merge headers
+        request_headers = {**self._headers}
+        if headers:
+            request_headers.update(headers)
+
+        response = await self._client.request(
+            method=method,
+            url=path,
+            params=params,
+            json=self._serialize_body(json),
+            headers=request_headers,
+        )
+
+        return self._handle_response(response, response_model)
+
+    async def upload(
+        self,
+        method: str,
+        path: str,
+        *,
+        file: Any,
+        file_name: str,
+        field_name: str = "file",
+        params: Optional[Dict[str, Any]] = None,
+        form_fields: Optional[Dict[str, str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Upload a file with streaming multipart/form-data."""
+        from ._upload import create_async_multipart_stream
+
+        content_stream, content_type = await create_async_multipart_stream(
+            file, field_name=field_name, file_name=file_name, form_fields=form_fields,
+        )
+
+        request_headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        request_headers["Content-Type"] = content_type
+        if headers:
+            request_headers.update(headers)
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+
+        response = await self._client.request(
+            method=method, url=path, content=content_stream, params=params, headers=request_headers,
+        )
+        return self._handle_response(response, response_model)
+
+    def _serialize_body(self, body: Any) -> Any:
+        """Serialize request body, converting Pydantic models to dicts."""
+        if body is None:
+            return None
+        if isinstance(body, BaseModel):
+            return body.model_dump(mode="json", exclude_none=True)
+        if isinstance(body, list):
+            return [self._serialize_body(item) for item in body]
+        return body
+
+    def _handle_response(
+        self,
+        response: httpx.Response,
+        response_model: Optional[Type[T]] = None,
+    ) -> Union[T, Dict[str, Any], None]:
+        """Handle HTTP response, raising errors or parsing data."""
+        if response.status_code == 204:
+            return None
+
+        if response.status_code >= 400:
+            self._raise_error(response)
+
+        if response_model:
+            return response_model.model_validate(response.json())
+
+        try:
+            return response.json()
+        except Exception:
+            return None
+
+    def _raise_error(self, response: httpx.Response) -> None:
+        """Raise appropriate error based on status code."""
+        try:
+            error_body = response.json()
+        except Exception:
+            error_body = {"message": response.text}
+
+        message = error_body.get("message", error_body.get("error", "Unknown error"))
+
+        if response.status_code == 401:
+            raise AuthenticationError(message, response.status_code, error_body)
+        elif response.status_code == 404:
+            raise NotFoundError(message, response.status_code, error_body)
+        elif response.status_code == 429:
+            raise RateLimitError(message, response.status_code, error_body)
+        else:
+            raise ApiError(message, response.status_code, error_body)

meibel-0.1.0b1/meibel/_pagination.py

@@ -0,0 +1,170 @@
+"""
+Pagination Module
+
+Provides iterators for paginated API responses.
+"""
+
+from __future__ import annotations
+
+from typing import (
+    Any,
+    AsyncIterator,
+    Callable,
+    Dict,
+    Generic,
+    Iterator,
+    List,
+    Optional,
+    TypeVar,
+)
+
+T = TypeVar("T")
+
+
+class PaginatedIterator(Generic[T]):
+    """
+    Iterator for paginated API responses.
+
+    Supports cursor-based, offset-based, and page-based pagination.
+    """
+
+    def __init__(
+        self,
+        fetch_page: Callable[[Optional[str]], Dict[str, Any]],
+        extract_items: Callable[[Dict[str, Any]], List[T]],
+        extract_cursor: Callable[[Dict[str, Any]], Optional[str]],
+    ):
+        """
+        Initialize the paginated iterator.
+
+        Args:
+            fetch_page: Function that fetches a page given a cursor (None for first page)
+            extract_items: Function that extracts items from the response
+            extract_cursor: Function that extracts the next cursor from the response
+        """
+        self._fetch_page = fetch_page
+        self._extract_items = extract_items
+        self._extract_cursor = extract_cursor
+        self._cursor: Optional[str] = None
+        self._buffer: List[T] = []
+        self._exhausted = False
+
+    def __iter__(self) -> Iterator[T]:
+        return self
+
+    def __next__(self) -> T:
+        # If we have items in the buffer, return the next one
+        if self._buffer:
+            return self._buffer.pop(0)
+
+        # If we've exhausted all pages, stop
+        if self._exhausted:
+            raise StopIteration
+
+        # Fetch the next page
+        response = self._fetch_page(self._cursor)
+        items = self._extract_items(response)
+        next_cursor = self._extract_cursor(response)
+
+        # Update state
+        if next_cursor:
+            self._cursor = next_cursor
+        else:
+            self._exhausted = True
+
+        # If no items, stop
+        if not items:
+            raise StopIteration
+
+        # Buffer items and return the first one
+        self._buffer = items[1:]
+        return items[0]
+
+    def collect(self) -> List[T]:
+        """Collect all items into a list."""
+        return list(self)
+
+    def take(self, n: int) -> List[T]:
+        """Take up to n items."""
+        result: List[T] = []
+        for item in self:
+            result.append(item)
+            if len(result) >= n:
+                break
+        return result
+
+
+class AsyncPaginatedIterator(Generic[T]):
+    """
+    Async iterator for paginated API responses.
+
+    Supports cursor-based, offset-based, and page-based pagination.
+    """
+
+    def __init__(
+        self,
+        fetch_page: Callable[[Optional[str]], Any],  # Returns Awaitable
+        extract_items: Callable[[Dict[str, Any]], List[T]],
+        extract_cursor: Callable[[Dict[str, Any]], Optional[str]],
+    ):
+        """
+        Initialize the async paginated iterator.
+
+        Args:
+            fetch_page: Async function that fetches a page given a cursor (None for first page)
+            extract_items: Function that extracts items from the response
+            extract_cursor: Function that extracts the next cursor from the response
+        """
+        self._fetch_page = fetch_page
+        self._extract_items = extract_items
+        self._extract_cursor = extract_cursor
+        self._cursor: Optional[str] = None
+        self._buffer: List[T] = []
+        self._exhausted = False
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        return self
+
+    async def __anext__(self) -> T:
+        # If we have items in the buffer, return the next one
+        if self._buffer:
+            return self._buffer.pop(0)
+
+        # If we've exhausted all pages, stop
+        if self._exhausted:
+            raise StopAsyncIteration
+
+        # Fetch the next page
+        response = await self._fetch_page(self._cursor)
+        items = self._extract_items(response)
+        next_cursor = self._extract_cursor(response)
+
+        # Update state
+        if next_cursor:
+            self._cursor = next_cursor
+        else:
+            self._exhausted = True
+
+        # If no items, stop
+        if not items:
+            raise StopAsyncIteration
+
+        # Buffer items and return the first one
+        self._buffer = items[1:]
+        return items[0]
+
+    async def collect(self) -> List[T]:
+        """Collect all items into a list."""
+        result: List[T] = []
+        async for item in self:
+            result.append(item)
+        return result
+
+    async def take(self, n: int) -> List[T]:
+        """Take up to n items."""
+        result: List[T] = []
+        async for item in self:
+            result.append(item)
+            if len(result) >= n:
+                break
+        return result