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

mixpeek/{embed → storage/sample}/client.py

@@ -4,48 +4,34 @@ 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.configs_response import ConfigsResponse
-from ..types.embedding_response import EmbeddingResponse
-from ..types.error_response import ErrorResponse
-from ..types.http_validation_error import HttpValidationError
-from ..types.modality import Modality
+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.error_response import ErrorResponse
+from ...types.http_validation_error import HttpValidationError
 
 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 EmbedClient:
+class SampleClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    def get_dimensions(
-        self,
-        *,
-        modality: typing.Optional[Modality] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> ConfigsResponse:
+    def database(self, database_name: str, *, request_options: typing.Optional[RequestOptions] = None) -> typing.Any:
         """
         Parameters:
-            - modality: typing.Optional[Modality].
-
-            - model: typing.Optional[str].
+            - database_name: str.
 
             - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
@@ -56,25 +42,18 @@ class EmbedClient:
             index_id="YOUR_INDEX_ID",
             api_key="YOUR_API_KEY",
         )
-        client.embed.get_dimensions()
+        client.storage.sample.database(
+            database_name="database_name",
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {}
-        if modality is not OMIT:
-            _request["modality"] = modality
-        if model is not OMIT:
-            _request["model"] = model
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "embed/config"),
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"storage/sample/database/{jsonable_encoder(database_name)}"
+            ),
             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(
                     {
@@ -90,7 +69,7 @@ class EmbedClient:
             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(ConfigsResponse, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _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:
@@ -109,21 +88,12 @@ class EmbedClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def input_embed_post(
-        self,
-        *,
-        input: str,
-        modality: typing.Optional[Modality] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> EmbeddingResponse:
+    def collection(
+        self, collection_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Any:
         """
         Parameters:
-            - input: str.
-
-            - modality: typing.Optional[Modality].
-
-            - model: typing.Optional[str].
+            - collection_name: str.
 
             - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
@@ -134,27 +104,19 @@ class EmbedClient:
             index_id="YOUR_INDEX_ID",
             api_key="YOUR_API_KEY",
         )
-        client.embed.input_embed_post(
-            input="input",
+        client.storage.sample.collection(
+            collection_name="collection_name",
         )
         """
-        _request: typing.Dict[str, typing.Any] = {"input": input}
-        if modality is not OMIT:
-            _request["modality"] = modality
-        if model is not OMIT:
-            _request["model"] = model
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "embed"),
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"storage/sample/collection/{jsonable_encoder(collection_name)}",
+            ),
             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(
                     {
@@ -170,7 +132,7 @@ class EmbedClient:
             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(EmbeddingResponse, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _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:
@@ -190,22 +152,16 @@ class EmbedClient:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
 
-class AsyncEmbedClient:
+class AsyncSampleClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    async def get_dimensions(
-        self,
-        *,
-        modality: typing.Optional[Modality] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> ConfigsResponse:
+    async def database(
+        self, database_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Any:
         """
         Parameters:
-            - modality: typing.Optional[Modality].
-
-            - model: typing.Optional[str].
+            - database_name: str.
 
             - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
@@ -216,25 +172,18 @@ class AsyncEmbedClient:
             index_id="YOUR_INDEX_ID",
             api_key="YOUR_API_KEY",
         )
-        await client.embed.get_dimensions()
+        await client.storage.sample.database(
+            database_name="database_name",
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {}
-        if modality is not OMIT:
-            _request["modality"] = modality
-        if model is not OMIT:
-            _request["model"] = model
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "embed/config"),
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"storage/sample/database/{jsonable_encoder(database_name)}"
+            ),
             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(
                     {
@@ -250,7 +199,7 @@ class AsyncEmbedClient:
             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(ConfigsResponse, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _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:
@@ -269,21 +218,12 @@ class AsyncEmbedClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def input_embed_post(
-        self,
-        *,
-        input: str,
-        modality: typing.Optional[Modality] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> EmbeddingResponse:
+    async def collection(
+        self, collection_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Any:
         """
         Parameters:
-            - input: str.
-
-            - modality: typing.Optional[Modality].
-
-            - model: typing.Optional[str].
+            - collection_name: str.
 
             - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
@@ -294,27 +234,19 @@ class AsyncEmbedClient:
             index_id="YOUR_INDEX_ID",
             api_key="YOUR_API_KEY",
         )
-        await client.embed.input_embed_post(
-            input="input",
+        await client.storage.sample.collection(
+            collection_name="collection_name",
         )
         """
-        _request: typing.Dict[str, typing.Any] = {"input": input}
-        if modality is not OMIT:
-            _request["modality"] = modality
-        if model is not OMIT:
-            _request["model"] = model
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "embed"),
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"storage/sample/collection/{jsonable_encoder(collection_name)}",
+            ),
             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(
                     {
@@ -330,7 +262,7 @@ class AsyncEmbedClient:
             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(EmbeddingResponse, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _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:

mixpeek/types/__init__.py

@@ -10,6 +10,7 @@ from .destination import Destination
 from .embedding_response import EmbeddingResponse
 from .error_message import ErrorMessage
 from .error_response import ErrorResponse
+from .extract_response import ExtractResponse
 from .field_type import FieldType
 from .generation_response import GenerationResponse
 from .html_params import HtmlParams
@@ -21,6 +22,8 @@ from .modality import Modality
 from .model import Model
 from .models import Models
 from .pdf_params import PdfParams
+from .pipeline_response import PipelineResponse
+from .pipeline_task_response import PipelineTaskResponse
 from .ppt_params import PptParams
 from .pptx_params import PptxParams
 from .settings import Settings
@@ -31,6 +34,7 @@ from .user import User
 from .validation_error import ValidationError
 from .validation_error_loc_item import ValidationErrorLocItem
 from .video_params import VideoParams
+from .workflow_code_response import WorkflowCodeResponse
 from .workflow_response import WorkflowResponse
 from .workflow_settings import WorkflowSettings
 from .xlsx_params import XlsxParams
@@ -46,6 +50,7 @@ __all__ = [
     "EmbeddingResponse",
     "ErrorMessage",
     "ErrorResponse",
+    "ExtractResponse",
     "FieldType",
     "GenerationResponse",
     "HtmlParams",
@@ -57,6 +62,8 @@ __all__ = [
     "Model",
     "Models",
     "PdfParams",
+    "PipelineResponse",
+    "PipelineTaskResponse",
     "PptParams",
     "PptxParams",
     "Settings",
@@ -67,6 +74,7 @@ __all__ = [
     "ValidationError",
     "ValidationErrorLocItem",
     "VideoParams",
+    "WorkflowCodeResponse",
     "WorkflowResponse",
     "WorkflowSettings",
     "XlsxParams",

mixpeek/types/configs_response.py

@@ -12,9 +12,20 @@ except ImportError:
 
 
 class ConfigsResponse(pydantic.BaseModel):
-    dimensions: int
-    elapsed_time: float
-    token_size: int
+    dimensions: int = pydantic.Field()
+    """
+    The dimensions of the processed data.
+    """
+
+    elapsed_time: float = pydantic.Field()
+    """
+    The time taken to process the data.
+    """
+
+    token_size: int = pydantic.Field()
+    """
+    The size of the tokens in the processed data.
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/destination.py

@@ -12,9 +12,20 @@ except ImportError:
 
 
 class Destination(pydantic.BaseModel):
-    collection: str
-    field: str
-    embedding: str
+    collection: str = pydantic.Field()
+    """
+    The collection name
+    """
+
+    field: str = pydantic.Field()
+    """
+    The field name
+    """
+
+    embedding: str = pydantic.Field()
+    """
+    The embedding
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/embedding_response.py

@@ -12,8 +12,12 @@ except ImportError:
 
 
 class EmbeddingResponse(pydantic.BaseModel):
-    embedding: typing.List[float]
-    elapsed_time: float
+    embedding: typing.List[float] = pydantic.Field()
+    """
+    The embedding of the processed data.
+    """
+
+    elapsed_time: typing.Optional[float] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/extract_response.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class ExtractResponse(pydantic.BaseModel):
+    output: typing.Any
+    metadata: typing.Dict[str, typing.Any] = pydantic.Field()
+    """
+    Metadata related to the extraction process.
+    """
+
+    elapsed_time: typing.Optional[float] = None
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        extra = pydantic.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

mixpeek/types/generation_response.py

@@ -13,11 +13,13 @@ except ImportError:
 
 
 class GenerationResponse(pydantic.BaseModel):
-    success: bool
-    status: int
-    error: typing.Optional[typing.Dict[str, typing.Any]] = None
-    response: typing.Dict[str, typing.Any]
+    response: typing.Dict[str, typing.Any] = pydantic.Field()
+    """
+    The response from the generation.
+    """
+
     metadata: typing.Optional[Metadata] = None
+    elapsed_time: typing.Optional[float] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/message.py

@@ -12,8 +12,15 @@ except ImportError:
 
 
 class Message(pydantic.BaseModel):
-    role: str
-    content: str
+    role: str = pydantic.Field()
+    """
+    The role of the message sender.
+    """
+
+    content: str = pydantic.Field()
+    """
+    The content of the message.
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/metadata.py

@@ -13,11 +13,9 @@ except ImportError:
 
 
 class Metadata(pydantic.BaseModel):
-    elapsed_time: typing.Optional[float] = None
     total_tokens: typing.Optional[int] = None
     generation_id: typing.Optional[str] = None
     model: typing.Optional[Model] = 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/modality.py

@@ -2,4 +2,4 @@
 
 import typing
 
-Modality = typing.Union[typing.AnyStr, typing.Literal["video", "image", "audio", "text"]]
+Modality = typing.Any

mixpeek/types/model.py

@@ -13,8 +13,15 @@ except ImportError:
 
 
 class Model(pydantic.BaseModel):
-    provider: str
-    model: Models
+    provider: str = pydantic.Field()
+    """
+    The provider of the model.
+    """
+
+    model: Models = pydantic.Field()
+    """
+    The model to be used.
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/pipeline_response.py

@@ -0,0 +1,49 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from .connection import Connection
+from .source_destination_mapping import SourceDestinationMapping
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class PipelineResponse(pydantic.BaseModel):
+    pipeline_id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The ID of the pipeline
+    """
+
+    enabled: typing.Optional[bool] = None
+    connection: typing.Optional[Connection] = None
+    source_destination_mappings: typing.List[SourceDestinationMapping] = pydantic.Field()
+    """
+    The source-destination mappings
+    """
+
+    metadata: typing.Optional[typing.Dict[str, typing.Any]] = None
+    created_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
+    """
+    The creation time
+    """
+
+    last_run: typing.Optional[dt.datetime] = None
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        extra = pydantic.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

mixpeek/types/pipeline_task_response.py

@@ -0,0 +1,32 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class PipelineTaskResponse(pydantic.BaseModel):
+    task_id: str = pydantic.Field()
+    """
+    The ID of the task
+    """
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        extra = pydantic.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

mixpeek/types/source.py

@@ -13,9 +13,20 @@ except ImportError:
 
 
 class Source(pydantic.BaseModel):
-    field: str
-    type: FieldType
-    settings: typing.Dict[str, typing.Any]
+    field: str = pydantic.Field()
+    """
+    The field name
+    """
+
+    type: FieldType = pydantic.Field()
+    """
+    The type of the field
+    """
+
+    settings: typing.Dict[str, typing.Any] = pydantic.Field()
+    """
+    The settings for the field
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

mixpeek/types/source_destination_mapping.py

@@ -14,9 +14,20 @@ except ImportError:
 
 
 class SourceDestinationMapping(pydantic.BaseModel):
-    embedding_model: str
-    source: Source
-    destination: Destination
+    embedding_model: str = pydantic.Field()
+    """
+    The embedding model
+    """
+
+    source: Source = pydantic.Field()
+    """
+    The source
+    """
+
+    destination: Destination = pydantic.Field()
+    """
+    The destination
+    """
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}