mixpeek 0.20.19__py3-none-any.whl → 0.21.1__py3-none-any.whl

mixpeek/models/bucketschema_output.py

@@ -0,0 +1,37 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .bucketschemafield_output import (
+    BucketSchemaFieldOutput,
+    BucketSchemaFieldOutputTypedDict,
+)
+from mixpeek.types import BaseModel
+import pydantic
+from pydantic import ConfigDict
+from typing import Any, Dict
+from typing_extensions import TypedDict
+
+
+class BucketSchemaOutputTypedDict(TypedDict):
+    r"""Schema definition for bucket objects"""
+
+    properties: Dict[str, BucketSchemaFieldOutputTypedDict]
+
+
+class BucketSchemaOutput(BaseModel):
+    r"""Schema definition for bucket objects"""
+
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
+
+    properties: Dict[str, BucketSchemaFieldOutput]
+
+    @property
+    def additional_properties(self):
+        return self.__pydantic_extra__
+
+    @additional_properties.setter
+    def additional_properties(self, value):
+        self.__pydantic_extra__ = value  # pyright: ignore[reportIncompatibleVariableOverride]

mixpeek/models/{featureresponse.py → bucketschemafield_input.py}

@@ -1,36 +1,49 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .bucketschemafieldtype import BucketSchemaFieldType
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import ConfigDict, model_serializer
-from typing import Any, Dict
+from typing import Any, Dict, List
 from typing_extensions import NotRequired, TypedDict
 
 
-class FeatureResponseTypedDict(TypedDict):
-    url: NotRequired[Nullable[str]]
-    r"""The presigned URL for accessing the asset"""
-    preview_url: NotRequired[Nullable[str]]
-    r"""The presigned URL for accessing the asset preview"""
-    duplicate_of: NotRequired[Nullable[str]]
-    r"""The asset_id of the asset that this asset is a duplicate of"""
+class BucketSchemaFieldInputTypedDict(TypedDict):
+    r"""Schema field definition for bucket objects"""
 
+    type: BucketSchemaFieldType
+    r"""Enum for field types in bucket schemas"""
+    default: NotRequired[Nullable[Any]]
+    items: NotRequired[Nullable[BucketSchemaFieldInputTypedDict]]
+    properties: NotRequired[Nullable[Dict[str, BucketSchemaFieldInputTypedDict]]]
+    example: NotRequired[Nullable[Any]]
+    description: NotRequired[Nullable[str]]
+    enum: NotRequired[Nullable[List[Any]]]
+
+
+class BucketSchemaFieldInput(BaseModel):
+    r"""Schema field definition for bucket objects"""
 
-class FeatureResponse(BaseModel):
     model_config = ConfigDict(
         populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
     )
     __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
 
-    url: OptionalNullable[str] = UNSET
-    r"""The presigned URL for accessing the asset"""
+    type: BucketSchemaFieldType
+    r"""Enum for field types in bucket schemas"""
+
+    default: OptionalNullable[Any] = UNSET
+
+    items: OptionalNullable[BucketSchemaFieldInput] = UNSET
+
+    properties: OptionalNullable[Dict[str, BucketSchemaFieldInput]] = UNSET
+
+    example: OptionalNullable[Any] = UNSET
 
-    preview_url: OptionalNullable[str] = UNSET
-    r"""The presigned URL for accessing the asset preview"""
+    description: OptionalNullable[str] = UNSET
 
-    duplicate_of: OptionalNullable[str] = UNSET
-    r"""The asset_id of the asset that this asset is a duplicate of"""
+    enum: OptionalNullable[List[Any]] = UNSET
 
     @property
     def additional_properties(self):
@@ -42,15 +55,29 @@ class FeatureResponse(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["url", "preview_url", "duplicate_of"]
-        nullable_fields = ["url", "preview_url", "duplicate_of"]
+        optional_fields = [
+            "default",
+            "items",
+            "properties",
+            "example",
+            "description",
+            "enum",
+        ]
+        nullable_fields = [
+            "default",
+            "items",
+            "properties",
+            "example",
+            "description",
+            "enum",
+        ]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/bucketschemafield_output.py

@@ -0,0 +1,101 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .bucketschemafieldtype import BucketSchemaFieldType
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import ConfigDict, model_serializer
+from typing import Any, Dict, List
+from typing_extensions import NotRequired, TypedDict
+
+
+class BucketSchemaFieldOutputTypedDict(TypedDict):
+    r"""Schema field definition for bucket objects"""
+
+    type: BucketSchemaFieldType
+    r"""Enum for field types in bucket schemas"""
+    default: NotRequired[Nullable[Any]]
+    items: NotRequired[Nullable[BucketSchemaFieldOutputTypedDict]]
+    properties: NotRequired[Nullable[Dict[str, BucketSchemaFieldOutputTypedDict]]]
+    example: NotRequired[Nullable[Any]]
+    description: NotRequired[Nullable[str]]
+    enum: NotRequired[Nullable[List[Any]]]
+
+
+class BucketSchemaFieldOutput(BaseModel):
+    r"""Schema field definition for bucket objects"""
+
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
+
+    type: BucketSchemaFieldType
+    r"""Enum for field types in bucket schemas"""
+
+    default: OptionalNullable[Any] = UNSET
+
+    items: OptionalNullable[BucketSchemaFieldOutput] = UNSET
+
+    properties: OptionalNullable[Dict[str, BucketSchemaFieldOutput]] = UNSET
+
+    example: OptionalNullable[Any] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    enum: OptionalNullable[List[Any]] = UNSET
+
+    @property
+    def additional_properties(self):
+        return self.__pydantic_extra__
+
+    @additional_properties.setter
+    def additional_properties(self, value):
+        self.__pydantic_extra__ = value  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "default",
+            "items",
+            "properties",
+            "example",
+            "description",
+            "enum",
+        ]
+        nullable_fields = [
+            "default",
+            "items",
+            "properties",
+            "example",
+            "description",
+            "enum",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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
+
+        for k, v in serialized.items():
+            m[k] = v
+
+        return m

mixpeek/models/bucketschemafieldtype.py

@@ -0,0 +1,29 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class BucketSchemaFieldType(str, Enum):
+    r"""Enum for field types in bucket schemas"""
+
+    STRING = "string"
+    NUMBER = "number"
+    INTEGER = "integer"
+    BOOLEAN = "boolean"
+    OBJECT = "object"
+    ARRAY = "array"
+    DATE = "date"
+    DATETIME = "datetime"
+    JSON = "json"
+    TEXT = "text"
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    PDF = "pdf"
+    DOCUMENT = "document"
+    SPREADSHEET = "spreadsheet"
+    PRESENTATION = "presentation"
+    DENSE_VECTOR = "dense_vector"
+    SPARSE_VECTOR = "sparse_vector"
+    INT8_VECTOR = "int8_vector"

mixpeek/models/bucketupdaterequest.py

@@ -0,0 +1,68 @@
+"""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_extensions import NotRequired, TypedDict
+
+
+class MetadataTypedDict(TypedDict):
+    pass
+
+
+class Metadata(BaseModel):
+    pass
+
+
+class BucketUpdateRequestTypedDict(TypedDict):
+    r"""Request model for updating an existing bucket"""
+
+    bucket_name: NotRequired[Nullable[str]]
+    r"""Human-readable name for the bucket"""
+    description: NotRequired[Nullable[str]]
+    r"""Description of the bucket"""
+    metadata: NotRequired[Nullable[MetadataTypedDict]]
+    r"""Additional metadata for the bucket"""
+
+
+class BucketUpdateRequest(BaseModel):
+    r"""Request model for updating an existing bucket"""
+
+    bucket_name: OptionalNullable[str] = UNSET
+    r"""Human-readable name for the bucket"""
+
+    description: OptionalNullable[str] = UNSET
+    r"""Description of the bucket"""
+
+    metadata: OptionalNullable[Metadata] = UNSET
+    r"""Additional metadata for the bucket"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["bucket_name", "description", "metadata"]
+        nullable_fields = ["bucket_name", "description", "metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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/cachestats.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel
+from typing import Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class CacheStatsTypedDict(TypedDict):
+    r"""Statistics about cache usage"""
+
+    hits: NotRequired[int]
+    r"""Number of cache hits"""
+    misses: NotRequired[int]
+    r"""Number of cache misses"""
+    size: NotRequired[int]
+    r"""Number of entries in cache"""
+    hit_ratio: NotRequired[float]
+    r"""Cache hit ratio"""
+    retriever_stats: NotRequired[Dict[str, Dict[str, int]]]
+    r"""Statistics per retriever"""
+
+
+class CacheStats(BaseModel):
+    r"""Statistics about cache usage"""
+
+    hits: Optional[int] = 0
+    r"""Number of cache hits"""
+
+    misses: Optional[int] = 0
+    r"""Number of cache misses"""
+
+    size: Optional[int] = 0
+    r"""Number of entries in cache"""
+
+    hit_ratio: Optional[float] = 0
+    r"""Cache hit ratio"""
+
+    retriever_stats: Optional[Dict[str, Dict[str, int]]] = None
+    r"""Statistics per retriever"""

mixpeek/models/{list_collections_v1_collections_getop.py → cleanup_cache_v1_collections_cache_cleanup_postop.py}

@@ -9,23 +9,34 @@ from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class ListCollectionsV1CollectionsGetRequestTypedDict(TypedDict):
-    page: NotRequired[Nullable[int]]
-    page_size: NotRequired[int]
+class CleanupCacheV1CollectionsCacheCleanupPostRequestTypedDict(TypedDict):
+    internal_id: str
+    batch_size: NotRequired[int]
+    redis_url: NotRequired[Nullable[str]]
+    prefix: NotRequired[Nullable[str]]
     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 ListCollectionsV1CollectionsGetRequest(BaseModel):
-    page: Annotated[
-        OptionalNullable[int],
+class CleanupCacheV1CollectionsCacheCleanupPostRequest(BaseModel):
+    internal_id: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+
+    batch_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 1000
+
+    redis_url: Annotated[
+        OptionalNullable[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
 
-    page_size: Annotated[
-        Optional[int],
+    prefix: Annotated[
+        OptionalNullable[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = 10
+    ] = UNSET
 
     x_namespace: Annotated[
         OptionalNullable[str],
@@ -36,15 +47,15 @@ class ListCollectionsV1CollectionsGetRequest(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["page", "page_size", "X-Namespace"]
-        nullable_fields = ["page", "X-Namespace"]
+        optional_fields = ["batch_size", "redis_url", "prefix", "X-Namespace"]
+        nullable_fields = ["redis_url", "prefix", "X-Namespace"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/{inputtype.py → clusteringmethod.py}

@@ -4,8 +4,6 @@ from __future__ import annotations
 from enum import Enum
 
 
-class InputType(str, Enum):
-    URL = "url"
-    TEXT = "text"
-    FILE = "file"
-    BASE64 = "base64"
+class ClusteringMethod(str, Enum):
+    HDBSCAN = "hdbscan"
+    KMEANS = "kmeans"

mixpeek/models/clustertype.py

@@ -0,0 +1,9 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class ClusterType(str, Enum):
+    VECTOR = "vector"
+    ATTRIBUTE = "attribute"

mixpeek/models/collectioncacheconfig_input.py

@@ -0,0 +1,92 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .invalidationevent import InvalidationEvent, InvalidationEventTypedDict
+from .invalidationstrategy import InvalidationStrategy
+from .retrievercacheconfig import RetrieverCacheConfig, RetrieverCacheConfigTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Dict, List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class CollectionCacheConfigInputTypedDict(TypedDict):
+    r"""Configuration for collection-level caching"""
+
+    enabled: NotRequired[bool]
+    r"""Whether caching is enabled"""
+    ttl_seconds: NotRequired[int]
+    r"""Time-to-live for cache entries in seconds"""
+    invalidation_strategy: NotRequired[InvalidationStrategy]
+    r"""Strategies for cache invalidation"""
+    max_entries_per_key: NotRequired[int]
+    r"""Maximum number of results to cache per key"""
+    score_threshold: NotRequired[Nullable[float]]
+    r"""Minimum score threshold for caching results"""
+    invalidation_events: NotRequired[List[InvalidationEventTypedDict]]
+    r"""Events that trigger cache invalidation"""
+    retriever_configs: NotRequired[Dict[str, RetrieverCacheConfigTypedDict]]
+    r"""Retriever-specific cache configurations"""
+
+
+class CollectionCacheConfigInput(BaseModel):
+    r"""Configuration for collection-level caching"""
+
+    enabled: Optional[bool] = True
+    r"""Whether caching is enabled"""
+
+    ttl_seconds: Optional[int] = 604800
+    r"""Time-to-live for cache entries in seconds"""
+
+    invalidation_strategy: Optional[InvalidationStrategy] = None
+    r"""Strategies for cache invalidation"""
+
+    max_entries_per_key: Optional[int] = 5
+    r"""Maximum number of results to cache per key"""
+
+    score_threshold: OptionalNullable[float] = UNSET
+    r"""Minimum score threshold for caching results"""
+
+    invalidation_events: Optional[List[InvalidationEvent]] = None
+    r"""Events that trigger cache invalidation"""
+
+    retriever_configs: Optional[Dict[str, RetrieverCacheConfig]] = None
+    r"""Retriever-specific cache configurations"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "enabled",
+            "ttl_seconds",
+            "invalidation_strategy",
+            "max_entries_per_key",
+            "score_threshold",
+            "invalidation_events",
+            "retriever_configs",
+        ]
+        nullable_fields = ["score_threshold"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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/collectioncacheconfig_output.py

@@ -0,0 +1,92 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .invalidationevent import InvalidationEvent, InvalidationEventTypedDict
+from .invalidationstrategy import InvalidationStrategy
+from .retrievercacheconfig import RetrieverCacheConfig, RetrieverCacheConfigTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Dict, List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class CollectionCacheConfigOutputTypedDict(TypedDict):
+    r"""Configuration for collection-level caching"""
+
+    enabled: NotRequired[bool]
+    r"""Whether caching is enabled"""
+    ttl_seconds: NotRequired[int]
+    r"""Time-to-live for cache entries in seconds"""
+    invalidation_strategy: NotRequired[InvalidationStrategy]
+    r"""Strategies for cache invalidation"""
+    max_entries_per_key: NotRequired[int]
+    r"""Maximum number of results to cache per key"""
+    score_threshold: NotRequired[Nullable[float]]
+    r"""Minimum score threshold for caching results"""
+    invalidation_events: NotRequired[List[InvalidationEventTypedDict]]
+    r"""Events that trigger cache invalidation"""
+    retriever_configs: NotRequired[Dict[str, RetrieverCacheConfigTypedDict]]
+    r"""Retriever-specific cache configurations"""
+
+
+class CollectionCacheConfigOutput(BaseModel):
+    r"""Configuration for collection-level caching"""
+
+    enabled: Optional[bool] = True
+    r"""Whether caching is enabled"""
+
+    ttl_seconds: Optional[int] = 604800
+    r"""Time-to-live for cache entries in seconds"""
+
+    invalidation_strategy: Optional[InvalidationStrategy] = None
+    r"""Strategies for cache invalidation"""
+
+    max_entries_per_key: Optional[int] = 5
+    r"""Maximum number of results to cache per key"""
+
+    score_threshold: OptionalNullable[float] = UNSET
+    r"""Minimum score threshold for caching results"""
+
+    invalidation_events: Optional[List[InvalidationEvent]] = None
+    r"""Events that trigger cache invalidation"""
+
+    retriever_configs: Optional[Dict[str, RetrieverCacheConfig]] = None
+    r"""Retriever-specific cache configurations"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "enabled",
+            "ttl_seconds",
+            "invalidation_strategy",
+            "max_entries_per_key",
+            "score_threshold",
+            "invalidation_events",
+            "retriever_configs",
+        ]
+        nullable_fields = ["score_threshold"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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/collectionconfig.py

@@ -0,0 +1,32 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .enrichmentfield import EnrichmentField, EnrichmentFieldTypedDict
+from .retrieverbinding import RetrieverBinding, RetrieverBindingTypedDict
+from mixpeek.types import BaseModel
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class CollectionConfigTypedDict(TypedDict):
+    r"""Configuration for a collection in the taxonomy"""
+
+    collection_id: str
+    r"""ID of the collection"""
+    retriever: RetrieverBindingTypedDict
+    r"""How a retriever should be used in a taxonomy"""
+    enrichment_fields: NotRequired[List[EnrichmentFieldTypedDict]]
+    r"""Fields to enrich with taxonomy metadata"""
+
+
+class CollectionConfig(BaseModel):
+    r"""Configuration for a collection in the taxonomy"""
+
+    collection_id: str
+    r"""ID of the collection"""
+
+    retriever: RetrieverBinding
+    r"""How a retriever should be used in a taxonomy"""
+
+    enrichment_fields: Optional[List[EnrichmentField]] = None
+    r"""Fields to enrich with taxonomy metadata"""