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

mixpeek/models/objectresponse.py

@@ -0,0 +1,124 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .blobmodel import BlobModel, BlobModelTypedDict
+from .taskstatus import TaskStatus
+from datetime import datetime
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List
+from typing_extensions import NotRequired, TypedDict
+
+
+class ObjectResponseMetadataTypedDict(TypedDict):
+    r"""Additional metadata for the object, appended to downstream documents of connected collections"""
+
+
+class ObjectResponseMetadata(BaseModel):
+    r"""Additional metadata for the object, appended to downstream documents of connected collections"""
+
+
+class ObjectResponseTypedDict(TypedDict):
+    r"""Response model for bucket objects"""
+
+    object_id: str
+    r"""Unique identifier for the object"""
+    bucket_id: str
+    r"""ID of the bucket this object belongs to"""
+    blobs: List[BlobModelTypedDict]
+    r"""List of blobs contained in this object"""
+    status: TaskStatus
+    metadata: ObjectResponseMetadataTypedDict
+    r"""Additional metadata for the object, appended to downstream documents of connected collections"""
+    task_id: NotRequired[Nullable[str]]
+    r"""ID of the task that created this object, used to track the object creation progress and status"""
+    key: NotRequired[Nullable[str]]
+    r"""Storage key/path of the object, used to retrieve the object from storage"""
+    created_by: NotRequired[Nullable[str]]
+    r"""Identifier of the entity that created this object"""
+    error: NotRequired[Nullable[str]]
+    r"""Error message if the object processing failed"""
+    created_at: NotRequired[Nullable[datetime]]
+    r"""Timestamp when the object was created"""
+    updated_at: NotRequired[Nullable[datetime]]
+    r"""Timestamp when the object was last updated"""
+
+
+class ObjectResponse(BaseModel):
+    r"""Response model for bucket objects"""
+
+    object_id: str
+    r"""Unique identifier for the object"""
+
+    bucket_id: str
+    r"""ID of the bucket this object belongs to"""
+
+    blobs: List[BlobModel]
+    r"""List of blobs contained in this object"""
+
+    status: TaskStatus
+
+    metadata: ObjectResponseMetadata
+    r"""Additional metadata for the object, appended to downstream documents of connected collections"""
+
+    task_id: OptionalNullable[str] = UNSET
+    r"""ID of the task that created this object, used to track the object creation progress and status"""
+
+    key: OptionalNullable[str] = UNSET
+    r"""Storage key/path of the object, used to retrieve the object from storage"""
+
+    created_by: OptionalNullable[str] = UNSET
+    r"""Identifier of the entity that created this object"""
+
+    error: OptionalNullable[str] = UNSET
+    r"""Error message if the object processing failed"""
+
+    created_at: OptionalNullable[datetime] = UNSET
+    r"""Timestamp when the object was created"""
+
+    updated_at: OptionalNullable[datetime] = UNSET
+    r"""Timestamp when the object was last updated"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "task_id",
+            "key",
+            "created_by",
+            "error",
+            "created_at",
+            "updated_at",
+        ]
+        nullable_fields = [
+            "task_id",
+            "key",
+            "created_by",
+            "error",
+            "created_at",
+            "updated_at",
+        ]
+        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/{db_model_paginationresponse.py → paginationresponse.py}

@@ -6,7 +6,7 @@ from pydantic import model_serializer
 from typing_extensions import TypedDict
 
 
-class DbModelPaginationResponseTypedDict(TypedDict):
+class PaginationResponseTypedDict(TypedDict):
     total: int
     page: int
     page_size: int
@@ -15,7 +15,7 @@ class DbModelPaginationResponseTypedDict(TypedDict):
     previous_page: Nullable[str]
 
 
-class DbModelPaginationResponse(BaseModel):
+class PaginationResponse(BaseModel):
     total: int
 
     page: int
@@ -38,7 +38,7 @@ class DbModelPaginationResponse(BaseModel):
 
         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/payloadindexconfig.py

@@ -73,7 +73,7 @@ class PayloadIndexConfig(BaseModel):
 
         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/plan.py

@@ -0,0 +1,82 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .resourcetotals import ResourceTotals, ResourceTotalsTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class PlanTypedDict(TypedDict):
+    r"""Subscription plan model"""
+
+    name: str
+    r"""Display name of the plan"""
+    totals: ResourceTotalsTypedDict
+    r"""Resource totals for the organization"""
+    description: NotRequired[Nullable[str]]
+    r"""Plan description"""
+    price_monthly_usd: NotRequired[Nullable[float]]
+    r"""Monthly price in USD"""
+    price_yearly_usd: NotRequired[Nullable[float]]
+    r"""Yearly price in USD"""
+    features: NotRequired[List[str]]
+    r"""Available features for extraction"""
+
+
+class Plan(BaseModel):
+    r"""Subscription plan model"""
+
+    name: str
+    r"""Display name of the plan"""
+
+    totals: ResourceTotals
+    r"""Resource totals for the organization"""
+
+    description: OptionalNullable[str] = UNSET
+    r"""Plan description"""
+
+    price_monthly_usd: OptionalNullable[float] = UNSET
+    r"""Monthly price in USD"""
+
+    price_yearly_usd: OptionalNullable[float] = UNSET
+    r"""Yearly price in USD"""
+
+    features: Optional[List[str]] = None
+    r"""Available features for extraction"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "description",
+            "price_monthly_usd",
+            "price_yearly_usd",
+            "features",
+        ]
+        nullable_fields = ["description", "price_monthly_usd", "price_yearly_usd"]
+        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/recomputestrategy.py

@@ -0,0 +1,12 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class RecomputeStrategy(str, Enum):
+    r"""Strategies for recomputing cache entries"""
+
+    IMMEDIATE = "immediate"
+    BACKGROUND = "background"
+    LAZY = "lazy"

mixpeek/models/resourcetotals.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class ResourceTotalsTypedDict(TypedDict):
+    r"""Resource totals for the organization"""
+
+    storage_gb: float
+    r"""Total storage in GB"""
+    api_calls_per_month: int
+    r"""Total API calls per month"""
+    documents: int
+    r"""Total number of documents"""
+    collections: int
+    r"""Total number of collections"""
+    namespaces: int
+    r"""Total number of namespaces"""
+
+
+class ResourceTotals(BaseModel):
+    r"""Resource totals for the organization"""
+
+    storage_gb: float
+    r"""Total storage in GB"""
+
+    api_calls_per_month: int
+    r"""Total API calls per month"""
+
+    documents: int
+    r"""Total number of documents"""
+
+    collections: int
+    r"""Total number of collections"""
+
+    namespaces: int
+    r"""Total number of namespaces"""

mixpeek/models/{jsonvideooutputsettings.py → retrieverbinding.py}

@@ -6,35 +6,43 @@ from pydantic import model_serializer
 from typing_extensions import NotRequired, TypedDict
 
 
-class JSONVideoOutputSettingsResponseShapeTypedDict(TypedDict):
+class InputsTypedDict(TypedDict):
     pass
 
 
-class JSONVideoOutputSettingsResponseShape(BaseModel):
+class Inputs(BaseModel):
     pass
 
 
-class JSONVideoOutputSettingsTypedDict(TypedDict):
-    response_shape: NotRequired[Nullable[JSONVideoOutputSettingsResponseShapeTypedDict]]
-    prompt: NotRequired[Nullable[str]]
+class RetrieverBindingTypedDict(TypedDict):
+    r"""How a retriever should be used in a taxonomy"""
 
+    retriever_id: str
+    r"""ID of the retriever to use"""
+    inputs: NotRequired[Nullable[InputsTypedDict]]
+    r"""Optional inputs to the retriever. If not provided, will use source collection schema"""
 
-class JSONVideoOutputSettings(BaseModel):
-    response_shape: OptionalNullable[JSONVideoOutputSettingsResponseShape] = UNSET
 
-    prompt: OptionalNullable[str] = UNSET
+class RetrieverBinding(BaseModel):
+    r"""How a retriever should be used in a taxonomy"""
+
+    retriever_id: str
+    r"""ID of the retriever to use"""
+
+    inputs: OptionalNullable[Inputs] = UNSET
+    r"""Optional inputs to the retriever. If not provided, will use source collection schema"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["response_shape", "prompt"]
-        nullable_fields = ["response_shape", "prompt"]
+        optional_fields = ["inputs"]
+        nullable_fields = ["inputs"]
         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/{logodetectsettings.py → retrievercacheconfig.py}

@@ -7,31 +7,40 @@ from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class LogoDetectSettingsTypedDict(TypedDict):
+class RetrieverCacheConfigTypedDict(TypedDict):
+    r"""Configuration for retriever-specific caching"""
+
     enabled: NotRequired[bool]
-    r"""Enable logo detection"""
-    confidence_threshold: NotRequired[Nullable[float]]
-    r"""Minimum confidence threshold for detected logos"""
+    r"""Whether caching is enabled for this retriever"""
+    ttl_seconds: NotRequired[Nullable[int]]
+    r"""Optional retriever-specific TTL override"""
+    score_threshold: NotRequired[Nullable[float]]
+    r"""Optional retriever-specific score threshold"""
+
 
+class RetrieverCacheConfig(BaseModel):
+    r"""Configuration for retriever-specific caching"""
 
-class LogoDetectSettings(BaseModel):
     enabled: Optional[bool] = True
-    r"""Enable logo detection"""
+    r"""Whether caching is enabled for this retriever"""
+
+    ttl_seconds: OptionalNullable[int] = UNSET
+    r"""Optional retriever-specific TTL override"""
 
-    confidence_threshold: OptionalNullable[float] = UNSET
-    r"""Minimum confidence threshold for detected logos"""
+    score_threshold: OptionalNullable[float] = UNSET
+    r"""Optional retriever-specific score threshold"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["enabled", "confidence_threshold"]
-        nullable_fields = ["confidence_threshold"]
+        optional_fields = ["enabled", "ttl_seconds", "score_threshold"]
+        nullable_fields = ["ttl_seconds", "score_threshold"]
         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/retrievermodel.py

@@ -0,0 +1,95 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .bucketschema_output import BucketSchemaOutput, BucketSchemaOutputTypedDict
+from .retrievercacheconfig import RetrieverCacheConfig, RetrieverCacheConfigTypedDict
+from .stageconfig_output import StageConfigOutput, StageConfigOutputTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class RetrieverModelMetadataTypedDict(TypedDict):
+    pass
+
+
+class RetrieverModelMetadata(BaseModel):
+    pass
+
+
+class RetrieverModelTypedDict(TypedDict):
+    r"""Definition of a retriever"""
+
+    retriever_name: str
+    r"""Name of the retriever"""
+    input_schema: BucketSchemaOutputTypedDict
+    r"""Schema definition for bucket objects"""
+    collection_ids: List[str]
+    r"""List of collection IDs to search in"""
+    stages: List[StageConfigOutputTypedDict]
+    r"""List of stages to execute in order"""
+    retriever_id: NotRequired[str]
+    r"""Unique identifier for the retriever"""
+    description: NotRequired[Nullable[str]]
+    r"""Description of the retriever"""
+    metadata: NotRequired[RetrieverModelMetadataTypedDict]
+    cache_config: NotRequired[Nullable[RetrieverCacheConfigTypedDict]]
+    r"""Configuration for retriever-level caching"""
+
+
+class RetrieverModel(BaseModel):
+    r"""Definition of a retriever"""
+
+    retriever_name: str
+    r"""Name of the retriever"""
+
+    input_schema: BucketSchemaOutput
+    r"""Schema definition for bucket objects"""
+
+    collection_ids: List[str]
+    r"""List of collection IDs to search in"""
+
+    stages: List[StageConfigOutput]
+    r"""List of stages to execute in order"""
+
+    retriever_id: Optional[str] = None
+    r"""Unique identifier for the retriever"""
+
+    description: OptionalNullable[str] = UNSET
+    r"""Description of the retriever"""
+
+    metadata: Optional[RetrieverModelMetadata] = None
+
+    cache_config: OptionalNullable[RetrieverCacheConfig] = UNSET
+    r"""Configuration for retriever-level caching"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["retriever_id", "description", "metadata", "cache_config"]
+        nullable_fields = ["description", "cache_config"]
+        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/retrieverqueryrequest.py

@@ -0,0 +1,114 @@
+"""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 List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class RetrieverQueryRequestInputsTypedDict(TypedDict):
+    r"""Input values for the retriever query. These map to the required inputs defined in the retriever's first stage."""
+
+
+class RetrieverQueryRequestInputs(BaseModel):
+    r"""Input values for the retriever query. These map to the required inputs defined in the retriever's first stage."""
+
+
+class RetrieverQueryRequestTypedDict(TypedDict):
+    r"""Query parameters for executing a retriever pipeline.
+
+    This model defines all the parameters that can be provided when running a
+    search using a predefined retriever pipeline. It allows for customizing the
+    query inputs, filtering, sorting, pagination, and result formatting.
+    """
+
+    inputs: RetrieverQueryRequestInputsTypedDict
+    r"""Input values for the retriever query. These map to the required inputs defined in the retriever's first stage."""
+    filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Logical operations for filtering results. Can include AND, OR, NOT conditions with field comparisons."""
+    sorts: NotRequired[Nullable[List[SortOptionTypedDict]]]
+    r"""Controls the ordering of results. Can sort by score (default) or any other document field. This sorts the results from the last stage."""
+    limit: NotRequired[int]
+    r"""Maximum number of results to return. Overrides the default pagination limit in the retriever definition."""
+    offset: NotRequired[int]
+    r"""Number of results to skip. Use with limit for pagination. For large offsets, consider using session_id for cursor-based pagination."""
+    select: NotRequired[Nullable[List[str]]]
+    r"""Specific fields to include in the response. If not specified, returns all fields."""
+    session_id: NotRequired[Nullable[str]]
+    r"""Session identifier for interaction tracking."""
+    return_urls: NotRequired[bool]
+    r"""When true, generates pre-signed URLs for any media assets in the results. May increase response time slightly."""
+
+
+class RetrieverQueryRequest(BaseModel):
+    r"""Query parameters for executing a retriever pipeline.
+
+    This model defines all the parameters that can be provided when running a
+    search using a predefined retriever pipeline. It allows for customizing the
+    query inputs, filtering, sorting, pagination, and result formatting.
+    """
+
+    inputs: RetrieverQueryRequestInputs
+    r"""Input values for the retriever query. These map to the required inputs defined in the retriever's first stage."""
+
+    filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Logical operations for filtering results. Can include AND, OR, NOT conditions with field comparisons."""
+
+    sorts: OptionalNullable[List[SortOption]] = UNSET
+    r"""Controls the ordering of results. Can sort by score (default) or any other document field. This sorts the results from the last stage."""
+
+    limit: Optional[int] = 10
+    r"""Maximum number of results to return. Overrides the default pagination limit in the retriever definition."""
+
+    offset: Optional[int] = 0
+    r"""Number of results to skip. Use with limit for pagination. For large offsets, consider using session_id for cursor-based pagination."""
+
+    select: OptionalNullable[List[str]] = UNSET
+    r"""Specific fields to include in the response. If not specified, returns all fields."""
+
+    session_id: OptionalNullable[str] = UNSET
+    r"""Session identifier for interaction tracking."""
+
+    return_urls: Optional[bool] = False
+    r"""When true, generates pre-signed URLs for any media assets in the results. May increase response time slightly."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "filters",
+            "sorts",
+            "limit",
+            "offset",
+            "select",
+            "session_id",
+            "return_urls",
+        ]
+        nullable_fields = ["filters", "sorts", "select", "session_id"]
+        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/retrieverresponse.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .stageresponse import StageResponse, StageResponseTypedDict
+from mixpeek.types import BaseModel
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class RetrieverResponseTypedDict(TypedDict):
+    r"""Response from a retriever execution"""
+
+    execution_time: float
+    stage_results: NotRequired[List[StageResponseTypedDict]]
+    r"""Results from each stage execution"""
+
+
+class RetrieverResponse(BaseModel):
+    r"""Response from a retriever execution"""
+
+    execution_time: float
+
+    stage_results: Optional[List[StageResponse]] = None
+    r"""Results from each stage execution"""