dbos 0.26.0a14__py3-none-any.whl → 0.26.0a18__py3-none-any.whl

dbos/_admin_server.py

@@ -7,6 +7,7 @@ from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import TYPE_CHECKING, Any, List, TypedDict
 
+from ._error import DBOSException
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
 from ._utils import GlobalParams
@@ -22,6 +23,7 @@ _workflow_queues_metadata_path = "/dbos-workflow-queues-metadata"
 # /workflows/:workflow_id/resume
 # /workflows/:workflow_id/restart
 # /workflows/:workflow_id/steps
+# /workflows/:workflow_id/fork
 
 
 class AdminServer:
@@ -123,6 +125,9 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             restart_match = re.match(
                 r"^/workflows/(?P<workflow_id>[^/]+)/restart$", self.path
             )
+            fork_match = re.match(
+                r"^/workflows/(?P<workflow_id>[^/]+)/fork$", self.path
+            )
             resume_match = re.match(
                 r"^/workflows/(?P<workflow_id>[^/]+)/resume$", self.path
             )
@@ -130,7 +135,23 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
                 r"^/workflows/(?P<workflow_id>[^/]+)/cancel$", self.path
             )
 
-            if restart_match:
+            if fork_match:
+                workflow_id = fork_match.group("workflow_id")
+                try:
+                    data = json.loads(post_data.decode("utf-8"))
+                    start_step: int = data.get("start_step", 1)
+                    self._handle_fork(workflow_id, start_step)
+                except (json.JSONDecodeError, AttributeError) as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(
+                        json.dumps({"error": f"Invalid JSON input: {str(e)}"}).encode(
+                            "utf-8"
+                        )
+                    )
+                    return
+            elif restart_match:
                 workflow_id = restart_match.group("workflow_id")
                 self._handle_restart(workflow_id)
             elif resume_match:
@@ -147,10 +168,33 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         return  # Disable admin server request logging
 
     def _handle_restart(self, workflow_id: str) -> None:
-        self.dbos.restart_workflow(workflow_id)
-        print("Restarting workflow", workflow_id)
-        self.send_response(204)
-        self._end_headers()
+        try:
+            print(f"Restarting workflow {workflow_id}")
+            self.dbos.restart_workflow(workflow_id)
+            self.send_response(204)
+            self._end_headers()
+        except DBOSException as e:
+            print(f"Error restarting workflow: {e}")
+            self.send_response(500)
+            response_body = json.dumps({"error": str(e)}).encode("utf-8")
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(response_body)))
+            self.end_headers()
+            self.wfile.write(response_body)
+
+    def _handle_fork(self, workflow_id: str, start_step: int) -> None:
+        try:
+            self.dbos.fork_workflow(workflow_id, start_step)
+            self.send_response(204)
+            self._end_headers()
+        except DBOSException as e:
+            print(f"Error forking workflow: {e}")
+            self.send_response(500)
+            response_body = json.dumps({"error": str(e)}).encode("utf-8")
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(response_body)))
+            self.end_headers()
+            self.wfile.write(response_body)
 
     def _handle_resume(self, workflow_id: str) -> None:
         print("Resuming workflow", workflow_id)

dbos/_app_db.py

@@ -228,3 +228,59 @@ class ApplicationDatabase:
             )
             for row in rows
         ]
+
+    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
+        with self.engine.begin() as conn:
+            max_function_id_row = conn.execute(
+                sa.select(
+                    sa.func.max(ApplicationSchema.transaction_outputs.c.function_id)
+                ).where(
+                    ApplicationSchema.transaction_outputs.c.workflow_uuid
+                    == workflow_uuid
+                )
+            ).fetchone()
+
+            max_function_id = max_function_id_row[0] if max_function_id_row else None
+
+            return max_function_id
+
+    def clone_workflow_transactions(
+        self, src_workflow_id: str, forked_workflow_id: str, start_step: int
+    ) -> None:
+        """
+        Copies all steps from dbos.transctions_outputs where function_id < input function_id
+        into a new workflow_uuid. Returns the new workflow_uuid.
+        """
+
+        with self.engine.begin() as conn:
+
+            insert_stmt = sa.insert(ApplicationSchema.transaction_outputs).from_select(
+                [
+                    "workflow_uuid",
+                    "function_id",
+                    "output",
+                    "error",
+                    "txn_id",
+                    "txn_snapshot",
+                    "executor_id",
+                    "function_name",
+                ],
+                sa.select(
+                    sa.literal(forked_workflow_id).label("workflow_uuid"),
+                    ApplicationSchema.transaction_outputs.c.function_id,
+                    ApplicationSchema.transaction_outputs.c.output,
+                    ApplicationSchema.transaction_outputs.c.error,
+                    ApplicationSchema.transaction_outputs.c.txn_id,
+                    ApplicationSchema.transaction_outputs.c.txn_snapshot,
+                    ApplicationSchema.transaction_outputs.c.executor_id,
+                    ApplicationSchema.transaction_outputs.c.function_name,
+                ).where(
+                    (
+                        ApplicationSchema.transaction_outputs.c.workflow_uuid
+                        == src_workflow_id
+                    )
+                    & (ApplicationSchema.transaction_outputs.c.function_id < start_step)
+                ),
+            )
+
+            conn.execute(insert_stmt)

dbos/_client.py

@@ -124,12 +124,7 @@ class DBOSClient:
             "kwargs": kwargs,
         }
 
-        wf_status = self._sys_db.insert_workflow_status(status)
-        self._sys_db.update_workflow_inputs(
-            workflow_id, _serialization.serialize_args(inputs)
-        )
-        if wf_status == WorkflowStatusString.ENQUEUED.value:
-            self._sys_db.enqueue(workflow_id, queue_name)
+        self._sys_db.init_workflow(status, _serialization.serialize_args(inputs))
         return workflow_id
 
     def enqueue(
@@ -184,7 +179,8 @@ class DBOSClient:
             "app_id": None,
             "app_version": None,
         }
-        self._sys_db.insert_workflow_status(status)
+        with self._sys_db.engine.begin() as conn:
+            self._sys_db.insert_workflow_status(status, conn)
         self._sys_db.send(status["workflow_uuid"], 0, destination_id, message, topic)
 
     async def send_async(
@@ -233,6 +229,7 @@ class DBOSClient:
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
+        workflow_id_prefix: Optional[str] = None,
     ) -> List[WorkflowStatus]:
         return list_workflows(
             self._sys_db,
@@ -246,6 +243,7 @@ class DBOSClient:
             limit=limit,
             offset=offset,
             sort_desc=sort_desc,
+            workflow_id_prefix=workflow_id_prefix,
         )
 
     async def list_workflows_async(

dbos/_core.py

@@ -280,18 +280,12 @@ def _init_workflow(
             raise DBOSNonExistentWorkflowError(wfid)
         wf_status = get_status_result["status"]
     else:
-        # Synchronously record the status and inputs for workflows
-        # TODO: Make this transactional (and with the queue step below)
-        wf_status = dbos._sys_db.insert_workflow_status(
-            status, max_recovery_attempts=max_recovery_attempts
+        wf_status = dbos._sys_db.init_workflow(
+            status,
+            _serialization.serialize_args(inputs),
+            max_recovery_attempts=max_recovery_attempts,
         )
 
-        # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
-        dbos._sys_db.update_workflow_inputs(wfid, _serialization.serialize_args(inputs))
-
-        if queue is not None and wf_status == WorkflowStatusString.ENQUEUED.value:
-            dbos._sys_db.enqueue(wfid, queue)
-
     status["status"] = wf_status
     return status
 

dbos/_dbos.py

@@ -363,13 +363,13 @@ class DBOS:
             check_config_consistency(name=unvalidated_config["name"])
 
         if unvalidated_config is not None:
-            self.config: ConfigFile = process_config(data=unvalidated_config)
+            self._config: ConfigFile = process_config(data=unvalidated_config)
         else:
             raise ValueError("No valid configuration was loaded.")
 
-        set_env_vars(self.config)
-        config_logger(self.config)
-        dbos_tracer.config(self.config)
+        set_env_vars(self._config)
+        config_logger(self._config)
+        dbos_tracer.config(self._config)
         dbos_logger.info("Initializing DBOS")
 
         # If using FastAPI, set up middleware and lifecycle events
@@ -453,19 +453,19 @@ class DBOS:
             self._executor_field = ThreadPoolExecutor(max_workers=64)
             self._background_event_loop.start()
             self._sys_db_field = SystemDatabase(
-                self.config["database"], debug_mode=debug_mode
+                self._config["database"], debug_mode=debug_mode
             )
             self._app_db_field = ApplicationDatabase(
-                self.config["database"], debug_mode=debug_mode
+                self._config["database"], debug_mode=debug_mode
             )
 
             if debug_mode:
                 return
 
-            admin_port = self.config.get("runtimeConfig", {}).get("admin_port")
+            admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
                 admin_port = 3001
-            run_admin_server = self.config.get("runtimeConfig", {}).get(
+            run_admin_server = self._config.get("runtimeConfig", {}).get(
                 "run_admin_server"
             )
             if run_admin_server:
@@ -563,7 +563,7 @@ class DBOS:
         assert (
             not self._launched
         ), "The system database cannot be reset after DBOS is launched. Resetting the system database is a destructive operation that should only be used in a test environment."
-        reset_system_database(self.config)
+        reset_system_database(self._config)
 
     def _destroy(self) -> None:
         self._initialized = False
@@ -960,14 +960,45 @@ class DBOS:
     def restart_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Restart a workflow with a new workflow ID"""
 
+        return cls.fork_workflow(workflow_id, 1)
+
+    @classmethod
+    def fork_workflow(
+        cls, workflow_id: str, start_step: int = 1
+    ) -> WorkflowHandle[Any]:
+        """Restart a workflow with a new workflow ID"""
+
+        def get_max_function_id(workflow_uuid: str) -> int:
+            max_transactions = (
+                _get_dbos_instance()._app_db.get_max_function_id(workflow_uuid) or 0
+            )
+            max_operations = (
+                _get_dbos_instance()._sys_db.get_max_function_id(workflow_uuid) or 0
+            )
+            return max(max_transactions, max_operations)
+
+        max_function_id = get_max_function_id(workflow_id)
+        if max_function_id > 0 and start_step > max_function_id:
+            raise DBOSException(
+                f"Cannot fork workflow {workflow_id} at step {start_step}. The workflow has  {max_function_id} steps."
+            )
+
         def fn() -> str:
-            dbos_logger.info(f"Restarting workflow: {workflow_id}")
-            return _get_dbos_instance()._sys_db.fork_workflow(workflow_id)
+            forked_workflow_id = str(uuid.uuid4())
+            dbos_logger.info(f"Forking workflow: {workflow_id} from step {start_step}")
+
+            _get_dbos_instance()._app_db.clone_workflow_transactions(
+                workflow_id, forked_workflow_id, start_step
+            )
+
+            return _get_dbos_instance()._sys_db.fork_workflow(
+                workflow_id, forked_workflow_id, start_step
+            )
 
-        forked_workflow_id = _get_dbos_instance()._sys_db.call_function_as_step(
-            fn, "DBOS.restartWorkflow"
+        new_id = _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.forkWorkflow"
         )
-        return cls.retrieve_workflow(forked_workflow_id)
+        return cls.retrieve_workflow(new_id)
 
     @classmethod
     def list_workflows(
@@ -983,6 +1014,7 @@ class DBOS:
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
+        workflow_id_prefix: Optional[str] = None,
     ) -> List[WorkflowStatus]:
         def fn() -> List[WorkflowStatus]:
             return list_workflows(
@@ -997,6 +1029,7 @@ class DBOS:
                 limit=limit,
                 offset=offset,
                 sort_desc=sort_desc,
+                workflow_id_prefix=workflow_id_prefix,
             )
 
         return _get_dbos_instance()._sys_db.call_function_as_step(
@@ -1043,15 +1076,15 @@ class DBOS:
         """Return the DBOS `ConfigFile` for the current context."""
         global _dbos_global_instance
         if _dbos_global_instance is not None:
-            return _dbos_global_instance.config
+            return _dbos_global_instance._config
         reg = _get_or_create_dbos_registry()
         if reg.config is not None:
             return reg.config
-        config = (
+        loaded_config = (
             load_config()
         )  # This will return the processed & validated config (with defaults)
-        reg.config = config
-        return config
+        reg.config = loaded_config
+        return loaded_config
 
     @classproperty
     def sql_session(cls) -> Session:

dbos/_sys_db.py

@@ -132,6 +132,9 @@ class GetWorkflowsInput:
         self.sort_desc: bool = (
             False  # If true, sort by created_at in DESC order. Default false (in ASC order).
         )
+        self.workflow_id_prefix: Optional[str] = (
+            None  # If set, search for workflow IDs starting with this string
+        )
 
 
 class GetQueuedWorkflowsInput(TypedDict):
@@ -282,6 +285,7 @@ class SystemDatabase:
     def insert_workflow_status(
         self,
         status: WorkflowStatusInternal,
+        conn: sa.Connection,
         *,
         max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
     ) -> WorkflowStatuses:
@@ -325,8 +329,7 @@ class SystemDatabase:
 
         cmd = cmd.returning(SystemSchema.workflow_status.c.recovery_attempts, SystemSchema.workflow_status.c.status, SystemSchema.workflow_status.c.name, SystemSchema.workflow_status.c.class_name, SystemSchema.workflow_status.c.config_name, SystemSchema.workflow_status.c.queue_name)  # type: ignore
 
-        with self.engine.begin() as c:
-            results = c.execute(cmd)
+        results = conn.execute(cmd)
 
         row = results.fetchone()
         if row is not None:
@@ -352,28 +355,30 @@ class SystemDatabase:
             # Every time we start executing a workflow (and thus attempt to insert its status), we increment `recovery_attempts` by 1.
             # When this number becomes equal to `maxRetries + 1`, we mark the workflow as `RETRIES_EXCEEDED`.
             if recovery_attempts > max_recovery_attempts + 1:
-                with self.engine.begin() as c:
-                    c.execute(
-                        sa.delete(SystemSchema.workflow_queue).where(
-                            SystemSchema.workflow_queue.c.workflow_uuid
-                            == status["workflow_uuid"]
-                        )
+                delete_cmd = sa.delete(SystemSchema.workflow_queue).where(
+                    SystemSchema.workflow_queue.c.workflow_uuid
+                    == status["workflow_uuid"]
+                )
+                conn.execute(delete_cmd)
+
+                dlq_cmd = (
+                    sa.update(SystemSchema.workflow_status)
+                    .where(
+                        SystemSchema.workflow_status.c.workflow_uuid
+                        == status["workflow_uuid"]
                     )
-                    c.execute(
-                        sa.update(SystemSchema.workflow_status)
-                        .where(
-                            SystemSchema.workflow_status.c.workflow_uuid
-                            == status["workflow_uuid"]
-                        )
-                        .where(
-                            SystemSchema.workflow_status.c.status
-                            == WorkflowStatusString.PENDING.value
-                        )
-                        .values(
-                            status=WorkflowStatusString.RETRIES_EXCEEDED.value,
-                            queue_name=None,
-                        )
+                    .where(
+                        SystemSchema.workflow_status.c.status
+                        == WorkflowStatusString.PENDING.value
+                    )
+                    .values(
+                        status=WorkflowStatusString.RETRIES_EXCEEDED.value,
+                        queue_name=None,
                     )
+                )
+                conn.execute(dlq_cmd)
+                # Need to commit here because we're throwing an exception
+                conn.commit()
                 raise DBOSDeadLetterQueueError(
                     status["workflow_uuid"], max_recovery_attempts
                 )
@@ -489,15 +494,29 @@ class SystemDatabase:
                 .values(status=WorkflowStatusString.ENQUEUED.value, recovery_attempts=0)
             )
 
-    def fork_workflow(self, original_workflow_id: str) -> str:
+    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
+        with self.engine.begin() as conn:
+            max_function_id_row = conn.execute(
+                sa.select(
+                    sa.func.max(SystemSchema.operation_outputs.c.function_id)
+                ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid)
+            ).fetchone()
+
+            max_function_id = max_function_id_row[0] if max_function_id_row else None
+
+            return max_function_id
+
+    def fork_workflow(
+        self, original_workflow_id: str, forked_workflow_id: str, start_step: int = 1
+    ) -> str:
+
         status = self.get_workflow_status(original_workflow_id)
         if status is None:
             raise Exception(f"Workflow {original_workflow_id} not found")
         inputs = self.get_workflow_inputs(original_workflow_id)
         if inputs is None:
             raise Exception(f"Workflow {original_workflow_id} not found")
-        # Generate a random ID for the forked workflow
-        forked_workflow_id = str(uuid.uuid4())
+
         with self.engine.begin() as c:
             # Create an entry for the forked workflow with the same
             # initial values as the original.
@@ -524,6 +543,37 @@ class SystemDatabase:
                     inputs=_serialization.serialize_args(inputs),
                 )
             )
+
+            if start_step > 1:
+
+                # Copy the original workflow's outputs into the forked workflow
+                insert_stmt = sa.insert(SystemSchema.operation_outputs).from_select(
+                    [
+                        "workflow_uuid",
+                        "function_id",
+                        "output",
+                        "error",
+                        "function_name",
+                        "child_workflow_id",
+                    ],
+                    sa.select(
+                        sa.literal(forked_workflow_id).label("workflow_uuid"),
+                        SystemSchema.operation_outputs.c.function_id,
+                        SystemSchema.operation_outputs.c.output,
+                        SystemSchema.operation_outputs.c.error,
+                        SystemSchema.operation_outputs.c.function_name,
+                        SystemSchema.operation_outputs.c.child_workflow_id,
+                    ).where(
+                        (
+                            SystemSchema.operation_outputs.c.workflow_uuid
+                            == original_workflow_id
+                        )
+                        & (SystemSchema.operation_outputs.c.function_id < start_step)
+                    ),
+                )
+
+                c.execute(insert_stmt)
+
             # Enqueue the forked workflow on the internal queue
             c.execute(
                 pg.insert(SystemSchema.workflow_queue).values(
@@ -607,7 +657,7 @@ class SystemDatabase:
             time.sleep(1)
 
     def update_workflow_inputs(
-        self, workflow_uuid: str, inputs: str, conn: Optional[sa.Connection] = None
+        self, workflow_uuid: str, inputs: str, conn: sa.Connection
     ) -> None:
         if self._debug_mode:
             raise Exception("called update_workflow_inputs in debug mode")
@@ -624,11 +674,8 @@ class SystemDatabase:
             )
             .returning(SystemSchema.workflow_inputs.c.inputs)
         )
-        if conn is not None:
-            row = conn.execute(cmd).fetchone()
-        else:
-            with self.engine.begin() as c:
-                row = c.execute(cmd).fetchone()
+
+        row = conn.execute(cmd).fetchone()
         if row is not None and row[0] != inputs:
             # In a distributed environment, scheduled workflows are enqueued multiple times with slightly different timestamps
             if not workflow_uuid.startswith("sched-"):
@@ -689,6 +736,12 @@ class SystemDatabase:
             query = query.where(
                 SystemSchema.workflow_status.c.workflow_uuid.in_(input.workflow_ids)
             )
+        if input.workflow_id_prefix:
+            query = query.where(
+                SystemSchema.workflow_status.c.workflow_uuid.startswith(
+                    input.workflow_id_prefix
+                )
+            )
         if input.limit:
             query = query.limit(input.limit)
         if input.offset:
@@ -1335,18 +1388,17 @@ class SystemDatabase:
             )
         return value
 
-    def enqueue(self, workflow_id: str, queue_name: str) -> None:
+    def enqueue(self, workflow_id: str, queue_name: str, conn: sa.Connection) -> None:
         if self._debug_mode:
             raise Exception("called enqueue in debug mode")
-        with self.engine.begin() as c:
-            c.execute(
-                pg.insert(SystemSchema.workflow_queue)
-                .values(
-                    workflow_uuid=workflow_id,
-                    queue_name=queue_name,
-                )
-                .on_conflict_do_nothing()
+        conn.execute(
+            pg.insert(SystemSchema.workflow_queue)
+            .values(
+                workflow_uuid=workflow_id,
+                queue_name=queue_name,
             )
+            .on_conflict_do_nothing()
+        )
 
     def start_queued_workflows(
         self, queue: "Queue", executor_id: str, app_version: str
@@ -1601,6 +1653,30 @@ class SystemDatabase:
             )
         return result
 
+    def init_workflow(
+        self,
+        status: WorkflowStatusInternal,
+        inputs: str,
+        *,
+        max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
+    ) -> WorkflowStatuses:
+        """
+        Synchronously record the status and inputs for workflows in a single transaction
+        """
+        with self.engine.begin() as conn:
+            wf_status = self.insert_workflow_status(
+                status, conn, max_recovery_attempts=max_recovery_attempts
+            )
+            # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
+            self.update_workflow_inputs(status["workflow_uuid"], inputs, conn)
+
+            if (
+                status["queue_name"] is not None
+                and wf_status == WorkflowStatusString.ENQUEUED.value
+            ):
+                self.enqueue(status["workflow_uuid"], status["queue_name"], conn)
+        return wf_status
+
 
 def reset_system_database(config: ConfigFile) -> None:
     sysdb_name = (

dbos/_workflow_commands.py

@@ -1,4 +1,5 @@
 import json
+import uuid
 from typing import Any, List, Optional
 
 from . import _serialization
@@ -70,6 +71,7 @@ def list_workflows(
     offset: Optional[int] = None,
     sort_desc: bool = False,
     request: bool = False,
+    workflow_id_prefix: Optional[str] = None,
 ) -> List[WorkflowStatus]:
     input = GetWorkflowsInput()
     input.workflow_ids = workflow_ids
@@ -82,6 +84,7 @@ def list_workflows(
     input.name = name
     input.offset = offset
     input.sort_desc = sort_desc
+    input.workflow_id_prefix = workflow_id_prefix
 
     output: GetWorkflowsOutput = sys_db.get_workflows(input)
     infos: List[WorkflowStatus] = []

dbos/cli/cli.py

@@ -433,13 +433,60 @@ def restart(
     ] = 3001,
 ) -> None:
     response = requests.post(
-        f"http://{host}:{port}/workflows/{uuid}/restart", json=[], timeout=5
+        f"http://{host}:{port}/workflows/{uuid}/restart",
+        json=[],
+        timeout=5,
     )
 
     if response.status_code == 204:
         print(f"Workflow {uuid} has been restarted")
     else:
-        print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
+        error_message = response.json().get("error", "Unknown error")
+        print(
+            f"Failed to restart workflow {uuid}. "
+            f"Status code: {response.status_code}. "
+            f"Error: {error_message}"
+        )
+
+
+@workflow.command(
+    help="fork a workflow from the beginning with a new id and from a step"
+)
+def fork(
+    uuid: Annotated[str, typer.Argument()],
+    host: Annotated[
+        typing.Optional[str],
+        typer.Option("--host", "-H", help="Specify the admin host"),
+    ] = "localhost",
+    port: Annotated[
+        typing.Optional[int],
+        typer.Option("--port", "-p", help="Specify the admin port"),
+    ] = 3001,
+    step: Annotated[
+        typing.Optional[int],
+        typer.Option(
+            "--step",
+            "-s",
+            help="Restart from this step (default: first step)",
+        ),
+    ] = 1,
+) -> None:
+    print(f"Forking workflow {uuid} from step {step}")
+    response = requests.post(
+        f"http://{host}:{port}/workflows/{uuid}/fork",
+        json={"start_step": step},
+        timeout=5,
+    )
+
+    if response.status_code == 204:
+        print(f"Workflow {uuid} has been forked")
+    else:
+        error_message = response.json().get("error", "Unknown error")
+        print(
+            f"Failed to fork workflow {uuid}. "
+            f"Status code: {response.status_code}. "
+            f"Error: {error_message}"
+        )
 
 
 @queue.command(name="list", help="List enqueued functions for your application")

{dbos-0.26.0a14.dist-info → dbos-0.26.0a18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.26.0a14
+Version: 0.26.0a18
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.26.0a14.dist-info → dbos-0.26.0a18.dist-info}/RECORD

@@ -1,19 +1,19 @@
-dbos-0.26.0a14.dist-info/METADATA,sha256=KmqNCgW2bcxs1qddgonsP0MDPe1tt5tlUvs07bN-XDY,5554
-dbos-0.26.0a14.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a14.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a14.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.26.0a18.dist-info/METADATA,sha256=QG3XkqovR0FvEIL1_sHK6K80-comGqhpyC1LCWUDEzA,5554
+dbos-0.26.0a18.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a18.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a18.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=3NQfGlBiiUSM_v88STdVP3rNZvGkUL_9WbSotKb8Voo,873
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
-dbos/_admin_server.py,sha256=vxPG_YJ6lYrkfPCSp42FiATVLBOij7Fm52Yngg5Z_tE,7027
-dbos/_app_db.py,sha256=IwnNlHEQYp2bl5BM66vVPFa40h8DOtvRgUWTJ1dz20A,8963
+dbos/_admin_server.py,sha256=RrbABfR1D3p9c_QLrCSrgFuYce6FKi0fjMRIYLjO_Y8,9038
+dbos/_app_db.py,sha256=Q9lEyCJFoZMTlnjMO8Pj8bczVmVWyDOP8qPQ6l5PpEU,11241
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=5iaoFsu5wAqwjjj3EWusZ1eDbBAW8FwYazhokdCJ9h4,10964
+dbos/_client.py,sha256=QiIR-mwRYb1ffgwGR96ICQgFORki2QpR5najtVJ2WsA,10906
 dbos/_conductor/conductor.py,sha256=HYzVL29IMMrs2Mnms_7cHJynCnmmEN5SDQOMjzn3UoU,16840
 dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
 dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
-dbos/_core.py,sha256=de8GecFmW5DNf5dYfnpSX3IDO24Wc6pBpCC1VZ1iVyI,45505
+dbos/_core.py,sha256=uxDIJui4WS_2V1k2np0Ifue_IRzLTyq-c52bgZSQYn4,45118
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=byXhhiG14nS3iU85NphvQ26vvnJ-gu1tMwTIoUc3dYc,46239
+dbos/_dbos.py,sha256=jtvBQOvwdXFfknx9pDHgKC4DuiH58ICAs_0NoJQMI4w,47526
 dbos/_dbos_config.py,sha256=m05IFjM0jSwZBsnFMF_4qP2JkjVFc0gqyM2tnotXq20,20636
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
 dbos/_docker_pg_helper.py,sha256=NmcgqmR5rQA_4igfeqh8ugNT2z3YmoOvuep_MEtxTiY,5854
@@ -45,7 +45,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=W9eSpL7SZzQkxcEZ4W07BOcwkkDr35b9oCjUOgfHWek,5336
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
-dbos/_sys_db.py,sha256=vQzr6qACjtmjVS151OJ45BlhOeB1tBBZemyEzOsy5nc,68343
+dbos/_sys_db.py,sha256=kfNR9R7rQ6MTqBuPt4OI5nZElIJNXlGuUjG_ypGKHWI,71195
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py,sha256=nJMN3ZD2lmwg4Dcgmiwqc-tQGuCJuJal2Xl85iA277U,2453
@@ -58,11 +58,11 @@ dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sh
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
 dbos/_tracer.py,sha256=dFDSFlta-rfA3-ahIRLYwnnoAOmlavdxAGllqwFgnCA,2440
 dbos/_utils.py,sha256=nFRUHzVjXG5AusF85AlYHikj63Tzi-kQm992ihsrAxA,201
-dbos/_workflow_commands.py,sha256=Tf7_hZQoPgP90KHQjMNlBggCNrLLCNRJxHtAJLvarc4,6153
+dbos/_workflow_commands.py,sha256=hHNcW4zopgxVXWfg3flHwqZEFGYpYp8ZAfUXmqiULUk,6261
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
-dbos/cli/cli.py,sha256=Lb_RYmXoT5KH0xDbwaYpROE4c-svZ0eCq2Kxg7cAxTw,16537
+dbos/cli/cli.py,sha256=1qCTs__A9LOEfU44XZ6TufwmRwe68ZEwbWEPli3vnVM,17873
 dbos/dbos-config.schema.json,sha256=i7jcxXqByKq0Jzv3nAUavONtj03vTwj6vWP4ylmBr8o,5694
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.26.0a14.dist-info/RECORD,,
+dbos-0.26.0a18.dist-info/RECORD,,