mixpeek 0.11.2__py3-none-any.whl → 0.13__py3-none-any.whl

mixpeek/models/listfeaturesrequest.py

@@ -0,0 +1,77 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .logicaloperator_input import LogicalOperatorInput, LogicalOperatorInputTypedDict
+from .sortoption import SortOption, SortOptionTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ListFeaturesRequestTypedDict(TypedDict):
+    collections: List[str]
+    r"""Collection identifiers - can be either collection IDs or collection names"""
+    filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Complex nested query filters"""
+    sort: NotRequired[Nullable[SortOptionTypedDict]]
+    r"""
+    List of fields to sort by, with direction (asc or desc).
+    NOTE: fields will require a specialty index to use this, consult with the team.
+
+    """
+    select: NotRequired[Nullable[List[Any]]]
+    r"""List of fields to return in results, supports dot notation. Everything else is excluded."""
+    return_urls: NotRequired[bool]
+    r"""When true, generates presigned URLs for assets"""
+
+
+class ListFeaturesRequest(BaseModel):
+    collections: List[str]
+    r"""Collection identifiers - can be either collection IDs or collection names"""
+
+    filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Complex nested query filters"""
+
+    sort: OptionalNullable[SortOption] = UNSET
+    r"""
+    List of fields to sort by, with direction (asc or desc).
+    NOTE: fields will require a specialty index to use this, consult with the team.
+
+    """
+
+    select: OptionalNullable[List[Any]] = UNSET
+    r"""List of fields to return in results, supports dot notation. Everything else is excluded."""
+
+    return_urls: Optional[bool] = False
+    r"""When true, generates presigned URLs for assets"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["filters", "sort", "select", "return_urls"]
+        nullable_fields = ["filters", "sort", "select"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mixpeek/models/listfeaturesresponse.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .featureresponse import FeatureResponse, FeatureResponseTypedDict
+from .features_model_paginationresponse import (
+    FeaturesModelPaginationResponse,
+    FeaturesModelPaginationResponseTypedDict,
+)
+from mixpeek.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class ListFeaturesResponseTypedDict(TypedDict):
+    results: List[FeatureResponseTypedDict]
+    pagination: FeaturesModelPaginationResponseTypedDict
+
+
+class ListFeaturesResponse(BaseModel):
+    results: List[FeatureResponse]
+
+    pagination: FeaturesModelPaginationResponse

mixpeek/models/logicaloperator_input.py

@@ -0,0 +1,88 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .filtercondition import FilterCondition, FilterConditionTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class LogicalOperatorInputTypedDict(TypedDict):
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
+    and_: NotRequired[Nullable[List[AndTypedDict]]]
+    r"""Logical AND operation"""
+    or_: NotRequired[Nullable[List[OrTypedDict]]]
+    r"""Logical OR operation"""
+    nor: NotRequired[Nullable[List[NorTypedDict]]]
+    r"""Logical NOR operation"""
+
+
+class LogicalOperatorInput(BaseModel):
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
+
+    and_: Annotated[OptionalNullable[List[And]], pydantic.Field(alias="AND")] = UNSET
+    r"""Logical AND operation"""
+
+    or_: Annotated[OptionalNullable[List[Or]], pydantic.Field(alias="OR")] = UNSET
+    r"""Logical OR operation"""
+
+    nor: Annotated[OptionalNullable[List[Nor]], pydantic.Field(alias="NOR")] = UNSET
+    r"""Logical NOR operation"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["case_sensitive", "AND", "OR", "NOR"]
+        nullable_fields = ["case_sensitive", "AND", "OR", "NOR"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
+AndTypedDict = TypeAliasType(
+    "AndTypedDict", Union[FilterConditionTypedDict, LogicalOperatorInputTypedDict]
+)
+
+
+And = TypeAliasType("And", Union[FilterCondition, LogicalOperatorInput])
+
+
+OrTypedDict = TypeAliasType(
+    "OrTypedDict", Union[FilterConditionTypedDict, LogicalOperatorInputTypedDict]
+)
+
+
+Or = TypeAliasType("Or", Union[FilterCondition, LogicalOperatorInput])
+
+
+NorTypedDict = TypeAliasType(
+    "NorTypedDict", Union[FilterConditionTypedDict, LogicalOperatorInputTypedDict]
+)
+
+
+Nor = TypeAliasType("Nor", Union[FilterCondition, LogicalOperatorInput])

mixpeek/models/logicaloperator_output.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .filtercondition import FilterCondition, FilterConditionTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class LogicalOperatorOutputTypedDict(TypedDict):
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
+    and_: NotRequired[Nullable[List[LogicalOperatorOutputANDTypedDict]]]
+    r"""Logical AND operation"""
+    or_: NotRequired[Nullable[List[LogicalOperatorOutputORTypedDict]]]
+    r"""Logical OR operation"""
+    nor: NotRequired[Nullable[List[LogicalOperatorOutputNORTypedDict]]]
+    r"""Logical NOR operation"""
+
+
+class LogicalOperatorOutput(BaseModel):
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
+
+    and_: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputAND]], pydantic.Field(alias="AND")
+    ] = UNSET
+    r"""Logical AND operation"""
+
+    or_: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputOR]], pydantic.Field(alias="OR")
+    ] = UNSET
+    r"""Logical OR operation"""
+
+    nor: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputNOR]], pydantic.Field(alias="NOR")
+    ] = UNSET
+    r"""Logical NOR operation"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["case_sensitive", "AND", "OR", "NOR"]
+        nullable_fields = ["case_sensitive", "AND", "OR", "NOR"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
+LogicalOperatorOutputANDTypedDict = TypeAliasType(
+    "LogicalOperatorOutputANDTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorOutputTypedDict],
+)
+
+
+LogicalOperatorOutputAND = TypeAliasType(
+    "LogicalOperatorOutputAND", Union[FilterCondition, LogicalOperatorOutput]
+)
+
+
+LogicalOperatorOutputORTypedDict = TypeAliasType(
+    "LogicalOperatorOutputORTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorOutputTypedDict],
+)
+
+
+LogicalOperatorOutputOR = TypeAliasType(
+    "LogicalOperatorOutputOR", Union[FilterCondition, LogicalOperatorOutput]
+)
+
+
+LogicalOperatorOutputNORTypedDict = TypeAliasType(
+    "LogicalOperatorOutputNORTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorOutputTypedDict],
+)
+
+
+LogicalOperatorOutputNOR = TypeAliasType(
+    "LogicalOperatorOutputNOR", Union[FilterCondition, LogicalOperatorOutput]
+)

mixpeek/models/logodetectsettings.py

@@ -0,0 +1,52 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class LogoDetectSettingsTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+    r"""Enable logo detection"""
+    confidence_threshold: NotRequired[Nullable[float]]
+    r"""Minimum confidence threshold for detected logos"""
+
+
+class LogoDetectSettings(BaseModel):
+    enabled: Optional[bool] = True
+    r"""Enable logo detection"""
+
+    confidence_threshold: OptionalNullable[float] = UNSET
+    r"""Minimum confidence threshold for detected logos"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["enabled", "confidence_threshold"]
+        nullable_fields = ["confidence_threshold"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mixpeek/models/modality.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class Modality(str, Enum):
+    VIDEO = "video"
+    AUDIO = "audio"
+    TEXT = "text"
+    IMAGE = "image"
+    KEYWORD = "keyword"
+    MULTIMODAL = "multimodal"

mixpeek/models/modeldetails.py

@@ -0,0 +1,57 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .modality import Modality
+from .vectortype import VectorType
+from mixpeek.types import BaseModel, Nullable, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List
+from typing_extensions import TypedDict
+
+
+class ModelDetailsTypedDict(TypedDict):
+    r"""Details about a model in the registry"""
+
+    supported_modalities: List[Modality]
+    vector_type: VectorType
+    size: Nullable[int]
+
+
+class ModelDetails(BaseModel):
+    r"""Details about a model in the registry"""
+
+    supported_modalities: List[Modality]
+
+    vector_type: VectorType
+
+    size: Nullable[int]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["size"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mixpeek/models/namespaceresponse.py

@@ -0,0 +1,54 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel, Nullable, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, List
+from typing_extensions import TypedDict
+
+
+class NamespaceResponseTypedDict(TypedDict):
+    namespace_id: str
+    namespace_name: str
+    vector_indexes: List[str]
+    payload_indexes: Nullable[List[Any]]
+
+
+class NamespaceResponse(BaseModel):
+    namespace_id: str
+
+    namespace_name: str
+
+    vector_indexes: List[str]
+
+    payload_indexes: Nullable[List[Any]]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["payload_indexes"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mixpeek/models/organizationmodel.py

@@ -0,0 +1,45 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .usermodel_output import UserModelOutput, UserModelOutputTypedDict
+from datetime import datetime
+from mixpeek.types import BaseModel
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class OrganizationModelMetadataTypedDict(TypedDict):
+    pass
+
+
+class OrganizationModelMetadata(BaseModel):
+    pass
+
+
+class OrganizationModelTypedDict(TypedDict):
+    organization_name: str
+    organization_id: NotRequired[str]
+    internal_id: NotRequired[str]
+    created_at: NotRequired[datetime]
+    account_type: NotRequired[str]
+    credit_count: NotRequired[int]
+    metadata: NotRequired[OrganizationModelMetadataTypedDict]
+    users: NotRequired[List[UserModelOutputTypedDict]]
+
+
+class OrganizationModel(BaseModel):
+    organization_name: str
+
+    organization_id: Optional[str] = None
+
+    internal_id: Optional[str] = None
+
+    created_at: Optional[datetime] = None
+
+    account_type: Optional[str] = "free"
+
+    credit_count: Optional[int] = 1000
+
+    metadata: Optional[OrganizationModelMetadata] = None
+
+    users: Optional[List[UserModelOutput]] = None

mixpeek/models/partial_asset_update_assets_asset_id_patchop.py

@@ -0,0 +1,69 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .updateassetrequest import UpdateAssetRequest, UpdateAssetRequestTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mixpeek.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    PathParamMetadata,
+    RequestMetadata,
+)
+import pydantic
+from pydantic import model_serializer
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class PartialAssetUpdateAssetsAssetIDPatchRequestTypedDict(TypedDict):
+    asset_id: str
+    update_asset_request: UpdateAssetRequestTypedDict
+    x_namespace: NotRequired[Nullable[str]]
+    r"""Optional namespace for data isolation. This can be a namespace name or namespace ID. Example: 'netflix_prod' or 'ns_1234567890'. To create a namespace, use the /namespaces endpoint."""
+
+
+class PartialAssetUpdateAssetsAssetIDPatchRequest(BaseModel):
+    asset_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
+
+    update_asset_request: Annotated[
+        UpdateAssetRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+
+    x_namespace: Annotated[
+        OptionalNullable[str],
+        pydantic.Field(alias="X-Namespace"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = UNSET
+    r"""Optional namespace for data isolation. This can be a namespace name or namespace ID. Example: 'netflix_prod' or 'ns_1234567890'. To create a namespace, use the /namespaces endpoint."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["X-Namespace"]
+        nullable_fields = ["X-Namespace"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mixpeek/models/payloadindexconfig.py

@@ -0,0 +1,94 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .boolindexparams import BoolIndexParams, BoolIndexParamsTypedDict
+from .datetimeindexparams import DatetimeIndexParams, DatetimeIndexParamsTypedDict
+from .floatindexparams import FloatIndexParams, FloatIndexParamsTypedDict
+from .geoindexparams import GeoIndexParams, GeoIndexParamsTypedDict
+from .integerindexparams import IntegerIndexParams, IntegerIndexParamsTypedDict
+from .keywordindexparams import KeywordIndexParams, KeywordIndexParamsTypedDict
+from .payloadschematype import PayloadSchemaType
+from .textindexparams import TextIndexParams, TextIndexParamsTypedDict
+from .uuidindexparams import UUIDIndexParams, UUIDIndexParamsTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+FieldSchemaTypedDict = TypeAliasType(
+    "FieldSchemaTypedDict",
+    Union[
+        FloatIndexParamsTypedDict,
+        GeoIndexParamsTypedDict,
+        DatetimeIndexParamsTypedDict,
+        BoolIndexParamsTypedDict,
+        KeywordIndexParamsTypedDict,
+        UUIDIndexParamsTypedDict,
+        IntegerIndexParamsTypedDict,
+        TextIndexParamsTypedDict,
+    ],
+)
+
+
+FieldSchema = TypeAliasType(
+    "FieldSchema",
+    Union[
+        FloatIndexParams,
+        GeoIndexParams,
+        DatetimeIndexParams,
+        BoolIndexParams,
+        KeywordIndexParams,
+        UUIDIndexParams,
+        IntegerIndexParams,
+        TextIndexParams,
+    ],
+)
+
+
+class PayloadIndexConfigTypedDict(TypedDict):
+    r"""Configuration for a payload index"""
+
+    field_name: str
+    type: PayloadSchemaType
+    field_schema: NotRequired[Nullable[FieldSchemaTypedDict]]
+
+
+class PayloadIndexConfig(BaseModel):
+    r"""Configuration for a payload index"""
+
+    field_name: str
+
+    type: PayloadSchemaType
+
+    field_schema: OptionalNullable[FieldSchema] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["field_schema"]
+        nullable_fields = ["field_schema"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m