vellum-workflow-server 0.14.72.post6__py3-none-any.whl → 0.14.72.post8__py3-none-any.whl

{vellum_workflow_server-0.14.72.post6.dist-info → vellum_workflow_server-0.14.72.post8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 0.14.72.post6
+Version: 0.14.72.post8
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4

{vellum_workflow_server-0.14.72.post6.dist-info → vellum_workflow_server-0.14.72.post8.dist-info}/RECORD

@@ -6,13 +6,14 @@ workflow_server/api/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 workflow_server/api/tests/test_input_display_mapping.py,sha256=drBZqMudFyB5wgiUOcMgRXz7E7ge-Qgxbstw4E4f0zE,2211
 workflow_server/api/tests/test_workflow_view.py,sha256=2nscM_QsYPHkkTG8_JhNbE2LmGL5FQKXEtaLLjXouw0,14591
 workflow_server/api/tests/test_workflow_view_stream_workflow_route.py,sha256=wmeH8oGo0lKx3YzEJQ9nGjw7adqQD0EL7-xGLPgYWqc,24872
-workflow_server/api/workflow_view.py,sha256=x9SSsWCzLuwXBhLJMc-vDMtmP626O6tw1AGh6KII_lc,17697
-workflow_server/code_exec_runner.py,sha256=p6lGaEGAfMFCxIpOJtH9KTvkffCDsJ3bbpmHdCGWquM,3265
+workflow_server/api/workflow_view.py,sha256=AOHccJXkhzw-iXBo4Q_EaLRynTuNmeQZaQxB5ttgrY4,15434
+workflow_server/code_exec_runner.py,sha256=XSs4w_b0vDUt0HqSakc26Gxx9aoG2wmwOo-JGVL5QJ4,2388
 workflow_server/config.py,sha256=K5Tavm7wiqCZt0RWWue7zzb8N6e8aWnFOTNlBqEJPcI,1330
 workflow_server/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 workflow_server/core/cancel_workflow.py,sha256=Ffkc3mzmrdMEUcD-sHfEhX4IwVrka-E--SxKA1dUfIU,2185
 workflow_server/core/events.py,sha256=24MA66DVQuaLJJcZrS8IL1Zq4Ohi9CoouKZ5VgoH3Cs,1402
-workflow_server/core/executor.py,sha256=-FR91th7vp_v-R_Mo3NVS5GcsmD7iPo3D18Xi-bUrHo,18017
+workflow_server/core/executor.py,sha256=TOnJ5FcmC8mWNdGvoyTwNlNlbhp6s6hk7Nc4M35jEe4,17148
+workflow_server/core/utils.py,sha256=lgzxkAEjEXPxGXXQlUYTYuCdHht-eDJJmHj5AhEb3_o,1500
 workflow_server/core/workflow_executor_context.py,sha256=a-v48GJbOWUh4JIf_bNwDX-BvfKkg4xwRSPEyRVQmp4,1373
 workflow_server/server.py,sha256=QBU12AaAfAgLqfCDBd24qIJl_mbheiq0-hfcWV7rZM4,1234
 workflow_server/start.py,sha256=DgtQhuCLc07BIWyJPLPZKZsQ8jwEFsvvfIo7MdwVrpw,1998
@@ -26,7 +27,7 @@ workflow_server/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 workflow_server/utils/tests/test_system_utils.py,sha256=MdBxI9gxUOpR_JBAHpEz6dGFY6JjxhMSM2oExpqFvNA,4314
 workflow_server/utils/tests/test_utils.py,sha256=qwK5Rmy3RQyjtlUrYAuGuDlBeRzZKsf1yS-y2IpUizQ,6452
 workflow_server/utils/utils.py,sha256=Wqqn-1l2ugkGgy5paWWdt0AVxAyPMQCYcnRSSOMjXlA,4355
-vellum_workflow_server-0.14.72.post6.dist-info/METADATA,sha256=pmr1HyQdJhIDgb7E0Qwu5YtfYqjXq9U1RAhfNqE_JyI,2243
-vellum_workflow_server-0.14.72.post6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_workflow_server-0.14.72.post6.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
-vellum_workflow_server-0.14.72.post6.dist-info/RECORD,,
+vellum_workflow_server-0.14.72.post8.dist-info/METADATA,sha256=nVRAxS08mE0rdcDEdVIP_WqV-0rtExCdf-OWc_PeVvI,2243
+vellum_workflow_server-0.14.72.post8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_workflow_server-0.14.72.post8.dist-info/entry_points.txt,sha256=uB_0yPkr7YV6RhEXzvFReUM8P4OQBlVXD6TN6eb9-oc,277
+vellum_workflow_server-0.14.72.post8.dist-info/RECORD,,

workflow_server/api/workflow_view.py

@@ -32,6 +32,7 @@ from workflow_server.core.events import (
     VembdaExecutionInitiatedEvent,
 )
 from workflow_server.core.executor import stream_node_pebble_timeout, stream_workflow_process_timeout
+from workflow_server.core.utils import create_vembda_rejected_event, serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     NodeExecutorContext,
@@ -119,19 +120,7 @@ def stream_workflow_route() -> Response:
         sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id))
         logger.exception(e)
 
-        vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id,
-            span_id=context.execution_id,
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                stderr=traceback.format_exc(),
-                container_overhead_latency=context.container_overhead_latency,
-            ),
-            parent=None,
-        )
-        process_output_queue.put(vembda_fulfilled_event.model_dump(mode="json"))
+        process_output_queue.put(create_vembda_rejected_event(context, traceback.format_exc()))
 
     first_item = process_output_queue.get(timeout=0.1)
     if isinstance(first_item, str) and first_item.startswith(SPAN_ID_EVENT):
@@ -184,18 +173,9 @@ def stream_workflow_route() -> Response:
             if get_is_oom_killed():
                 logger.warning("Workflow stream OOM Kill event")
 
-                yield VembdaExecutionFulfilledEvent(
-                    id=uuid4(),
-                    timestamp=datetime.now(),
-                    trace_id=context.trace_id,
-                    span_id=context.execution_id,
-                    body=VembdaExecutionFulfilledBody(
-                        exit_code=-1,
-                        container_overhead_latency=context.container_overhead_latency,
-                        stderr=f"Organization Workflow server has exceeded {MEMORY_LIMIT_MB}MB memory limit.",
-                    ),
-                    parent=None,
-                ).model_dump(mode="json")
+                yield create_vembda_rejected_event(
+                    context, f"Organization Workflow server has exceeded {MEMORY_LIMIT_MB}MB memory limit."
+                )
 
                 if process and process.is_alive():
                     process.kill()
@@ -216,18 +196,9 @@ def stream_workflow_route() -> Response:
                     if process and not process.is_alive():
                         logger.error("Workflow process exited abnormally")
 
-                        yield VembdaExecutionFulfilledEvent(
-                            id=uuid4(),
-                            timestamp=datetime.now(),
-                            trace_id=context.trace_id,
-                            span_id=context.execution_id,
-                            body=VembdaExecutionFulfilledBody(
-                                exit_code=-1,
-                                container_overhead_latency=context.container_overhead_latency,
-                                stderr="Internal Server Error, Workflow process exited abnormally",
-                            ),
-                            parent=None,
-                        ).model_dump(mode="json")
+                        yield create_vembda_rejected_event(
+                            context, "Internal Server Error, Workflow process exited abnormally"
+                        )
 
                         break
 
@@ -330,19 +301,7 @@ def stream_node_route() -> Response:
                 if stream_future.exception() is not None:
                     # This happens when theres a problem with the stream function call
                     # itself not the workflow runner
-                    vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-                        id=uuid4(),
-                        timestamp=datetime.now(),
-                        trace_id=context.trace_id,
-                        span_id=context.execution_id,
-                        body=VembdaExecutionFulfilledBody(
-                            exit_code=-1,
-                            stderr="Internal Server Error",
-                            container_overhead_latency=context.container_overhead_latency,
-                        ),
-                        parent=None,
-                    )
-                    yield vembda_fulfilled_event.model_dump(mode="json")
+                    yield create_vembda_rejected_event(context, "Internal Server Error")
                     sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id))
                     app.logger.exception(stream_future.exception())
                     break
@@ -454,18 +413,7 @@ def startup_error_generator(
         yield "\n"
         yield vembda_initiated_event.model_dump_json()
         yield "\n"
-        yield VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id,
-            span_id=context.execution_id,
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                container_overhead_latency=context.container_overhead_latency,
-                stderr=message,
-            ),
-            parent=None,
-        ).model_dump_json()
+        yield serialize_vembda_rejected_event(context, message)
         yield "\n"
         yield "END"
         yield "\n"

workflow_server/code_exec_runner.py

@@ -9,13 +9,9 @@ import sentry_sdk
 
 from vellum.workflows.exceptions import WorkflowInitializationException
 from workflow_server.api.workflow_view import get_workflow_request_context
-from workflow_server.core.events import (
-    VembdaExecutionFulfilledBody,
-    VembdaExecutionFulfilledEvent,
-    VembdaExecutionInitiatedBody,
-    VembdaExecutionInitiatedEvent,
-)
+from workflow_server.core.events import VembdaExecutionInitiatedBody, VembdaExecutionInitiatedEvent
 from workflow_server.core.executor import stream_workflow
+from workflow_server.core.utils import serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import WorkflowExecutorContext
 from workflow_server.utils.utils import get_version
 
@@ -57,34 +53,11 @@ def run_code_exec_stream() -> None:
             for line in stream_iterator:
                 print(f"{_EVENT_LINE}{json.dumps(line)}")  # noqa: T201
         except WorkflowInitializationException as e:
-            fulfilled_event = VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=context.trace_id,
-                span_id=context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr=str(e),
-                    container_overhead_latency=context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-
-            print(f"{_EVENT_LINE}{json.dumps(fulfilled_event)}")  # noqa: T201
+            fulfilled_event = serialize_vembda_rejected_event(context, str(e))
+            print(f"{_EVENT_LINE}{fulfilled_event}")  # noqa: T201
     except Exception as e:
         sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id) if context else "unknown")
         logger.exception(e)
 
-        vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id if context else uuid4(),
-            span_id=context.execution_id if context else uuid4(),
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                stderr="Internal Server Error",
-            ),
-            parent=None,
-        )
-        event = json.dumps(vembda_fulfilled_event.model_dump(mode="json"))
+        event = serialize_vembda_rejected_event(context, "Internal Server Error")
         print(f"{_EVENT_LINE}{event}")  # noqa: T201

workflow_server/core/executor.py

@@ -40,6 +40,7 @@ from workflow_server.core.events import (
     VembdaExecutionFulfilledBody,
     VembdaExecutionFulfilledEvent,
 )
+from workflow_server.core.utils import serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     BaseExecutorContext,
@@ -101,40 +102,14 @@ def _stream_workflow_wrapper(executor_context: WorkflowExecutorContext, queue: Q
         if not span_id_emitted:
             queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
 
-        queue.put(
-            VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=executor_context.trace_id,
-                span_id=executor_context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr=str(e),
-                    container_overhead_latency=executor_context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-        )
+        queue.put(serialize_vembda_rejected_event(executor_context, str(e)))
     except Exception as e:
         if not span_id_emitted:
             queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
 
         sentry_sdk.set_tag("vellum_trace_id", str(executor_context.trace_id))
         logger.exception(e)
-        queue.put(
-            VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=executor_context.trace_id,
-                span_id=executor_context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr="Internal Server Error",
-                    container_overhead_latency=executor_context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-        )
+        queue.put(serialize_vembda_rejected_event(executor_context, "Internal Server Error"))
     queue.put(STREAM_FINISHED_EVENT)
 
     exit(0)

workflow_server/core/utils.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+from uuid import uuid4
+from typing import Optional
+
+from workflow_server.core.events import VembdaExecutionFulfilledBody, VembdaExecutionFulfilledEvent
+from workflow_server.core.workflow_executor_context import BaseExecutorContext
+
+
+def _create_vembda_rejected_event_base(
+    executor_context: Optional[BaseExecutorContext], error_message: str
+) -> VembdaExecutionFulfilledEvent:
+    if executor_context:
+        trace_id = executor_context.trace_id
+        span_id = executor_context.execution_id
+        container_overhead_latency = executor_context.container_overhead_latency
+    else:
+        trace_id = uuid4()
+        span_id = uuid4()
+        container_overhead_latency = None
+
+    return VembdaExecutionFulfilledEvent(
+        id=uuid4(),
+        timestamp=datetime.now(),
+        trace_id=trace_id,
+        span_id=span_id,
+        body=VembdaExecutionFulfilledBody(
+            exit_code=-1,
+            stderr=error_message,
+            container_overhead_latency=container_overhead_latency,
+        ),
+        parent=None,
+    )
+
+
+def create_vembda_rejected_event(executor_context: Optional[BaseExecutorContext], error_message: str) -> dict:
+    return _create_vembda_rejected_event_base(executor_context, error_message).model_dump(mode="json")
+
+
+def serialize_vembda_rejected_event(executor_context: Optional[BaseExecutorContext], error_message: str) -> str:
+    return _create_vembda_rejected_event_base(executor_context, error_message).model_dump_json()