vellum-ai 0.10.9__py3-none-any.whl → 0.11.0__py3-none-any.whl

vellum/workflows/runner/runner.py

@@ -37,6 +37,8 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionRejectedBody,
     WorkflowExecutionResumedBody,
     WorkflowExecutionResumedEvent,
+    WorkflowExecutionSnapshottedBody,
+    WorkflowExecutionSnapshottedEvent,
     WorkflowExecutionStreamingBody,
 )
 from vellum.workflows.exceptions import NodeException
@@ -45,7 +47,6 @@ from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
-from vellum.workflows.runner.types import WorkItemEvent
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
 
@@ -73,11 +74,10 @@ class WorkflowRunner(Generic[StateType]):
         parent_context: Optional[ParentContext] = None,
     ):
         if state and external_inputs:
-            raise ValueError(
-                "Can only run a Workflow providing one of state or external inputs, not both"
-            )
+            raise ValueError("Can only run a Workflow providing one of state or external inputs, not both")
 
         self.workflow = workflow
+        self._is_resuming = False
         if entrypoint_nodes:
             if len(list(entrypoint_nodes)) > 1:
                 raise ValueError("Cannot resume from multiple nodes")
@@ -100,10 +100,9 @@ class WorkflowRunner(Generic[StateType]):
                 for ei in external_inputs
                 if issubclass(ei.inputs_class.__parent_class__, BaseNode)
             ]
+            self._is_resuming = True
         else:
-            normalized_inputs = (
-                deepcopy(inputs) if inputs else self.workflow.get_default_inputs()
-            )
+            normalized_inputs = deepcopy(inputs) if inputs else self.workflow.get_default_inputs()
             if state:
                 self._initial_state = deepcopy(state)
                 self._initial_state.meta.workflow_inputs = normalized_inputs
@@ -111,9 +110,16 @@ class WorkflowRunner(Generic[StateType]):
                 self._initial_state = self.workflow.get_default_state(normalized_inputs)
             self._entrypoints = self.workflow.get_entrypoints()
 
-        self._work_item_event_queue: Queue[WorkItemEvent[StateType]] = Queue()
-        self._workflow_event_queue: Queue[WorkflowEvent] = Queue()
+        # This queue is responsible for sending events from WorkflowRunner to the outside world
+        self._workflow_event_outer_queue: Queue[WorkflowEvent] = Queue()
+
+        # This queue is responsible for sending events from the inner worker threads to WorkflowRunner
+        self._workflow_event_inner_queue: Queue[WorkflowEvent] = Queue()
+
+        # This queue is responsible for sending events from WorkflowRunner to the background thread
+        # for user defined emitters
         self._background_thread_queue: Queue[BackgroundThreadItem] = Queue()
+
         self._dependencies: Dict[Type[BaseNode], Set[Type[BaseNode]]] = defaultdict(set)
         self._state_forks: Set[StateType] = {self._initial_state}
 
@@ -126,9 +132,20 @@ class WorkflowRunner(Generic[StateType]):
             "__snapshot_callback__",
             lambda s: self._snapshot_state(s),
         )
-        self.workflow.context._register_event_queue(self._workflow_event_queue)
+        self.workflow.context._register_event_queue(self._workflow_event_inner_queue)
 
     def _snapshot_state(self, state: StateType) -> StateType:
+        self._workflow_event_inner_queue.put(
+            WorkflowExecutionSnapshottedEvent(
+                trace_id=state.meta.trace_id,
+                span_id=state.meta.span_id,
+                body=WorkflowExecutionSnapshottedBody(
+                    workflow_definition=self.workflow.__class__,
+                    state=state,
+                ),
+                parent=self._parent_context,
+            )
+        )
         self.workflow._store.append_state_snapshot(state)
         self._background_thread_queue.put(state)
         return state
@@ -139,22 +156,19 @@ class WorkflowRunner(Generic[StateType]):
         return event
 
     def _run_work_item(self, node: BaseNode[StateType], span_id: UUID) -> None:
-        self._work_item_event_queue.put(
-            WorkItemEvent(
-                node=node,
-                event=NodeExecutionInitiatedEvent(
-                    trace_id=node.state.meta.trace_id,
+        self._workflow_event_inner_queue.put(
+            NodeExecutionInitiatedEvent(
+                trace_id=node.state.meta.trace_id,
+                span_id=span_id,
+                body=NodeExecutionInitiatedBody(
+                    node_definition=node.__class__,
+                    inputs=node._inputs,
+                ),
+                parent=WorkflowParentContext(
                     span_id=span_id,
-                    body=NodeExecutionInitiatedBody(
-                        node_definition=node.__class__,
-                        inputs=node._inputs,
-                    ),
-                    parent=WorkflowParentContext(
-                        span_id=span_id,
-                        workflow_definition=self.workflow.__class__,
-                        parent=self._parent_context,
-                        type="WORKFLOW",
-                    ),
+                    workflow_definition=self.workflow.__class__,
+                    parent=self._parent_context,
+                    type="WORKFLOW",
                 ),
             )
         )
@@ -190,29 +204,24 @@ class WorkflowRunner(Generic[StateType]):
                         instance=None,
                         outputs_class=node.Outputs,
                     )
-                    node.state.meta.node_outputs[output_descriptor] = (
-                        streaming_output_queues[output.name]
-                    )
+                    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._work_item_event_queue.put(
-                        WorkItemEvent(
-                            node=node,
-                            event=NodeExecutionStreamingEvent(
-                                trace_id=node.state.meta.trace_id,
+                    self._workflow_event_inner_queue.put(
+                        NodeExecutionStreamingEvent(
+                            trace_id=node.state.meta.trace_id,
+                            span_id=span_id,
+                            body=NodeExecutionStreamingBody(
+                                node_definition=node.__class__,
+                                output=initiated_output,
+                                invoked_ports=initiated_ports,
+                            ),
+                            parent=WorkflowParentContext(
                                 span_id=span_id,
-                                body=NodeExecutionStreamingBody(
-                                    node_definition=node.__class__,
-                                    output=initiated_output,
-                                    invoked_ports=initiated_ports,
-                                ),
-                                parent=WorkflowParentContext(
-                                    span_id=span_id,
-                                    workflow_definition=self.workflow.__class__,
-                                    parent=self._parent_context,
-                                ),
+                                workflow_definition=self.workflow.__class__,
+                                parent=self._parent_context,
                             ),
-                        )
+                        ),
                     )
 
                 for output in node_run_response:
@@ -224,50 +233,47 @@ class WorkflowRunner(Generic[StateType]):
                             initiate_node_streaming_output(output)
 
                         streaming_output_queues[output.name].put(output.delta)
-                        self._work_item_event_queue.put(
-                            WorkItemEvent(
-                                node=node,
-                                event=NodeExecutionStreamingEvent(
-                                    trace_id=node.state.meta.trace_id,
+                        self._workflow_event_inner_queue.put(
+                            NodeExecutionStreamingEvent(
+                                trace_id=node.state.meta.trace_id,
+                                span_id=span_id,
+                                body=NodeExecutionStreamingBody(
+                                    node_definition=node.__class__,
+                                    output=output,
+                                    invoked_ports=invoked_ports,
+                                ),
+                                parent=WorkflowParentContext(
                                     span_id=span_id,
-                                    body=NodeExecutionStreamingBody(
-                                        node_definition=node.__class__,
-                                        output=output,
-                                        invoked_ports=invoked_ports,
-                                    ),
-                                    parent=WorkflowParentContext(
-                                        span_id=span_id,
-                                        workflow_definition=self.workflow.__class__,
-                                        parent=self._parent_context,
-                                    ),
+                                    workflow_definition=self.workflow.__class__,
+                                    parent=self._parent_context,
                                 ),
-                            )
+                            ),
                         )
                     elif output.is_fulfilled:
                         if output.name in streaming_output_queues:
                             streaming_output_queues[output.name].put(UNDEF)
 
                         setattr(outputs, output.name, output.value)
-                        self._work_item_event_queue.put(
-                            WorkItemEvent(
-                                node=node,
-                                event=NodeExecutionStreamingEvent(
-                                    trace_id=node.state.meta.trace_id,
+                        self._workflow_event_inner_queue.put(
+                            NodeExecutionStreamingEvent(
+                                trace_id=node.state.meta.trace_id,
+                                span_id=span_id,
+                                body=NodeExecutionStreamingBody(
+                                    node_definition=node.__class__,
+                                    output=output,
+                                    invoked_ports=invoked_ports,
+                                ),
+                                parent=WorkflowParentContext(
                                     span_id=span_id,
-                                    body=NodeExecutionStreamingBody(
-                                        node_definition=node.__class__,
-                                        output=output,
-                                        invoked_ports=invoked_ports,
-                                    ),
-                                    parent=WorkflowParentContext(
-                                        span_id=span_id,
-                                        workflow_definition=self.workflow.__class__,
-                                        parent=self._parent_context,
-                                    ),
+                                    workflow_definition=self.workflow.__class__,
+                                    parent=self._parent_context,
                                 ),
                             )
                         )
 
+            invoked_ports = ports(outputs, node.state)
+            node.state.meta.node_execution_cache.fulfill_node_execution(node.__class__, span_id)
+
             for descriptor, output_value in outputs:
                 if output_value is UNDEF:
                     if descriptor in node.state.meta.node_outputs:
@@ -276,81 +282,63 @@ class WorkflowRunner(Generic[StateType]):
 
                 node.state.meta.node_outputs[descriptor] = output_value
 
-            invoked_ports = ports(outputs, node.state)
-            node.state.meta.node_execution_cache.fulfill_node_execution(
-                node.__class__, span_id
-            )
-
-            self._work_item_event_queue.put(
-                WorkItemEvent(
-                    node=node,
-                    event=NodeExecutionFulfilledEvent(
-                        trace_id=node.state.meta.trace_id,
+            self._workflow_event_inner_queue.put(
+                NodeExecutionFulfilledEvent(
+                    trace_id=node.state.meta.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionFulfilledBody(
+                        node_definition=node.__class__,
+                        outputs=outputs,
+                        invoked_ports=invoked_ports,
+                    ),
+                    parent=WorkflowParentContext(
                         span_id=span_id,
-                        body=NodeExecutionFulfilledBody(
-                            node_definition=node.__class__,
-                            outputs=outputs,
-                            invoked_ports=invoked_ports,
-                        ),
-                        parent=WorkflowParentContext(
-                            span_id=span_id,
-                            workflow_definition=self.workflow.__class__,
-                            parent=self._parent_context,
-                        ),
+                        workflow_definition=self.workflow.__class__,
+                        parent=self._parent_context,
                     ),
                 )
             )
         except NodeException as e:
-            self._work_item_event_queue.put(
-                WorkItemEvent(
-                    node=node,
-                    event=NodeExecutionRejectedEvent(
-                        trace_id=node.state.meta.trace_id,
+            self._workflow_event_inner_queue.put(
+                NodeExecutionRejectedEvent(
+                    trace_id=node.state.meta.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionRejectedBody(
+                        node_definition=node.__class__,
+                        error=e.error,
+                    ),
+                    parent=WorkflowParentContext(
                         span_id=span_id,
-                        body=NodeExecutionRejectedBody(
-                            node_definition=node.__class__,
-                            error=e.error,
-                        ),
-                        parent=WorkflowParentContext(
-                            span_id=span_id,
-                            workflow_definition=self.workflow.__class__,
-                            parent=self._parent_context,
-                        ),
+                        workflow_definition=self.workflow.__class__,
+                        parent=self._parent_context,
                     ),
                 )
             )
         except Exception as e:
-            logger.exception(
-                f"An unexpected error occurred while running node {node.__class__.__name__}"
-            )
+            logger.exception(f"An unexpected error occurred while running node {node.__class__.__name__}")
 
-            self._work_item_event_queue.put(
-                WorkItemEvent(
-                    node=node,
-                    event=NodeExecutionRejectedEvent(
-                        trace_id=node.state.meta.trace_id,
-                        span_id=span_id,
-                        body=NodeExecutionRejectedBody(
-                            node_definition=node.__class__,
-                            error=VellumError(
-                                message=str(e),
-                                code=VellumErrorCode.INTERNAL_ERROR,
-                            ),
-                        ),
-                        parent=WorkflowParentContext(
-                            span_id=span_id,
-                            workflow_definition=self.workflow.__class__,
-                            parent=self._parent_context,
+            self._workflow_event_inner_queue.put(
+                NodeExecutionRejectedEvent(
+                    trace_id=node.state.meta.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionRejectedBody(
+                        node_definition=node.__class__,
+                        error=VellumError(
+                            message=str(e),
+                            code=VellumErrorCode.INTERNAL_ERROR,
                         ),
                     ),
-                )
+                    parent=WorkflowParentContext(
+                        span_id=span_id,
+                        workflow_definition=self.workflow.__class__,
+                        parent=self._parent_context,
+                    ),
+                ),
             )
 
         logger.debug(f"Finished running node: {node.__class__.__name__}")
 
-    def _handle_invoked_ports(
-        self, state: StateType, ports: Optional[Iterable[Port]]
-    ) -> None:
+    def _handle_invoked_ports(self, state: StateType, ports: Optional[Iterable[Port]]) -> None:
         if not ports:
             return
 
@@ -380,16 +368,12 @@ class WorkflowRunner(Generic[StateType]):
                     return
 
             all_deps = self._dependencies[node_class]
-            node_span_id = state.meta.node_execution_cache.queue_node_execution(
-                node_class, all_deps, invoked_by
-            )
+            node_span_id = state.meta.node_execution_cache.queue_node_execution(node_class, all_deps, invoked_by)
             if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
                 return
 
             node = node_class(state=state, context=self.workflow.context)
-            state.meta.node_execution_cache.initiate_node_execution(
-                node_class, node_span_id
-            )
+            state.meta.node_execution_cache.initiate_node_execution(node_class, node_span_id)
             self._active_nodes_by_execution_id[node_span_id] = node
 
             worker_thread = Thread(
@@ -398,13 +382,9 @@ class WorkflowRunner(Generic[StateType]):
             )
             worker_thread.start()
 
-    def _handle_work_item_event(
-        self, work_item_event: WorkItemEvent[StateType]
-    ) -> Optional[VellumError]:
-        node = work_item_event.node
-        event = work_item_event.event
-
-        if event.name == "node.execution.initiated":
+    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[VellumError]:
+        node = self._active_nodes_by_execution_id.get(event.span_id)
+        if not node:
             return None
 
         if event.name == "node.execution.rejected":
@@ -416,15 +396,12 @@ class WorkflowRunner(Generic[StateType]):
                 node_output_descriptor = workflow_output_descriptor.instance
                 if not isinstance(node_output_descriptor, OutputReference):
                     continue
-                if (
-                    node_output_descriptor.outputs_class
-                    != event.node_definition.Outputs
-                ):
+                if node_output_descriptor.outputs_class != event.node_definition.Outputs:
                     continue
                 if node_output_descriptor.name != event.output.name:
                     continue
 
-                self._workflow_event_queue.put(
+                self._workflow_event_outer_queue.put(
                     self._stream_workflow_event(
                         BaseOutput(
                             name=workflow_output_descriptor.name,
@@ -444,7 +421,7 @@ class WorkflowRunner(Generic[StateType]):
 
             return None
 
-        raise ValueError(f"Invalid event name: {event.name}")
+        return None
 
     def _initiate_workflow_event(self) -> WorkflowExecutionInitiatedEvent:
         return WorkflowExecutionInitiatedEvent(
@@ -457,9 +434,7 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._parent_context,
         )
 
-    def _stream_workflow_event(
-        self, output: BaseOutput
-    ) -> WorkflowExecutionStreamingEvent:
+    def _stream_workflow_event(self, output: BaseOutput) -> WorkflowExecutionStreamingEvent:
         return WorkflowExecutionStreamingEvent(
             trace_id=self._initial_state.meta.trace_id,
             span_id=self._initial_state.meta.span_id,
@@ -470,9 +445,7 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._parent_context,
         )
 
-    def _fulfill_workflow_event(
-        self, outputs: OutputsType
-    ) -> WorkflowExecutionFulfilledEvent:
+    def _fulfill_workflow_event(self, outputs: OutputsType) -> WorkflowExecutionFulfilledEvent:
         return WorkflowExecutionFulfilledEvent(
             trace_id=self._initial_state.meta.trace_id,
             span_id=self._initial_state.meta.span_id,
@@ -483,9 +456,7 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._parent_context,
         )
 
-    def _reject_workflow_event(
-        self, error: VellumError
-    ) -> WorkflowExecutionRejectedEvent:
+    def _reject_workflow_event(self, error: VellumError) -> WorkflowExecutionRejectedEvent:
         return WorkflowExecutionRejectedEvent(
             trace_id=self._initial_state.meta.trace_id,
             span_id=self._initial_state.meta.span_id,
@@ -505,9 +476,7 @@ class WorkflowRunner(Generic[StateType]):
             ),
         )
 
-    def _pause_workflow_event(
-        self, external_inputs: Iterable[ExternalInputReference]
-    ) -> WorkflowExecutionPausedEvent:
+    def _pause_workflow_event(self, external_inputs: Iterable[ExternalInputReference]) -> WorkflowExecutionPausedEvent:
         return WorkflowExecutionPausedEvent(
             trace_id=self._initial_state.meta.trace_id,
             span_id=self._initial_state.meta.span_id,
@@ -522,7 +491,7 @@ class WorkflowRunner(Generic[StateType]):
         # TODO: We should likely handle this during initialization
         # https://app.shortcut.com/vellum/story/4327
         if not self._entrypoints:
-            self._workflow_event_queue.put(
+            self._workflow_event_outer_queue.put(
                 self._reject_workflow_event(
                     VellumError(
                         message="No entrypoints defined",
@@ -539,16 +508,14 @@ class WorkflowRunner(Generic[StateType]):
             try:
                 self._run_node_if_ready(self._initial_state, node_cls)
             except NodeException as e:
-                self._workflow_event_queue.put(self._reject_workflow_event(e.error))
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
                 return
             except Exception:
                 err_message = f"An unexpected error occurred while initializing node {node_cls.__name__}"
                 logger.exception(err_message)
-                self._workflow_event_queue.put(
+                self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
-                        VellumError(
-                            code=VellumErrorCode.INTERNAL_ERROR, message=err_message
-                        ),
+                        VellumError(code=VellumErrorCode.INTERNAL_ERROR, message=err_message),
                     )
                 )
                 return
@@ -559,21 +526,20 @@ class WorkflowRunner(Generic[StateType]):
             if not self._active_nodes_by_execution_id:
                 break
 
-            work_item_event = self._work_item_event_queue.get()
-            event = work_item_event.event
+            event = self._workflow_event_inner_queue.get()
 
-            self._workflow_event_queue.put(event)
+            self._workflow_event_outer_queue.put(event)
 
-            rejection_error = self._handle_work_item_event(work_item_event)
+            rejection_error = self._handle_work_item_event(event)
             if rejection_error:
                 break
 
         # Handle any remaining events
         try:
-            while work_item_event := self._work_item_event_queue.get_nowait():
-                self._workflow_event_queue.put(work_item_event.event)
+            while event := self._workflow_event_inner_queue.get_nowait():
+                self._workflow_event_outer_queue.put(event)
 
-                rejection_error = self._handle_work_item_event(work_item_event)
+                rejection_error = self._handle_work_item_event(event)
                 if rejection_error:
                     break
         except Empty:
@@ -589,14 +555,13 @@ class WorkflowRunner(Generic[StateType]):
             if node_input_value is UNDEF
         }
         if unresolved_external_inputs:
-            self._workflow_event_queue.put(
+            self._workflow_event_outer_queue.put(
                 self._pause_workflow_event(unresolved_external_inputs),
             )
             return
 
-        final_state.meta.is_terminated = True
         if rejection_error:
-            self._workflow_event_queue.put(self._reject_workflow_event(rejection_error))
+            self._workflow_event_outer_queue.put(self._reject_workflow_event(rejection_error))
             return
 
         fulfilled_outputs = self.workflow.Outputs()
@@ -610,7 +575,7 @@ class WorkflowRunner(Generic[StateType]):
                     descriptor.instance.resolve(final_state),
                 )
 
-        self._workflow_event_queue.put(self._fulfill_workflow_event(fulfilled_outputs))
+        self._workflow_event_outer_queue.put(self._fulfill_workflow_event(fulfilled_outputs))
 
     def _run_background_thread(self) -> None:
         state_class = self.workflow.get_state_class()
@@ -631,7 +596,7 @@ class WorkflowRunner(Generic[StateType]):
             return
 
         self._cancel_signal.wait()
-        self._workflow_event_queue.put(
+        self._workflow_event_outer_queue.put(
             self._reject_workflow_event(
                 VellumError(
                     code=VellumErrorCode.WORKFLOW_CANCELLED,
@@ -664,16 +629,12 @@ class WorkflowRunner(Generic[StateType]):
             cancel_thread.start()
 
         event: WorkflowEvent
-        if (
-            self._initial_state.meta.is_terminated
-            or self._initial_state.meta.is_terminated is None
-        ):
-            event = self._initiate_workflow_event()
-        else:
+        if self._is_resuming:
             event = self._resume_workflow_event()
+        else:
+            event = self._initiate_workflow_event()
 
         yield self._emit_event(event)
-        self._initial_state.meta.is_terminated = False
 
         # The extra level of indirection prevents the runner from waiting on the caller to consume the event stream
         stream_thread = Thread(
@@ -684,7 +645,7 @@ class WorkflowRunner(Generic[StateType]):
 
         while stream_thread.is_alive():
             try:
-                event = self._workflow_event_queue.get(timeout=0.1)
+                event = self._workflow_event_outer_queue.get(timeout=0.1)
             except Empty:
                 continue
 
@@ -694,7 +655,7 @@ class WorkflowRunner(Generic[StateType]):
                 break
 
         try:
-            while event := self._workflow_event_queue.get_nowait():
+            while event := self._workflow_event_outer_queue.get_nowait():
                 yield self._emit_event(event)
         except Empty:
             pass

vellum/workflows/state/base.py

@@ -192,7 +192,6 @@ class StateMeta(UniversalBaseModel):
     node_outputs: Dict[OutputReference, Any] = field(default_factory=dict)
     node_execution_cache: NodeExecutionCache = field(default_factory=NodeExecutionCache)
     parent: Optional["BaseState"] = None
-    is_terminated: Optional[bool] = None
     __snapshot_callback__: Optional[Callable[[], None]] = field(init=False, default=None)
 
     def model_post_init(self, context: Any) -> None:
@@ -286,7 +285,6 @@ class BaseState(metaclass=_BaseStateMeta):
 {values}
     meta:
         id={self.meta.id}
-        is_terminated={self.meta.is_terminated}
         updated_ts={self.meta.updated_ts}
         node_outputs:{' Empty' if not node_outputs else ''}
 {node_outputs}

vellum/workflows/types/core.py

@@ -85,6 +85,7 @@ class MergeBehavior(Enum):
     AWAIT_ANY = "AWAIT_ANY"
     AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
 
+
 class ConditionType(Enum):
     IF = "IF"
     ELIF = "ELIF"

vellum/workflows/types/tests/test_utils.py

@@ -33,6 +33,7 @@ class ExampleGenericClass(Generic[T]):
 class ExampleInheritedClass(ExampleClass):
     theta: int
 
+
 @TryNode.wrap()
 class ExampleNode(BaseNode):
     class Outputs(BaseNode.Outputs):

vellum/workflows/types/utils.py

@@ -1,7 +1,6 @@
 from copy import deepcopy
 from datetime import datetime
 import importlib
-import sys
 from typing import (
     Any,
     ClassVar,