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

vellum/types/generate_request.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 .chat_message_request import ChatMessageRequest
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateRequest(pydantic.BaseModel):
-    input_values: typing.Dict[str, typing.Any] = pydantic.Field()
+class GenerateRequest(pydantic_v1.BaseModel):
+    input_values: typing.Dict[str, typing.Any] = pydantic_v1.Field()
     """
     Key/value pairs for each template variable defined in the deployment's prompt.
     """
 
-    chat_history: typing.Optional[typing.List[ChatMessageRequest]] = pydantic.Field(default=None)
+    chat_history: typing.Optional[typing.List[ChatMessageRequest]] = pydantic_v1.Field(default=None)
     """
     Optionally provide a list of chat messages that'll be used in place of the special chat_history variable, if included in the prompt.
     """
 
-    external_ids: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
+    external_ids: typing.Optional[typing.List[str]] = pydantic_v1.Field(default=None)
     """
     Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.
     """
@@ -39,5 +35,5 @@ class GenerateRequest(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/generate_result.py

@@ -4,22 +4,18 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
 from .generate_result_data import GenerateResultData
 from .generate_result_error import GenerateResultError
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateResult(pydantic.BaseModel):
-    data: typing.Optional[GenerateResultData] = pydantic.Field(default=None)
+class GenerateResult(pydantic_v1.BaseModel):
+    data: typing.Optional[GenerateResultData] = pydantic_v1.Field(default=None)
     """
     An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.
     """
 
-    error: typing.Optional[GenerateResultError] = pydantic.Field(default=None)
+    error: typing.Optional[GenerateResultError] = pydantic_v1.Field(default=None)
     """
     An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.
     """
@@ -35,5 +31,5 @@ class GenerateResult(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/generate_result_data.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 .enriched_normalized_completion import EnrichedNormalizedCompletion
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateResultData(pydantic.BaseModel):
-    completions: typing.List[EnrichedNormalizedCompletion] = pydantic.Field()
+class GenerateResultData(pydantic_v1.BaseModel):
+    completions: typing.List[EnrichedNormalizedCompletion] = pydantic_v1.Field()
     """
     The generated completions. This will generally be a list of length one.
     """
@@ -29,5 +25,5 @@ class GenerateResultData(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/generate_result_error.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 GenerateResultError(pydantic.BaseModel):
-    message: str = pydantic.Field()
+class GenerateResultError(pydantic_v1.BaseModel):
+    message: str = pydantic_v1.Field()
     """
     The error message returned by the LLM provider.
     """
@@ -28,5 +24,5 @@ class GenerateResultError(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/generate_stream_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
 from .generate_stream_result import GenerateStreamResult
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateStreamResponse(pydantic.BaseModel):
+class GenerateStreamResponse(pydantic_v1.BaseModel):
     delta: GenerateStreamResult
 
     def json(self, **kwargs: typing.Any) -> str:
@@ -26,5 +22,5 @@ class GenerateStreamResponse(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/generate_stream_result.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 .generate_result_error import GenerateResultError
 from .generate_stream_result_data import GenerateStreamResultData
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateStreamResult(pydantic.BaseModel):
+class GenerateStreamResult(pydantic_v1.BaseModel):
     request_index: int
     data: typing.Optional[GenerateStreamResultData] = None
     error: typing.Optional[GenerateResultError] = None
@@ -29,5 +25,5 @@ class GenerateStreamResult(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/generate_stream_result_data.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 .enriched_normalized_completion import EnrichedNormalizedCompletion
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class GenerateStreamResultData(pydantic.BaseModel):
+class GenerateStreamResultData(pydantic_v1.BaseModel):
     completion_index: int
     completion: EnrichedNormalizedCompletion
 
@@ -27,5 +23,5 @@ class GenerateStreamResultData(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/image_chat_message_content.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_image import VellumImage
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class ImageChatMessageContent(pydantic.BaseModel):
+class ImageChatMessageContent(pydantic_v1.BaseModel):
     """
     An image value that is used in a chat message.
     """
@@ -30,5 +26,5 @@ class ImageChatMessageContent(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/image_chat_message_content_request.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_image_request import VellumImageRequest
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class ImageChatMessageContentRequest(pydantic.BaseModel):
+class ImageChatMessageContentRequest(pydantic_v1.BaseModel):
     """
     An image value that is used in a chat message.
     """
@@ -30,5 +26,5 @@ class ImageChatMessageContentRequest(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/image_variable_value.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_image import VellumImage
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class ImageVariableValue(pydantic.BaseModel):
+class ImageVariableValue(pydantic_v1.BaseModel):
     """
     A base Vellum primitive value representing an image.
     """
@@ -30,5 +26,5 @@ class ImageVariableValue(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/indexing_state_enum.py

@@ -1,41 +1,7 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import enum
 import typing
 
-T_Result = typing.TypeVar("T_Result")
-
-
-class IndexingStateEnum(str, enum.Enum):
-    """
-    - `AWAITING_PROCESSING` - Awaiting Processing
-    - `QUEUED` - Queued
-    - `INDEXING` - Indexing
-    - `INDEXED` - Indexed
-    - `FAILED` - Failed
-    """
-
-    AWAITING_PROCESSING = "AWAITING_PROCESSING"
-    QUEUED = "QUEUED"
-    INDEXING = "INDEXING"
-    INDEXED = "INDEXED"
-    FAILED = "FAILED"
-
-    def visit(
-        self,
-        awaiting_processing: typing.Callable[[], T_Result],
-        queued: typing.Callable[[], T_Result],
-        indexing: typing.Callable[[], T_Result],
-        indexed: typing.Callable[[], T_Result],
-        failed: typing.Callable[[], T_Result],
-    ) -> T_Result:
-        if self is IndexingStateEnum.AWAITING_PROCESSING:
-            return awaiting_processing()
-        if self is IndexingStateEnum.QUEUED:
-            return queued()
-        if self is IndexingStateEnum.INDEXING:
-            return indexing()
-        if self is IndexingStateEnum.INDEXED:
-            return indexed()
-        if self is IndexingStateEnum.FAILED:
-            return failed()
+IndexingStateEnum = typing.Union[
+    typing.Literal["AWAITING_PROCESSING", "QUEUED", "INDEXING", "INDEXED", "FAILED"], typing.Any
+]

vellum/types/initiated_execute_prompt_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 .initiated_prompt_execution_meta import InitiatedPromptExecutionMeta
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class InitiatedExecutePromptEvent(pydantic.BaseModel):
+class InitiatedExecutePromptEvent(pydantic_v1.BaseModel):
     """
     The initial data returned indicating that the response from the model has returned and begun streaming.
     """
@@ -31,5 +27,5 @@ class InitiatedExecutePromptEvent(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/initiated_prompt_execution_meta.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 InitiatedPromptExecutionMeta(pydantic.BaseModel):
+class InitiatedPromptExecutionMeta(pydantic_v1.BaseModel):
     """
     The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
     """
@@ -32,5 +28,5 @@ class InitiatedPromptExecutionMeta(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/initiated_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 .node_input_variable_compiled_value import NodeInputVariableCompiledValue
 from .workflow_node_result_data import WorkflowNodeResultData
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
 
-
-class InitiatedWorkflowNodeResultEvent(pydantic.BaseModel):
+class InitiatedWorkflowNodeResultEvent(pydantic_v1.BaseModel):
     """
     An event that indicates that the node has initiated its execution.
     """
@@ -37,5 +33,5 @@ class InitiatedWorkflowNodeResultEvent(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/json_input_request.py

@@ -4,19 +4,15 @@ 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 JsonInputRequest(pydantic.BaseModel):
+class JsonInputRequest(pydantic_v1.BaseModel):
     """
     A user input representing a JSON object
     """
 
-    name: str = pydantic.Field()
+    name: str = pydantic_v1.Field()
     """
     The variable's name, as defined in the deployment.
     """
@@ -34,5 +30,5 @@ class JsonInputRequest(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/json_variable_value.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 JsonVariableValue(pydantic.BaseModel):
+class JsonVariableValue(pydantic_v1.BaseModel):
     value: typing.Optional[typing.Dict[str, typing.Any]] = None
 
     def json(self, **kwargs: typing.Any) -> str:
@@ -25,5 +21,5 @@ class JsonVariableValue(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/logical_operator.py

@@ -1,177 +1,27 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import enum
 import typing
 
-T_Result = typing.TypeVar("T_Result")
-
-
-class LogicalOperator(str, enum.Enum):
-    """
-    - `=` - EQUALS
-    - `!=` - DOES_NOT_EQUAL
-    - `<` - LESS_THAN
-    - `>` - GREATER_THAN
-    - `<=` - LESS_THAN_OR_EQUAL_TO
-    - `>=` - GREATER_THAN_OR_EQUAL_TO
-    - `contains` - CONTAINS
-    - `beginsWith` - BEGINS_WITH
-    - `endsWith` - ENDS_WITH
-    - `doesNotContain` - DOES_NOT_CONTAIN
-    - `doesNotBeginWith` - DOES_NOT_BEGIN_WITH
-    - `doesNotEndWith` - DOES_NOT_END_WITH
-    - `null` - NULL
-    - `notNull` - NOT_NULL
-    - `in` - IN
-    - `notIn` - NOT_IN
-    - `between` - BETWEEN
-    - `notBetween` - NOT_BETWEEN
-    """
-
-    EQUALS = "="
-    """
-    Equals
-    """
-
-    DOES_NOT_EQUAL = "!="
-    """
-    Does not equal
-    """
-
-    LESS_THAN = "<"
-    """
-    Less than
-    """
-
-    GREATER_THAN = ">"
-    """
-    Greater than
-    """
-
-    LESS_THAN_OR_EQUAL_TO = "<="
-    """
-    Less than or equal to
-    """
-
-    GREATER_THAN_OR_EQUAL_TO = ">="
-    """
-    Greater than or equal to
-    """
-
-    CONTAINS = "contains"
-    """
-    Contains
-    """
-
-    BEGINS_WITH = "beginsWith"
-    """
-    Begins with
-    """
-
-    ENDS_WITH = "endsWith"
-    """
-    Ends with
-    """
-
-    DOES_NOT_CONTAIN = "doesNotContain"
-    """
-    Does not contain
-    """
-
-    DOES_NOT_BEGIN_WITH = "doesNotBeginWith"
-    """
-    Does not begin with
-    """
-
-    DOES_NOT_END_WITH = "doesNotEndWith"
-    """
-    Does not end with
-    """
-
-    NULL = "null"
-    """
-    Null
-    """
-
-    NOT_NULL = "notNull"
-    """
-    Not null
-    """
-
-    IN = "in"
-    """
-    In
-    """
-
-    NOT_IN = "notIn"
-    """
-    Not in
-    """
-
-    BETWEEN = "between"
-    """
-    Between
-    """
-
-    NOT_BETWEEN = "notBetween"
-    """
-    Not between
-    """
-
-    def visit(
-        self,
-        equals: typing.Callable[[], T_Result],
-        does_not_equal: typing.Callable[[], T_Result],
-        less_than: typing.Callable[[], T_Result],
-        greater_than: typing.Callable[[], T_Result],
-        less_than_or_equal_to: typing.Callable[[], T_Result],
-        greater_than_or_equal_to: typing.Callable[[], T_Result],
-        contains: typing.Callable[[], T_Result],
-        begins_with: typing.Callable[[], T_Result],
-        ends_with: typing.Callable[[], T_Result],
-        does_not_contain: typing.Callable[[], T_Result],
-        does_not_begin_with: typing.Callable[[], T_Result],
-        does_not_end_with: typing.Callable[[], T_Result],
-        null: typing.Callable[[], T_Result],
-        not_null: typing.Callable[[], T_Result],
-        in_: typing.Callable[[], T_Result],
-        not_in: typing.Callable[[], T_Result],
-        between: typing.Callable[[], T_Result],
-        not_between: typing.Callable[[], T_Result],
-    ) -> T_Result:
-        if self is LogicalOperator.EQUALS:
-            return equals()
-        if self is LogicalOperator.DOES_NOT_EQUAL:
-            return does_not_equal()
-        if self is LogicalOperator.LESS_THAN:
-            return less_than()
-        if self is LogicalOperator.GREATER_THAN:
-            return greater_than()
-        if self is LogicalOperator.LESS_THAN_OR_EQUAL_TO:
-            return less_than_or_equal_to()
-        if self is LogicalOperator.GREATER_THAN_OR_EQUAL_TO:
-            return greater_than_or_equal_to()
-        if self is LogicalOperator.CONTAINS:
-            return contains()
-        if self is LogicalOperator.BEGINS_WITH:
-            return begins_with()
-        if self is LogicalOperator.ENDS_WITH:
-            return ends_with()
-        if self is LogicalOperator.DOES_NOT_CONTAIN:
-            return does_not_contain()
-        if self is LogicalOperator.DOES_NOT_BEGIN_WITH:
-            return does_not_begin_with()
-        if self is LogicalOperator.DOES_NOT_END_WITH:
-            return does_not_end_with()
-        if self is LogicalOperator.NULL:
-            return null()
-        if self is LogicalOperator.NOT_NULL:
-            return not_null()
-        if self is LogicalOperator.IN:
-            return in_()
-        if self is LogicalOperator.NOT_IN:
-            return not_in()
-        if self is LogicalOperator.BETWEEN:
-            return between()
-        if self is LogicalOperator.NOT_BETWEEN:
-            return not_between()
+LogicalOperator = typing.Union[
+    typing.Literal[
+        "=",
+        "!=",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        "contains",
+        "beginsWith",
+        "endsWith",
+        "doesNotContain",
+        "doesNotBeginWith",
+        "doesNotEndWith",
+        "null",
+        "notNull",
+        "in",
+        "notIn",
+        "between",
+        "notBetween",
+    ],
+    typing.Any,
+]

vellum/types/logprobs_enum.py

@@ -1,22 +1,5 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import enum
 import typing
 
-T_Result = typing.TypeVar("T_Result")
-
-
-class LogprobsEnum(str, enum.Enum):
-    """
-    - `ALL` - ALL
-    - `NONE` - NONE
-    """
-
-    ALL = "ALL"
-    NONE = "NONE"
-
-    def visit(self, all_: typing.Callable[[], T_Result], none: typing.Callable[[], T_Result]) -> T_Result:
-        if self is LogprobsEnum.ALL:
-            return all_()
-        if self is LogprobsEnum.NONE:
-            return none()
+LogprobsEnum = typing.Union[typing.Literal["ALL", "NONE"], typing.Any]