mixpeek 0.21.7__py3-none-any.whl → 0.22.0__py3-none-any.whl

mixpeek/models/errordetail.py

@@ -3,21 +3,14 @@
 from __future__ import annotations
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
+from typing import Any, Dict
 from typing_extensions import NotRequired, TypedDict
 
 
-class DetailsTypedDict(TypedDict):
-    pass
-
-
-class Details(BaseModel):
-    pass
-
-
 class ErrorDetailTypedDict(TypedDict):
     message: str
     type: str
-    details: NotRequired[Nullable[DetailsTypedDict]]
+    details: NotRequired[Nullable[Dict[str, Any]]]
 
 
 class ErrorDetail(BaseModel):
@@ -25,7 +18,7 @@ class ErrorDetail(BaseModel):
 
     type: str
 
-    details: OptionalNullable[Details] = UNSET
+    details: OptionalNullable[Dict[str, Any]] = UNSET
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):

mixpeek/models/featureextractorconfig.py

@@ -6,18 +6,10 @@ from .documentoutputhandling import DocumentOutputHandling
 from .documentoutputtype import DocumentOutputType
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class ParametersTypedDict(TypedDict):
-    r"""Custom parameters for the extractor"""
-
-
-class Parameters(BaseModel):
-    r"""Custom parameters for the extractor"""
-
-
 class FeatureExtractorConfigTypedDict(TypedDict):
     r"""Configuration for a feature extractor that is selected for use within a collection.
     This model represents a selected feature extractor along with its specific configuration
@@ -29,7 +21,7 @@ class FeatureExtractorConfigTypedDict(TypedDict):
     r"""Name of the feature extractor"""
     version: str
     r"""Version of the feature extractor"""
-    parameters: NotRequired[ParametersTypedDict]
+    parameters: NotRequired[Dict[str, Any]]
     r"""Custom parameters for the extractor"""
     input_mapping: NotRequired[Dict[str, str]]
     r"""Maps pipeline inputs to extractor inputs (source -> target)"""
@@ -56,7 +48,7 @@ class FeatureExtractorConfig(BaseModel):
     version: str
     r"""Version of the feature extractor"""
 
-    parameters: Optional[Parameters] = None
+    parameters: Optional[Dict[str, Any]] = None
     r"""Custom parameters for the extractor"""
 
     input_mapping: Optional[Dict[str, str]] = None

mixpeek/models/featureextractordefinition.py

@@ -12,38 +12,6 @@ from typing import Any, Dict, List, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class InputSchemaTypedDict(TypedDict):
-    r"""Schema for input data"""
-
-
-class InputSchema(BaseModel):
-    r"""Schema for input data"""
-
-
-class OutputSchemaTypedDict(TypedDict):
-    r"""Schema for output data"""
-
-
-class OutputSchema(BaseModel):
-    r"""Schema for output data"""
-
-
-class ParameterSchemaTypedDict(TypedDict):
-    r"""Schema for parameters"""
-
-
-class ParameterSchema(BaseModel):
-    r"""Schema for parameters"""
-
-
-class DefaultParametersTypedDict(TypedDict):
-    r"""Default parameters"""
-
-
-class DefaultParameters(BaseModel):
-    r"""Default parameters"""
-
-
 class FeatureExtractorDefinitionTypedDict(TypedDict):
     r"""Definition of a feature extractor."""
 
@@ -53,21 +21,21 @@ class FeatureExtractorDefinitionTypedDict(TypedDict):
     r"""Description of the feature extractor"""
     version: str
     r"""Version of the feature extractor"""
-    module_path: str
-    r"""Python module path for the feature extractor"""
     feature_id: NotRequired[str]
     r"""Unique identifier for the feature extractor"""
-    input_schema: NotRequired[InputSchemaTypedDict]
+    module_path: NotRequired[Nullable[str]]
+    r"""Python module path for the feature extractor"""
+    input_schema: NotRequired[Dict[str, Any]]
     r"""Schema for input data"""
-    output_schema: NotRequired[OutputSchemaTypedDict]
+    output_schema: NotRequired[Dict[str, Any]]
     r"""Schema for output data"""
-    parameter_schema: NotRequired[ParameterSchemaTypedDict]
+    parameter_schema: NotRequired[Dict[str, Any]]
     r"""Schema for parameters"""
     supported_input_types: NotRequired[List[str]]
     r"""Supported input types"""
     max_inputs: NotRequired[Dict[str, int]]
     r"""Maximum number of inputs of each type"""
-    default_parameters: NotRequired[DefaultParametersTypedDict]
+    default_parameters: NotRequired[Dict[str, Any]]
     r"""Default parameters"""
     document_output_type: NotRequired[DocumentOutputType]
     r"""Enum for document output types"""
@@ -79,6 +47,8 @@ class FeatureExtractorDefinitionTypedDict(TypedDict):
     r"""Vector indexes required by the extractor"""
     required_payload_indexes: NotRequired[Nullable[List[Any]]]
     r"""Payload indexes required by the extractor"""
+    supported_retriever_stages: NotRequired[Nullable[List[str]]]
+    r"""Retriever stages supported by the extractor"""
 
 
 class FeatureExtractorDefinition(BaseModel):
@@ -98,19 +68,19 @@ class FeatureExtractorDefinition(BaseModel):
     version: str
     r"""Version of the feature extractor"""
 
-    module_path: str
-    r"""Python module path for the feature extractor"""
-
     feature_id: Optional[str] = ""
     r"""Unique identifier for the feature extractor"""
 
-    input_schema: Optional[InputSchema] = None
+    module_path: OptionalNullable[str] = UNSET
+    r"""Python module path for the feature extractor"""
+
+    input_schema: Optional[Dict[str, Any]] = None
     r"""Schema for input data"""
 
-    output_schema: Optional[OutputSchema] = None
+    output_schema: Optional[Dict[str, Any]] = None
     r"""Schema for output data"""
 
-    parameter_schema: Optional[ParameterSchema] = None
+    parameter_schema: Optional[Dict[str, Any]] = None
     r"""Schema for parameters"""
 
     supported_input_types: Optional[List[str]] = None
@@ -119,7 +89,7 @@ class FeatureExtractorDefinition(BaseModel):
     max_inputs: Optional[Dict[str, int]] = None
     r"""Maximum number of inputs of each type"""
 
-    default_parameters: Optional[DefaultParameters] = None
+    default_parameters: Optional[Dict[str, Any]] = None
     r"""Default parameters"""
 
     document_output_type: Optional[DocumentOutputType] = None
@@ -137,6 +107,9 @@ class FeatureExtractorDefinition(BaseModel):
     required_payload_indexes: OptionalNullable[List[Any]] = UNSET
     r"""Payload indexes required by the extractor"""
 
+    supported_retriever_stages: OptionalNullable[List[str]] = UNSET
+    r"""Retriever stages supported by the extractor"""
+
     @property
     def additional_properties(self):
         return self.__pydantic_extra__
@@ -149,6 +122,7 @@ class FeatureExtractorDefinition(BaseModel):
     def serialize_model(self, handler):
         optional_fields = [
             "feature_id",
+            "module_path",
             "input_schema",
             "output_schema",
             "parameter_schema",
@@ -160,8 +134,14 @@ class FeatureExtractorDefinition(BaseModel):
             "document_output_handling",
             "required_vector_indexes",
             "required_payload_indexes",
+            "supported_retriever_stages",
+        ]
+        nullable_fields = [
+            "module_path",
+            "required_vector_indexes",
+            "required_payload_indexes",
+            "supported_retriever_stages",
         ]
-        nullable_fields = ["required_vector_indexes", "required_payload_indexes"]
         null_default_fields = []
 
         serialized = handler(self)

mixpeek/models/interactionresponse.py

@@ -4,18 +4,10 @@ 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 import Any, Dict, List
 from typing_extensions import NotRequired, TypedDict
 
 
-class InteractionResponseMetadataTypedDict(TypedDict):
-    pass
-
-
-class InteractionResponseMetadata(BaseModel):
-    pass
-
-
 class InteractionResponseTypedDict(TypedDict):
     feature_id: str
     r"""ID of the item that was interacted with"""
@@ -25,7 +17,7 @@ class InteractionResponseTypedDict(TypedDict):
     r"""Unique identifier for this interaction"""
     position: NotRequired[Nullable[int]]
     r"""Position in search results where interaction occurred"""
-    metadata: NotRequired[Nullable[InteractionResponseMetadataTypedDict]]
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     r"""Additional context about the interaction"""
     user_id: NotRequired[Nullable[str]]
     r"""Customer's authenticated user identifier - persists across sessions"""
@@ -46,7 +38,7 @@ class InteractionResponse(BaseModel):
     position: OptionalNullable[int] = UNSET
     r"""Position in search results where interaction occurred"""
 
-    metadata: OptionalNullable[InteractionResponseMetadata] = UNSET
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
     r"""Additional context about the interaction"""
 
     user_id: OptionalNullable[str] = UNSET

mixpeek/models/internal/__init__.py

@@ -1,6 +1,40 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from .globals import Globals, GlobalsTypedDict
+from typing import TYPE_CHECKING
+from importlib import import_module
 
+if TYPE_CHECKING:
+    from .globals import Globals, GlobalsTypedDict
 
 __all__ = ["Globals", "GlobalsTypedDict"]
+
+_dynamic_imports: dict[str, str] = {
+    "Globals": ".globals",
+    "GlobalsTypedDict": ".globals",
+}
+
+
+def __getattr__(attr_name: str) -> object:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(
+            f"No {attr_name} found in _dynamic_imports for module name -> {__name__} "
+        )
+
+    try:
+        module = import_module(module_name, __package__)
+        result = getattr(module, attr_name)
+        return result
+    except ImportError as e:
+        raise ImportError(
+            f"Failed to import {attr_name} from {module_name}: {e}"
+        ) from e
+    except AttributeError as e:
+        raise AttributeError(
+            f"Failed to get {attr_name} from {module_name}: {e}"
+        ) from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)

mixpeek/models/logicaloperator_input.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 from .filtercondition import FilterCondition, FilterConditionTypedDict
+from .logicaloperatorbase_input import (
+    LogicalOperatorBaseInput,
+    LogicalOperatorBaseInputTypedDict,
+)
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import model_serializer
@@ -9,14 +13,33 @@ from typing import List, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
+AndTypedDict = TypeAliasType(
+    "AndTypedDict", Union[FilterConditionTypedDict, LogicalOperatorBaseInputTypedDict]
+)
+
+
+And = TypeAliasType("And", Union[FilterCondition, LogicalOperatorBaseInput])
+
+
+OrTypedDict = TypeAliasType(
+    "OrTypedDict", Union[FilterConditionTypedDict, LogicalOperatorBaseInputTypedDict]
+)
+
+
+Or = TypeAliasType("Or", Union[FilterCondition, LogicalOperatorBaseInput])
+
+
+NotTypedDict = TypeAliasType(
+    "NotTypedDict", Union[FilterConditionTypedDict, LogicalOperatorBaseInputTypedDict]
+)
+
+
+Not = TypeAliasType("Not", Union[FilterCondition, LogicalOperatorBaseInput])
+
+
 class LogicalOperatorInputTypedDict(TypedDict):
     r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
-
-    Attributes:
-    AND: List of conditions that must all be true
-    OR: List of conditions where at least one must be true
-    NOT: List of conditions that must all be false
-    case_sensitive: Whether string comparisons are case sensitive
+    Allows one level of nesting to prevent infinite recursion.
     """
 
     and_: NotRequired[Nullable[List[AndTypedDict]]]
@@ -31,12 +54,7 @@ class LogicalOperatorInputTypedDict(TypedDict):
 
 class LogicalOperatorInput(BaseModel):
     r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
-
-    Attributes:
-    AND: List of conditions that must all be true
-    OR: List of conditions where at least one must be true
-    NOT: List of conditions that must all be false
-    case_sensitive: Whether string comparisons are case sensitive
+    Allows one level of nesting to prevent infinite recursion.
     """
 
     and_: Annotated[OptionalNullable[List[And]], pydantic.Field(alias="AND")] = UNSET
@@ -80,27 +98,3 @@ class LogicalOperatorInput(BaseModel):
                 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"])
-
-
-NotTypedDict = TypeAliasType(
-    "NotTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorInputTypedDict"]
-)
-
-
-Not = TypeAliasType("Not", Union[FilterCondition, "LogicalOperatorInput"])

mixpeek/models/logicaloperator_output.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 from .filtercondition import FilterCondition, FilterConditionTypedDict
+from .logicaloperatorbase_output import (
+    LogicalOperatorBaseOutput,
+    LogicalOperatorBaseOutputTypedDict,
+)
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import model_serializer
@@ -9,14 +13,42 @@ from typing import List, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
+LogicalOperatorOutputANDTypedDict = TypeAliasType(
+    "LogicalOperatorOutputANDTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorBaseOutputTypedDict],
+)
+
+
+LogicalOperatorOutputAND = TypeAliasType(
+    "LogicalOperatorOutputAND", Union[FilterCondition, LogicalOperatorBaseOutput]
+)
+
+
+LogicalOperatorOutputORTypedDict = TypeAliasType(
+    "LogicalOperatorOutputORTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorBaseOutputTypedDict],
+)
+
+
+LogicalOperatorOutputOR = TypeAliasType(
+    "LogicalOperatorOutputOR", Union[FilterCondition, LogicalOperatorBaseOutput]
+)
+
+
+LogicalOperatorOutputNOTTypedDict = TypeAliasType(
+    "LogicalOperatorOutputNOTTypedDict",
+    Union[FilterConditionTypedDict, LogicalOperatorBaseOutputTypedDict],
+)
+
+
+LogicalOperatorOutputNOT = TypeAliasType(
+    "LogicalOperatorOutputNOT", Union[FilterCondition, LogicalOperatorBaseOutput]
+)
+
+
 class LogicalOperatorOutputTypedDict(TypedDict):
     r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
-
-    Attributes:
-    AND: List of conditions that must all be true
-    OR: List of conditions where at least one must be true
-    NOT: List of conditions that must all be false
-    case_sensitive: Whether string comparisons are case sensitive
+    Allows one level of nesting to prevent infinite recursion.
     """
 
     and_: NotRequired[Nullable[List[LogicalOperatorOutputANDTypedDict]]]
@@ -31,12 +63,7 @@ class LogicalOperatorOutputTypedDict(TypedDict):
 
 class LogicalOperatorOutput(BaseModel):
     r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
-
-    Attributes:
-    AND: List of conditions that must all be true
-    OR: List of conditions where at least one must be true
-    NOT: List of conditions that must all be false
-    case_sensitive: Whether string comparisons are case sensitive
+    Allows one level of nesting to prevent infinite recursion.
     """
 
     and_: Annotated[
@@ -86,36 +113,3 @@ class LogicalOperatorOutput(BaseModel):
                 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"]
-)
-
-
-LogicalOperatorOutputNOTTypedDict = TypeAliasType(
-    "LogicalOperatorOutputNOTTypedDict",
-    Union[FilterConditionTypedDict, "LogicalOperatorOutputTypedDict"],
-)
-
-
-LogicalOperatorOutputNOT = TypeAliasType(
-    "LogicalOperatorOutputNOT", Union[FilterCondition, "LogicalOperatorOutput"]
-)

mixpeek/models/logicaloperatorbase_input.py

@@ -0,0 +1,74 @@
+"""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
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class LogicalOperatorBaseInputTypedDict(TypedDict):
+    r"""Base logical operation without nesting, used to prevent infinite recursion."""
+
+    and_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical AND operation - all conditions must be true"""
+    or_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical OR operation - at least one condition must be true"""
+    not_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical NOT operation - all conditions must be false"""
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
+
+
+class LogicalOperatorBaseInput(BaseModel):
+    r"""Base logical operation without nesting, used to prevent infinite recursion."""
+
+    and_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="AND")
+    ] = UNSET
+    r"""Logical AND operation - all conditions must be true"""
+
+    or_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="OR")
+    ] = UNSET
+    r"""Logical OR operation - at least one condition must be true"""
+
+    not_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="NOT")
+    ] = UNSET
+    r"""Logical NOT operation - all conditions must be false"""
+
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        nullable_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        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/logicaloperatorbase_output.py

@@ -0,0 +1,74 @@
+"""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
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class LogicalOperatorBaseOutputTypedDict(TypedDict):
+    r"""Base logical operation without nesting, used to prevent infinite recursion."""
+
+    and_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical AND operation - all conditions must be true"""
+    or_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical OR operation - at least one condition must be true"""
+    not_: NotRequired[Nullable[List[FilterConditionTypedDict]]]
+    r"""Logical NOT operation - all conditions must be false"""
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
+
+
+class LogicalOperatorBaseOutput(BaseModel):
+    r"""Base logical operation without nesting, used to prevent infinite recursion."""
+
+    and_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="AND")
+    ] = UNSET
+    r"""Logical AND operation - all conditions must be true"""
+
+    or_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="OR")
+    ] = UNSET
+    r"""Logical OR operation - at least one condition must be true"""
+
+    not_: Annotated[
+        OptionalNullable[List[FilterCondition]], pydantic.Field(alias="NOT")
+    ] = UNSET
+    r"""Logical NOT operation - all conditions must be false"""
+
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        nullable_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        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