dbos 0.21.0a7__tar.gz → 0.22.0a2__tar.gz

{dbos-0.21.0a7 → dbos-0.22.0a2}/PKG-INFO

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

{dbos-0.21.0a7 → dbos-0.22.0a2}/dbos/_core.py

@@ -63,6 +63,7 @@ from ._registrations import (
     get_or_create_func_info,
     get_temp_workflow_type,
     set_dbos_func_name,
+    set_func_info,
     set_temp_workflow_type,
 )
 from ._roles import check_required_roles
@@ -286,6 +287,7 @@ def execute_workflow_by_id(
         ctx.request = (
             _serialization.deserialize(request) if request is not None else None
         )
+        # If this function belongs to a configured class, add that class instance as its first argument
         if status["config_name"] is not None:
             config_name = status["config_name"]
             class_name = status["class_name"]
@@ -295,28 +297,9 @@ def execute_workflow_by_id(
                     workflow_id,
                     f"Cannot execute workflow because instance '{iname}' is not registered",
                 )
-
-            if startNew:
-                return start_workflow(
-                    dbos,
-                    wf_func,
-                    status["queue_name"],
-                    True,
-                    dbos._registry.instance_info_map[iname],
-                    *inputs["args"],
-                    **inputs["kwargs"],
-                )
-            else:
-                with SetWorkflowID(workflow_id):
-                    return start_workflow(
-                        dbos,
-                        wf_func,
-                        status["queue_name"],
-                        True,
-                        dbos._registry.instance_info_map[iname],
-                        *inputs["args"],
-                        **inputs["kwargs"],
-                    )
+            class_instance = dbos._registry.instance_info_map[iname]
+            inputs["args"] = (class_instance,) + inputs["args"]
+        # If this function is a class method, add that class object as its first argument
         elif status["class_name"] is not None:
             class_name = status["class_name"]
             if class_name not in dbos._registry.class_info_map:
@@ -324,30 +307,20 @@ def execute_workflow_by_id(
                     workflow_id,
                     f"Cannot execute workflow because class '{class_name}' is not registered",
                 )
+            class_object = dbos._registry.class_info_map[class_name]
+            inputs["args"] = (class_object,) + inputs["args"]
 
-            if startNew:
-                return start_workflow(
-                    dbos,
-                    wf_func,
-                    status["queue_name"],
-                    True,
-                    dbos._registry.class_info_map[class_name],
-                    *inputs["args"],
-                    **inputs["kwargs"],
-                )
-            else:
-                with SetWorkflowID(workflow_id):
-                    return start_workflow(
-                        dbos,
-                        wf_func,
-                        status["queue_name"],
-                        True,
-                        dbos._registry.class_info_map[class_name],
-                        *inputs["args"],
-                        **inputs["kwargs"],
-                    )
+        if startNew:
+            return start_workflow(
+                dbos,
+                wf_func,
+                status["queue_name"],
+                True,
+                *inputs["args"],
+                **inputs["kwargs"],
+            )
         else:
-            if startNew:
+            with SetWorkflowID(workflow_id):
                 return start_workflow(
                     dbos,
                     wf_func,
@@ -356,16 +329,6 @@ def execute_workflow_by_id(
                     *inputs["args"],
                     **inputs["kwargs"],
                 )
-            else:
-                with SetWorkflowID(workflow_id):
-                    return start_workflow(
-                        dbos,
-                        wf_func,
-                        status["queue_name"],
-                        True,
-                        *inputs["args"],
-                        **inputs["kwargs"],
-                    )
 
 
 @overload
@@ -398,9 +361,12 @@ def start_workflow(
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> "WorkflowHandle[R]":
+    # If the function has a class, add the class object as its first argument
     fself: Optional[object] = None
     if hasattr(func, "__self__"):
         fself = func.__self__
+    if fself is not None:
+        args = (fself,) + args  # type: ignore
 
     fi = get_func_info(func)
     if fi is None:
@@ -436,17 +402,13 @@ def start_workflow(
     new_wf_ctx.id_assigned_for_next_workflow = new_wf_ctx.assign_workflow_id()
     new_wf_id = new_wf_ctx.id_assigned_for_next_workflow
 
-    gin_args: Tuple[Any, ...] = args
-    if fself is not None:
-        gin_args = (fself,)
-
     status = _init_workflow(
         dbos,
         new_wf_ctx,
         inputs=inputs,
         wf_name=get_dbos_func_name(func),
-        class_name=get_dbos_class_name(fi, func, gin_args),
-        config_name=get_config_name(fi, func, gin_args),
+        class_name=get_dbos_class_name(fi, func, args),
+        config_name=get_config_name(fi, func, args),
         temp_wf_type=get_temp_workflow_type(func),
         queue=queue_name,
         max_recovery_attempts=fi.max_recovery_attempts,
@@ -464,27 +426,15 @@ def start_workflow(
         )
         return WorkflowHandlePolling(new_wf_id, dbos)
 
-    if fself is not None:
-        future = dbos._executor.submit(
-            cast(Callable[..., R], _execute_workflow_wthread),
-            dbos,
-            status,
-            func,
-            new_wf_ctx,
-            fself,
-            *args,
-            **kwargs,
-        )
-    else:
-        future = dbos._executor.submit(
-            cast(Callable[..., R], _execute_workflow_wthread),
-            dbos,
-            status,
-            func,
-            new_wf_ctx,
-            *args,
-            **kwargs,
-        )
+    future = dbos._executor.submit(
+        cast(Callable[..., R], _execute_workflow_wthread),
+        dbos,
+        status,
+        func,
+        new_wf_ctx,
+        *args,
+        **kwargs,
+    )
     return WorkflowHandleFuture(new_wf_id, future, dbos)
 
 
@@ -516,6 +466,8 @@ def workflow_wrapper(
 
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> R:
+        fi = get_func_info(func)
+        assert fi is not None
         if dbosreg.dbos is None:
             raise DBOSException(
                 f"Function {func.__name__} invoked before DBOS initialized"
@@ -726,6 +678,8 @@ def decorate_transaction(
         set_temp_workflow_type(temp_wf, "transaction")
         dbosreg.register_wf_function(get_dbos_func_name(temp_wf), wrapped_wf)
         wrapper.__orig_func = temp_wf  # type: ignore
+        set_func_info(wrapped_wf, get_or_create_func_info(func))
+        set_func_info(temp_wf, get_or_create_func_info(func))
 
         return cast(F, wrapper)
 
@@ -875,6 +829,8 @@ def decorate_step(
         set_temp_workflow_type(temp_wf, "step")
         dbosreg.register_wf_function(get_dbos_func_name(temp_wf), wrapped_wf)
         wrapper.__orig_func = temp_wf  # type: ignore
+        set_func_info(wrapped_wf, get_or_create_func_info(func))
+        set_func_info(temp_wf, get_or_create_func_info(func))
 
         return cast(Callable[P, R], wrapper)
 

{dbos-0.21.0a7 → dbos-0.22.0a2}/dbos/_registrations.py

@@ -1,4 +1,5 @@
 import inspect
+from dataclasses import dataclass
 from enum import Enum
 from types import FunctionType
 from typing import Any, Callable, List, Literal, Optional, Tuple, Type, cast
@@ -31,9 +32,9 @@ def set_temp_workflow_type(f: Any, name: TempWorkflowType) -> None:
     setattr(f, "dbos_temp_workflow_type", name)
 
 
+@dataclass
 class DBOSClassInfo:
-    def __init__(self) -> None:
-        self.def_required_roles: Optional[List[str]] = None
+    def_required_roles: Optional[List[str]] = None
 
 
 class DBOSFuncType(Enum):
@@ -44,12 +45,12 @@ class DBOSFuncType(Enum):
     Instance = 4
 
 
+@dataclass
 class DBOSFuncInfo:
-    def __init__(self) -> None:
-        self.class_info: Optional[DBOSClassInfo] = None
-        self.func_type: DBOSFuncType = DBOSFuncType.Unknown
-        self.required_roles: Optional[List[str]] = None
-        self.max_recovery_attempts = DEFAULT_MAX_RECOVERY_ATTEMPTS
+    class_info: Optional[DBOSClassInfo] = None
+    func_type: DBOSFuncType = DBOSFuncType.Unknown
+    required_roles: Optional[List[str]] = None
+    max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
 
 
 def get_or_create_class_info(cls: Type[Any]) -> DBOSClassInfo:
@@ -110,6 +111,10 @@ def get_or_create_func_info(func: Callable[..., Any]) -> DBOSFuncInfo:
     return fi
 
 
+def set_func_info(func: Callable[..., Any], fi: DBOSFuncInfo) -> None:
+    setattr(func, "dbos_func_decorator_info", fi)
+
+
 def get_class_info(cls: Type[Any]) -> Optional[DBOSClassInfo]:
     if hasattr(cls, "dbos_class_decorator_info"):
         ci: DBOSClassInfo = getattr(cls, "dbos_class_decorator_info")

{dbos-0.21.0a7 → dbos-0.22.0a2}/dbos/_sys_db.py

@@ -227,7 +227,12 @@ class SystemDatabase:
             self.engine.url.render_as_string(hide_password=False),
         )
         alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
-        command.upgrade(alembic_cfg, "head")
+        try:
+            command.upgrade(alembic_cfg, "head")
+        except Exception as e:
+            dbos_logger.warning(
+                f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
+            )
 
         self.notification_conn: Optional[psycopg.connection.Connection] = None
         self.notifications_map: Dict[str, threading.Condition] = {}

{dbos-0.21.0a7 → dbos-0.22.0a2}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.21.0a7"
+version = "0.22.0a2"
 
 [project.license]
 text = "MIT"

{dbos-0.21.0a7 → dbos-0.22.0a2}/tests/conftest.py

@@ -1,7 +1,7 @@
 import glob
 import os
 import subprocess
-import warnings
+import time
 from typing import Any, Generator, Tuple
 
 import pytest
@@ -10,6 +10,7 @@ from fastapi import FastAPI
 from flask import Flask
 
 from dbos import DBOS, ConfigFile
+from dbos._schemas.system_database import SystemSchema
 
 
 @pytest.fixture(scope="session")
@@ -149,3 +150,19 @@ def dbos_flask(
 def pytest_collection_modifyitems(session: Any, config: Any, items: Any) -> None:
     for item in items:
         item._nodeid = "\n" + item.nodeid + "\n"
+
+
+def queue_entries_are_cleaned_up(dbos: DBOS) -> bool:
+    max_tries = 10
+    success = False
+    for i in range(max_tries):
+        with dbos._sys_db.engine.begin() as c:
+            query = sa.select(sa.func.count()).select_from(SystemSchema.workflow_queue)
+            row = c.execute(query).fetchone()
+            assert row is not None
+            count = row[0]
+            if count == 0:
+                success = True
+                break
+        time.sleep(1)
+    return success

{dbos-0.21.0a7 → dbos-0.22.0a2}/tests/test_classdecorators.py

@@ -1,13 +1,16 @@
-from typing import Optional
+import threading
+import uuid
+from typing import Callable, Optional
 
 import pytest
 import sqlalchemy as sa
 
 # Public API
-from dbos import DBOS, DBOSConfiguredInstance, SetWorkflowID
+from dbos import DBOS, DBOSConfiguredInstance, Queue, SetWorkflowID
 
 # Private API used because this is a test
 from dbos._context import DBOSContextEnsure, assert_current_dbos_context
+from tests.conftest import queue_entries_are_cleaned_up
 
 
 def test_required_roles(dbos: DBOS) -> None:
@@ -414,13 +417,14 @@ def test_class_recovery(dbos: DBOS) -> None:
 
 
 def test_inst_recovery(dbos: DBOS) -> None:
+    wfid = str(uuid.uuid4())
     exc_cnt: int = 0
-    last_inst: Optional[DBOSTestInstRec] = None
+    last_inst: Optional[TestClass] = None
 
     @DBOS.dbos_class()
-    class DBOSTestInstRec(DBOSConfiguredInstance):
+    class TestClass(DBOSConfiguredInstance):
         def __init__(self) -> None:
-            super().__init__("bob")
+            super().__init__("test_class")
 
         @DBOS.workflow()
         def check_inst(self, arg1: str) -> str:
@@ -431,8 +435,8 @@ def test_inst_recovery(dbos: DBOS) -> None:
             last_inst = self
             return "ran2"
 
-    inst = DBOSTestInstRec()
-    with SetWorkflowID("run2"):
+    inst = TestClass()
+    with SetWorkflowID(wfid):
         assert "ran2" == inst.check_inst("arg1")
 
     assert exc_cnt == 1
@@ -440,7 +444,422 @@ def test_inst_recovery(dbos: DBOS) -> None:
 
     # Test we can execute the workflow by uuid as recovery would do
     last_inst = None
-    handle = DBOS.execute_workflow_id("run2")
+    handle = DBOS.execute_workflow_id(wfid)
     assert handle.get_result() == "ran2"
     assert exc_cnt == 2
     assert last_inst is inst
+
+    status = DBOS.retrieve_workflow(wfid).get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+
+def test_inst_async_recovery(dbos: DBOS) -> None:
+    wfid = str(uuid.uuid4())
+    event = threading.Event()
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.workflow()
+        def workflow(self, x: int) -> int:
+            event.wait()
+            return self.multiply(x)
+
+    input = 2
+    multiplier = 5
+    inst = TestClass(multiplier)
+
+    with SetWorkflowID(wfid):
+        orig_handle = DBOS.start_workflow(inst.workflow, input)
+
+    status = orig_handle.get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+    recovery_handle = DBOS.execute_workflow_id(wfid)
+
+    event.set()
+    assert orig_handle.get_result() == input * multiplier
+    assert recovery_handle.get_result() == input * multiplier
+
+
+def test_inst_async_step_recovery(dbos: DBOS) -> None:
+    wfid = str(uuid.uuid4())
+    event = threading.Event()
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.step()
+        def step(self, x: int) -> int:
+            event.wait()
+            return self.multiply(x)
+
+    input = 2
+    multiplier = 5
+    inst = TestClass(multiplier)
+
+    with SetWorkflowID(wfid):
+        orig_handle = DBOS.start_workflow(inst.step, input)
+
+    status = orig_handle.get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+    recovery_handle = DBOS.execute_workflow_id(wfid)
+
+    event.set()
+    assert orig_handle.get_result() == input * multiplier
+    assert recovery_handle.get_result() == input * multiplier
+
+
+def test_step_recovery(dbos: DBOS) -> None:
+    wfid = str(uuid.uuid4())
+    thread_event = threading.Event()
+    blocking_event = threading.Event()
+    return_value = None
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.step()
+        def step(self, x: int) -> int:
+            thread_event.set()
+            blocking_event.wait()
+            return self.multiply(x)
+
+    input = 2
+    multiplier = 5
+    inst = TestClass(multiplier)
+
+    # We're testing synchronously calling the step, but need to do so
+    # asynchronously. Hence, a thread.
+    def call_step() -> None:
+        with SetWorkflowID(wfid):
+            nonlocal return_value
+            return_value = inst.step(input)
+
+    thread = threading.Thread(target=call_step)
+    thread.start()
+    thread_event.wait()
+
+    status = DBOS.retrieve_workflow(wfid).get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+    recovery_handle = DBOS.execute_workflow_id(wfid)
+
+    blocking_event.set()
+    thread.join()
+    assert return_value == input * multiplier
+    assert recovery_handle.get_result() == input * multiplier
+
+
+def test_class_queue_recovery(dbos: DBOS) -> None:
+    step_counter: int = 0
+    queued_steps = 5
+    multiplier = 5
+
+    wfid = str(uuid.uuid4())
+    queue = Queue("test_queue")
+    step_events = [threading.Event() for _ in range(queued_steps)]
+    event = threading.Event()
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.workflow()
+        def test_workflow(self) -> list[int]:
+            assert DBOS.workflow_id == wfid
+            handles = []
+            for i in range(queued_steps):
+                h = queue.enqueue(self.test_step, i)
+                handles.append(h)
+            return [h.get_result() for h in handles]
+
+        @DBOS.step()
+        def test_step(self, i: int) -> int:
+            nonlocal step_counter
+            step_counter += 1
+            step_events[i].set()
+            event.wait()
+            return self.multiply(i)
+
+    inst = TestClass(multiplier)
+
+    # Start the workflow. Wait for all five steps to start. Verify that they started.
+    with SetWorkflowID(wfid):
+        original_handle = DBOS.start_workflow(inst.test_workflow)
+    for e in step_events:
+        e.wait()
+        e.clear()
+
+    assert step_counter == 5
+
+    # Recover the workflow, then resume it.
+    recovery_handles = DBOS.recover_pending_workflows()
+    # Wait until the 2nd invocation of the workflows are dequeued and executed
+    for e in step_events:
+        e.wait()
+    event.set()
+
+    # There should be one handle for the workflow and another for each queued step.
+    assert len(recovery_handles) == queued_steps + 1
+    # Verify that both the recovered and original workflows complete correctly.
+    result = [i * multiplier for i in range(5)]
+    for h in recovery_handles:
+        status = h.get_status()
+        assert status.class_name == "TestClass"
+        assert status.config_name == "test_class"
+        if h.get_workflow_id() == wfid:
+            assert h.get_result() == result
+    assert original_handle.get_result() == result
+    # Each step should start twice, once originally and once in recovery.
+    assert step_counter == 10
+
+    # Rerun the workflow. Because each step is complete, none should start again.
+    with SetWorkflowID(wfid):
+        assert inst.test_workflow() == result
+    assert step_counter == 10
+
+    # Verify all queue entries eventually get cleaned up.
+    assert queue_entries_are_cleaned_up(dbos)
+
+
+def test_class_static_queue_recovery(dbos: DBOS) -> None:
+    step_counter: int = 0
+    queued_steps = 5
+
+    wfid = str(uuid.uuid4())
+    queue = Queue("test_queue")
+    step_events = [threading.Event() for _ in range(queued_steps)]
+    event = threading.Event()
+
+    @DBOS.dbos_class()
+    class TestClass:
+        @staticmethod
+        @DBOS.workflow()
+        def test_workflow() -> list[int]:
+            assert DBOS.workflow_id == wfid
+            handles = []
+            for i in range(queued_steps):
+                h = queue.enqueue(TestClass.test_step, i)
+                handles.append(h)
+            return [h.get_result() for h in handles]
+
+        @staticmethod
+        @DBOS.step()
+        def test_step(i: int) -> int:
+            nonlocal step_counter
+            step_counter += 1
+            step_events[i].set()
+            event.wait()
+            return i
+
+    # Start the workflow. Wait for all five steps to start. Verify that they started.
+    with SetWorkflowID(wfid):
+        original_handle = DBOS.start_workflow(TestClass.test_workflow)
+    for e in step_events:
+        e.wait()
+        e.clear()
+
+    assert step_counter == 5
+
+    # Recover the workflow, then resume it.
+    recovery_handles = DBOS.recover_pending_workflows()
+    # Wait until the 2nd invocation of the workflows are dequeued and executed
+    for e in step_events:
+        e.wait()
+    event.set()
+
+    # There should be one handle for the workflow and another for each queued step.
+    assert len(recovery_handles) == queued_steps + 1
+    # Verify that both the recovered and original workflows complete correctly.
+    result = [i for i in range(5)]
+    for h in recovery_handles:
+        status = h.get_status()
+        # Class name is not recorded for static methods
+        assert status.class_name == None
+        assert status.config_name == None
+        if h.get_workflow_id() == wfid:
+            assert h.get_result() == result
+    assert original_handle.get_result() == result
+    # Each step should start twice, once originally and once in recovery.
+    assert step_counter == 10
+
+    # Rerun the workflow. Because each step is complete, none should start again.
+    with SetWorkflowID(wfid):
+        assert TestClass.test_workflow() == result
+    assert step_counter == 10
+
+    # Verify all queue entries eventually get cleaned up.
+    assert queue_entries_are_cleaned_up(dbos)
+
+
+def test_class_classmethod_queue_recovery(dbos: DBOS) -> None:
+    step_counter: int = 0
+    multiplier = 5
+    queued_steps = 5
+
+    wfid = str(uuid.uuid4())
+    queue = Queue("test_queue")
+    step_events = [threading.Event() for _ in range(queued_steps)]
+    event = threading.Event()
+
+    @DBOS.dbos_class()
+    class TestClass:
+        multiply: Callable[[int], int] = lambda _: 0
+
+        @classmethod
+        @DBOS.workflow()
+        def test_workflow(cls) -> list[int]:
+            cls.multiply = lambda x: x * multiplier
+            assert DBOS.workflow_id == wfid
+            handles = []
+            for i in range(queued_steps):
+                h = queue.enqueue(TestClass.test_step, i)
+                handles.append(h)
+            return [h.get_result() for h in handles]
+
+        @classmethod
+        @DBOS.step()
+        def test_step(cls, i: int) -> int:
+            nonlocal step_counter
+            step_counter += 1
+            step_events[i].set()
+            event.wait()
+            return cls.multiply(i)
+
+    # Start the workflow. Wait for all five steps to start. Verify that they started.
+    with SetWorkflowID(wfid):
+        original_handle = DBOS.start_workflow(TestClass.test_workflow)
+    for e in step_events:
+        e.wait()
+        e.clear()
+
+    assert step_counter == 5
+
+    # Recover the workflow, then resume it.
+    recovery_handles = DBOS.recover_pending_workflows()
+    # Wait until the 2nd invocation of the workflows are dequeued and executed
+    for e in step_events:
+        e.wait()
+    event.set()
+
+    # There should be one handle for the workflow and another for each queued step.
+    assert len(recovery_handles) == queued_steps + 1
+    # Verify that both the recovered and original workflows complete correctly.
+    result = [i * multiplier for i in range(5)]
+    for h in recovery_handles:
+        status = h.get_status()
+        # Class name is recorded for class methods
+        assert status.class_name == "TestClass"
+        assert status.config_name == None
+        if h.get_workflow_id() == wfid:
+            assert h.get_result() == result
+    assert original_handle.get_result() == result
+    # Each step should start twice, once originally and once in recovery.
+    assert step_counter == 10
+
+    # Rerun the workflow. Because each step is complete, none should start again.
+    with SetWorkflowID(wfid):
+        assert TestClass.test_workflow() == result
+    assert step_counter == 10
+
+    # Verify all queue entries eventually get cleaned up.
+    assert queue_entries_are_cleaned_up(dbos)
+
+
+def test_inst_txn(dbos: DBOS) -> None:
+    wfid = str(uuid.uuid4())
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.transaction()
+        def transaction(self, x: int) -> int:
+            return self.multiply(x)
+
+    input = 2
+    multiplier = 5
+    inst = TestClass(multiplier)
+
+    with SetWorkflowID(wfid):
+        assert inst.transaction(input) == input * multiplier
+    dbos._sys_db.wait_for_buffer_flush()
+    status = DBOS.retrieve_workflow(wfid).get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+    handle = DBOS.start_workflow(inst.transaction, input)
+    assert handle.get_result() == input * multiplier
+    dbos._sys_db.wait_for_buffer_flush()
+    status = handle.get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+
+def test_mixed_methods(dbos: DBOS) -> None:
+
+    @DBOS.dbos_class()
+    class TestClass(DBOSConfiguredInstance):
+
+        def __init__(self, multiplier: int) -> None:
+            self.multiply: Callable[[int], int] = lambda x: x * multiplier
+            super().__init__("test_class")
+
+        @DBOS.workflow()
+        def instance_workflow(self, x: int) -> int:
+            return self.multiply(x)
+
+        @classmethod
+        @DBOS.workflow()
+        def classmethod_workflow(cls, x: int) -> int:
+            return x
+
+        @staticmethod
+        @DBOS.workflow()
+        def staticmethod_workflow(x: int) -> int:
+            return x
+
+    input = 2
+    multiplier = 5
+    inst = TestClass(multiplier)
+
+    handle = DBOS.start_workflow(inst.instance_workflow, input)
+    assert handle.get_result() == input * multiplier
+    status = handle.get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == "test_class"
+
+    handle = DBOS.start_workflow(inst.classmethod_workflow, input)
+    assert handle.get_result() == input
+    status = handle.get_status()
+    assert status.class_name == "TestClass"
+    assert status.config_name == None
+
+    handle = DBOS.start_workflow(inst.staticmethod_workflow, input)
+    assert handle.get_result() == input
+    status = handle.get_status()
+    assert status.class_name == None
+    assert status.config_name == None

{dbos-0.21.0a7 → dbos-0.22.0a2}/tests/test_queue.py

@@ -17,26 +17,9 @@ from dbos import (
     SetWorkflowID,
     WorkflowHandle,
 )
-from dbos._error import DBOSDeadLetterQueueError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import WorkflowStatusString
-from tests.conftest import default_config
-
-
-def queue_entries_are_cleaned_up(dbos: DBOS) -> bool:
-    max_tries = 10
-    success = False
-    for i in range(max_tries):
-        with dbos._sys_db.engine.begin() as c:
-            query = sa.select(sa.func.count()).select_from(SystemSchema.workflow_queue)
-            row = c.execute(query).fetchone()
-            assert row is not None
-            count = row[0]
-            if count == 0:
-                success = True
-                break
-        time.sleep(1)
-    return success
+from tests.conftest import default_config, queue_entries_are_cleaned_up
 
 
 def test_simple_queue(dbos: DBOS) -> None: