vellum-ai 0.14.38__tar.gz → 0.14.39__tar.gz

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/PKG-INFO

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

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/ee/vellum_cli/push.py

@@ -36,9 +36,6 @@ def push_command(
     logger = load_cli_logger()
     config = load_vellum_cli_config()
 
-    if not config.workflows:
-        raise ValueError("No Workflows found in project to push.")
-
     workflow_configs = (
         [
             w
@@ -61,6 +58,8 @@ def push_command(
             )
             config.workflows.append(new_config)
             workflow_configs = [new_config]
+        elif not module:
+            raise ValueError("No Workflows found in project to push.")
         else:
             raise ValueError(f"No workflow config for '{module}' found in project to push.")
 

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/ee/vellum_cli/tests/test_push.py

@@ -133,6 +133,58 @@ def test_push__happy_path(mock_module, vellum_client, base_command):
     assert extracted_files["workflow.py"] == workflow_py_file_content
 
 
+def test_push__no_config__module_found(mock_module, vellum_client):
+    # GIVEN no config file set
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    mock_module.set_pyproject_toml({"workflows": []})
+
+    # AND a workflow exists in the module successfully
+    workflow_py_file_content = _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    new_workflow_sandbox_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=new_workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push`
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module])
+
+    # THEN it should successfully push the workflow
+    assert result.exit_code == 0, result.stdout
+
+    # Get the last part of the module path and format it
+    expected_artifact_name = f"{mock_module.module.replace('.', '__')}.tar.gz"
+
+    # AND we should have called the push API with the correct args
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
+    assert call_args["workflow_sandbox_id"] is None
+    assert "deplyment_config" not in call_args
+
+    # AND we should have pushed the correct artifact
+    assert call_args["artifact"].name == expected_artifact_name
+    extracted_files = _extract_tar_gz(call_args["artifact"].read())
+    assert extracted_files["workflow.py"] == workflow_py_file_content
+
+    # AND there should be a new entry in the lock file
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        assert lock_file_content["workflows"][0] == {
+            "container_image_name": None,
+            "container_image_tag": None,
+            "deployments": [],
+            "ignore": None,
+            "module": module,
+            "target_directory": None,
+            "workflow_sandbox_id": new_workflow_sandbox_id,
+            "workspace": "default",
+        }
+
+
 @pytest.mark.parametrize(
     "base_command",
     [

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/pyproject.toml

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

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/__init__.py

@@ -443,6 +443,7 @@ from .types import (
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricOutput,
     TestSuiteRunMetricStringOutput,
+    TestSuiteRunProgress,
     TestSuiteRunPromptSandboxExecConfigDataRequest,
     TestSuiteRunPromptSandboxExecConfigRequest,
     TestSuiteRunPromptSandboxHistoryItemExecConfig,
@@ -1072,6 +1073,7 @@ __all__ = [
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
+    "TestSuiteRunProgress",
     "TestSuiteRunPromptSandboxExecConfigDataRequest",
     "TestSuiteRunPromptSandboxExecConfigRequest",
     "TestSuiteRunPromptSandboxHistoryItemExecConfig",

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/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.14.38",
+            "X-Fern-SDK-Version": "0.14.39",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/client/types/__init__.py

@@ -453,6 +453,7 @@ from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from .test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
+from .test_suite_run_progress import TestSuiteRunProgress
 from .test_suite_run_prompt_sandbox_exec_config_data_request import TestSuiteRunPromptSandboxExecConfigDataRequest
 from .test_suite_run_prompt_sandbox_exec_config_request import TestSuiteRunPromptSandboxExecConfigRequest
 from .test_suite_run_prompt_sandbox_history_item_exec_config import TestSuiteRunPromptSandboxHistoryItemExecConfig
@@ -1052,6 +1053,7 @@ __all__ = [
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
+    "TestSuiteRunProgress",
     "TestSuiteRunPromptSandboxExecConfigDataRequest",
     "TestSuiteRunPromptSandboxExecConfigRequest",
     "TestSuiteRunPromptSandboxHistoryItemExecConfig",

vellum_ai-0.14.39/src/vellum/client/types/test_suite_run_progress.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class TestSuiteRunProgress(UniversalBaseModel):
+    number_of_requested_test_cases: int
+    number_of_completed_test_cases: int
+
+    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

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/client/types/test_suite_run_read.py

@@ -9,6 +9,7 @@ from .test_suite_run_state import TestSuiteRunState
 import pydantic
 import typing
 from .test_suite_run_exec_config import TestSuiteRunExecConfig
+from .test_suite_run_progress import TestSuiteRunProgress
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 from ..core.pydantic_utilities import update_forward_refs
 
@@ -33,6 +34,8 @@ class TestSuiteRunRead(UniversalBaseModel):
     Configuration that defines how the Test Suite should be run
     """
 
+    progress: typing.Optional[TestSuiteRunProgress] = None
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/client/types/vellum_sdk_error_code_enum.py

@@ -11,6 +11,7 @@ VellumSdkErrorCodeEnum = typing.Union[
         "INVALID_CODE",
         "INVALID_TEMPLATE",
         "INTERNAL_ERROR",
+        "PROVIDER_CREDENTIALS_UNAVAILABLE",
         "PROVIDER_ERROR",
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/client/types/workflow_execution_event_error_code.py

@@ -6,6 +6,7 @@ WorkflowExecutionEventErrorCode = typing.Union[
     typing.Literal[
         "WORKFLOW_INITIALIZATION",
         "WORKFLOW_CANCELLED",
+        "PROVIDER_CREDENTIALS_UNAVAILABLE",
         "NODE_EXECUTION_COUNT_LIMIT_REACHED",
         "INTERNAL_SERVER_ERROR",
         "NODE_EXECUTION",

vellum_ai-0.14.39/src/vellum/types/test_suite_run_progress.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.test_suite_run_progress import *

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/errors/types.py

@@ -17,6 +17,7 @@ class WorkflowErrorCode(Enum):
     INVALID_TEMPLATE = "INVALID_TEMPLATE"
     INTERNAL_ERROR = "INTERNAL_ERROR"
     NODE_EXECUTION = "NODE_EXECUTION"
+    PROVIDER_CREDENTIALS_UNAVAILABLE = "PROVIDER_CREDENTIALS_UNAVAILABLE"
     PROVIDER_ERROR = "PROVIDER_ERROR"
     USER_DEFINED_ERROR = "USER_DEFINED_ERROR"
     WORKFLOW_CANCELLED = "WORKFLOW_CANCELLED"

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/events/tests/test_event.py

@@ -89,6 +89,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                         "foo": "bar",
                     },
                     "display_context": None,
+                    "initial_state": None,
                 },
                 "parent": None,
             },

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/events/workflow.py

@@ -54,8 +54,10 @@ class WorkflowEventDisplayContext(UniversalBaseModel):
     workflow_outputs: Dict[str, UUID]
 
 
-class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType]):
+class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType, StateType]):
     inputs: InputsType
+    initial_state: Optional[StateType] = None
+
     # It is still the responsibility of the workflow server to populate this context. The SDK's
     # Workflow Runner will always leave this field None.
     #
@@ -67,15 +69,23 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)
 
+    @field_serializer("initial_state")
+    def serialize_initial_state(self, initial_state: Optional[StateType], _info: Any) -> Optional[Dict[str, Any]]:
+        return default_serializer(initial_state)
+
 
-class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType, StateType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
-    body: WorkflowExecutionInitiatedBody[InputsType]
+    body: WorkflowExecutionInitiatedBody[InputsType, StateType]
 
     @property
     def inputs(self) -> InputsType:
         return self.body.inputs
 
+    @property
+    def initial_state(self) -> Optional[StateType]:
+        return self.body.initial_state
+
 
 class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
     output: BaseOutput

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -69,7 +69,13 @@ class BasePromptNode(BaseNode, Generic[StateType]):
         return outputs
 
     def _handle_api_error(self, e: ApiError):
-        if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+        if e.status_code and e.status_code == 403 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("detail", "Provider credentials is missing or unavailable"),
+                code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+            )
+
+        elif e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
             raise NodeException(
                 message=e.body.get("detail", "Failed to execute Prompt"),
                 code=WorkflowErrorCode.INVALID_INPUTS,

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -170,8 +170,13 @@ def test_inline_prompt_node__function_definitions(vellum_adhoc_prompt_client):
             WorkflowErrorCode.INTERNAL_ERROR,
             "Failed to execute Prompt",
         ),
+        (
+            ApiError(status_code=403, body={"detail": "Provider credentials is missing or unavailable"}),
+            WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+            "Provider credentials is missing or unavailable",
+        ),
     ],
-    ids=["404", "invalid_dict", "invalid_body", "no_status_code", "500"],
+    ids=["404", "invalid_dict", "invalid_body", "no_status_code", "500", "403"],
 )
 def test_inline_prompt_node__api_error__invalid_inputs_node_exception(
     vellum_adhoc_prompt_client, exception, expected_code, expected_message

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py

@@ -491,3 +491,29 @@ def test_prompt_deployment_node__no_fallbacks(vellum_client):
 
     # AND the client should have been called only once (for the primary model)
     assert vellum_client.execute_prompt_stream.call_count == 1
+
+
+def test_prompt_deployment_node__provider_credentials_missing(vellum_client):
+    # GIVEN a Prompt Deployment Node
+    class TestPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "test_deployment"
+        prompt_inputs = {}
+
+    # AND the client responds with a 403 error of provider credentials missing
+    primary_error = ApiError(
+        body={"detail": "Provider credentials is missing or unavailable"},
+        status_code=403,
+    )
+
+    vellum_client.execute_prompt_stream.side_effect = primary_error
+
+    # WHEN we run the node
+    node = TestPromptDeploymentNode()
+
+    # THEN the node should raise an exception
+    with pytest.raises(NodeException) as exc_info:
+        list(node.run())
+
+    # AND the exception should contain the original error message
+    assert exc_info.value.message == "Provider credentials is missing or unavailable"
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/runner/runner.py

@@ -4,11 +4,11 @@ from dataclasses import dataclass
 import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Iterator, Optional, Sequence, Set, Tuple, Type, Union
 
 from vellum.workflows.constants import undefined
-from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context, get_parent_context
+from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
@@ -30,7 +30,7 @@ from vellum.workflows.events.node import (
     NodeExecutionRejectedBody,
     NodeExecutionStreamingBody,
 )
-from vellum.workflows.events.types import BaseEvent, NodeParentContext, WorkflowParentContext
+from vellum.workflows.events.types import BaseEvent, NodeParentContext, ParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionInitiatedBody,
@@ -90,6 +90,7 @@ class WorkflowRunner(Generic[StateType]):
 
         self.workflow = workflow
         self._is_resuming = False
+        self._should_emit_initial_state = True
         if entrypoint_nodes:
             if len(list(entrypoint_nodes)) > 1:
                 raise ValueError("Cannot resume from multiple nodes")
@@ -98,7 +99,8 @@ class WorkflowRunner(Generic[StateType]):
             # https://app.shortcut.com/vellum/story/4408
             node = next(iter(entrypoint_nodes))
             if state:
-                self._initial_state = state
+                self._initial_state = deepcopy(state)
+                self._initial_state.meta.span_id = uuid4()
             else:
                 self._initial_state = self.workflow.get_state_at_node(node)
             self._entrypoints = entrypoint_nodes
@@ -123,8 +125,13 @@ class WorkflowRunner(Generic[StateType]):
             if state:
                 self._initial_state = deepcopy(state)
                 self._initial_state.meta.workflow_inputs = normalized_inputs
+                self._initial_state.meta.span_id = uuid4()
             else:
                 self._initial_state = self.workflow.get_default_state(normalized_inputs)
+                # We don't want to emit the initial state on the base case of Workflow Runs, since
+                # all of that data is redundant and is derivable. It also clearly communicates that
+                # there was no initial state provided by the user to invoke the workflow.
+                self._should_emit_initial_state = False
             self._entrypoints = self.workflow.get_entrypoints()
 
         # This queue is responsible for sending events from WorkflowRunner to the outside world
@@ -239,7 +246,8 @@ class WorkflowRunner(Generic[StateType]):
                         instance=None,
                         outputs_class=node.Outputs,
                     )
-                    node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
+                    with node.state.__quiet__():
+                        node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
                     initiated_output: BaseOutput = BaseOutput(name=output.name)
                     initiated_ports = initiated_output > ports
                     self._workflow_event_inner_queue.put(
@@ -297,13 +305,14 @@ class WorkflowRunner(Generic[StateType]):
 
             node.state.meta.node_execution_cache.fulfill_node_execution(node.__class__, span_id)
 
-            for descriptor, output_value in outputs:
-                if output_value is undefined:
-                    if descriptor in node.state.meta.node_outputs:
-                        del node.state.meta.node_outputs[descriptor]
-                    continue
+            with node.state.__atomic__():
+                for descriptor, output_value in outputs:
+                    if output_value is undefined:
+                        if descriptor in node.state.meta.node_outputs:
+                            del node.state.meta.node_outputs[descriptor]
+                        continue
 
-                node.state.meta.node_outputs[descriptor] = output_value
+                    node.state.meta.node_outputs[descriptor] = output_value
 
             invoked_ports = ports(outputs, node.state)
             self._workflow_event_inner_queue.put(
@@ -365,11 +374,16 @@ class WorkflowRunner(Generic[StateType]):
 
         logger.debug(f"Finished running node: {node.__class__.__name__}")
 
-    def _context_run_work_item(self, node: BaseNode[StateType], span_id: UUID, parent_context=None) -> None:
-        execution = get_execution_context()
+    def _context_run_work_item(
+        self,
+        node: BaseNode[StateType],
+        span_id: UUID,
+        parent_context: ParentContext,
+        trace_id: UUID,
+    ) -> None:
         with execution_context(
-            parent_context=parent_context or execution.parent_context,
-            trace_id=execution.trace_id,
+            parent_context=parent_context,
+            trace_id=trace_id,
         ):
             self._run_work_item(node, span_id)
 
@@ -419,14 +433,19 @@ class WorkflowRunner(Generic[StateType]):
             if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
                 return
 
-            current_parent = get_parent_context()
+            execution = get_execution_context()
             node = node_class(state=state, context=self.workflow.context)
             state.meta.node_execution_cache.initiate_node_execution(node_class, node_span_id)
             self._active_nodes_by_execution_id[node_span_id] = ActiveNode(node=node)
 
             worker_thread = Thread(
                 target=self._context_run_work_item,
-                kwargs={"node": node, "span_id": node_span_id, "parent_context": current_parent},
+                kwargs={
+                    "node": node,
+                    "span_id": node_span_id,
+                    "parent_context": execution.parent_context,
+                    "trace_id": execution.trace_id,
+                },
             )
             worker_thread.start()
 
@@ -500,6 +519,7 @@ class WorkflowRunner(Generic[StateType]):
             body=WorkflowExecutionInitiatedBody(
                 workflow_definition=self.workflow.__class__,
                 inputs=self._initial_state.meta.workflow_inputs,
+                initial_state=deepcopy(self._initial_state) if self._should_emit_initial_state else None,
             ),
             parent=self._execution_context.parent_context,
         )

{vellum_ai-0.14.38 → vellum_ai-0.14.39}/src/vellum/workflows/state/base.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from contextlib import contextmanager
 from copy import deepcopy
 from dataclasses import field
 from datetime import datetime
@@ -404,11 +405,11 @@ class BaseState(metaclass=_BaseStateMeta):
     meta: StateMeta = field(init=False)
 
     __lock__: Lock = field(init=False)
-    __is_initializing__: bool = field(init=False)
+    __is_quiet__: bool = field(init=False)
     __snapshot_callback__: Callable[["BaseState"], None] = field(init=False)
 
     def __init__(self, meta: Optional[StateMeta] = None, **kwargs: Any) -> None:
-        self.__is_initializing__ = True
+        self.__is_quiet__ = True
         self.__snapshot_callback__ = lambda state: None
         self.__lock__ = Lock()
 
@@ -418,14 +419,14 @@ class BaseState(metaclass=_BaseStateMeta):
         # Make all class attribute values snapshottable
         for name, value in self.__class__.__dict__.items():
             if not name.startswith("_") and name != "meta":
-                # Bypass __is_initializing__ instead of `setattr`
+                # Bypass __is_quiet__ instead of `setattr`
                 snapshottable_value = _make_snapshottable(value, self.__snapshot__)
                 super().__setattr__(name, snapshottable_value)
 
         for name, value in kwargs.items():
             setattr(self, name, value)
 
-        self.__is_initializing__ = False
+        self.__is_quiet__ = False
 
     def __deepcopy__(self, memo: Any) -> "BaseState":
         new_state = deepcopy_with_exclusions(
@@ -472,7 +473,7 @@ class BaseState(metaclass=_BaseStateMeta):
         return self.__dict__[key]
 
     def __setattr__(self, name: str, value: Any) -> None:
-        if name.startswith("_") or self.__is_initializing__:
+        if name.startswith("_"):
             super().__setattr__(name, value)
             return
 
@@ -513,11 +514,33 @@ class BaseState(metaclass=_BaseStateMeta):
         Snapshots the current state to the workflow emitter. The invoked callback is overridden by the
         workflow runner.
         """
+        if self.__is_quiet__:
+            return
+
         try:
             self.__snapshot_callback__(deepcopy(self))
         except Exception:
             logger.exception("Failed to snapshot Workflow state.")
 
+    @contextmanager
+    def __quiet__(self):
+        prev = self.__is_quiet__
+        self.__is_quiet__ = True
+        try:
+            yield
+        finally:
+            self.__is_quiet__ = prev
+
+    @contextmanager
+    def __atomic__(self):
+        prev = self.__is_quiet__
+        self.__is_quiet__ = True
+        try:
+            yield
+        finally:
+            self.__is_quiet__ = prev
+            self.__snapshot__()
+
     @classmethod
     def __get_pydantic_core_schema__(
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler