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

mixpeek/__init__.py

@@ -1,73 +1,102 @@
-# mixpeek.py
-import requests
-import json
+# This file was auto-generated by Fern from our API Definition.
 
+from .types import (
+    ApiKey,
+    AudioParams,
+    ConfigsResponse,
+    Connection,
+    ConnectionEngine,
+    CsvParams,
+    Destination,
+    EmbeddingResponse,
+    ErrorMessage,
+    ErrorResponse,
+    FieldType,
+    GenerationResponse,
+    HtmlParams,
+    HttpValidationError,
+    ImageParams,
+    Message,
+    Metadata,
+    Modality,
+    Model,
+    Models,
+    PdfParams,
+    PptParams,
+    PptxParams,
+    Settings,
+    Source,
+    SourceDestinationMapping,
+    TxtParams,
+    User,
+    ValidationError,
+    ValidationErrorLocItem,
+    VideoParams,
+    WorkflowResponse,
+    WorkflowSettings,
+    XlsxParams,
+)
+from .errors import (
+    BadRequestError,
+    ForbiddenError,
+    InternalServerError,
+    NotFoundError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+)
+from . import embed, extract, generators, parse, pipelines, storage, users, workflows
+from .environment import MixpeekEnvironment
+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__ = [
+    "ApiKey",
+    "AudioParams",
+    "BadRequestError",
+    "ConfigsResponse",
+    "Connection",
+    "ConnectionEngine",
+    "CsvParams",
+    "Destination",
+    "EmbeddingResponse",
+    "ErrorMessage",
+    "ErrorResponse",
+    "FieldType",
+    "ForbiddenError",
+    "GenerationResponse",
+    "HtmlParams",
+    "HttpValidationError",
+    "ImageParams",
+    "InternalServerError",
+    "Message",
+    "Metadata",
+    "MixpeekEnvironment",
+    "Modality",
+    "Model",
+    "Models",
+    "NotFoundError",
+    "PdfParams",
+    "PptParams",
+    "PptxParams",
+    "Settings",
+    "Source",
+    "SourceDestinationMapping",
+    "TxtParams",
+    "UnauthorizedError",
+    "UnprocessableEntityError",
+    "User",
+    "ValidationError",
+    "ValidationErrorLocItem",
+    "VideoParams",
+    "WorkflowResponse",
+    "WorkflowSettings",
+    "XlsxParams",
+    "__version__",
+    "embed",
+    "extract",
+    "generators",
+    "parse",
+    "pipelines",
+    "storage",
+    "users",
+    "workflows",
+]

mixpeek/base_client.py

@@ -0,0 +1,155 @@
+# 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 .embed.client import AsyncEmbedClient, EmbedClient
+from .environment import MixpeekEnvironment
+from .extract.client import AsyncExtractClient, ExtractClient
+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 .users.client import AsyncUsersClient, UsersClient
+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: typing.Optional[str]. The base url to use for requests from the client.
+
+        - environment: MixpeekEnvironment. The environment to use for requests from the client. from .environment import MixpeekEnvironment
+
+                                           Defaults to MixpeekEnvironment.DEFAULT
+
+        - 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",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: MixpeekEnvironment = MixpeekEnvironment.DEFAULT,
+        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=_get_base_url(base_url=base_url, environment=environment),
+            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.users = UsersClient(client_wrapper=self._client_wrapper)
+        self.extract = ExtractClient(client_wrapper=self._client_wrapper)
+        self.generators = GeneratorsClient(client_wrapper=self._client_wrapper)
+        self.embed = EmbedClient(client_wrapper=self._client_wrapper)
+        self.pipelines = PipelinesClient(client_wrapper=self._client_wrapper)
+        self.workflows = WorkflowsClient(client_wrapper=self._client_wrapper)
+        self.storage = StorageClient(client_wrapper=self._client_wrapper)
+        self.parse = ParseClient(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: typing.Optional[str]. The base url to use for requests from the client.
+
+        - environment: MixpeekEnvironment. The environment to use for requests from the client. from .environment import MixpeekEnvironment
+
+                                           Defaults to MixpeekEnvironment.DEFAULT
+
+        - 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",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: MixpeekEnvironment = MixpeekEnvironment.DEFAULT,
+        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=_get_base_url(base_url=base_url, environment=environment),
+            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.users = AsyncUsersClient(client_wrapper=self._client_wrapper)
+        self.extract = AsyncExtractClient(client_wrapper=self._client_wrapper)
+        self.generators = AsyncGeneratorsClient(client_wrapper=self._client_wrapper)
+        self.embed = AsyncEmbedClient(client_wrapper=self._client_wrapper)
+        self.pipelines = AsyncPipelinesClient(client_wrapper=self._client_wrapper)
+        self.workflows = AsyncWorkflowsClient(client_wrapper=self._client_wrapper)
+        self.storage = AsyncStorageClient(client_wrapper=self._client_wrapper)
+        self.parse = AsyncParseClient(client_wrapper=self._client_wrapper)
+
+
+def _get_base_url(*, base_url: typing.Optional[str] = None, environment: MixpeekEnvironment) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Please pass in either base_url or environment to construct the client")

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.2",
+        }
+        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