vellum-ai 0.3.23__py3-none-any.whl → 0.5.0__py3-none-any.whl

vellum/types/prompt_deployment_expand_meta_request_request.py

@@ -4,40 +4,36 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class PromptDeploymentExpandMetaRequestRequest(pydantic.BaseModel):
-    model_name: typing.Optional[bool] = pydantic.Field(default=None)
+class PromptDeploymentExpandMetaRequestRequest(pydantic_v1.BaseModel):
+    model_name: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include the model identifier representing the ML Model invoked by the Prompt Deployment.
     """
 
-    latency: typing.Optional[bool] = pydantic.Field(default=None)
+    latency: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include the time in nanoseconds it took to execute the Prompt Deployment.
     """
 
-    deployment_release_tag: typing.Optional[bool] = pydantic.Field(default=None)
+    deployment_release_tag: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include the release tag of the Prompt Deployment.
     """
 
-    prompt_version_id: typing.Optional[bool] = pydantic.Field(default=None)
+    prompt_version_id: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include the ID of the Prompt Version backing the deployment.
     """
 
-    finish_reason: typing.Optional[bool] = pydantic.Field(default=None)
+    finish_reason: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include the reason provided by the model for why the execution finished.
     """
 
-    usage: typing.Optional[bool] = pydantic.Field(default=None)
+    usage: typing.Optional[bool] = pydantic_v1.Field(default=None)
     """
     If enabled, the response will include model host usage tracking. This may increase latency for some model hosts.
     """
@@ -53,5 +49,5 @@ class PromptDeploymentExpandMetaRequestRequest(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/prompt_execution_meta.py

@@ -4,16 +4,12 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .finish_reason_enum import FinishReasonEnum
 from .ml_model_usage import MlModelUsage
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class PromptExecutionMeta(pydantic.BaseModel):
+class PromptExecutionMeta(pydantic_v1.BaseModel):
     """
     The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
     """
@@ -36,5 +32,5 @@ class PromptExecutionMeta(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/prompt_node_result.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .prompt_node_result_data import PromptNodeResultData
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class PromptNodeResult(pydantic.BaseModel):
+class PromptNodeResult(pydantic_v1.BaseModel):
     """
     A Node Result Event emitted from a Prompt Node.
     """
@@ -30,5 +26,5 @@ class PromptNodeResult(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/prompt_node_result_data.py

@@ -4,14 +4,10 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class PromptNodeResultData(pydantic.BaseModel):
+class PromptNodeResultData(pydantic_v1.BaseModel):
     output_id: str
     array_output_id: typing.Optional[str] = None
     text: typing.Optional[str] = None
@@ -28,5 +24,5 @@ class PromptNodeResultData(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/raw_prompt_execution_overrides_request.py

@@ -4,21 +4,17 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RawPromptExecutionOverridesRequest(pydantic.BaseModel):
+class RawPromptExecutionOverridesRequest(pydantic_v1.BaseModel):
     body: typing.Optional[typing.Dict[str, typing.Any]] = None
-    headers: typing.Optional[typing.Dict[str, typing.Optional[str]]] = pydantic.Field(default=None)
+    headers: typing.Optional[typing.Dict[str, typing.Optional[str]]] = pydantic_v1.Field(default=None)
     """
     The raw headers to send to the model host.
     """
 
-    url: typing.Optional[str] = pydantic.Field(default=None)
+    url: typing.Optional[str] = pydantic_v1.Field(default=None)
     """
     The raw URL to send to the model host.
     """
@@ -34,5 +30,5 @@ class RawPromptExecutionOverridesRequest(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_execute_prompt_event.py

@@ -4,16 +4,12 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .rejected_prompt_execution_meta import RejectedPromptExecutionMeta
 from .vellum_error import VellumError
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedExecutePromptEvent(pydantic.BaseModel):
+class RejectedExecutePromptEvent(pydantic_v1.BaseModel):
     """
     The final data returned indicating an error occurred during the stream.
     """
@@ -33,5 +29,5 @@ class RejectedExecutePromptEvent(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_execute_prompt_response.py

@@ -4,27 +4,23 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .prompt_execution_meta import PromptExecutionMeta
 from .vellum_error import VellumError
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedExecutePromptResponse(pydantic.BaseModel):
+class RejectedExecutePromptResponse(pydantic_v1.BaseModel):
     """
     The unsuccessful response from the model containing an error of what went wrong.
     """
 
     meta: typing.Optional[PromptExecutionMeta] = None
-    raw: typing.Optional[typing.Dict[str, typing.Any]] = pydantic.Field(default=None)
+    raw: typing.Optional[typing.Dict[str, typing.Any]] = pydantic_v1.Field(default=None)
     """
     The subset of the raw response from the model that the request opted into with `expand_raw`.
     """
 
-    execution_id: str = pydantic.Field()
+    execution_id: str = pydantic_v1.Field()
     """
     The ID of the execution.
     """
@@ -42,5 +38,5 @@ class RejectedExecutePromptResponse(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_execute_workflow_workflow_result_event.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .workflow_event_error import WorkflowEventError
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedExecuteWorkflowWorkflowResultEvent(pydantic.BaseModel):
+class RejectedExecuteWorkflowWorkflowResultEvent(pydantic_v1.BaseModel):
     """
     The unsuccessful response from the Workflow execution containing an error specifying what went wrong.
     """
@@ -32,5 +28,5 @@ class RejectedExecuteWorkflowWorkflowResultEvent(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_function_call.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .vellum_error import VellumError
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedFunctionCall(pydantic.BaseModel):
+class RejectedFunctionCall(pydantic_v1.BaseModel):
     """
     Returned if the function call failed to parse for some reason.
     """
@@ -32,5 +28,5 @@ class RejectedFunctionCall(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_prompt_execution_meta.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .finish_reason_enum import FinishReasonEnum
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedPromptExecutionMeta(pydantic.BaseModel):
+class RejectedPromptExecutionMeta(pydantic_v1.BaseModel):
     """
     The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
     """
@@ -31,5 +27,5 @@ class RejectedPromptExecutionMeta(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/rejected_workflow_node_result_event.py

@@ -4,16 +4,12 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .workflow_event_error import WorkflowEventError
 from .workflow_node_result_data import WorkflowNodeResultData
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RejectedWorkflowNodeResultEvent(pydantic.BaseModel):
+class RejectedWorkflowNodeResultEvent(pydantic_v1.BaseModel):
     """
     An event that indicates that the node has rejected its execution.
     """
@@ -37,5 +33,5 @@ class RejectedWorkflowNodeResultEvent(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/sandbox_scenario.py

@@ -4,26 +4,22 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .scenario_input import ScenarioInput
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SandboxScenario(pydantic.BaseModel):
+class SandboxScenario(pydantic_v1.BaseModel):
     """
     Sandbox Scenario
     """
 
     label: typing.Optional[str] = None
-    inputs: typing.List[ScenarioInput] = pydantic.Field()
+    inputs: typing.List[ScenarioInput] = pydantic_v1.Field()
     """
     The inputs for the scenario
     """
 
-    id: str = pydantic.Field()
+    id: str = pydantic_v1.Field()
     """
     The id of the scenario
     """
@@ -39,5 +35,5 @@ class SandboxScenario(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/scenario_input.py

@@ -1,34 +1,31 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import datetime as dt
+from __future__ import annotations
+
 import typing
 
-from ..core.datetime_utils import serialize_datetime
-from .chat_message import ChatMessage
-from .scenario_input_type_enum import ScenarioInputTypeEnum
+from .scenario_input_chat_history_variable_value import ScenarioInputChatHistoryVariableValue
+from .scenario_input_string_variable_value import ScenarioInputStringVariableValue
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
+class ScenarioInput_String(ScenarioInputStringVariableValue):
+    type: typing.Literal["STRING"] = "STRING"
 
-class ScenarioInput(pydantic.BaseModel):
-    key: str
-    type: typing.Optional[ScenarioInputTypeEnum] = None
-    value: typing.Optional[str] = None
-    chat_history: typing.Optional[typing.List[ChatMessage]] = None
+    class Config:
+        frozen = True
+        smart_union = True
+        allow_population_by_field_name = True
+        populate_by_name = True
 
-    def json(self, **kwargs: typing.Any) -> str:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().json(**kwargs_with_defaults)
 
-    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().dict(**kwargs_with_defaults)
+class ScenarioInput_ChatHistory(ScenarioInputChatHistoryVariableValue):
+    type: typing.Literal["CHAT_HISTORY"] = "CHAT_HISTORY"
 
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
-        json_encoders = {dt.datetime: serialize_datetime}
+        allow_population_by_field_name = True
+        populate_by_name = True
+
+
+ScenarioInput = typing.Union[ScenarioInput_String, ScenarioInput_ChatHistory]

vellum/types/{registered_prompt_sandbox.py → scenario_input_chat_history_variable_value.py}

@@ -4,23 +4,17 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
+from .chat_message import ChatMessage
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RegisteredPromptSandbox(pydantic.BaseModel):
-    id: str = pydantic.Field()
+class ScenarioInputChatHistoryVariableValue(pydantic_v1.BaseModel):
     """
-    The ID of the generated sandbox.
+    Prompt Sandbox Scenario input value that is of type CHAT_HISTORY
     """
 
-    label: str = pydantic.Field()
-    """
-    A human-friendly label for the generated sandbox.
-    """
+    value: typing.Optional[typing.List[ChatMessage]] = None
+    input_variable_id: str
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
@@ -33,5 +27,5 @@ class RegisteredPromptSandbox(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/{register_prompt_error_response.py → scenario_input_string_variable_value.py}

@@ -4,19 +4,17 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class RegisterPromptErrorResponse(pydantic.BaseModel):
-    detail: str = pydantic.Field()
+class ScenarioInputStringVariableValue(pydantic_v1.BaseModel):
     """
-    Details about why the request failed.
+    Prompt Sandbox Scenario input value that is of type STRING
     """
 
+    value: typing.Optional[str] = None
+    input_variable_id: str
+
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
         return super().json(**kwargs_with_defaults)
@@ -28,5 +26,5 @@ class RegisterPromptErrorResponse(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/search_error_response.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SearchErrorResponse(pydantic.BaseModel):
-    detail: str = pydantic.Field()
+class SearchErrorResponse(pydantic_v1.BaseModel):
+    detail: str = pydantic_v1.Field()
     """
     Details about why the request failed.
     """
@@ -28,5 +24,5 @@ class SearchErrorResponse(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/search_filters_request.py

@@ -4,21 +4,17 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .metadata_filter_config_request import MetadataFilterConfigRequest
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SearchFiltersRequest(pydantic.BaseModel):
-    external_ids: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
+class SearchFiltersRequest(pydantic_v1.BaseModel):
+    external_ids: typing.Optional[typing.List[str]] = pydantic_v1.Field(default=None)
     """
     The document external IDs to filter by
     """
 
-    metadata: typing.Optional[MetadataFilterConfigRequest] = pydantic.Field(default=None)
+    metadata: typing.Optional[MetadataFilterConfigRequest] = pydantic_v1.Field(default=None)
     """
     The metadata filters to apply to the search
     """
@@ -34,5 +30,5 @@ class SearchFiltersRequest(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/search_node_result.py

@@ -4,15 +4,11 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .search_node_result_data import SearchNodeResultData
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SearchNodeResult(pydantic.BaseModel):
+class SearchNodeResult(pydantic_v1.BaseModel):
     """
     A Node Result Event emitted from a Search Node.
     """
@@ -30,5 +26,5 @@ class SearchNodeResult(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/search_node_result_data.py

@@ -4,17 +4,13 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .search_result import SearchResult
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SearchNodeResultData(pydantic.BaseModel):
+class SearchNodeResultData(pydantic_v1.BaseModel):
     results_output_id: str
-    results: typing.List[SearchResult] = pydantic.Field()
+    results: typing.List[SearchResult] = pydantic_v1.Field()
     """
     The results of the search. Each result represents a chunk that matches the search query.
     """
@@ -33,5 +29,5 @@ class SearchNodeResultData(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}

vellum/types/search_request_options_request.py

@@ -4,33 +4,29 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .search_filters_request import SearchFiltersRequest
 from .search_result_merging_request import SearchResultMergingRequest
 from .search_weights_request import SearchWeightsRequest
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class SearchRequestOptionsRequest(pydantic.BaseModel):
-    limit: typing.Optional[int] = pydantic.Field(default=None)
+class SearchRequestOptionsRequest(pydantic_v1.BaseModel):
+    limit: typing.Optional[int] = pydantic_v1.Field(default=None)
     """
     The maximum number of results to return.
     """
 
-    weights: typing.Optional[SearchWeightsRequest] = pydantic.Field(default=None)
+    weights: typing.Optional[SearchWeightsRequest] = pydantic_v1.Field(default=None)
     """
     The weights to use for the search. Must add up to 1.0.
     """
 
-    result_merging: typing.Optional[SearchResultMergingRequest] = pydantic.Field(default=None)
+    result_merging: typing.Optional[SearchResultMergingRequest] = pydantic_v1.Field(default=None)
     """
     The configuration for merging results.
     """
 
-    filters: typing.Optional[SearchFiltersRequest] = pydantic.Field(default=None)
+    filters: typing.Optional[SearchFiltersRequest] = pydantic_v1.Field(default=None)
     """
     The filters to apply to the search.
     """
@@ -46,5 +42,5 @@ class SearchRequestOptionsRequest(pydantic.BaseModel):
     class Config:
         frozen = True
         smart_union = True
-        extra = pydantic.Extra.allow
+        extra = pydantic_v1.Extra.allow
         json_encoders = {dt.datetime: serialize_datetime}