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

mixpeek/types/__init__.py

@@ -1,17 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from .api_key import ApiKey
 from .audio_params import AudioParams
-from .configs_request import ConfigsRequest
 from .configs_response import ConfigsResponse
 from .connection import Connection
 from .connection_engine import ConnectionEngine
 from .csv_params import CsvParams
-from .destination_schema import DestinationSchema
-from .embedding_request import EmbeddingRequest
+from .destination import Destination
 from .embedding_response import EmbeddingResponse
 from .error_message import ErrorMessage
 from .error_response import ErrorResponse
-from .field_schema import FieldSchema
 from .field_type import FieldType
 from .generation_response import GenerationResponse
 from .html_params import HtmlParams
@@ -21,13 +19,15 @@ from .message import Message
 from .metadata import Metadata
 from .modality import Modality
 from .model import Model
+from .models import Models
 from .pdf_params import PdfParams
-from .pipeline_response import PipelineResponse
 from .ppt_params import PptParams
 from .pptx_params import PptxParams
 from .settings import Settings
-from .source_schema import SourceSchema
+from .source import Source
+from .source_destination_mapping import SourceDestinationMapping
 from .txt_params import TxtParams
+from .user import User
 from .validation_error import ValidationError
 from .validation_error_loc_item import ValidationErrorLocItem
 from .video_params import VideoParams
@@ -36,18 +36,16 @@ from .workflow_settings import WorkflowSettings
 from .xlsx_params import XlsxParams
 
 __all__ = [
+    "ApiKey",
     "AudioParams",
-    "ConfigsRequest",
     "ConfigsResponse",
     "Connection",
     "ConnectionEngine",
     "CsvParams",
-    "DestinationSchema",
-    "EmbeddingRequest",
+    "Destination",
     "EmbeddingResponse",
     "ErrorMessage",
     "ErrorResponse",
-    "FieldSchema",
     "FieldType",
     "GenerationResponse",
     "HtmlParams",
@@ -57,13 +55,15 @@ __all__ = [
     "Metadata",
     "Modality",
     "Model",
+    "Models",
     "PdfParams",
-    "PipelineResponse",
     "PptParams",
     "PptxParams",
     "Settings",
-    "SourceSchema",
+    "Source",
+    "SourceDestinationMapping",
     "TxtParams",
+    "User",
     "ValidationError",
     "ValidationErrorLocItem",
     "VideoParams",

mixpeek/types/{configs_request.py → api_key.py}

@@ -4,7 +4,6 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
-from .modality import Modality
 
 try:
     import pydantic.v1 as pydantic  # type: ignore
@@ -12,9 +11,10 @@ except ImportError:
     import pydantic  # type: ignore
 
 
-class ConfigsRequest(pydantic.BaseModel):
-    modality: typing.Optional[Modality] = None
-    model: typing.Optional[str] = None
+class ApiKey(pydantic.BaseModel):
+    key: typing.Optional[str] = None
+    name: typing.Optional[str] = None
+    created_at: typing.Optional[dt.datetime] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/connection.py

@@ -18,7 +18,7 @@ class Connection(pydantic.BaseModel):
     port: typing.Optional[int] = None
     database: str
     username: str
-    password: typing.Optional[str] = None
+    password: str
     extra_params: typing.Optional[typing.Dict[str, typing.Any]] = None
 
     def json(self, **kwargs: typing.Any) -> str:

mixpeek/types/{destination_schema.py → destination.py}

@@ -11,10 +11,10 @@ except ImportError:
     import pydantic  # type: ignore
 
 
-class DestinationSchema(pydantic.BaseModel):
+class Destination(pydantic.BaseModel):
     collection: str
-    new_field_name: str
-    new_embeddings: str
+    field: str
+    embedding: str
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/field_type.py

@@ -2,4 +2,4 @@
 
 import typing
 
-FieldType = typing.Union[typing.AnyStr, typing.Literal["url", "inline"]]
+FieldType = typing.Union[typing.AnyStr, typing.Literal["file_url", "contents"]]

mixpeek/types/model.py

@@ -4,6 +4,7 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from .models import Models
 
 try:
     import pydantic.v1 as pydantic  # type: ignore
@@ -13,7 +14,7 @@ except ImportError:
 
 class Model(pydantic.BaseModel):
     provider: str
-    model: str
+    model: Models
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/models.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+Models = typing.Union[typing.AnyStr, typing.Literal["gpt-3.5-turbo", "gpt-4-turbo-preview"]]

mixpeek/types/{field_schema.py → source.py}

@@ -12,11 +12,10 @@ except ImportError:
     import pydantic  # type: ignore
 
 
-class FieldSchema(pydantic.BaseModel):
-    name: str
+class Source(pydantic.BaseModel):
+    field: str
     type: FieldType
-    embedding_model: typing.Optional[str] = None
-    settings: typing.Optional[typing.Dict[str, typing.Any]] = None
+    settings: typing.Dict[str, typing.Any]
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/{source_schema.py → source_destination_mapping.py}

@@ -4,7 +4,8 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
-from .field_schema import FieldSchema
+from .destination import Destination
+from .source import Source
 
 try:
     import pydantic.v1 as pydantic  # type: ignore
@@ -12,10 +13,10 @@ except ImportError:
     import pydantic  # type: ignore
 
 
-class SourceSchema(pydantic.BaseModel):
-    filters: typing.Dict[str, typing.Any]
-    on_operation: typing.List[str]
-    field: FieldSchema
+class SourceDestinationMapping(pydantic.BaseModel):
+    embedding_model: str
+    source: Source
+    destination: Destination
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/{pipeline_response.py → user.py}

@@ -4,9 +4,8 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from .api_key import ApiKey
 from .connection import Connection
-from .destination_schema import DestinationSchema
-from .source_schema import SourceSchema
 
 try:
     import pydantic.v1 as pydantic  # type: ignore
@@ -14,15 +13,13 @@ except ImportError:
     import pydantic  # type: ignore
 
 
-class PipelineResponse(pydantic.BaseModel):
-    pipeline_id: str
-    created_at: dt.datetime
-    last_run: typing.Optional[dt.datetime] = None
-    enabled: bool
-    connection: Connection
-    source: SourceSchema
-    destination: DestinationSchema
+class User(pydantic.BaseModel):
+    user_id: typing.Optional[str] = None
+    email: str
+    api_keys: typing.Optional[typing.List[ApiKey]] = None
+    index_ids: typing.Optional[typing.List[str]] = None
     metadata: typing.Optional[typing.Dict[str, typing.Any]] = None
+    connections: typing.Optional[typing.List[Connection]] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/users/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+

mixpeek/users/client.py

@@ -0,0 +1,308 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.jsonable_encoder import jsonable_encoder
+from ..core.remove_none_from_dict import remove_none_from_dict
+from ..core.request_options import RequestOptions
+from ..errors.bad_request_error import BadRequestError
+from ..errors.forbidden_error import ForbiddenError
+from ..errors.internal_server_error import InternalServerError
+from ..errors.not_found_error import NotFoundError
+from ..errors.unauthorized_error import UnauthorizedError
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.api_key import ApiKey
+from ..types.connection import Connection
+from ..types.error_response import ErrorResponse
+from ..types.http_validation_error import HttpValidationError
+from ..types.user import User
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class UsersClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def get_user_users_get(self, *, request_options: typing.Optional[RequestOptions] = None) -> User:
+        """
+        Parameters:
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from mixpeek.client import Mixpeek
+
+        client = Mixpeek(
+            authorization="YOUR_AUTHORIZATION",
+            index_id="YOUR_INDEX_ID",
+            api_key="YOUR_API_KEY",
+        )
+        client.users.get_user_users_get()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "users"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(User, _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 401:
+            raise UnauthorizedError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 403:
+            raise ForbiddenError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def update_user_users_put(
+        self,
+        *,
+        api_keys: typing.Optional[typing.Sequence[ApiKey]] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
+        connections: typing.Optional[typing.Sequence[Connection]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> User:
+        """
+        Parameters:
+            - api_keys: typing.Optional[typing.Sequence[ApiKey]].
+
+            - metadata: typing.Optional[typing.Dict[str, typing.Any]].
+
+            - connections: typing.Optional[typing.Sequence[Connection]].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from mixpeek.client import Mixpeek
+
+        client = Mixpeek(
+            authorization="YOUR_AUTHORIZATION",
+            index_id="YOUR_INDEX_ID",
+            api_key="YOUR_API_KEY",
+        )
+        client.users.update_user_users_put()
+        """
+        _request: typing.Dict[str, typing.Any] = {}
+        if api_keys is not OMIT:
+            _request["api_keys"] = api_keys
+        if metadata is not OMIT:
+            _request["metadata"] = metadata
+        if connections is not OMIT:
+            _request["connections"] = connections
+        _response = self._client_wrapper.httpx_client.request(
+            "PUT",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "users"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder(_request)
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(User, _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 401:
+            raise UnauthorizedError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 403:
+            raise ForbiddenError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncUsersClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def get_user_users_get(self, *, request_options: typing.Optional[RequestOptions] = None) -> User:
+        """
+        Parameters:
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from mixpeek.client import AsyncMixpeek
+
+        client = AsyncMixpeek(
+            authorization="YOUR_AUTHORIZATION",
+            index_id="YOUR_INDEX_ID",
+            api_key="YOUR_API_KEY",
+        )
+        await client.users.get_user_users_get()
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "users"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(User, _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 401:
+            raise UnauthorizedError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 403:
+            raise ForbiddenError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def update_user_users_put(
+        self,
+        *,
+        api_keys: typing.Optional[typing.Sequence[ApiKey]] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
+        connections: typing.Optional[typing.Sequence[Connection]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> User:
+        """
+        Parameters:
+            - api_keys: typing.Optional[typing.Sequence[ApiKey]].
+
+            - metadata: typing.Optional[typing.Dict[str, typing.Any]].
+
+            - connections: typing.Optional[typing.Sequence[Connection]].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from mixpeek.client import AsyncMixpeek
+
+        client = AsyncMixpeek(
+            authorization="YOUR_AUTHORIZATION",
+            index_id="YOUR_INDEX_ID",
+            api_key="YOUR_API_KEY",
+        )
+        await client.users.update_user_users_put()
+        """
+        _request: typing.Dict[str, typing.Any] = {}
+        if api_keys is not OMIT:
+            _request["api_keys"] = api_keys
+        if metadata is not OMIT:
+            _request["metadata"] = metadata
+        if connections is not OMIT:
+            _request["connections"] = connections
+        _response = await self._client_wrapper.httpx_client.request(
+            "PUT",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "users"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder(_request)
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(User, _response.json())  # type: ignore
+        if _response.status_code == 400:
+            raise BadRequestError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 401:
+            raise UnauthorizedError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 403:
+            raise ForbiddenError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic.parse_obj_as(ErrorResponse, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)