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

mixpeek/models/searchinteraction.py

@@ -0,0 +1,81 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .interactiontype import InteractionType
+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 SearchInteractionMetadataTypedDict(TypedDict):
+    pass
+
+
+class SearchInteractionMetadata(BaseModel):
+    pass
+
+
+class SearchInteractionTypedDict(TypedDict):
+    feature_id: str
+    r"""ID of the item that was interacted with"""
+    interaction_type: List[InteractionType]
+    r"""Type of interaction or feedback"""
+    position: NotRequired[Nullable[int]]
+    r"""Position in search results where interaction occurred"""
+    metadata: NotRequired[Nullable[SearchInteractionMetadataTypedDict]]
+    r"""Additional context about the interaction"""
+    user_id: NotRequired[Nullable[str]]
+    r"""Customer's authenticated user identifier - persists across sessions"""
+    session_id: NotRequired[Nullable[str]]
+    r"""Temporary identifier for a single search journey/session (typically 30min-1hr) - tracks anonymous and authenticated users"""
+
+
+class SearchInteraction(BaseModel):
+    feature_id: str
+    r"""ID of the item that was interacted with"""
+
+    interaction_type: List[InteractionType]
+    r"""Type of interaction or feedback"""
+
+    position: OptionalNullable[int] = UNSET
+    r"""Position in search results where interaction occurred"""
+
+    metadata: OptionalNullable[SearchInteractionMetadata] = UNSET
+    r"""Additional context about the interaction"""
+
+    user_id: OptionalNullable[str] = UNSET
+    r"""Customer's authenticated user identifier - persists across sessions"""
+
+    session_id: OptionalNullable[str] = UNSET
+    r"""Temporary identifier for a single search journey/session (typically 30min-1hr) - tracks anonymous and authenticated users"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["position", "metadata", "user_id", "session_id"]
+        nullable_fields = ["position", "metadata", "user_id", "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/singlelineageentry.py

@@ -0,0 +1,99 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .bucketschema_output import BucketSchemaOutput, BucketSchemaOutputTypedDict
+from .featureextractorconfig import (
+    FeatureExtractorConfig,
+    FeatureExtractorConfigTypedDict,
+)
+from .sourceconfig_output import SourceConfigOutput, SourceConfigOutputTypedDict
+from .sourcetype import SourceType
+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 SingleLineageEntryTypedDict(TypedDict):
+    r"""A single entry in the collection lineage path"""
+
+    source_type: SourceType
+    r"""Types of entries in a collection lineage"""
+    output_schema: BucketSchemaOutputTypedDict
+    r"""Schema definition for bucket objects"""
+    collection_id: NotRequired[Nullable[str]]
+    r"""ID of this entry (collection_id)"""
+    bucket_id: NotRequired[Nullable[str]]
+    r"""ID of this entry (bucket_id)"""
+    bucket_config: NotRequired[Nullable[SourceConfigOutputTypedDict]]
+    r"""Bucket details if this is a bucket or using a bucket source"""
+    collection_config: NotRequired[Nullable[SourceConfigOutputTypedDict]]
+    r"""Collection details if this is a collection or using a collection source"""
+    feature_extractors: NotRequired[List[FeatureExtractorConfigTypedDict]]
+    r"""Feature extractors applied"""
+
+
+class SingleLineageEntry(BaseModel):
+    r"""A single entry in the collection lineage path"""
+
+    source_type: SourceType
+    r"""Types of entries in a collection lineage"""
+
+    output_schema: BucketSchemaOutput
+    r"""Schema definition for bucket objects"""
+
+    collection_id: OptionalNullable[str] = UNSET
+    r"""ID of this entry (collection_id)"""
+
+    bucket_id: OptionalNullable[str] = UNSET
+    r"""ID of this entry (bucket_id)"""
+
+    bucket_config: OptionalNullable[SourceConfigOutput] = UNSET
+    r"""Bucket details if this is a bucket or using a bucket source"""
+
+    collection_config: OptionalNullable[SourceConfigOutput] = UNSET
+    r"""Collection details if this is a collection or using a collection source"""
+
+    feature_extractors: Optional[List[FeatureExtractorConfig]] = None
+    r"""Feature extractors applied"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "collection_id",
+            "bucket_id",
+            "bucket_config",
+            "collection_config",
+            "feature_extractors",
+        ]
+        nullable_fields = [
+            "collection_id",
+            "bucket_id",
+            "bucket_config",
+            "collection_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/sortdirection.py

@@ -0,0 +1,11 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class SortDirection(str, Enum):
+    r"""Sort direction options."""
+
+    ASC = "asc"
+    DESC = "desc"

mixpeek/models/sortoption.py

@@ -1,28 +1,36 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from enum import Enum
+from .sortdirection import SortDirection
 from mixpeek.types import BaseModel
-from typing_extensions import TypedDict
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
 
 
-class Direction(str, Enum):
-    r"""Sort direction"""
-
-    ASC = "asc"
-    DESC = "desc"
+class SortOptionTypedDict(TypedDict):
+    r"""Specifies how to sort query results.
 
+    Attributes:
+    field: Field to sort by
+    direction: Sort direction (ascending or descending)
+    """
 
-class SortOptionTypedDict(TypedDict):
     field: str
     r"""Field to sort by, supports dot notation for nested fields"""
-    direction: Direction
-    r"""Sort direction"""
+    direction: NotRequired[SortDirection]
+    r"""Sort direction options."""
 
 
 class SortOption(BaseModel):
+    r"""Specifies how to sort query results.
+
+    Attributes:
+    field: Field to sort by
+    direction: Sort direction (ascending or descending)
+    """
+
     field: str
     r"""Field to sort by, supports dot notation for nested fields"""
 
-    direction: Direction
-    r"""Sort direction"""
+    direction: Optional[SortDirection] = None
+    r"""Sort direction options."""

mixpeek/models/sourceconfig_input.py

@@ -0,0 +1,72 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .logicaloperator_input import LogicalOperatorInput, LogicalOperatorInputTypedDict
+from .sourcetype import SourceType
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class SourceConfigInputTypedDict(TypedDict):
+    r"""Configuration for a collection source"""
+
+    type: SourceType
+    r"""Types of entries in a collection lineage"""
+    bucket_id: NotRequired[Nullable[str]]
+    r"""ID of the source bucket"""
+    prefix_key: NotRequired[Nullable[str]]
+    r"""Optional prefix to filter bucket objects"""
+    collection_id: NotRequired[Nullable[str]]
+    r"""ID of the source collection"""
+    filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Optional filters to apply to the source collection"""
+
+
+class SourceConfigInput(BaseModel):
+    r"""Configuration for a collection source"""
+
+    type: SourceType
+    r"""Types of entries in a collection lineage"""
+
+    bucket_id: OptionalNullable[str] = UNSET
+    r"""ID of the source bucket"""
+
+    prefix_key: OptionalNullable[str] = UNSET
+    r"""Optional prefix to filter bucket objects"""
+
+    collection_id: OptionalNullable[str] = UNSET
+    r"""ID of the source collection"""
+
+    filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Optional filters to apply to the source collection"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["bucket_id", "prefix_key", "collection_id", "filters"]
+        nullable_fields = ["bucket_id", "prefix_key", "collection_id", "filters"]
+        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/sourceconfig_output.py

@@ -0,0 +1,75 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .logicaloperator_output import (
+    LogicalOperatorOutput,
+    LogicalOperatorOutputTypedDict,
+)
+from .sourcetype import SourceType
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class SourceConfigOutputTypedDict(TypedDict):
+    r"""Configuration for a collection source"""
+
+    type: SourceType
+    r"""Types of entries in a collection lineage"""
+    bucket_id: NotRequired[Nullable[str]]
+    r"""ID of the source bucket"""
+    prefix_key: NotRequired[Nullable[str]]
+    r"""Optional prefix to filter bucket objects"""
+    collection_id: NotRequired[Nullable[str]]
+    r"""ID of the source collection"""
+    filters: NotRequired[Nullable[LogicalOperatorOutputTypedDict]]
+    r"""Optional filters to apply to the source collection"""
+
+
+class SourceConfigOutput(BaseModel):
+    r"""Configuration for a collection source"""
+
+    type: SourceType
+    r"""Types of entries in a collection lineage"""
+
+    bucket_id: OptionalNullable[str] = UNSET
+    r"""ID of the source bucket"""
+
+    prefix_key: OptionalNullable[str] = UNSET
+    r"""Optional prefix to filter bucket objects"""
+
+    collection_id: OptionalNullable[str] = UNSET
+    r"""ID of the source collection"""
+
+    filters: OptionalNullable[LogicalOperatorOutput] = UNSET
+    r"""Optional filters to apply to the source collection"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["bucket_id", "prefix_key", "collection_id", "filters"]
+        nullable_fields = ["bucket_id", "prefix_key", "collection_id", "filters"]
+        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/sourcetype.py

@@ -0,0 +1,11 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class SourceType(str, Enum):
+    r"""Types of entries in a collection lineage"""
+
+    BUCKET = "bucket"
+    COLLECTION = "collection"

mixpeek/models/stageconfig_input.py

@@ -0,0 +1,111 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .logicaloperator_input import LogicalOperatorInput, LogicalOperatorInputTypedDict
+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 StageConfigInputParametersTypedDict(TypedDict):
+    r"""Parameters for the stage"""
+
+
+class StageConfigInputParameters(BaseModel):
+    r"""Parameters for the stage"""
+
+
+class StageConfigInputTypedDict(TypedDict):
+    r"""Configuration for how a retriever stage processes queries and handles results.
+
+    This model consolidates stage-specific settings that control behavior
+    during retrieval operations, making it easier to configure stages
+    with consistent options.
+    """
+
+    stage_name: str
+    r"""Name of the stage"""
+    version: str
+    r"""Version of the stage"""
+    module_path: str
+    r"""Python module path for the stage"""
+    parameters: NotRequired[StageConfigInputParametersTypedDict]
+    r"""Parameters for the stage"""
+    pre_filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Filters to apply before the main search is executed"""
+    post_filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Filters to apply to search results after retrieval"""
+    timeout_seconds: NotRequired[Nullable[float]]
+    r"""Maximum execution time for this stage in seconds"""
+    exclude_from_final: NotRequired[bool]
+    r"""If True, results from this stage are used for subsequent stages but excluded from final output"""
+
+
+class StageConfigInput(BaseModel):
+    r"""Configuration for how a retriever stage processes queries and handles results.
+
+    This model consolidates stage-specific settings that control behavior
+    during retrieval operations, making it easier to configure stages
+    with consistent options.
+    """
+
+    stage_name: str
+    r"""Name of the stage"""
+
+    version: str
+    r"""Version of the stage"""
+
+    module_path: str
+    r"""Python module path for the stage"""
+
+    parameters: Optional[StageConfigInputParameters] = None
+    r"""Parameters for the stage"""
+
+    pre_filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Filters to apply before the main search is executed"""
+
+    post_filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Filters to apply to search results after retrieval"""
+
+    timeout_seconds: OptionalNullable[float] = UNSET
+    r"""Maximum execution time for this stage in seconds"""
+
+    exclude_from_final: Optional[bool] = False
+    r"""If True, results from this stage are used for subsequent stages but excluded from final output"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "parameters",
+            "pre_filters",
+            "post_filters",
+            "timeout_seconds",
+            "exclude_from_final",
+        ]
+        nullable_fields = ["pre_filters", "post_filters", "timeout_seconds"]
+        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/stageconfig_output.py

@@ -0,0 +1,114 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .logicaloperator_output import (
+    LogicalOperatorOutput,
+    LogicalOperatorOutputTypedDict,
+)
+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 StageConfigOutputParametersTypedDict(TypedDict):
+    r"""Parameters for the stage"""
+
+
+class StageConfigOutputParameters(BaseModel):
+    r"""Parameters for the stage"""
+
+
+class StageConfigOutputTypedDict(TypedDict):
+    r"""Configuration for how a retriever stage processes queries and handles results.
+
+    This model consolidates stage-specific settings that control behavior
+    during retrieval operations, making it easier to configure stages
+    with consistent options.
+    """
+
+    stage_name: str
+    r"""Name of the stage"""
+    version: str
+    r"""Version of the stage"""
+    module_path: str
+    r"""Python module path for the stage"""
+    parameters: NotRequired[StageConfigOutputParametersTypedDict]
+    r"""Parameters for the stage"""
+    pre_filters: NotRequired[Nullable[LogicalOperatorOutputTypedDict]]
+    r"""Filters to apply before the main search is executed"""
+    post_filters: NotRequired[Nullable[LogicalOperatorOutputTypedDict]]
+    r"""Filters to apply to search results after retrieval"""
+    timeout_seconds: NotRequired[Nullable[float]]
+    r"""Maximum execution time for this stage in seconds"""
+    exclude_from_final: NotRequired[bool]
+    r"""If True, results from this stage are used for subsequent stages but excluded from final output"""
+
+
+class StageConfigOutput(BaseModel):
+    r"""Configuration for how a retriever stage processes queries and handles results.
+
+    This model consolidates stage-specific settings that control behavior
+    during retrieval operations, making it easier to configure stages
+    with consistent options.
+    """
+
+    stage_name: str
+    r"""Name of the stage"""
+
+    version: str
+    r"""Version of the stage"""
+
+    module_path: str
+    r"""Python module path for the stage"""
+
+    parameters: Optional[StageConfigOutputParameters] = None
+    r"""Parameters for the stage"""
+
+    pre_filters: OptionalNullable[LogicalOperatorOutput] = UNSET
+    r"""Filters to apply before the main search is executed"""
+
+    post_filters: OptionalNullable[LogicalOperatorOutput] = UNSET
+    r"""Filters to apply to search results after retrieval"""
+
+    timeout_seconds: OptionalNullable[float] = UNSET
+    r"""Maximum execution time for this stage in seconds"""
+
+    exclude_from_final: Optional[bool] = False
+    r"""If True, results from this stage are used for subsequent stages but excluded from final output"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "parameters",
+            "pre_filters",
+            "post_filters",
+            "timeout_seconds",
+            "exclude_from_final",
+        ]
+        nullable_fields = ["pre_filters", "post_filters", "timeout_seconds"]
+        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