dbos 0.24.0a3__tar.gz → 0.24.0a5__tar.gz

{dbos-0.24.0a3 → dbos-0.24.0a5}/PKG-INFO

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

{dbos-0.24.0a3 → dbos-0.24.0a5}/dbos/__init__.py

@@ -1,13 +1,14 @@
 from . import _error as error
 from ._context import DBOSContextEnsure, DBOSContextSetAuth, SetWorkflowID
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowStatus
-from ._dbos_config import ConfigFile, get_dbos_database_url, load_config
+from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatusString
 
 __all__ = [
     "ConfigFile",
+    "DBOSConfig",
     "DBOS",
     "DBOSConfiguredInstance",
     "DBOSContextEnsure",

{dbos-0.24.0a3 → dbos-0.24.0a5}/dbos/_conductor/conductor.py

@@ -194,6 +194,22 @@ class ConductorWebsocket(threading.Thread):
                                 ),
                             )
                             websocket.send(get_workflow_response.to_json())
+                        elif msg_type == p.MessageType.EXIST_PENDING_WORKFLOWS:
+                            exist_pending_workflows_message = (
+                                p.ExistPendingWorkflowsRequest.from_json(message)
+                            )
+                            pending_wfs = self.dbos._sys_db.get_pending_workflows(
+                                exist_pending_workflows_message.executor_id,
+                                exist_pending_workflows_message.application_version,
+                            )
+                            exist_pending_workflows_response = (
+                                p.ExistPendingWorkflowsResponse(
+                                    type=p.MessageType.EXIST_PENDING_WORKFLOWS,
+                                    request_id=base_message.request_id,
+                                    exist=len(pending_wfs) > 0,
+                                )
+                            )
+                            websocket.send(exist_pending_workflows_response.to_json())
                         else:
                             self.dbos.logger.warning(
                                 f"Unexpected message type: {msg_type}"

{dbos-0.24.0a3 → dbos-0.24.0a5}/dbos/_conductor/protocol.py

@@ -15,6 +15,7 @@ class MessageType(str, Enum):
     RESUME = "resume"
     RESTART = "restart"
     GET_WORKFLOW = "get_workflow"
+    EXIST_PENDING_WORKFLOWS = "exist_pending_workflows"
 
 
 T = TypeVar("T", bound="BaseMessage")
@@ -195,3 +196,14 @@ class GetWorkflowRequest(BaseMessage):
 @dataclass
 class GetWorkflowResponse(BaseMessage):
     output: Optional[WorkflowsOutput]
+
+
+@dataclass
+class ExistPendingWorkflowsRequest(BaseMessage):
+    executor_id: str
+    application_version: str
+
+
+@dataclass
+class ExistPendingWorkflowsResponse(BaseMessage):
+    exist: bool

{dbos-0.24.0a3 → dbos-0.24.0a5}/dbos/_db_wizard.py

@@ -28,7 +28,20 @@ class DatabaseConnection(TypedDict):
     local_suffix: Optional[bool]
 
 
-def db_wizard(config: "ConfigFile", config_file_path: str) -> "ConfigFile":
+def db_wizard(config: "ConfigFile") -> "ConfigFile":
+    """Checks database connectivity and helps the user start a database if needed
+
+    First, check connectivity to the database configured in the provided `config` object.
+    If it fails:
+     - Return an error if the connection failed due to incorrect credentials.
+     - Return an error if it detects a non-default configuration.
+     - Otherwise assume the configured database is not running and guide the user through setting it up.
+
+     The wizard will first attempt to start a local Postgres instance using Docker.
+     If Docker is not available, it will prompt the user to connect to a DBOS Cloud database.
+
+     Finally, if a database was configured, its connection details will be saved in the local `.dbos/db_connection` file.
+    """
     # 1. Check the connectivity to the database. Return if successful. If cannot connect, continue to the following steps.
     db_connection_error = _check_db_connectivity(config)
     if db_connection_error is None:
@@ -44,27 +57,18 @@ def db_wizard(config: "ConfigFile", config_file_path: str) -> "ConfigFile":
         raise DBOSInitializationError(
             f"Could not connect to Postgres: password authentication failed: {db_connection_error}"
         )
-    db_config = config["database"]
-
-    # Read the config file and check if the database hostname/port/username are set. If so, skip the wizard.
-    with open(config_file_path, "r") as file:
-        content = file.read()
-        local_config = yaml.safe_load(content)
-        if "database" not in local_config:
-            local_config["database"] = {}
-        local_config = cast("ConfigFile", local_config)
 
+    # If the database config is not the default one, surface the error and exit.
+    db_config = config["database"]  # FIXME: what if database is not in config?
     if (
-        local_config["database"].get("hostname")
-        or local_config["database"].get("port")
-        or local_config["database"].get("username")
-        or db_config["hostname"] != "localhost"
+        db_config["hostname"] != "localhost"
         or db_config["port"] != 5432
         or db_config["username"] != "postgres"
     ):
         raise DBOSInitializationError(
             f"Could not connect to the database. Exception: {db_connection_error}"
         )
+
     print("[yellow]Postgres not detected locally[/yellow]")
 
     # 3. If the database config is the default one, check if the user has Docker properly installed.

{dbos-0.24.0a3 → dbos-0.24.0a5}/dbos/_dbos.py

@@ -88,13 +88,23 @@ from ._context import (
     assert_current_dbos_context,
     get_local_dbos_context,
 )
-from ._dbos_config import ConfigFile, load_config, set_env_vars
+from ._dbos_config import (
+    ConfigFile,
+    DBOSConfig,
+    check_config_consistency,
+    is_dbos_configfile,
+    load_config,
+    overwrite_config,
+    process_config,
+    set_env_vars,
+    translate_dbos_config_to_config_file,
+)
 from ._error import (
     DBOSConflictingRegistrationError,
     DBOSException,
     DBOSNonExistentWorkflowError,
 )
-from ._logger import add_otlp_to_all_loggers, dbos_logger
+from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
@@ -257,7 +267,7 @@ class DBOS:
     def __new__(
         cls: Type[DBOS],
         *,
-        config: Optional[ConfigFile] = None,
+        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -302,7 +312,7 @@ class DBOS:
     def __init__(
         self,
         *,
-        config: Optional[ConfigFile] = None,
+        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -312,12 +322,7 @@ class DBOS:
             return
 
         self._initialized: bool = True
-        if config is None:
-            config = load_config()
-        set_env_vars(config)
-        dbos_tracer.config(config)
-        dbos_logger.info("Initializing DBOS")
-        self.config: ConfigFile = config
+
         self._launched: bool = False
         self._debug_mode: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
@@ -334,6 +339,36 @@ class DBOS:
         self.conductor_key: Optional[str] = conductor_key
         self.conductor_websocket: Optional[ConductorWebsocket] = None
 
+        init_logger()
+
+        unvalidated_config: Optional[ConfigFile] = None
+
+        if config is None:
+            # If no config is provided, load it from dbos-config.yaml
+            unvalidated_config = load_config(run_process_config=False)
+        elif is_dbos_configfile(config):
+            unvalidated_config = cast(ConfigFile, config)
+            if os.environ.get("DBOS__CLOUD") == "true":
+                unvalidated_config = overwrite_config(unvalidated_config)
+            check_config_consistency(name=unvalidated_config["name"])
+        else:
+            unvalidated_config = translate_dbos_config_to_config_file(
+                cast(DBOSConfig, config)
+            )
+            if os.environ.get("DBOS__CLOUD") == "true":
+                unvalidated_config = overwrite_config(unvalidated_config)
+            check_config_consistency(name=unvalidated_config["name"])
+
+        if unvalidated_config is not None:
+            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)
+        dbos_logger.info("Initializing DBOS")
+
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
             from ._fastapi import setup_fastapi_middleware
@@ -419,7 +454,7 @@ class DBOS:
             if debug_mode:
                 return
 
-            admin_port = self.config["runtimeConfig"].get("admin_port")
+            admin_port = self.config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
                 admin_port = 3001
             self._admin_server_field = AdminServer(dbos=self, port=admin_port)
@@ -923,7 +958,9 @@ class DBOS:
         reg = _get_or_create_dbos_registry()
         if reg.config is not None:
             return reg.config
-        config = load_config()
+        config = (
+            load_config()
+        )  # This will return the processed & validated config (with defaults)
         reg.config = config
         return config