dbos 0.26.0a7__tar.gz → 0.26.0a9__tar.gz

{dbos-0.26.0a7 → dbos-0.26.0a9}/PKG-INFO

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

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_app_db.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session, sessionmaker
 
 from . import _serialization
 from ._dbos_config import ConfigFile, DatabaseConfig
-from ._error import DBOSWorkflowConflictIDError
+from ._error import DBOSUnexpectedStepError, DBOSWorkflowConflictIDError
 from ._schemas.application_database import ApplicationSchema
 from ._sys_db import StepInfo
 
@@ -171,22 +171,31 @@ class ApplicationDatabase:
 
     @staticmethod
     def check_transaction_execution(
-        session: Session, workflow_uuid: str, function_id: int
+        session: Session, workflow_id: str, function_id: int, function_name: str
     ) -> Optional[RecordedResult]:
         rows = session.execute(
             sa.select(
                 ApplicationSchema.transaction_outputs.c.output,
                 ApplicationSchema.transaction_outputs.c.error,
+                ApplicationSchema.transaction_outputs.c.function_name,
             ).where(
-                ApplicationSchema.transaction_outputs.c.workflow_uuid == workflow_uuid,
+                ApplicationSchema.transaction_outputs.c.workflow_uuid == workflow_id,
                 ApplicationSchema.transaction_outputs.c.function_id == function_id,
             )
         ).all()
         if len(rows) == 0:
             return None
+        output, error, recorded_function_name = rows[0][0], rows[0][1], rows[0][2]
+        if function_name != recorded_function_name:
+            raise DBOSUnexpectedStepError(
+                workflow_id=workflow_id,
+                step_id=function_id,
+                expected_name=function_name,
+                recorded_name=recorded_function_name,
+            )
         result: RecordedResult = {
-            "output": rows[0][0],
-            "error": rows[0][1],
+            "output": output,
+            "error": error,
         }
         return result
 

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_conductor/conductor.py

@@ -67,7 +67,7 @@ class ConductorWebsocket(threading.Thread):
                             recovery_message = p.RecoveryRequest.from_json(message)
                             success = True
                             try:
-                                self.dbos.recover_pending_workflows(
+                                self.dbos._recover_pending_workflows(
                                     recovery_message.executor_ids
                                 )
                             except Exception as e:

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_core.py

@@ -52,6 +52,7 @@ from ._error import (
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
     DBOSRecoveryError,
+    DBOSUnexpectedStepError,
     DBOSWorkflowCancelledError,
     DBOSWorkflowConflictIDError,
     DBOSWorkflowFunctionNotFoundError,
@@ -783,7 +784,7 @@ def decorate_transaction(
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
 
-        transactionName = func.__qualname__
+        transaction_name = func.__qualname__
 
         def invoke_tx(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
@@ -791,13 +792,14 @@ def decorate_transaction(
                     f"Function {func.__name__} invoked before DBOS initialized"
                 )
 
+            dbos = dbosreg.dbos
             ctx = assert_current_dbos_context()
-            if dbosreg.is_workflow_cancelled(ctx.workflow_id):
+            status = dbos._sys_db.get_workflow_status(ctx.workflow_id)
+            if status and status["status"] == WorkflowStatusString.CANCELLED.value:
                 raise DBOSWorkflowCancelledError(
                     f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
                 )
 
-            dbos = dbosreg.dbos
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
                     "name": func.__name__,
@@ -813,18 +815,12 @@ def decorate_transaction(
                         "txn_snapshot": "",  # TODO: add actual snapshot
                         "executor_id": None,
                         "txn_id": None,
-                        "function_name": transactionName,
+                        "function_name": transaction_name,
                     }
                     retry_wait_seconds = 0.001
                     backoff_factor = 1.5
                     max_retry_wait_seconds = 2.0
                     while True:
-
-                        if dbosreg.is_workflow_cancelled(ctx.workflow_id):
-                            raise DBOSWorkflowCancelledError(
-                                f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
-                            )
-
                         has_recorded_error = False
                         txn_error: Optional[Exception] = None
                         try:
@@ -841,6 +837,7 @@ def decorate_transaction(
                                         session,
                                         ctx.workflow_id,
                                         ctx.function_id,
+                                        transaction_name,
                                     )
                                 )
                                 if dbos.debug_mode and recorded_output is None:
@@ -904,6 +901,8 @@ def decorate_transaction(
                             )
                             txn_error = invalid_request_error
                             raise
+                        except DBOSUnexpectedStepError:
+                            raise
                         except Exception as error:
                             txn_error = error
                             raise
@@ -969,7 +968,7 @@ def decorate_step(
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
 
-        stepName = func.__qualname__
+        step_name = func.__qualname__
 
         def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
@@ -983,13 +982,6 @@ def decorate_step(
                 "operationType": OperationType.STEP.value,
             }
 
-            # Check if the workflow is cancelled
-            ctx = assert_current_dbos_context()
-            if dbosreg.is_workflow_cancelled(ctx.workflow_id):
-                raise DBOSWorkflowCancelledError(
-                    f"Workflow {ctx.workflow_id} is cancelled. Aborting step {func.__name__}."
-                )
-
             attempts = max_attempts if retries_allowed else 1
             max_retry_interval_seconds: float = 3600  # 1 Hour
 
@@ -1017,7 +1009,7 @@ def decorate_step(
                 step_output: OperationResultInternal = {
                     "workflow_uuid": ctx.workflow_id,
                     "function_id": ctx.function_id,
-                    "function_name": stepName,
+                    "function_name": step_name,
                     "output": None,
                     "error": None,
                 }
@@ -1035,7 +1027,7 @@ def decorate_step(
             def check_existing_result() -> Union[NoResult, R]:
                 ctx = assert_current_dbos_context()
                 recorded_output = dbos._sys_db.check_operation_execution(
-                    ctx.workflow_id, ctx.function_id
+                    ctx.workflow_id, ctx.function_id, step_name
                 )
                 if dbos.debug_mode and recorded_output is None:
                     raise DBOSException("Step output not found in debug mode")

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_dbos.py

@@ -166,7 +166,6 @@ class DBOSRegistry:
         self.pollers: list[RegisteredJob] = []
         self.dbos: Optional[DBOS] = None
         self.config: Optional[ConfigFile] = None
-        self.workflow_cancelled_map: dict[str, bool] = {}
 
     def register_wf_function(self, name: str, wrapped_func: F, functype: str) -> None:
         if name in self.function_type_map:
@@ -215,15 +214,6 @@ class DBOSRegistry:
         else:
             self.instance_info_map[fn] = inst
 
-    def cancel_workflow(self, workflow_id: str) -> None:
-        self.workflow_cancelled_map[workflow_id] = True
-
-    def is_workflow_cancelled(self, workflow_id: str) -> bool:
-        return self.workflow_cancelled_map.get(workflow_id, False)
-
-    def clear_workflow_cancelled(self, workflow_id: str) -> None:
-        self.workflow_cancelled_map.pop(workflow_id, None)
-
     def compute_app_version(self) -> str:
         """
         An application's version is computed from a hash of the source of its workflows.
@@ -740,32 +730,11 @@ class DBOS:
     @classmethod
     def get_workflow_status(cls, workflow_id: str) -> Optional[WorkflowStatus]:
         """Return the status of a workflow execution."""
-        sys_db = _get_dbos_instance()._sys_db
-        ctx = get_local_dbos_context()
-        if ctx and ctx.is_within_workflow():
-            ctx.function_id += 1
-            res = sys_db.check_operation_execution(ctx.workflow_id, ctx.function_id)
-            if res is not None:
-                if res["output"]:
-                    resstat: WorkflowStatus = _serialization.deserialize(res["output"])
-                    return resstat
-                else:
-                    raise DBOSException(
-                        "Workflow status record not found. This should not happen! \033[1m Hint: Check if your workflow is deterministic.\033[0m"
-                    )
-        stat = get_workflow(_get_dbos_instance()._sys_db, workflow_id, True)
-
-        if ctx and ctx.is_within_workflow():
-            sys_db.record_operation_result(
-                {
-                    "workflow_uuid": ctx.workflow_id,
-                    "function_id": ctx.function_id,
-                    "function_name": "DBOS.getStatus",
-                    "output": _serialization.serialize(stat),
-                    "error": None,
-                }
-            )
-        return stat
+
+        def fn() -> Optional[WorkflowStatus]:
+            return get_workflow(_get_dbos_instance()._sys_db, workflow_id, True)
+
+        return _get_dbos_instance()._sys_db.call_function_as_step(fn, "DBOS.getStatus")
 
     @classmethod
     async def get_workflow_status_async(
@@ -941,12 +910,12 @@ class DBOS:
         )
 
     @classmethod
-    def execute_workflow_id(cls, workflow_id: str) -> WorkflowHandle[Any]:
+    def _execute_workflow_id(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Execute a workflow by ID (for recovery)."""
         return execute_workflow_by_id(_get_dbos_instance(), workflow_id)
 
     @classmethod
-    def recover_pending_workflows(
+    def _recover_pending_workflows(
         cls, executor_ids: List[str] = ["local"]
     ) -> List[WorkflowHandle[Any]]:
         """Find all PENDING workflows and execute them."""
@@ -955,22 +924,37 @@ class DBOS:
     @classmethod
     def cancel_workflow(cls, workflow_id: str) -> None:
         """Cancel a workflow by ID."""
-        dbos_logger.info(f"Cancelling workflow: {workflow_id}")
-        _get_dbos_instance()._sys_db.cancel_workflow(workflow_id)
-        _get_or_create_dbos_registry().cancel_workflow(workflow_id)
+
+        def fn() -> None:
+            dbos_logger.info(f"Cancelling workflow: {workflow_id}")
+            _get_dbos_instance()._sys_db.cancel_workflow(workflow_id)
+
+        return _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.cancelWorkflow"
+        )
 
     @classmethod
     def resume_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Resume a workflow by ID."""
-        dbos_logger.info(f"Resuming workflow: {workflow_id}")
-        _get_dbos_instance()._sys_db.resume_workflow(workflow_id)
-        _get_or_create_dbos_registry().clear_workflow_cancelled(workflow_id)
+
+        def fn() -> None:
+            dbos_logger.info(f"Resuming workflow: {workflow_id}")
+            _get_dbos_instance()._sys_db.resume_workflow(workflow_id)
+
+        _get_dbos_instance()._sys_db.call_function_as_step(fn, "DBOS.resumeWorkflow")
         return cls.retrieve_workflow(workflow_id)
 
     @classmethod
     def restart_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Restart a workflow with a new workflow ID"""
-        forked_workflow_id = _get_dbos_instance()._sys_db.fork_workflow(workflow_id)
+
+        def fn() -> str:
+            dbos_logger.info(f"Restarting workflow: {workflow_id}")
+            return _get_dbos_instance()._sys_db.fork_workflow(workflow_id)
+
+        forked_workflow_id = _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.restartWorkflow"
+        )
         return cls.retrieve_workflow(forked_workflow_id)
 
     @classmethod
@@ -988,18 +972,23 @@ class DBOS:
         offset: Optional[int] = None,
         sort_desc: bool = False,
     ) -> List[WorkflowStatus]:
-        return list_workflows(
-            _get_dbos_instance()._sys_db,
-            workflow_ids=workflow_ids,
-            status=status,
-            start_time=start_time,
-            end_time=end_time,
-            name=name,
-            app_version=app_version,
-            user=user,
-            limit=limit,
-            offset=offset,
-            sort_desc=sort_desc,
+        def fn() -> List[WorkflowStatus]:
+            return list_workflows(
+                _get_dbos_instance()._sys_db,
+                workflow_ids=workflow_ids,
+                status=status,
+                start_time=start_time,
+                end_time=end_time,
+                name=name,
+                app_version=app_version,
+                user=user,
+                limit=limit,
+                offset=offset,
+                sort_desc=sort_desc,
+            )
+
+        return _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.listWorkflows"
         )
 
     @classmethod
@@ -1015,16 +1004,21 @@ class DBOS:
         offset: Optional[int] = None,
         sort_desc: bool = False,
     ) -> List[WorkflowStatus]:
-        return list_queued_workflows(
-            _get_dbos_instance()._sys_db,
-            queue_name=queue_name,
-            status=status,
-            start_time=start_time,
-            end_time=end_time,
-            name=name,
-            limit=limit,
-            offset=offset,
-            sort_desc=sort_desc,
+        def fn() -> List[WorkflowStatus]:
+            return list_queued_workflows(
+                _get_dbos_instance()._sys_db,
+                queue_name=queue_name,
+                status=status,
+                start_time=start_time,
+                end_time=end_time,
+                name=name,
+                limit=limit,
+                offset=offset,
+                sort_desc=sort_desc,
+            )
+
+        return _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.listQueuedWorkflows"
         )
 
     @classproperty

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_dbos_config.py

@@ -15,7 +15,6 @@ from jsonschema import ValidationError, validate
 from rich import print
 from sqlalchemy import URL, make_url
 
-from ._db_wizard import db_wizard, load_db_connection
 from ._error import DBOSInitializationError
 from ._logger import dbos_logger
 
@@ -70,7 +69,6 @@ class DatabaseConfig(TypedDict, total=False):
     sys_db_pool_size: Optional[int]
     ssl: Optional[bool]
     ssl_ca: Optional[str]
-    local_suffix: Optional[bool]
     migrate: Optional[List[str]]
     rollback: Optional[List[str]]
 
@@ -288,7 +286,6 @@ def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,
     run_process_config: bool = True,
-    use_db_wizard: bool = True,
     silent: bool = False,
 ) -> ConfigFile:
     """
@@ -339,13 +336,12 @@ def load_config(
 
     data = cast(ConfigFile, data)
     if run_process_config:
-        data = process_config(data=data, use_db_wizard=use_db_wizard, silent=silent)
+        data = process_config(data=data, silent=silent)
     return data  # type: ignore
 
 
 def process_config(
     *,
-    use_db_wizard: bool = True,
     data: ConfigFile,
     silent: bool = False,
 ) -> ConfigFile:
@@ -372,22 +368,17 @@ def process_config(
     # database_url takes precedence over database config, but we need to preserve rollback and migrate if they exist
     migrate = data["database"].get("migrate", False)
     rollback = data["database"].get("rollback", False)
-    local_suffix = data["database"].get("local_suffix", False)
     if data.get("database_url"):
         dbconfig = parse_database_url_to_dbconfig(cast(str, data["database_url"]))
         if migrate:
             dbconfig["migrate"] = cast(List[str], migrate)
         if rollback:
             dbconfig["rollback"] = cast(List[str], rollback)
-        if local_suffix:
-            dbconfig["local_suffix"] = cast(bool, local_suffix)
         data["database"] = dbconfig
 
     if "app_db_name" not in data["database"] or not (data["database"]["app_db_name"]):
         data["database"]["app_db_name"] = _app_name_to_db_name(data["name"])
 
-    # Load the DB connection file. Use its values for missing connection parameters. Use defaults otherwise.
-    db_connection = load_db_connection()
     connection_passed_in = data["database"].get("hostname", None) is not None
 
     dbos_dbport: Optional[int] = None
@@ -397,49 +388,22 @@ def process_config(
             dbos_dbport = int(dbport_env)
         except ValueError:
             pass
-    dbos_dblocalsuffix: Optional[bool] = None
-    dblocalsuffix_env = os.getenv("DBOS_DBLOCALSUFFIX")
-    if dblocalsuffix_env:
-        try:
-            dbos_dblocalsuffix = dblocalsuffix_env.casefold() == "true".casefold()
-        except ValueError:
-            pass
 
     data["database"]["hostname"] = (
-        os.getenv("DBOS_DBHOST")
-        or data["database"].get("hostname")
-        or db_connection.get("hostname")
-        or "localhost"
+        os.getenv("DBOS_DBHOST") or data["database"].get("hostname") or "localhost"
     )
 
-    data["database"]["port"] = (
-        dbos_dbport or data["database"].get("port") or db_connection.get("port") or 5432
-    )
+    data["database"]["port"] = dbos_dbport or data["database"].get("port") or 5432
     data["database"]["username"] = (
-        os.getenv("DBOS_DBUSER")
-        or data["database"].get("username")
-        or db_connection.get("username")
-        or "postgres"
+        os.getenv("DBOS_DBUSER") or data["database"].get("username") or "postgres"
     )
     data["database"]["password"] = (
         os.getenv("DBOS_DBPASSWORD")
         or data["database"].get("password")
-        or db_connection.get("password")
         or os.environ.get("PGPASSWORD")
         or "dbos"
     )
 
-    local_suffix = False
-    dbcon_local_suffix = db_connection.get("local_suffix")
-    if dbcon_local_suffix is not None:
-        local_suffix = dbcon_local_suffix
-    db_local_suffix = data["database"].get("local_suffix")
-    if db_local_suffix is not None:
-        local_suffix = db_local_suffix
-    if dbos_dblocalsuffix is not None:
-        local_suffix = dbos_dblocalsuffix
-    data["database"]["local_suffix"] = local_suffix
-
     if not data["database"].get("app_db_pool_size"):
         data["database"]["app_db_pool_size"] = 20
     if not data["database"].get("sys_db_pool_size"):
@@ -454,10 +418,6 @@ def process_config(
     elif "run_admin_server" not in data["runtimeConfig"]:
         data["runtimeConfig"]["run_admin_server"] = True
 
-    # Check the connectivity to the database and make sure it's properly configured
-    # Note, never use db wizard if the DBOS is running in debug mode (i.e. DBOS_DEBUG_WORKFLOW_ID env var is set)
-    debugWorkflowId = os.getenv("DBOS_DEBUG_WORKFLOW_ID")
-
     # Pretty-print where we've loaded database connection information from, respecting the log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
         d = data["database"]
@@ -470,21 +430,11 @@ def process_config(
             print(
                 f"[bold blue]Using database connection string: {conn_string}[/bold blue]"
             )
-        elif db_connection.get("hostname"):
-            print(
-                f"[bold blue]Loading database connection string from .dbos/db_connection: {conn_string}[/bold blue]"
-            )
         else:
             print(
                 f"[bold blue]Using default database connection string: {conn_string}[/bold blue]"
             )
 
-    if use_db_wizard and debugWorkflowId is None:
-        data = db_wizard(data)
-
-    if "local_suffix" in data["database"] and data["database"]["local_suffix"]:
-        data["database"]["app_db_name"] = f"{data['database']['app_db_name']}_local"
-
     # Return data as ConfigFile type
     return data
 

{dbos-0.26.0a7 → dbos-0.26.0a9}/dbos/_debug.py

@@ -28,7 +28,7 @@ def debug_workflow(workflow_id: str, entrypoint: Union[str, PythonModule]) -> No
 
     DBOS.logger.info(f"Debugging workflow {workflow_id}...")
     DBOS.launch(debug_mode=True)
-    handle = DBOS.execute_workflow_id(workflow_id)
+    handle = DBOS._execute_workflow_id(workflow_id)
     handle.get_result()
     DBOS.logger.info("Workflow Debugging complete. Exiting process.")