vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum_ee/workflows/tests/test_virtual_files.py

@@ -80,3 +80,51 @@ def test_base_class_dynamic_import(files):
         assert instance.id
     except Exception as e:
         pytest.fail(f"Failed to create an instance of BaseClass: {e}")
+
+
+def test_display_directory_not_auto_generated():
+    """
+    Test that the top-level display directory is NOT auto-generated with empty __init__.py.
+    Display directories typically have specific __init__.py content (e.g., "from .workflow import *")
+    that should not be replaced with empty auto-generated files.
+    """
+    # GIVEN a workflow with display/workflow.py but NO display/__init__.py
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.bases import BaseNode
+
+class StartNode(BaseNode):
+    pass
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+""",
+        "display/workflow.py": """\
+from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
+
+class WorkflowDisplay(BaseWorkflowDisplay):
+    pass
+""",
+        # Note: NO "display/__init__.py" in files dict
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    try:
+        # WHEN we try to resolve display/__init__.py
+        import importlib.util
+
+        spec = importlib.util.find_spec(f"{namespace}.display")
+
+        # THEN the spec should be found because we now support dynamic display module imports
+        assert spec
+        assert spec.origin == "display/__init__.py"
+
+    finally:
+        # Clean up
+        sys.meta_path = [finder for finder in sys.meta_path if not isinstance(finder, VirtualFileFinder)]

vellum/client/resources/release_reviews/client.py

@@ -1,254 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ...core.client_wrapper import SyncClientWrapper
-import typing
-from ...core.request_options import RequestOptions
-from ...types.prompt_deployment_release import PromptDeploymentRelease
-from ...core.jsonable_encoder import jsonable_encoder
-from ...core.pydantic_utilities import parse_obj_as
-from json.decoder import JSONDecodeError
-from ...core.api_error import ApiError
-from ...types.workflow_deployment_release import WorkflowDeploymentRelease
-from ...core.client_wrapper import AsyncClientWrapper
-
-
-class ReleaseReviewsClient:
-    def __init__(self, *, client_wrapper: SyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    def retrieve_prompt_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> PromptDeploymentRelease:
-        """
-        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        PromptDeploymentRelease
-
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.release_reviews.retrieve_prompt_deployment_release(
-            id="id",
-            release_id_or_release_tag="release_id_or_release_tag",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    PromptDeploymentRelease,
-                    parse_obj_as(
-                        type_=PromptDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    def retrieve_workflow_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> WorkflowDeploymentRelease:
-        """
-        Retrieve a specific Workflow Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this workflow deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Workflow Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Workflow Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        WorkflowDeploymentRelease
-
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.release_reviews.retrieve_workflow_deployment_release(
-            id="id",
-            release_id_or_release_tag="release_id_or_release_tag",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    WorkflowDeploymentRelease,
-                    parse_obj_as(
-                        type_=WorkflowDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-
-class AsyncReleaseReviewsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def retrieve_prompt_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> PromptDeploymentRelease:
-        """
-        Retrieve a specific Prompt Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Prompt Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Prompt Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        PromptDeploymentRelease
-
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.release_reviews.retrieve_prompt_deployment_release(
-                id="id",
-                release_id_or_release_tag="release_id_or_release_tag",
-            )
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            f"v1/deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    PromptDeploymentRelease,
-                    parse_obj_as(
-                        type_=PromptDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    async def retrieve_workflow_deployment_release(
-        self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> WorkflowDeploymentRelease:
-        """
-        Retrieve a specific Workflow Deployment Release by either its UUID or the name of a Release Tag that points to it.
-
-        Parameters
-        ----------
-        id : str
-            A UUID string identifying this workflow deployment.
-
-        release_id_or_release_tag : str
-            Either the UUID of Workflow Deployment Release you'd like to retrieve, or the name of a Release Tag that's pointing to the Workflow Deployment Release you'd like to retrieve.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        WorkflowDeploymentRelease
-
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.release_reviews.retrieve_workflow_deployment_release(
-                id="id",
-                release_id_or_release_tag="release_id_or_release_tag",
-            )
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases/{jsonable_encoder(release_id_or_release_tag)}",
-            base_url=self._client_wrapper.get_environment().default,
-            method="GET",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    WorkflowDeploymentRelease,
-                    parse_obj_as(
-                        type_=WorkflowDeploymentRelease,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)

vellum/client/types/node_event_display_context.py

@@ -1,30 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from __future__ import annotations
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-from ..core.pydantic_utilities import update_forward_refs
-
-
-class NodeEventDisplayContext(UniversalBaseModel):
-    input_display: typing.Dict[str, str]
-    output_display: typing.Dict[str, str]
-    port_display: typing.Dict[str, str]
-    subworkflow_display: typing.Optional["WorkflowEventDisplayContext"] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
-
-
-from .workflow_event_display_context import WorkflowEventDisplayContext  # noqa: E402
-
-update_forward_refs(WorkflowEventDisplayContext, NodeEventDisplayContext=NodeEventDisplayContext)
-update_forward_refs(NodeEventDisplayContext)

vellum/client/types/workflow_event_display_context.py

@@ -1,28 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from __future__ import annotations
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-from ..core.pydantic_utilities import update_forward_refs
-
-
-class WorkflowEventDisplayContext(UniversalBaseModel):
-    node_displays: typing.Dict[str, "NodeEventDisplayContext"]
-    workflow_inputs: typing.Dict[str, str]
-    workflow_outputs: typing.Dict[str, str]
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
-
-
-from .node_event_display_context import NodeEventDisplayContext  # noqa: E402
-
-update_forward_refs(WorkflowEventDisplayContext)

vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py

@@ -1,5 +0,0 @@
-from .node import OpenAIChatCompletionNode
-
-__all__ = [
-    "OpenAIChatCompletionNode",
-]

vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py

@@ -1,266 +0,0 @@
-import json
-import logging
-import os
-from uuid import uuid4
-from typing import Any, Iterable, Iterator, List, Literal, Union, cast
-
-from openai import OpenAI
-from openai.types.chat import (
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionContentPartImageParam,
-    ChatCompletionContentPartInputAudioParam,
-    ChatCompletionContentPartParam,
-    ChatCompletionContentPartRefusalParam,
-    ChatCompletionContentPartTextParam,
-    ChatCompletionMessageParam,
-    ChatCompletionSystemMessageParam,
-    ChatCompletionUserMessageParam,
-)
-from openai.types.chat.chat_completion_chunk import Choice
-
-from vellum import (
-    AdHocExecutePromptEvent,
-    FulfilledAdHocExecutePromptEvent,
-    InitiatedAdHocExecutePromptEvent,
-    RejectedAdHocExecutePromptEvent,
-    StreamingAdHocExecutePromptEvent,
-    StringVellumValue,
-    VellumAudio,
-    VellumError,
-    VellumImage,
-)
-from vellum.prompts.blocks.compilation import compile_prompt_blocks
-from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock
-from vellum.workflows.errors import WorkflowErrorCode
-from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes import InlinePromptNode
-from vellum.workflows.types.generics import StateType
-
-logger = logging.getLogger(__name__)
-
-
-class OpenAIChatCompletionNode(InlinePromptNode[StateType]):
-    """
-    Used to execute a Prompt using the OpenAI API.
-    """
-
-    # Override
-    def _get_prompt_event_stream(self) -> Iterator[AdHocExecutePromptEvent]:
-        client = self._get_client()
-
-        execution_id = str(uuid4())
-
-        yield InitiatedAdHocExecutePromptEvent(
-            execution_id=execution_id,
-        )
-
-        try:
-            stream = client.chat.completions.create(
-                messages=self._get_messages(),
-                model=self.ml_model,
-                # TODO: Add support for additional parameters
-                stream=True,
-            )
-        except Exception as exc:
-            yield RejectedAdHocExecutePromptEvent(
-                error=VellumError(
-                    code=WorkflowErrorCode.PROVIDER_ERROR,
-                    message=exc.args[0],
-                ),
-                execution_id=execution_id,
-            )
-            return
-
-        combined_delta_content = ""
-        for chunk in stream:
-            choices: List[Choice] = chunk.choices
-            if len(choices) != 1:
-                yield RejectedAdHocExecutePromptEvent(
-                    error=VellumError(
-                        code=WorkflowErrorCode.PROVIDER_ERROR,
-                        message="Expected one choice per chunk, but found more than one.",
-                    ),
-                    execution_id=execution_id,
-                )
-                return
-
-            choice = choices[0]
-            delta = choice.delta
-
-            if delta.tool_calls:
-                # TODO: Add support for tool calls
-                raise NotImplementedError("This node hasn't been extended to support tool calling yet.")
-
-            if delta.content:
-                combined_delta_content += delta.content
-
-            StreamingAdHocExecutePromptEvent(
-                output=StringVellumValue(value=delta.content),
-                # TODO: Add support for multiple outputs
-                output_index=1,
-                execution_id=execution_id,
-            )
-
-        yield FulfilledAdHocExecutePromptEvent(
-            # TODO: Add support for multiple outputs
-            outputs=[
-                StringVellumValue(value=combined_delta_content),
-            ],
-            execution_id=execution_id,
-        )
-
-    def _get_client(self) -> OpenAI:
-        """Used to retrieve an API client for interacting with the OpenAI API.
-
-        Note: This method can be overridden if you'd like to use your own API client that conforms to the same
-            interfaces as that of OpenAI.
-        """
-
-        openai_api_key = os.environ.get("OPENAI_API_KEY")
-
-        if not openai_api_key:
-            raise NodeException(
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-                message="Unable to determine an OpenAI API key.",
-            )
-
-        client = OpenAI(api_key=openai_api_key)
-        return client
-
-    def _get_messages(self) -> Iterable[ChatCompletionMessageParam]:
-        input_variables, input_values = self._compile_prompt_inputs()
-
-        compiled_blocks = compile_prompt_blocks(
-            blocks=self.blocks, inputs=input_values, input_variables=input_variables
-        )
-
-        chat_message_blocks: list[CompiledChatMessagePromptBlock] = [
-            block for block in compiled_blocks if block.block_type == "CHAT_MESSAGE"
-        ]
-        messages = [self._create_message(block) for block in chat_message_blocks]
-
-        return messages
-
-    @classmethod
-    def _create_message(cls, chat_message_block: CompiledChatMessagePromptBlock) -> ChatCompletionMessageParam:
-        name = chat_message_block.source
-        content = cls._create_message_content(chat_message_block)
-
-        if chat_message_block.role == "SYSTEM":
-            relevant_system_content = [
-                cast(ChatCompletionContentPartTextParam, c) for c in content if c["type"] == "text"
-            ]
-            system_message: ChatCompletionSystemMessageParam = {
-                "content": relevant_system_content,
-                "role": "system",
-            }
-            if name:
-                system_message["name"] = name
-
-            return system_message
-        elif chat_message_block.role == "USER":
-            user_message: ChatCompletionUserMessageParam = {
-                "content": content,
-                "role": "user",
-            }
-            if name:
-                user_message["name"] = name
-
-            return user_message
-        elif chat_message_block.role == "ASSISTANT":
-            relevant_assistant_content = [
-                cast(Union[ChatCompletionContentPartTextParam, ChatCompletionContentPartRefusalParam], c)
-                for c in content
-                if c["type"] in ["text", "refusal"]
-            ]
-            assistant_message: ChatCompletionAssistantMessageParam = {
-                "content": relevant_assistant_content,
-                "role": "assistant",
-            }
-            if name:
-                assistant_message["name"] = name
-
-            return assistant_message
-        else:
-            logger.error(f"Unexpected role: {chat_message_block.role}")
-            raise NodeException(
-                code=WorkflowErrorCode.INTERNAL_ERROR, message="Unexpected role found when compiling prompt blocks"
-            )
-
-    @classmethod
-    def _create_message_content(
-        cls,
-        chat_message_block: CompiledChatMessagePromptBlock,
-    ) -> List[ChatCompletionContentPartParam]:
-        content: List[ChatCompletionContentPartParam] = []
-        for block in chat_message_block.blocks:
-            if block.content.type == "STRING":
-                string_value = cast(str, block.content.value)
-                string_content_item: ChatCompletionContentPartTextParam = {"type": "text", "text": string_value}
-                content.append(string_content_item)
-            elif block.content.type == "JSON":
-                json_value = cast(Any, block.content.value)
-                json_content_item: ChatCompletionContentPartTextParam = {"type": "text", "text": json.dumps(json_value)}
-                content.append(json_content_item)
-            elif block.content.type == "IMAGE":
-                image_value = cast(VellumImage, block.content.value)
-                image_content_item: ChatCompletionContentPartImageParam = {
-                    "type": "image_url",
-                    "image_url": {"url": image_value.src},
-                }
-                if image_value.metadata and image_value.metadata.get("detail"):
-                    detail = image_value.metadata["detail"]
-
-                    if detail not in ["auto", "low", "high"]:
-                        raise NodeException(
-                            code=WorkflowErrorCode.INTERNAL_ERROR,
-                            message="Image detail must be one of 'auto', 'low', or 'high.",
-                        )
-
-                    image_content_item["image_url"]["detail"] = cast(Literal["auto", "low", "high"], detail)
-
-                content.append(image_content_item)
-            elif block.content.type == "AUDIO":
-                audio_value = cast(VellumAudio, block.content.value)
-                audio_value_src_parts = audio_value.src.split(",")
-                if len(audio_value_src_parts) != 2:
-                    raise NodeException(
-                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio data is not properly encoded."
-                    )
-                _, cleaned_audio_value = audio_value_src_parts
-                if not audio_value.metadata:
-                    raise NodeException(
-                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio metadata is required for audio input."
-                    )
-                audio_format = audio_value.metadata.get("format")
-                if not audio_format:
-                    raise NodeException(
-                        code=WorkflowErrorCode.INTERNAL_ERROR, message="Audio format is required for audio input."
-                    )
-                if audio_format not in {"wav", "mp3"}:
-                    raise NodeException(
-                        code=WorkflowErrorCode.INTERNAL_ERROR,
-                        message="Audio format must be one of 'wav' or 'mp3'.",
-                    )
-
-                audio_content_item: ChatCompletionContentPartInputAudioParam = {
-                    "type": "input_audio",
-                    "input_audio": {
-                        "data": cleaned_audio_value,
-                        "format": cast(Literal["wav", "mp3"], audio_format),
-                    },
-                }
-
-                content.append(audio_content_item)
-            elif block.content.type == "DOCUMENT":
-                raise NodeException(
-                    code=WorkflowErrorCode.PROVIDER_ERROR,
-                    message="Document chat message content type is not currently supported",
-                )
-            else:
-                raise NodeException(
-                    code=WorkflowErrorCode.INTERNAL_ERROR,
-                    message=f"Failed to parse chat message block {block.content.type}",
-                )
-
-        return content

vellum/workflows/nodes/experimental/tool_calling_node/__init__.py

@@ -1,3 +0,0 @@
-from vellum.workflows.nodes.experimental.tool_calling_node.node import ToolCallingNode
-
-__all__ = ["ToolCallingNode"]