vellum-ai 0.9.16__py3-none-any.whl → 0.9.16rc4__py3-none-any.whl

vellum/workflows/workflows/base.py

@@ -0,0 +1,365 @@
+# flake8: noqa: E402
+
+import importlib
+import inspect
+
+from vellum.plugins.utils import load_runtime_plugins
+
+load_runtime_plugins()
+
+from datetime import datetime
+from functools import lru_cache
+from threading import Event as ThreadingEvent
+from uuid import uuid4
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+)
+
+from vellum.workflows.edges import Edge
+from vellum.workflows.emitters.base import BaseWorkflowEmitter
+from vellum.workflows.errors import VellumError, VellumErrorCode
+from vellum.workflows.events.node import (
+    NodeExecutionFulfilledBody,
+    NodeExecutionInitiatedBody,
+    NodeExecutionPausedBody,
+    NodeExecutionRejectedBody,
+    NodeExecutionResumedBody,
+    NodeExecutionStreamingBody,
+)
+from vellum.workflows.events.types import WorkflowEventType
+from vellum.workflows.events.workflow import (
+    GenericWorkflowEvent,
+    WorkflowExecutionFulfilledBody,
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionInitiatedBody,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionPausedBody,
+    WorkflowExecutionPausedEvent,
+    WorkflowExecutionRejectedBody,
+    WorkflowExecutionRejectedEvent,
+    WorkflowExecutionResumedBody,
+    WorkflowExecutionResumedEvent,
+    WorkflowExecutionStreamingBody,
+)
+from vellum.workflows.graph import Graph
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.resolvers.base import BaseWorkflowResolver
+from vellum.workflows.runner import WorkflowRunner
+from vellum.workflows.runner.runner import ExternalInputsArg, RunFromNodeArg
+from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.state.store import Store
+from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.types.utils import get_original_base
+
+
+class _BaseWorkflowMeta(type):
+    def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        if "graph" not in dct:
+            dct["graph"] = []
+
+        return super().__new__(mcs, name, bases, dct)
+
+
+class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkflowMeta):
+    graph: ClassVar[Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]]
+    emitters: List[BaseWorkflowEmitter]
+    resolvers: List[BaseWorkflowResolver]
+
+    class Outputs(BaseOutputs):
+        pass
+
+    WorkflowEvent = Union[  # type: ignore
+        GenericWorkflowEvent,
+        WorkflowExecutionInitiatedEvent[WorkflowInputsType],  # type: ignore[valid-type]
+        WorkflowExecutionFulfilledEvent[Outputs],
+    ]
+
+    TerminalWorkflowEvent = Union[
+        WorkflowExecutionFulfilledEvent[Outputs],
+        WorkflowExecutionRejectedEvent,
+        WorkflowExecutionPausedEvent,
+    ]
+
+    WorkflowEventStream = Generator[WorkflowEvent, None, None]
+
+    def __init__(
+        self,
+        parent_state: Optional[BaseState] = None,
+        emitters: Optional[List[BaseWorkflowEmitter]] = None,
+        resolvers: Optional[List[BaseWorkflowResolver]] = None,
+        context: Optional[WorkflowContext] = None,
+    ):
+        self._parent_state = parent_state
+        self.emitters = emitters or (self.emitters if hasattr(self, "emitters") else [])
+        self.resolvers = resolvers or (self.resolvers if hasattr(self, "resolvers") else [])
+        self._context = context or WorkflowContext()
+        self._store = Store()
+
+        self.validate()
+
+    @property
+    def context(self) -> WorkflowContext:
+        return self._context
+
+    @classmethod
+    def get_subgraphs(cls) -> List[Graph]:
+        original_graph = cls.graph
+        if isinstance(original_graph, Graph):
+            return [original_graph]
+        if isinstance(original_graph, set):
+            return [
+                subgraph if isinstance(subgraph, Graph) else Graph.from_node(subgraph) for subgraph in original_graph
+            ]
+        if issubclass(original_graph, BaseNode):
+            return [Graph.from_node(original_graph)]
+
+        raise ValueError(f"Unexpected graph type: {original_graph.__class__}")
+
+    @classmethod
+    def get_edges(cls) -> Iterator[Edge]:
+        """
+        Returns an iterator over the edges in the workflow. We use a set to
+        ensure uniqueness, and the iterator to preserve order.
+        """
+
+        edges = set()
+        subgraphs = cls.get_subgraphs()
+        for subgraph in subgraphs:
+            for edge in subgraph.edges:
+                if edge not in edges:
+                    edges.add(edge)
+                    yield edge
+
+    @classmethod
+    def get_nodes(cls) -> Iterator[Type[BaseNode]]:
+        """
+        Returns an iterator over the nodes in the workflow. We use a set to
+        ensure uniqueness, and the iterator to preserve order.
+        """
+
+        nodes = set()
+        for subgraph in cls.get_subgraphs():
+            for node in subgraph.nodes:
+                if node not in nodes:
+                    nodes.add(node)
+                    yield node
+
+    @classmethod
+    def get_entrypoints(cls) -> Iterable[Type[BaseNode]]:
+        return iter({e for g in cls.get_subgraphs() for e in g.entrypoints})
+
+    def run(
+        self,
+        inputs: Optional[WorkflowInputsType] = None,
+        state: Optional[StateType] = None,
+        entrypoint_nodes: Optional[RunFromNodeArg] = None,
+        external_inputs: Optional[ExternalInputsArg] = None,
+        cancel_signal: Optional[ThreadingEvent] = None,
+    ) -> TerminalWorkflowEvent:
+        events = WorkflowRunner(
+            self,
+            inputs=inputs,
+            state=state,
+            entrypoint_nodes=entrypoint_nodes,
+            external_inputs=external_inputs,
+            cancel_signal=cancel_signal,
+        ).stream()
+        first_event: Optional[Union[WorkflowExecutionInitiatedEvent, WorkflowExecutionResumedEvent]] = None
+        last_event = None
+        for event in events:
+            if event.name == "workflow.execution.initiated" or event.name == "workflow.execution.resumed":
+                first_event = event
+            last_event = event
+
+        if not last_event:
+            return WorkflowExecutionRejectedEvent(
+                trace_id=uuid4(),
+                span_id=uuid4(),
+                body=WorkflowExecutionRejectedBody(
+                    error=VellumError(code=VellumErrorCode.INTERNAL_ERROR, message="No events were emitted"),
+                    workflow_definition=self.__class__,
+                ),
+            )
+
+        if not first_event:
+            return WorkflowExecutionRejectedEvent(
+                trace_id=uuid4(),
+                span_id=uuid4(),
+                body=WorkflowExecutionRejectedBody(
+                    error=VellumError(code=VellumErrorCode.INTERNAL_ERROR, message="Initiated event was never emitted"),
+                    workflow_definition=self.__class__,
+                ),
+            )
+
+        if (
+            last_event.name == "workflow.execution.rejected"
+            or last_event.name == "workflow.execution.fulfilled"
+            or last_event.name == "workflow.execution.paused"
+        ):
+            return last_event
+
+        return WorkflowExecutionRejectedEvent(
+            trace_id=first_event.trace_id,
+            span_id=first_event.span_id,
+            body=WorkflowExecutionRejectedBody(
+                workflow_definition=self.__class__,
+                error=VellumError(
+                    code=VellumErrorCode.INTERNAL_ERROR,
+                    message=f"Unexpected last event name found: {last_event.name}",
+                ),
+            ),
+        )
+
+    def stream(
+        self,
+        event_types: Optional[Set[WorkflowEventType]] = None,
+        inputs: Optional[WorkflowInputsType] = None,
+        state: Optional[StateType] = None,
+        entrypoint_nodes: Optional[RunFromNodeArg] = None,
+        external_inputs: Optional[ExternalInputsArg] = None,
+        cancel_signal: Optional[ThreadingEvent] = None,
+    ) -> WorkflowEventStream:
+        event_types = event_types or {WorkflowEventType.WORKFLOW}
+        for event in WorkflowRunner(
+            self,
+            inputs=inputs,
+            state=state,
+            entrypoint_nodes=entrypoint_nodes,
+            external_inputs=external_inputs,
+            cancel_signal=cancel_signal,
+        ).stream():
+            if WorkflowEventType(event.name.split(".")[0].upper()) in event_types:
+                yield event
+
+    def validate(self) -> None:
+        """
+        Validates the Workflow, by running through our list of linter rules.
+        """
+        # TODO: Implement rule that all entrypoints are non empty
+        # https://app.shortcut.com/vellum/story/4327
+        pass
+
+    @classmethod
+    @lru_cache
+    def _get_parameterized_classes(cls) -> Tuple[Type[WorkflowInputsType], Type[StateType]]:
+        original_base = get_original_base(cls)
+
+        inputs_type, state_type = get_args(original_base)
+
+        if isinstance(inputs_type, TypeVar):
+            inputs_type = BaseInputs
+        if isinstance(state_type, TypeVar):
+            state_type = BaseState
+
+        if not issubclass(inputs_type, BaseInputs):
+            raise ValueError(f"Expected first type to be a subclass of BaseInputs, was: {inputs_type}")
+
+        if not issubclass(state_type, BaseState):
+            raise ValueError(f"Expected second type to be a subclass of BaseState, was: {state_type}")
+
+        return (inputs_type, state_type)
+
+    @classmethod
+    def get_inputs_class(cls) -> Type[WorkflowInputsType]:
+        return cls._get_parameterized_classes()[0]
+
+    @classmethod
+    def get_state_class(cls) -> Type[StateType]:
+        return cls._get_parameterized_classes()[1]
+
+    def get_default_inputs(self) -> WorkflowInputsType:
+        return self.get_inputs_class()()
+
+    def get_default_state(self, workflow_inputs: Optional[WorkflowInputsType] = None) -> StateType:
+        return self.get_state_class()(
+            meta=StateMeta(parent=self._parent_state, workflow_inputs=workflow_inputs or self.get_default_inputs())
+        )
+
+    def get_state_at_node(self, node: Type[BaseNode]) -> StateType:
+        event_ts = datetime.min
+        for event in self._store.events:
+            if event.name == "node.execution.initiated" and event.node_definition == node:
+                event_ts = event.timestamp
+
+        most_recent_state_snapshot: Optional[StateType] = None
+        for snapshot in self._store.state_snapshots:
+            if snapshot.meta.updated_ts > event_ts:
+                break
+
+            most_recent_state_snapshot = cast(StateType, snapshot)
+
+        if not most_recent_state_snapshot:
+            return self.get_default_state()
+
+        return most_recent_state_snapshot
+
+    def get_most_recent_state(self) -> StateType:
+        most_recent_state_snapshot: Optional[StateType] = None
+
+        for snapshot in self._store.state_snapshots:
+            next_state = cast(StateType, snapshot)
+            if not most_recent_state_snapshot:
+                most_recent_state_snapshot = next_state
+            elif next_state.meta.updated_ts >= most_recent_state_snapshot.meta.updated_ts:
+                most_recent_state_snapshot = next_state
+
+        if not most_recent_state_snapshot:
+            return self.get_default_state()
+
+        return most_recent_state_snapshot
+
+    @staticmethod
+    def load_from_module(module_path: str) -> Type["BaseWorkflow"]:
+        workflow_path = f"{module_path}.workflow"
+        module = importlib.import_module(workflow_path)
+
+        workflows: List[Type[BaseWorkflow]] = []
+        for name in dir(module):
+            attr = getattr(module, name)
+            if (
+                inspect.isclass(attr)
+                and issubclass(attr, BaseWorkflow)
+                and attr != BaseWorkflow
+                and attr.__module__ == workflow_path
+            ):
+                workflows.append(attr)
+
+        if len(workflows) == 0:
+            raise ValueError(f"No workflows found in {module_path}")
+        elif len(workflows) > 1:
+            raise ValueError(f"Multiple workflows found in {module_path}")
+
+        return workflows[0]
+
+
+WorkflowExecutionInitiatedBody.model_rebuild()
+WorkflowExecutionFulfilledBody.model_rebuild()
+WorkflowExecutionRejectedBody.model_rebuild()
+WorkflowExecutionPausedBody.model_rebuild()
+WorkflowExecutionResumedBody.model_rebuild()
+WorkflowExecutionStreamingBody.model_rebuild()
+
+NodeExecutionInitiatedBody.model_rebuild()
+NodeExecutionFulfilledBody.model_rebuild()
+NodeExecutionRejectedBody.model_rebuild()
+NodeExecutionPausedBody.model_rebuild()
+NodeExecutionResumedBody.model_rebuild()
+NodeExecutionStreamingBody.model_rebuild()

{vellum_ai-0.9.16.dist-info → vellum_ai-0.9.16rc4.dist-info}/LICENSE

@@ -1,6 +1,14 @@
-MIT License
+Copyright (c) 2023-present Vocify Inc. dba Velum
 
-Copyright (c) Vocify Inc. dba Vellum
+Portions of this software are licensed as follows:
+
+* All content that resides under the "ee/" directory of this repository, if
+that directory exists, is licensed under the license defined in "ee/LICENSE".
+* All third party components incorporated into the Vellum Software are
+licensed under the original license provided by the owner of the applicable
+component.
+* Content outside of the above mentioned directories or restrictions above is
+available under the "MIT Expat" license as defined below.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +26,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

vellum_ai-0.9.16rc4.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: vellum-ai
+Version: 0.9.16rc4
+Summary: 
+License: MIT
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: Jinja2 (==3.1.2)
+Requires-Dist: cdktf (>=0.20.5,<0.21.0)
+Requires-Dist: click (==8.1.7)
+Requires-Dist: docker (==7.1.0)
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
+Requires-Dist: publication (==0.0.3)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: pydash (==7.0.6)
+Requires-Dist: python-dotenv (==1.0.1)
+Requires-Dist: pytz (==2022.6)
+Requires-Dist: pyyaml (==6.0.1)
+Requires-Dist: requests (==2.32.3)
+Requires-Dist: tomli (==2.0.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <h1 align="center">
+  Vellum
+  </h1>
+  <p align="center">
+    <a href="https://vellum.ai">Learn more</a>
+    ·
+    <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pepy.tech/project/vellum-ai">
+    <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
+  </a>
+  <a href="https://pypi.org/project/vellum-ai" target="_blank">
+    <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.ycombinator.com/companies/vellum">
+    <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
+
+# Introduction
+
+
+[Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications
+
+### Core Features
+
+- **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
+- **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
+- **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale.
+- **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
+  optimized for AI systems
+- **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
+  one-click deploy
+- **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback
+
+## Table of Contents
+
+- [Get Started](#get-started)
+- [Client SDK](#client-sdk)
+- [Workflows SDK](#workflows-sdk)
+- [Contributing](#contributing)
+- [Open-source vs paid](#open-source-vs-paid)
+
+
+## Get Started
+Most functionality within the SDKs here requires a Vellum account and API key. To sign up, [talk to us](https://www.vellum.ai/landing-pages/request-demo)
+or visit our [pricing page](https://www.vellum.ai/pricing).
+
+Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
+more below](#workflows-sdk).
+
+
+
+## Client SDK
+The Vellum Client SDK, found within `src/client` is a low-level client used to interact directly with the Vellum API.
+Learn more and get started by visiting the [Vellum Client SDK README](/src/client/README.md).
+
+
+## Workflows SDK
+The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
+it's core, it's a powerful workflow engine with syntactic sugar for intuitively defining graphs, the nodes within,
+and the relationships between them.
+
+The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
+out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
+and debugging via a UI.
+
+To learn more and get started, visit the [Vellum Workflows SDK README](/src/workflows/README.md).
+
+
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).