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

mixpeek/models/documentresponse.py

@@ -0,0 +1,87 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from datetime import datetime
+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 DocumentResponseMetadataTypedDict(TypedDict):
+    pass
+
+
+class DocumentResponseMetadata(BaseModel):
+    pass
+
+
+class DocumentResponseTypedDict(TypedDict):
+    r"""Model for document response"""
+
+    document_id: str
+    r"""Unique identifier for the document"""
+    collection_id: str
+    r"""ID of the collection this document belongs to"""
+    internal_id: str
+    r"""Internal organization ID"""
+    namespace_id: str
+    r"""Namespace ID"""
+    created_at: NotRequired[datetime]
+    updated_at: NotRequired[Nullable[datetime]]
+    metadata: NotRequired[DocumentResponseMetadataTypedDict]
+    vectors: NotRequired[Dict[str, List[float]]]
+
+
+class DocumentResponse(BaseModel):
+    r"""Model for document response"""
+
+    document_id: str
+    r"""Unique identifier for the document"""
+
+    collection_id: str
+    r"""ID of the collection this document belongs to"""
+
+    internal_id: str
+    r"""Internal organization ID"""
+
+    namespace_id: str
+    r"""Namespace ID"""
+
+    created_at: Optional[datetime] = None
+
+    updated_at: OptionalNullable[datetime] = UNSET
+
+    metadata: Optional[DocumentResponseMetadata] = None
+
+    vectors: Optional[Dict[str, List[float]]] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["created_at", "updated_at", "metadata", "vectors"]
+        nullable_fields = ["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/{nodeupdate.py → documentupdate.py}

@@ -3,34 +3,43 @@
 from __future__ import annotations
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
+from typing import Dict, List
 from typing_extensions import NotRequired, TypedDict
 
 
-class NodeUpdateTypedDict(TypedDict):
-    node_name: str
-    r"""Name of the taxonomy node (must be lowercase without spaces)"""
-    node_description: NotRequired[Nullable[str]]
-    r"""Optional description of what this node represents"""
+class DocumentUpdateMetadataTypedDict(TypedDict):
+    pass
 
 
-class NodeUpdate(BaseModel):
-    node_name: str
-    r"""Name of the taxonomy node (must be lowercase without spaces)"""
+class DocumentUpdateMetadata(BaseModel):
+    pass
 
-    node_description: OptionalNullable[str] = UNSET
-    r"""Optional description of what this node represents"""
+
+class DocumentUpdateTypedDict(TypedDict):
+    r"""Model for updating an existing document"""
+
+    metadata: NotRequired[Nullable[DocumentUpdateMetadataTypedDict]]
+    vectors: NotRequired[Nullable[Dict[str, List[float]]]]
+
+
+class DocumentUpdate(BaseModel):
+    r"""Model for updating an existing document"""
+
+    metadata: OptionalNullable[DocumentUpdateMetadata] = UNSET
+
+    vectors: OptionalNullable[Dict[str, List[float]]] = UNSET
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["node_description"]
-        nullable_fields = ["node_description"]
+        optional_fields = ["metadata", "vectors"]
+        nullable_fields = ["metadata", "vectors"]
         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/enrichmentfield.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class EnrichmentFieldTypedDict(TypedDict):
+    r"""Configuration for how a field should be enriched"""
+
+    field_name: str
+    r"""Name of the field to enrich"""
+    append: NotRequired[bool]
+    r"""Whether to append to existing values or replace them"""
+
+
+class EnrichmentField(BaseModel):
+    r"""Configuration for how a field should be enriched"""
+
+    field_name: str
+    r"""Name of the field to enrich"""
+
+    append: Optional[bool] = False
+    r"""Whether to append to existing values or replace them"""

mixpeek/models/errordetail.py

@@ -37,7 +37,7 @@ class ErrorDetail(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/{update_node_v1_entities_taxonomies_nodes_node_patchop.py → execute_retriever_v1_retrievers_retrievers_retriever_id_execute_postop.py}

@@ -1,7 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .nodeupdate import NodeUpdate, NodeUpdateTypedDict
+from .retrieverqueryrequest import RetrieverQueryRequest, RetrieverQueryRequestTypedDict
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mixpeek.utils import (
     FieldMetadata,
@@ -14,22 +14,22 @@ from pydantic import model_serializer
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class UpdateNodeV1EntitiesTaxonomiesNodesNodePatchRequestTypedDict(TypedDict):
-    node: str
-    r"""The ID or name of the node to update"""
-    node_update: NodeUpdateTypedDict
+class ExecuteRetrieverV1RetrieversRetrieversRetrieverIDExecutePostRequestTypedDict(
+    TypedDict
+):
+    retriever_id: str
+    retriever_query_request: RetrieverQueryRequestTypedDict
     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 UpdateNodeV1EntitiesTaxonomiesNodesNodePatchRequest(BaseModel):
-    node: Annotated[
+class ExecuteRetrieverV1RetrieversRetrieversRetrieverIDExecutePostRequest(BaseModel):
+    retriever_id: Annotated[
         str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
     ]
-    r"""The ID or name of the node to update"""
 
-    node_update: Annotated[
-        NodeUpdate,
+    retriever_query_request: Annotated[
+        RetrieverQueryRequest,
         FieldMetadata(request=RequestMetadata(media_type="application/json")),
     ]
 
@@ -50,7 +50,7 @@ class UpdateNodeV1EntitiesTaxonomiesNodesNodePatchRequest(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/featureextractorconfig.py

@@ -0,0 +1,116 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .documentinputhandling import DocumentInputHandling
+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_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
+    for a particular collection.
+    This gets stored in the collection settings.
+    """
+
+    feature_extractor_name: str
+    r"""Name of the feature extractor"""
+    version: str
+    r"""Version of the feature extractor"""
+    parameters: NotRequired[ParametersTypedDict]
+    r"""Custom parameters for the extractor"""
+    input_mapping: NotRequired[Dict[str, str]]
+    r"""Maps pipeline inputs to extractor inputs (source -> target)"""
+    output_mapping: NotRequired[Dict[str, str]]
+    r"""Maps extractor outputs to pipeline outputs (source -> target)"""
+    document_output_type: NotRequired[Nullable[DocumentOutputType]]
+    r"""Type of document output produced by the extractor"""
+    document_input_handling: NotRequired[Nullable[DocumentInputHandling]]
+    r"""How documents are provided to the extractor"""
+    document_output_handling: NotRequired[Nullable[DocumentOutputHandling]]
+    r"""How extractor output is handled for documents"""
+
+
+class FeatureExtractorConfig(BaseModel):
+    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
+    for a particular collection.
+    This gets stored in the collection settings.
+    """
+
+    feature_extractor_name: str
+    r"""Name of the feature extractor"""
+
+    version: str
+    r"""Version of the feature extractor"""
+
+    parameters: Optional[Parameters] = None
+    r"""Custom parameters for the extractor"""
+
+    input_mapping: Optional[Dict[str, str]] = None
+    r"""Maps pipeline inputs to extractor inputs (source -> target)"""
+
+    output_mapping: Optional[Dict[str, str]] = None
+    r"""Maps extractor outputs to pipeline outputs (source -> target)"""
+
+    document_output_type: OptionalNullable[DocumentOutputType] = UNSET
+    r"""Type of document output produced by the extractor"""
+
+    document_input_handling: OptionalNullable[DocumentInputHandling] = UNSET
+    r"""How documents are provided to the extractor"""
+
+    document_output_handling: OptionalNullable[DocumentOutputHandling] = UNSET
+    r"""How extractor output is handled for documents"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "parameters",
+            "input_mapping",
+            "output_mapping",
+            "document_output_type",
+            "document_input_handling",
+            "document_output_handling",
+        ]
+        nullable_fields = [
+            "document_output_type",
+            "document_input_handling",
+            "document_output_handling",
+        ]
+        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/featureextractordefinition.py

@@ -0,0 +1,192 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .documentinputhandling import DocumentInputHandling
+from .documentoutputhandling import DocumentOutputHandling
+from .documentoutputtype import DocumentOutputType
+from .vectorindexdefinition import VectorIndexDefinition, VectorIndexDefinitionTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import ConfigDict, model_serializer
+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."""
+
+    feature_extractor_name: str
+    r"""Name of the feature extractor"""
+    description: str
+    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]
+    r"""Schema for input data"""
+    output_schema: NotRequired[OutputSchemaTypedDict]
+    r"""Schema for output data"""
+    parameter_schema: NotRequired[ParameterSchemaTypedDict]
+    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]
+    r"""Default parameters"""
+    document_output_type: NotRequired[DocumentOutputType]
+    r"""Enum for document output types"""
+    document_input_handling: NotRequired[DocumentInputHandling]
+    r"""How documents are provided to the feature extractor"""
+    document_output_handling: NotRequired[DocumentOutputHandling]
+    r"""Enum for document output handling types"""
+    required_vector_indexes: NotRequired[Nullable[List[VectorIndexDefinitionTypedDict]]]
+    r"""Vector indexes required by the extractor"""
+    required_payload_indexes: NotRequired[Nullable[List[Any]]]
+    r"""Payload indexes required by the extractor"""
+
+
+class FeatureExtractorDefinition(BaseModel):
+    r"""Definition of a feature extractor."""
+
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
+
+    feature_extractor_name: str
+    r"""Name of the feature extractor"""
+
+    description: str
+    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: Optional[str] = ""
+    r"""Unique identifier for the feature extractor"""
+
+    input_schema: Optional[InputSchema] = None
+    r"""Schema for input data"""
+
+    output_schema: Optional[OutputSchema] = None
+    r"""Schema for output data"""
+
+    parameter_schema: Optional[ParameterSchema] = None
+    r"""Schema for parameters"""
+
+    supported_input_types: Optional[List[str]] = None
+    r"""Supported input types"""
+
+    max_inputs: Optional[Dict[str, int]] = None
+    r"""Maximum number of inputs of each type"""
+
+    default_parameters: Optional[DefaultParameters] = None
+    r"""Default parameters"""
+
+    document_output_type: Optional[DocumentOutputType] = None
+    r"""Enum for document output types"""
+
+    document_input_handling: Optional[DocumentInputHandling] = None
+    r"""How documents are provided to the feature extractor"""
+
+    document_output_handling: Optional[DocumentOutputHandling] = None
+    r"""Enum for document output handling types"""
+
+    required_vector_indexes: OptionalNullable[List[VectorIndexDefinition]] = UNSET
+    r"""Vector indexes required by the extractor"""
+
+    required_payload_indexes: OptionalNullable[List[Any]] = UNSET
+    r"""Payload indexes required by the extractor"""
+
+    @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 = [
+            "feature_id",
+            "input_schema",
+            "output_schema",
+            "parameter_schema",
+            "supported_input_types",
+            "max_inputs",
+            "default_parameters",
+            "document_output_type",
+            "document_input_handling",
+            "document_output_handling",
+            "required_vector_indexes",
+            "required_payload_indexes",
+        ]
+        nullable_fields = ["required_vector_indexes", "required_payload_indexes"]
+        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/filtercondition.py

@@ -1,51 +1,51 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from enum import Enum
+from .filteroperator import FilterOperator
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
 from typing import Any, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class Operator(str, Enum):
-    r"""Comparison operator"""
-
-    EQ = "eq"
-    NE = "ne"
-    GT = "gt"
-    LT = "lt"
-    GTE = "gte"
-    LTE = "lte"
-    IN = "in"
-    NIN = "nin"
-    IS_NULL = "is_null"
-    TEXT = "text"
-    EXISTS = "exists"
+class FilterConditionTypedDict(TypedDict):
+    r"""Represents a single filter condition.
 
+    Attributes:
+    field: The field to filter on
+    operator: The comparison operator
+    value: The value to compare against
+    """
 
-class FilterConditionTypedDict(TypedDict):
-    key: str
+    field: str
     r"""Field name to filter on"""
+    operator: NotRequired[FilterOperator]
+    r"""Supported filter operators across database implementations."""
     value: NotRequired[Nullable[Any]]
     r"""Value to compare against"""
-    operator: NotRequired[Operator]
-    r"""Comparison operator"""
 
 
 class FilterCondition(BaseModel):
-    key: str
+    r"""Represents a single filter condition.
+
+    Attributes:
+    field: The field to filter on
+    operator: The comparison operator
+    value: The value to compare against
+    """
+
+    field: str
     r"""Field name to filter on"""
 
+    operator: Optional[FilterOperator] = None
+    r"""Supported filter operators across database implementations."""
+
     value: OptionalNullable[Any] = UNSET
     r"""Value to compare against"""
 
-    operator: Optional[Operator] = Operator.EQ
-    r"""Comparison operator"""
-
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["value", "operator"]
+        optional_fields = ["operator", "value"]
         nullable_fields = ["value"]
         null_default_fields = []
 
@@ -53,7 +53,7 @@ class FilterCondition(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/filteroperator.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class FilterOperator(str, Enum):
+    r"""Supported filter operators across database implementations."""
+
+    EQ = "eq"
+    NE = "ne"
+    GT = "gt"
+    LT = "lt"
+    GTE = "gte"
+    LTE = "lte"
+    IN = "in"
+    NIN = "nin"
+    CONTAINS = "contains"
+    STARTS_WITH = "starts_with"
+    ENDS_WITH = "ends_with"
+    REGEX = "regex"
+    EXISTS = "exists"
+    IS_NULL = "is_null"
+    TEXT = "text"

mixpeek/models/generativemodels.py

@@ -0,0 +1,10 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class GenerativeModels(str, Enum):
+    GPT_4 = "gpt-4"
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet"
+    GEMINI_1_5_FLASH = "gemini-1.5-flash"