vellum-ai 0.13.5__tar.gz → 0.13.7__tar.gz

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.13.5
+Version: 0.13.7
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/ee/vellum_ee/workflows/display/nodes/vellum/base_node.py

@@ -3,8 +3,12 @@ from typing import Any, Generic, TypeVar, cast
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.is_nil import IsNilExpression
+from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.execution_count import ExecutionCountReference
@@ -104,17 +108,27 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         return explicit_value if explicit_value else GenericNodeDisplayData()
 
     def serialize_condition(self, display_context: WorkflowDisplayContext, condition: BaseDescriptor) -> JsonObject:
-        if isinstance(condition, (IsNullExpression, IsNotNullExpression)):
-            lhs = self.serialize_value(display_context, condition._expression)  # type: ignore[attr-defined]
+        if isinstance(
+            condition,
+            (
+                IsNullExpression,
+                IsNotNullExpression,
+                IsNilExpression,
+                IsNotNilExpression,
+                IsUndefinedExpression,
+                IsNotUndefinedExpression,
+            ),
+        ):
+            lhs = self.serialize_value(display_context, condition._expression)
             return {
                 "type": "UNARY_EXPRESSION",
                 "lhs": lhs,
                 "operator": convert_descriptor_to_operator(condition),
             }
         elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-            base = self.serialize_value(display_context, condition._value)  # type: ignore[attr-defined]
-            lhs = self.serialize_value(display_context, condition._start)  # type: ignore[attr-defined]
-            rhs = self.serialize_value(display_context, condition._end)  # type: ignore[attr-defined]
+            base = self.serialize_value(display_context, condition._value)
+            lhs = self.serialize_value(display_context, condition._start)
+            rhs = self.serialize_value(display_context, condition._end)
 
             return {
                 "type": "TERNARY_EXPRESSION",

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/ee/vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -5,8 +5,12 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, TypeVar,
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.is_nil import IsNilExpression
+from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.nodes.displayable import ConditionalNode
@@ -89,7 +93,17 @@ but the defined conditions have length {len(condition_ids)}"""
                 }
 
             # Base cases for other descriptors
-            elif isinstance(descriptor, (IsNullExpression, IsNotNullExpression)):
+            elif isinstance(
+                descriptor,
+                (
+                    IsNullExpression,
+                    IsNotNullExpression,
+                    IsNilExpression,
+                    IsNotNilExpression,
+                    IsUndefinedExpression,
+                    IsNotUndefinedExpression,
+                ),
+            ):
                 expression_node_input = create_node_input(
                     node_id, f"{current_id}.field", descriptor._expression, display_context, field_node_input_id
                 )

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/ee/vellum_ee/workflows/display/types.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass, field
+from uuid import UUID
 from typing import TYPE_CHECKING, Dict, Generic, Tuple, Type, TypeVar
 
+from vellum.client.core import UniversalBaseModel
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports import Port
@@ -12,6 +14,7 @@ from vellum_ee.workflows.display.base import (
     WorkflowMetaDisplayType,
     WorkflowOutputDisplayType,
 )
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
 
 if TYPE_CHECKING:
@@ -22,6 +25,18 @@ NodeDisplayType = TypeVar("NodeDisplayType", bound="BaseNodeDisplay")
 WorkflowDisplayType = TypeVar("WorkflowDisplayType", bound="BaseWorkflowDisplay")
 
 
+class NodeDisplay(UniversalBaseModel):
+    input_display: Dict[str, UUID]
+    output_display: Dict[str, UUID]
+    port_display: Dict[str, UUID]
+
+
+class WorkflowEventDisplayContext(UniversalBaseModel):
+    node_displays: Dict[str, NodeDisplay]
+    workflow_inputs: Dict[str, UUID]
+    workflow_outputs: Dict[str, UUID]
+
+
 @dataclass
 class WorkflowDisplayContext(
     Generic[
@@ -48,3 +63,32 @@ class WorkflowDisplayContext(
     workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayType] = field(default_factory=dict)
     edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplayType] = field(default_factory=dict)
     port_displays: Dict[Port, "PortDisplay"] = field(default_factory=dict)
+
+    def build_event_display_context(self) -> WorkflowEventDisplayContext:
+        workflow_outputs = {
+            output.name: self.workflow_output_displays[output].id for output in self.workflow_output_displays
+        }
+        workflow_inputs = {input.name: self.workflow_input_displays[input].id for input in self.workflow_input_displays}
+        node_displays = {str(node.__id__): self.node_displays[node] for node in self.node_displays}
+        temp_node_displays = {}
+        for node in node_displays:
+            current_node = node_displays[node]
+            input_display = {}
+            if issubclass(current_node.__class__, BaseNodeVellumDisplay):
+                input_display = current_node.node_input_ids_by_name  # type: ignore[attr-defined]
+            node_display_meta = {
+                output.name: current_node.output_display[output].id for output in current_node.output_display
+            }
+            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
+
+            temp_node_displays[node] = NodeDisplay(
+                input_display=input_display,
+                output_display=node_display_meta,
+                port_display=port_display_meta,
+            )
+        display_meta = WorkflowEventDisplayContext(
+            workflow_outputs=workflow_outputs,
+            workflow_inputs=workflow_inputs,
+            node_displays=temp_node_displays,
+        )
+        return display_meta

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -1,10 +1,12 @@
 from abc import abstractmethod
 from copy import copy
 from functools import cached_property
+import importlib
 import logging
 from uuid import UUID
-from typing import Any, Dict, Generic, Iterator, List, Optional, Tuple, Type, get_args
+from typing import Any, Dict, Generic, Iterator, List, Optional, Tuple, Type, Union, get_args
 
+from vellum.workflows import BaseWorkflow
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
@@ -29,7 +31,7 @@ from vellum_ee.workflows.display.base import (
 )
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
+from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext, WorkflowEventDisplayContext
 
 logger = logging.getLogger(__name__)
 
@@ -333,3 +335,14 @@ class BaseWorkflowDisplay(
 
         workflow_class = get_args(cls.__orig_bases__[0])[0]  # type: ignore [attr-defined]
         cls._workflow_display_registry[workflow_class] = cls
+
+    @staticmethod
+    def gather_event_display_context(
+        module_path: str, workflow_class: Type[BaseWorkflow]
+    ) -> Union[WorkflowEventDisplayContext, None]:
+        workflow_display_module = f"{module_path}.display.workflow"
+        try:
+            display_class = importlib.import_module(workflow_display_module)
+        except ModuleNotFoundError:
+            return None
+        return display_class.WorkflowDisplay(workflow_class).display_context.build_event_display_context()

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_files/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa: F401, F403
+
+from .display import *

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_files/base_class.py

@@ -0,0 +1,15 @@
+from uuid import uuid4
+
+from .inner_files.inner_class import InnerClass
+
+
+class BaseClass:
+    result = None
+
+    def __init__(self):
+        self.id = uuid4()
+        self.inner_class = InnerClass
+
+    def run(self):
+        self.result = self.inner_class().introduce()
+        return self.result

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_files/display/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa: F401, F403
+
+from .display import env

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_files/display/display.py

@@ -0,0 +1 @@
+env = "local"

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_files/inner_files/inner_class.py

@@ -0,0 +1,9 @@
+import uuid
+
+
+class InnerClass:
+    def __init__(self):
+        self.id = uuid.uuid4()
+
+    def introduce(self):
+        return self.id

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/display/__init__.py

@@ -0,0 +1,4 @@
+# flake8: noqa: F401, F403
+
+from .nodes import *
+from .workflow import *

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/display/nodes/__init__.py

@@ -0,0 +1,4 @@
+from .final_output import FinalOutputDisplay
+from .templating_node import TemplatingNodeDisplay
+
+__all__ = ["TemplatingNodeDisplay", "FinalOutputDisplay"]

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/display/nodes/final_output.py

@@ -0,0 +1,21 @@
+from uuid import UUID
+
+from vellum_ee.workflows.display.nodes import BaseFinalOutputNodeDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
+
+from ...nodes.final_output import FinalOutput
+
+
+class FinalOutputDisplay(BaseFinalOutputNodeDisplay[FinalOutput]):
+    label = "Final Output"
+    node_id = UUID("f3ef4b2b-fec9-4026-9cc6-e5eac295307f")
+    target_handle_id = UUID("3ec34f6e-da48-40d5-a65b-a48fefa75763")
+    output_id = UUID("5469b810-6ea6-4362-9e79-e360d44a1405")
+    output_name = "final-output"
+    node_input_id = UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")
+    node_input_ids_by_name = {"node_input": UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")}
+    output_display = {
+        FinalOutput.Outputs.value: NodeOutputDisplay(id=UUID("5469b810-6ea6-4362-9e79-e360d44a1405"), name="value")
+    }
+    display_data = NodeDisplayData(position=NodeDisplayPosition(x=2750, y=210), width=459, height=234)

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/display/nodes/templating_node.py

@@ -0,0 +1,27 @@
+from uuid import UUID
+
+from vellum_ee.workflows.display.nodes import BaseTemplatingNodeDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplayOverrides
+from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
+
+from ...nodes.templating_node import TemplatingNode
+
+
+class TemplatingNodeDisplay(BaseTemplatingNodeDisplay[TemplatingNode]):
+    label = "Templating Node"
+    node_id = UUID("533c6bd8-6088-4abc-a168-8c1758abcd33")
+    target_handle_id = UUID("048d310e-1a4d-4038-b534-8c68a4509b93")
+    template_input_id = UUID("f97d721a-e685-498e-90c3-9c3d9358fdad")
+    node_input_ids_by_name = {
+        "example_var_1": UUID("a0d1d7cf-242a-4bd9-a437-d308a7ced9b3"),
+        "template": UUID("f97d721a-e685-498e-90c3-9c3d9358fdad"),
+    }
+    output_display = {
+        TemplatingNode.Outputs.result: NodeOutputDisplay(id=UUID("423bc529-1a1a-4f72-af4d-cbdb5f0a5929"), name="result")
+    }
+    port_displays = {
+        TemplatingNode.Ports.default: PortDisplayOverrides(id=UUID("afda9a19-0618-42e1-9b63-5d0db2a88f62"))
+    }
+    display_data = NodeDisplayData(
+        position=NodeDisplayPosition(x=1970.9393258426965, y=232.4943117977528), width=466, height=224
+    )

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/display/workflow.py

@@ -0,0 +1,58 @@
+from uuid import UUID
+
+from vellum_ee.workflows.display.vellum import (
+    EdgeVellumDisplayOverrides,
+    EntrypointVellumDisplayOverrides,
+    NodeDisplayData,
+    NodeDisplayPosition,
+    WorkflowDisplayData,
+    WorkflowDisplayDataViewport,
+    WorkflowInputsVellumDisplayOverrides,
+    WorkflowMetaVellumDisplayOverrides,
+    WorkflowOutputVellumDisplayOverrides,
+)
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+from ..inputs import Inputs
+from ..nodes.final_output import FinalOutput
+from ..nodes.templating_node import TemplatingNode
+from ..workflow import Workflow
+
+
+class WorkflowDisplay(VellumWorkflowDisplay[Workflow]):
+    workflow_display = WorkflowMetaVellumDisplayOverrides(
+        entrypoint_node_id=UUID("0bf86989-13f2-438c-ab9c-d172e5771d31"),
+        entrypoint_node_source_handle_id=UUID("23448f09-81ad-4378-abbd-1cccff350627"),
+        entrypoint_node_display=NodeDisplayData(position=NodeDisplayPosition(x=1545, y=330), width=124, height=48),
+        display_data=WorkflowDisplayData(
+            viewport=WorkflowDisplayDataViewport(x=-1137.2395104895104, y=110.60314685314688, zoom=0.7779720279720279)
+        ),
+    )
+    inputs_display = {
+        Inputs.input_value: WorkflowInputsVellumDisplayOverrides(
+            id=UUID("2268a996-bd17-4832-b3ff-f5662d54b306"), name="input-value", required=True
+        )
+    }
+    entrypoint_displays = {
+        TemplatingNode: EntrypointVellumDisplayOverrides(
+            id=UUID("0bf86989-13f2-438c-ab9c-d172e5771d31"),
+            edge_display=EdgeVellumDisplayOverrides(id=UUID("38532a0e-9432-4ed2-8a34-48a29fd6984d")),
+        )
+    }
+    edge_displays = {
+        (TemplatingNode.Ports.default, FinalOutput): EdgeVellumDisplayOverrides(
+            id=UUID("417c56a4-cdc1-4f9d-a10c-b535163f51e8")
+        )
+    }
+    output_displays = {
+        Workflow.Outputs.final_output: WorkflowOutputVellumDisplayOverrides(
+            id=UUID("5469b810-6ea6-4362-9e79-e360d44a1405"),
+            node_id=UUID("f3ef4b2b-fec9-4026-9cc6-e5eac295307f"),
+            node_input_id=UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb"),
+            name="final-output",
+            label="Final Output",
+            target_handle_id=UUID("3ec34f6e-da48-40d5-a65b-a48fefa75763"),
+            display_data=NodeDisplayData(position=NodeDisplayPosition(x=2750, y=210), width=459, height=234),
+            edge_id=UUID("417c56a4-cdc1-4f9d-a10c-b535163f51e8"),
+        )
+    }

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/inputs.py

@@ -0,0 +1,5 @@
+from vellum.workflows.inputs import BaseInputs
+
+
+class Inputs(BaseInputs):
+    input_value: str

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/metadata.json

@@ -0,0 +1 @@
+{"runner_config": null}

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/nodes/__init__.py

@@ -0,0 +1,4 @@
+from .final_output import FinalOutput
+from .templating_node import TemplatingNode
+
+__all__ = ["TemplatingNode", "FinalOutput"]

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/nodes/final_output.py

@@ -0,0 +1,9 @@
+from vellum.workflows.nodes.displayable import FinalOutputNode
+from vellum.workflows.state import BaseState
+
+from .templating_node import TemplatingNode
+
+
+class FinalOutput(FinalOutputNode[BaseState, str]):
+    class Outputs(FinalOutputNode.Outputs):
+        value = TemplatingNode.Outputs.result

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/nodes/templating_node.py

@@ -0,0 +1,11 @@
+from vellum.workflows.nodes.displayable import TemplatingNode as BaseTemplatingNode
+from vellum.workflows.state import BaseState
+
+from ..inputs import Inputs
+
+
+class TemplatingNode(BaseTemplatingNode[BaseState, str]):
+    template = """{{ example_var_1 }}"""
+    inputs = {
+        "example_var_1": Inputs.input_value,
+    }

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/local_workflow/workflow.py

@@ -0,0 +1,13 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.state import BaseState
+
+from .inputs import Inputs
+from .nodes.final_output import FinalOutput
+from .nodes.templating_node import TemplatingNode
+
+
+class Workflow(BaseWorkflow[Inputs, BaseState]):
+    graph = TemplatingNode >> FinalOutput
+
+    class Outputs(BaseWorkflow.Outputs):
+        final_output = FinalOutput.Outputs.value

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/test_display_meta.py

@@ -0,0 +1,54 @@
+import pytest
+import os
+import sys
+from uuid import UUID, uuid4
+
+from vellum.workflows import BaseWorkflow
+from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
+from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
+
+
+@pytest.fixture
+def files() -> dict[str, str]:
+    base_directory = os.path.join(os.path.dirname(__file__), "local_workflow")
+    files = {}
+
+    for root, _, filenames in os.walk(base_directory):
+        for filename in filenames:
+            file_path = os.path.join(root, filename)
+            # Key will be the relative path inside `local_files`
+            relative_path = str(os.path.relpath(file_path, start=base_directory))
+            with open(file_path, encoding="utf-8") as f:
+                files[relative_path] = f.read()
+
+    return files
+
+
+def test_base_class_dynamic_import(files):
+    namespace = str(uuid4())  # Create a unique namespace
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    display_meta = BaseWorkflowDisplay.gather_event_display_context(namespace, Workflow)
+
+    expected_result = {
+        "node_displays": {
+            "533c6bd8-6088-4abc-a168-8c1758abcd33": {
+                "input_display": {
+                    "example_var_1": UUID("a0d1d7cf-242a-4bd9-a437-d308a7ced9b3"),
+                    "template": UUID("f97d721a-e685-498e-90c3-9c3d9358fdad"),
+                },
+                "output_display": {"result": UUID("423bc529-1a1a-4f72-af4d-cbdb5f0a5929")},
+                "port_display": {"default": UUID("afda9a19-0618-42e1-9b63-5d0db2a88f62")},
+            },
+            "f3ef4b2b-fec9-4026-9cc6-e5eac295307f": {
+                "input_display": {"node_input": UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")},
+                "output_display": {"value": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
+                "port_display": {},
+            },
+        },
+        "workflow_inputs": {"input_value": UUID("2268a996-bd17-4832-b3ff-f5662d54b306")},
+        "workflow_outputs": {"final_output": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
+    }
+    assert display_meta
+    assert display_meta.dict() == expected_result

vellum_ai-0.13.7/ee/vellum_ee/workflows/tests/test_virtual_files.py

@@ -0,0 +1,82 @@
+import pytest
+import importlib
+import os
+import sys
+from uuid import uuid4
+
+from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
+
+
+@pytest.fixture
+def files() -> dict[str, str]:
+    base_directory = os.path.join(os.path.dirname(__file__), "local_files")
+    files = {}
+
+    for root, _, filenames in os.walk(base_directory):
+        for filename in filenames:
+            file_path = os.path.join(root, filename)
+            # Key will be the relative path inside `local_files`
+            relative_path = str(os.path.relpath(file_path, start=base_directory))
+            with open(file_path, encoding="utf-8") as f:
+                files[relative_path] = f.read()
+
+    return files
+
+
+def test_base_class_dynamic_import(files):
+    """
+    Test dynamically importing the base class and ensuring all required modules are loaded.
+    """
+    namespace = str(uuid4())  # Create a unique namespace
+    sys.meta_path.append(VirtualFileFinder(files, namespace))  # Use virtual file loader
+    base_class_module_path = "base_class.py"
+
+    # When given a valid module path
+    assert base_class_module_path in files, f"{base_class_module_path} is missing from local_files"
+
+    # fully qualified module name for the base class
+    full_module_name = f"{namespace}.base_class"
+
+    # sys.modules keys before import
+    existing_modules = set(sys.modules.keys())
+
+    # If we import the base module (should implicitly load its dependencies)
+    base_class_module = importlib.import_module(full_module_name)
+    assert base_class_module, f"Failed to import module: {full_module_name}"
+
+    baseclass = None
+    for name in dir(base_class_module):
+        if name.startswith("__"):
+            continue
+        obj = getattr(base_class_module, name)
+        if isinstance(obj, type):
+            baseclass = obj
+            break
+
+    assert baseclass
+    # Then we should import all required files
+    new_modules = set(sys.modules.keys()) - existing_modules
+    assert new_modules
+
+    required_modules = [
+        "uuid",
+        f"{namespace}",
+        f"{namespace}.base_class",
+        f"{namespace}.inner_files",
+        f"{namespace}.inner_files.inner_class",
+        f"{namespace}.display",
+        f"{namespace}.display.display",
+    ]
+    for module in required_modules:
+        assert module in sys.modules, f"Module '{module}' was not loaded as expected"
+
+    # Verify that BaseClass can be instantiated without missing imports
+    try:
+        instance = baseclass()
+        assert instance, "Failed to instantiate BaseClass"
+
+        results = instance.run()
+        assert results, "Failed to run BaseClass"
+        assert instance.id
+    except Exception as e:
+        pytest.fail(f"Failed to create an instance of BaseClass: {e}")

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.5"
+version = "0.13.7"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.13.5 → vellum_ai-0.13.7}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.13.5",
+            "X-Fern-SDK-Version": "0.13.7",
         }
         headers["X_API_KEY"] = self.api_key
         return headers