mixpeek 0.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

mixpeek/__init__.py

@@ -1,73 +1,97 @@
-# mixpeek.py
-import requests
-import json
+# This file was auto-generated by Fern from our API Definition.
 
+from .types import (
+    AudioParams,
+    ConfigsRequest,
+    ConfigsResponse,
+    Connection,
+    ConnectionEngine,
+    CsvParams,
+    DestinationSchema,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    ErrorMessage,
+    ErrorResponse,
+    FieldSchema,
+    FieldType,
+    GenerationResponse,
+    HtmlParams,
+    HttpValidationError,
+    ImageParams,
+    Message,
+    Metadata,
+    Modality,
+    Model,
+    PdfParams,
+    PipelineResponse,
+    PptParams,
+    PptxParams,
+    Settings,
+    SourceSchema,
+    TxtParams,
+    ValidationError,
+    ValidationErrorLocItem,
+    VideoParams,
+    WorkflowResponse,
+    WorkflowSettings,
+    XlsxParams,
+)
+from .errors import (
+    BadRequestError,
+    ForbiddenError,
+    InternalServerError,
+    NotFoundError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+)
+from . import generators, parse, pipelines, storage, workflows
+from .version import __version__
 
-class Mixpeek:
-    def __init__(self, api_key):
-        self.base_url = "http://localhost:8000"
-        self.headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        }
-        self.generate = self.Generate(self)
-        self.parse = self.Parse(self)
-
-    def _send_post(self, url, payload):
-        return requests.post(url, headers=self.headers, data=json.dumps(payload)).json()
-
-    def _send_get(self, url):
-        return requests.get(url, headers=self.headers).json()
-
-    class Generate:
-        def __init__(self, mixpeek):
-            self.mixpeek = mixpeek
-            self.openai = self.OpenAI(self.mixpeek)
-
-        class OpenAI:
-            def __init__(self, mixpeek):
-                self.mixpeek = mixpeek
-                self.generate_openai_url = f"{self.mixpeek.base_url}/generate"
-
-            def _construct_request_format(
-                self, model, context, response_format, settings=None
-            ):
-                payload = {
-                    "model": {"provider": "gpt", "model": model},
-                    "context": context,
-                    "messages": [{"role": "user", "content": ""}],
-                    **settings,
-                }
-
-                if response_format is not None:
-                    json_schema = response_format.model_json_schema()
-                    payload["response_format"] = json_schema
-
-                return payload
-
-            def chat(self, model, response_format, context, settings=None):
-                payload = self._construct_request_format(
-                    model, context, response_format, settings
-                )
-                return self.mixpeek._send_post(self.generate_openai_url, payload)
-
-    class Parse:
-        def __init__(self, mixpeek):
-            self.mixpeek = mixpeek
-            self.text = self.Text(self.mixpeek)
-
-        class Text:
-            def __init__(self, mixpeek):
-                self.mixpeek = mixpeek
-                self.parse_url = f"{self.mixpeek.base_url}/parsers"
-
-            def extract(self, file_url, should_chunk=True):
-                url = self.parse_url + "?should_chunk=" + str(should_chunk)
-                return self.mixpeek._send_post(url, {"file_url": file_url})
-
-            def chunk(self, corpus):
-                pass
-
-        class Index:
-            def __init__(self):
-                pass
+__all__ = [
+    "AudioParams",
+    "BadRequestError",
+    "ConfigsRequest",
+    "ConfigsResponse",
+    "Connection",
+    "ConnectionEngine",
+    "CsvParams",
+    "DestinationSchema",
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+    "ErrorMessage",
+    "ErrorResponse",
+    "FieldSchema",
+    "FieldType",
+    "ForbiddenError",
+    "GenerationResponse",
+    "HtmlParams",
+    "HttpValidationError",
+    "ImageParams",
+    "InternalServerError",
+    "Message",
+    "Metadata",
+    "Modality",
+    "Model",
+    "NotFoundError",
+    "PdfParams",
+    "PipelineResponse",
+    "PptParams",
+    "PptxParams",
+    "Settings",
+    "SourceSchema",
+    "TxtParams",
+    "UnauthorizedError",
+    "UnprocessableEntityError",
+    "ValidationError",
+    "ValidationErrorLocItem",
+    "VideoParams",
+    "WorkflowResponse",
+    "WorkflowSettings",
+    "XlsxParams",
+    "__version__",
+    "generators",
+    "parse",
+    "pipelines",
+    "storage",
+    "workflows",
+]

mixpeek/base_client.py

@@ -0,0 +1,128 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import os
+import typing
+
+import httpx
+
+from .core.api_error import ApiError
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .generators.client import AsyncGeneratorsClient, GeneratorsClient
+from .parse.client import AsyncParseClient, ParseClient
+from .pipelines.client import AsyncPipelinesClient, PipelinesClient
+from .storage.client import AsyncStorageClient, StorageClient
+from .workflows.client import AsyncWorkflowsClient, WorkflowsClient
+
+
+class BaseMixpeek:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
+
+    Parameters:
+        - base_url: str. The base url to use for requests from the client.
+
+        - authorization: typing.Optional[str].
+
+        - index_id: typing.Optional[str].
+
+        - api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]].
+
+        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds, unless a custom httpx client is used, in which case a default is not set.
+
+        - httpx_client: typing.Optional[httpx.Client]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+    ---
+    from mixpeek.client import Mixpeek
+
+    client = Mixpeek(
+        authorization="YOUR_AUTHORIZATION",
+        index_id="YOUR_INDEX_ID",
+        api_key="YOUR_API_KEY",
+        base_url="https://yourhost.com/path/to/api",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        authorization: typing.Optional[str] = None,
+        index_id: typing.Optional[str] = None,
+        api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = os.getenv("MIXPEEK_API_KEY"),
+        timeout: typing.Optional[float] = None,
+        httpx_client: typing.Optional[httpx.Client] = None
+    ):
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting MIXPEEK_API_KEY"
+            )
+        self._client_wrapper = SyncClientWrapper(
+            base_url=base_url,
+            authorization=authorization,
+            index_id=index_id,
+            api_key=api_key,
+            httpx_client=httpx.Client(timeout=_defaulted_timeout) if httpx_client is None else httpx_client,
+            timeout=_defaulted_timeout,
+        )
+        self.pipelines = PipelinesClient(client_wrapper=self._client_wrapper)
+        self.parse = ParseClient(client_wrapper=self._client_wrapper)
+        self.workflows = WorkflowsClient(client_wrapper=self._client_wrapper)
+        self.generators = GeneratorsClient(client_wrapper=self._client_wrapper)
+        self.storage = StorageClient(client_wrapper=self._client_wrapper)
+
+
+class AsyncBaseMixpeek:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
+
+    Parameters:
+        - base_url: str. The base url to use for requests from the client.
+
+        - authorization: typing.Optional[str].
+
+        - index_id: typing.Optional[str].
+
+        - api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]].
+
+        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds, unless a custom httpx client is used, in which case a default is not set.
+
+        - httpx_client: typing.Optional[httpx.AsyncClient]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+    ---
+    from mixpeek.client import AsyncMixpeek
+
+    client = AsyncMixpeek(
+        authorization="YOUR_AUTHORIZATION",
+        index_id="YOUR_INDEX_ID",
+        api_key="YOUR_API_KEY",
+        base_url="https://yourhost.com/path/to/api",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        authorization: typing.Optional[str] = None,
+        index_id: typing.Optional[str] = None,
+        api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = os.getenv("MIXPEEK_API_KEY"),
+        timeout: typing.Optional[float] = None,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None
+    ):
+        _defaulted_timeout = timeout if timeout is not None else 60 if httpx_client is None else None
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting MIXPEEK_API_KEY"
+            )
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=base_url,
+            authorization=authorization,
+            index_id=index_id,
+            api_key=api_key,
+            httpx_client=httpx.AsyncClient(timeout=_defaulted_timeout) if httpx_client is None else httpx_client,
+            timeout=_defaulted_timeout,
+        )
+        self.pipelines = AsyncPipelinesClient(client_wrapper=self._client_wrapper)
+        self.parse = AsyncParseClient(client_wrapper=self._client_wrapper)
+        self.workflows = AsyncWorkflowsClient(client_wrapper=self._client_wrapper)
+        self.generators = AsyncGeneratorsClient(client_wrapper=self._client_wrapper)
+        self.storage = AsyncStorageClient(client_wrapper=self._client_wrapper)

mixpeek/client.py

@@ -0,0 +1,65 @@
+
+import typing
+import httpx
+
+from .base_client import BaseMixpeek, \
+    AsyncBaseMixpeek
+from .types.message import Message
+from .types.model import Model
+from .types.settings import Settings
+from .types.generation_response import GenerationResponse
+from .core.request_options import RequestOptions
+
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class Mixpeek(BaseMixpeek): 
+
+    def generate(
+        self,
+        *,
+        model: Model,
+        # Pydantic model that represents the JSON schema of the response
+        response_format: typing.Optional[typing.Any],
+        context: typing.Optional[str] = OMIT,
+        messages: typing.Sequence[Message],
+        settings: typing.Optional[Settings] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> GenerationResponse:
+        if response_format is not None:
+            response_format = response_format.model_json_schema()
+        return self.generators.generate(
+            model=model,
+            response_format=response_format,
+            context=context,
+            messages=messages,
+            settings=settings,
+            request_options=request_options,
+        )
+
+
+class AsyncMixpeek(AsyncBaseMixpeek):
+
+    async def generate(
+        self,
+        *,
+        model: Model,
+        # Pydantic model that represents the JSON schema of the response
+        response_format: typing.Optional[typing.Any],
+        context: typing.Optional[str] = OMIT,
+        messages: typing.Sequence[Message],
+        settings: typing.Optional[Settings] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> GenerationResponse:
+        if response_format is not None:
+            response_format = response_format.model_json_schema()
+        return await self.generators.generate(
+            model=model,
+            response_format=response_format,
+            context=context,
+            messages=messages,
+            settings=settings,
+            request_options=request_options,
+        )

mixpeek/core/__init__.py

@@ -0,0 +1,25 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .api_error import ApiError
+from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+from .datetime_utils import serialize_datetime
+from .file import File, convert_file_dict_to_httpx_tuples
+from .http_client import AsyncHttpClient, HttpClient
+from .jsonable_encoder import jsonable_encoder
+from .remove_none_from_dict import remove_none_from_dict
+from .request_options import RequestOptions
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "AsyncHttpClient",
+    "BaseClientWrapper",
+    "File",
+    "HttpClient",
+    "RequestOptions",
+    "SyncClientWrapper",
+    "convert_file_dict_to_httpx_tuples",
+    "jsonable_encoder",
+    "remove_none_from_dict",
+    "serialize_datetime",
+]

mixpeek/core/api_error.py

@@ -0,0 +1,15 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+
+class ApiError(Exception):
+    status_code: typing.Optional[int]
+    body: typing.Any
+
+    def __init__(self, *, status_code: typing.Optional[int] = None, body: typing.Any = None):
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"status_code: {self.status_code}, body: {self.body}"

mixpeek/core/client_wrapper.py

@@ -0,0 +1,83 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+from .http_client import AsyncHttpClient, HttpClient
+
+
+class BaseClientWrapper:
+    def __init__(
+        self,
+        *,
+        authorization: typing.Optional[str] = None,
+        index_id: typing.Optional[str] = None,
+        api_key: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+    ):
+        self._authorization = authorization
+        self._index_id = index_id
+        self._api_key = api_key
+        self._base_url = base_url
+        self._timeout = timeout
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        headers: typing.Dict[str, str] = {
+            "X-Fern-Language": "Python",
+            "X-Fern-SDK-Name": "mixpeek",
+            "X-Fern-SDK-Version": "0.6.1",
+        }
+        if self._authorization is not None:
+            headers["Authorization"] = self._authorization
+        if self._index_id is not None:
+            headers["index-id"] = self._index_id
+        headers["Authorization"] = f"Bearer {self._get_api_key()}"
+        return headers
+
+    def _get_api_key(self) -> str:
+        if isinstance(self._api_key, str):
+            return self._api_key
+        else:
+            return self._api_key()
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+    def get_timeout(self) -> typing.Optional[float]:
+        return self._timeout
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        authorization: typing.Optional[str] = None,
+        index_id: typing.Optional[str] = None,
+        api_key: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        httpx_client: httpx.Client,
+    ):
+        super().__init__(
+            authorization=authorization, index_id=index_id, api_key=api_key, base_url=base_url, timeout=timeout
+        )
+        self.httpx_client = HttpClient(httpx_client=httpx_client)
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        authorization: typing.Optional[str] = None,
+        index_id: typing.Optional[str] = None,
+        api_key: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        httpx_client: httpx.AsyncClient,
+    ):
+        super().__init__(
+            authorization=authorization, index_id=index_id, api_key=api_key, base_url=base_url, timeout=timeout
+        )
+        self.httpx_client = AsyncHttpClient(httpx_client=httpx_client)

mixpeek/core/datetime_utils.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

mixpeek/core/file.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+# File typing inspired by the flexibility of types within the httpx library
+# https://github.com/encode/httpx/blob/master/httpx/_types.py
+FileContent = typing.Union[typing.IO[bytes], bytes, str]
+File = typing.Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    typing.Tuple[typing.Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str], typing.Mapping[str, str]],
+]
+
+
+def convert_file_dict_to_httpx_tuples(
+    d: typing.Dict[str, typing.Union[File, typing.List[File]]]
+) -> typing.List[typing.Tuple[str, File]]:
+    """
+    The format we use is a list of tuples, where the first element is the
+    name of the file and the second is the file object. Typically HTTPX wants
+    a dict, but to be able to send lists of files, you have to use the list
+    approach (which also works for non-lists)
+    https://github.com/encode/httpx/pull/1032
+    """
+
+    httpx_tuples = []
+    for key, file_like in d.items():
+        if isinstance(file_like, list):
+            for file_like_item in file_like:
+                httpx_tuples.append((key, file_like_item))
+        else:
+            httpx_tuples.append((key, file_like))
+    return httpx_tuples

mixpeek/core/http_client.py

@@ -0,0 +1,130 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import asyncio
+import email.utils
+import re
+import time
+import typing
+from contextlib import asynccontextmanager, contextmanager
+from functools import wraps
+from random import random
+
+import httpx
+
+INITIAL_RETRY_DELAY_SECONDS = 0.5
+MAX_RETRY_DELAY_SECONDS = 10
+MAX_RETRY_DELAY_SECONDS_FROM_HEADER = 30
+
+
+def _parse_retry_after(response_headers: httpx.Headers) -> typing.Optional[float]:
+    """
+    This function parses the `Retry-After` header in a HTTP response and returns the number of seconds to wait.
+
+    Inspired by the urllib3 retry implementation.
+    """
+    retry_after_ms = response_headers.get("retry-after-ms")
+    if retry_after_ms is not None:
+        try:
+            return int(retry_after_ms) / 1000 if retry_after_ms > 0 else 0
+        except Exception:
+            pass
+
+    retry_after = response_headers.get("retry-after")
+    if retry_after is None:
+        return None
+
+    # Attempt to parse the header as an int.
+    if re.match(r"^\s*[0-9]+\s*$", retry_after):
+        seconds = float(retry_after)
+    # Fallback to parsing it as a date.
+    else:
+        retry_date_tuple = email.utils.parsedate_tz(retry_after)
+        if retry_date_tuple is None:
+            return None
+        if retry_date_tuple[9] is None:  # Python 2
+            # Assume UTC if no timezone was specified
+            # On Python2.7, parsedate_tz returns None for a timezone offset
+            # instead of 0 if no timezone is given, where mktime_tz treats
+            # a None timezone offset as local time.
+            retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:]
+
+        retry_date = email.utils.mktime_tz(retry_date_tuple)
+        seconds = retry_date - time.time()
+
+    if seconds < 0:
+        seconds = 0
+
+    return seconds
+
+
+def _retry_timeout(response: httpx.Response, retries: int) -> float:
+    """
+    Determine the amount of time to wait before retrying a request.
+    This function begins by trying to parse a retry-after header from the response, and then proceeds to use exponential backoff
+    with a jitter to determine the number of seconds to wait.
+    """
+
+    # If the API asks us to wait a certain amount of time (and it's a reasonable amount), just do what it says.
+    retry_after = _parse_retry_after(response.headers)
+    if retry_after is not None and retry_after <= MAX_RETRY_DELAY_SECONDS_FROM_HEADER:
+        return retry_after
+
+    # Apply exponential backoff, capped at MAX_RETRY_DELAY_SECONDS.
+    retry_delay = min(INITIAL_RETRY_DELAY_SECONDS * pow(2.0, retries), MAX_RETRY_DELAY_SECONDS)
+
+    # Add a randomness / jitter to the retry delay to avoid overwhelming the server with retries.
+    timeout = retry_delay * (1 - 0.25 * random())
+    return timeout if timeout >= 0 else 0
+
+
+def _should_retry(response: httpx.Response) -> bool:
+    retriable_400s = [429, 408, 409]
+    return response.status_code >= 500 or response.status_code in retriable_400s
+
+
+class HttpClient:
+    def __init__(self, *, httpx_client: httpx.Client):
+        self.httpx_client = httpx_client
+
+    # Ensure that the signature of the `request` method is the same as the `httpx.Client.request` method
+    @wraps(httpx.Client.request)
+    def request(
+        self, *args: typing.Any, max_retries: int = 0, retries: int = 0, **kwargs: typing.Any
+    ) -> httpx.Response:
+        response = self.httpx_client.request(*args, **kwargs)
+        if _should_retry(response=response):
+            if max_retries > retries:
+                time.sleep(_retry_timeout(response=response, retries=retries))
+                return self.request(max_retries=max_retries, retries=retries + 1, *args, **kwargs)
+        return response
+
+    @wraps(httpx.Client.stream)
+    @contextmanager
+    def stream(self, *args: typing.Any, max_retries: int = 0, retries: int = 0, **kwargs: typing.Any) -> typing.Any:
+        with self.httpx_client.stream(*args, **kwargs) as stream:
+            yield stream
+
+
+class AsyncHttpClient:
+    def __init__(self, *, httpx_client: httpx.AsyncClient):
+        self.httpx_client = httpx_client
+
+    # Ensure that the signature of the `request` method is the same as the `httpx.Client.request` method
+    @wraps(httpx.AsyncClient.request)
+    async def request(
+        self, *args: typing.Any, max_retries: int = 0, retries: int = 0, **kwargs: typing.Any
+    ) -> httpx.Response:
+        response = await self.httpx_client.request(*args, **kwargs)
+        if _should_retry(response=response):
+            if max_retries > retries:
+                await asyncio.sleep(_retry_timeout(response=response, retries=retries))
+                return await self.request(max_retries=max_retries, retries=retries + 1, *args, **kwargs)
+        return response
+
+    @wraps(httpx.AsyncClient.stream)
+    @asynccontextmanager
+    async def stream(
+        self, *args: typing.Any, max_retries: int = 0, retries: int = 0, **kwargs: typing.Any
+    ) -> typing.Any:
+        async with self.httpx_client.stream(*args, **kwargs) as stream:
+            yield stream