dbos 1.14.0a9__py3-none-any.whl → 1.15.0a2__py3-none-any.whl

dbos/_client.py

@@ -1,5 +1,4 @@
 import asyncio
-import sys
 import time
 import uuid
 from typing import (
@@ -15,25 +14,15 @@ from typing import (
     Union,
 )
 
+from dbos import _serialization
 from dbos._app_db import ApplicationDatabase
 from dbos._context import MaxPriority, MinPriority
 from dbos._sys_db import SystemDatabase
 
-if sys.version_info < (3, 11):
-    from typing_extensions import NotRequired
-else:
-    from typing import NotRequired
-
-from dbos import _serialization
-
 if TYPE_CHECKING:
     from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
 
-from dbos._dbos_config import (
-    get_application_database_url,
-    get_system_database_url,
-    is_valid_database_url,
-)
+from dbos._dbos_config import get_system_database_url, is_valid_database_url
 from dbos._error import DBOSException, DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
@@ -58,14 +47,20 @@ from dbos._workflow_commands import (
 R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 
 
-class EnqueueOptions(TypedDict):
+# Required EnqueueOptions fields
+class _EnqueueOptionsRequired(TypedDict):
     workflow_name: str
     queue_name: str
-    workflow_id: NotRequired[str]
-    app_version: NotRequired[str]
-    workflow_timeout: NotRequired[float]
-    deduplication_id: NotRequired[str]
-    priority: NotRequired[int]
+
+
+# Optional EnqueueOptions fields
+class EnqueueOptions(_EnqueueOptionsRequired, total=False):
+    workflow_id: str
+    app_version: str
+    workflow_timeout: float
+    deduplication_id: str
+    priority: int
+    max_recovery_attempts: int
 
 
 def validate_enqueue_options(options: EnqueueOptions) -> None:
@@ -119,6 +114,9 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
 
 class DBOSClient:
+
+    _app_db: ApplicationDatabase | None = None
+
     def __init__(
         self,
         database_url: Optional[str] = None,  # DEPRECATED
@@ -127,13 +125,8 @@ class DBOSClient:
         application_database_url: Optional[str] = None,
         system_database: Optional[str] = None,  # DEPRECATED
     ):
-        application_database_url = get_application_database_url(
-            {
-                "system_database_url": system_database_url,
-                "database_url": (
-                    database_url if database_url else application_database_url
-                ),
-            }
+        application_database_url = (
+            database_url if database_url else application_database_url
         )
         system_database_url = get_system_database_url(
             {
@@ -143,7 +136,8 @@ class DBOSClient:
             }
         )
         assert is_valid_database_url(system_database_url)
-        assert is_valid_database_url(application_database_url)
+        if application_database_url:
+            assert is_valid_database_url(application_database_url)
         # We only create database connections but do not run migrations
         self._sys_db = SystemDatabase.create(
             system_database_url=system_database_url,
@@ -154,14 +148,15 @@ class DBOSClient:
             },
         )
         self._sys_db.check_connection()
-        self._app_db = ApplicationDatabase.create(
-            database_url=application_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
-        )
+        if application_database_url:
+            self._app_db = ApplicationDatabase.create(
+                database_url=application_database_url,
+                engine_kwargs={
+                    "pool_timeout": 30,
+                    "max_overflow": 0,
+                    "pool_size": 2,
+                },
+            )
 
     def destroy(self) -> None:
         self._sys_db.destroy()

dbos/_context.py

@@ -8,9 +8,11 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from enum import Enum
 from types import TracebackType
-from typing import List, Literal, Optional, Type, TypedDict
+from typing import TYPE_CHECKING, List, Literal, Optional, Type, TypedDict
+
+if TYPE_CHECKING:
+    from opentelemetry.trace import Span
 
-from opentelemetry.trace import Span, Status, StatusCode, use_span
 from sqlalchemy.orm import Session
 
 from dbos._utils import GlobalParams
@@ -78,8 +80,8 @@ class ContextSpan:
         context_manager: The context manager that is used to manage the span's lifecycle.
     """
 
-    span: Span
-    context_manager: AbstractContextManager[Span]
+    span: "Span"
+    context_manager: "AbstractContextManager[Span]"
 
 
 class DBOSContext:
@@ -217,19 +219,21 @@ class DBOSContext:
 
     """ Return the current DBOS span if any. It must be a span created by DBOS."""
 
-    def get_current_dbos_span(self) -> Optional[Span]:
+    def get_current_dbos_span(self) -> "Optional[Span]":
         if len(self.context_spans) > 0:
             return self.context_spans[-1].span
         return None
 
     """ Return the current active span if any. It might not be a DBOS span."""
 
-    def get_current_active_span(self) -> Optional[Span]:
+    def get_current_active_span(self) -> "Optional[Span]":
         return dbos_tracer.get_current_span()
 
     def _start_span(self, attributes: TracedAttributes) -> None:
         if dbos_tracer.disable_otlp:
             return
+        from opentelemetry.trace import use_span
+
         attributes["operationUUID"] = (
             self.workflow_id if len(self.workflow_id) > 0 else None
         )
@@ -257,6 +261,8 @@ class DBOSContext:
     def _end_span(self, exc_value: Optional[BaseException]) -> None:
         if dbos_tracer.disable_otlp:
             return
+        from opentelemetry.trace import Status, StatusCode
+
         context_span = self.context_spans.pop()
         if exc_value is None:
             context_span.span.set_status(Status(StatusCode.OK))

dbos/_core.py

@@ -14,6 +14,7 @@ from typing import (
     Coroutine,
     Generic,
     Optional,
+    ParamSpec,
     TypeVar,
     Union,
     cast,
@@ -22,14 +23,8 @@ from typing import (
 from dbos._outcome import Immediate, NoResult, Outcome, Pending
 from dbos._utils import GlobalParams, retriable_postgres_exception
 
-from ._app_db import ApplicationDatabase, TransactionResultInternal
-
-if sys.version_info < (3, 10):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec
-
 from . import _serialization
+from ._app_db import ApplicationDatabase, TransactionResultInternal
 from ._context import (
     DBOSAssumeRole,
     DBOSContext,
@@ -901,7 +896,9 @@ def decorate_transaction(
                 raise DBOSWorkflowCancelledError(
                     f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {transaction_name}."
                 )
-
+            assert (
+                dbos._app_db
+            ), "Transactions can only be used if DBOS is configured with an application_database_url"
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
                     "name": transaction_name,

dbos/_dbos.py

@@ -28,9 +28,6 @@ from typing import (
     Union,
 )
 
-from opentelemetry.trace import Span
-from rich import print
-
 from dbos._conductor.conductor import ConductorWebsocket
 from dbos._debouncer import debouncer_workflow
 from dbos._sys_db import SystemDatabase, WorkflowStatus
@@ -53,7 +50,6 @@ from ._core import (
     set_event,
     start_workflow,
     start_workflow_async,
-    workflow_wrapper,
 )
 from ._queue import Queue, queue_thread
 from ._recovery import recover_pending_workflows, startup_recovery_thread
@@ -62,8 +58,6 @@ from ._registrations import (
     DBOSClassInfo,
     _class_fqn,
     get_or_create_class_info,
-    set_dbos_func_name,
-    set_temp_workflow_type,
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
@@ -80,13 +74,11 @@ if TYPE_CHECKING:
     from fastapi import FastAPI
     from ._kafka import _KafkaConsumerWorkflow
     from flask import Flask
+    from opentelemetry.trace import Span
 
-from sqlalchemy.orm import Session
+from typing import ParamSpec
 
-if sys.version_info < (3, 10):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec
+from sqlalchemy.orm import Session
 
 from ._admin_server import AdminServer
 from ._app_db import ApplicationDatabase
@@ -417,13 +409,8 @@ class DBOS:
         return rv
 
     @property
-    def _app_db(self) -> ApplicationDatabase:
-        if self._app_db_field is None:
-            raise DBOSException(
-                "Application database accessed before DBOS was launched"
-            )
-        rv: ApplicationDatabase = self._app_db_field
-        return rv
+    def _app_db(self) -> ApplicationDatabase | None:
+        return self._app_db_field
 
     @property
     def _admin_server(self) -> AdminServer:
@@ -456,7 +443,6 @@ class DBOS:
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
             self._background_event_loop.start()
-            assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
             self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
@@ -464,18 +450,20 @@ class DBOS:
                 debug_mode=debug_mode,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
-            self._app_db_field = ApplicationDatabase.create(
-                database_url=self._config["database_url"],
-                engine_kwargs=self._config["database"]["db_engine_kwargs"],
-                debug_mode=debug_mode,
-            )
+            if self._config["database_url"]:
+                self._app_db_field = ApplicationDatabase.create(
+                    database_url=self._config["database_url"],
+                    engine_kwargs=self._config["database"]["db_engine_kwargs"],
+                    debug_mode=debug_mode,
+                )
 
             if debug_mode:
                 return
 
             # Run migrations for the system and application databases
             self._sys_db.run_migrations()
-            self._app_db.run_migrations()
+            if self._app_db:
+                self._app_db.run_migrations()
 
             admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
@@ -558,7 +546,7 @@ class DBOS:
                     f"https://console.dbos.dev/self-host?appname={app_name}"
                 )
                 print(
-                    f"[bold]To view and manage workflows, connect to DBOS Conductor at:[/bold] [bold blue]{conductor_registration_url}[/bold blue]"
+                    f"To view and manage workflows, connect to DBOS Conductor at:{conductor_registration_url}"
                 )
 
             # Flush handlers and add OTLP to all loggers if enabled
@@ -1297,7 +1285,7 @@ class DBOS:
         return ctx.parent_workflow_id
 
     @classproperty
-    def span(cls) -> Span:
+    def span(cls) -> "Span":
         """Return the tracing `Span` associated with the current context."""
         ctx = assert_current_dbos_context()
         span = ctx.get_current_active_span()

dbos/_dbos_config.py

@@ -5,8 +5,6 @@ from importlib import resources
 from typing import Any, Dict, List, Optional, TypedDict, cast
 
 import yaml
-from jsonschema import ValidationError, validate
-from rich import print
 from sqlalchemy import make_url
 
 from ._error import DBOSInitializationError
@@ -36,7 +34,7 @@ class DBOSConfig(TypedDict, total=False):
         otlp_attributes (dict[str, str]): A set of custom attributes to apply OTLP-exported logs and traces
         application_version (str): Application version
         executor_id (str): Executor ID, used to identify the application instance in distributed environments
-        disable_otlp (bool): If True, disables OTLP tracing and logging. Defaults to False.
+        enable_otlp (bool): If True, enable built-in DBOS OTLP tracing and logging.
     """
 
     name: str
@@ -54,7 +52,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_attributes: Optional[dict[str, str]]
     application_version: Optional[str]
     executor_id: Optional[str]
-    disable_otlp: Optional[bool]
+    enable_otlp: Optional[bool]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -97,7 +95,7 @@ class TelemetryConfig(TypedDict, total=False):
     logs: Optional[LoggerConfig]
     OTLPExporter: Optional[OTLPExporterConfig]
     otlp_attributes: Optional[dict[str, str]]
-    disable_otlp: Optional[bool]
+    disable_otlp: bool
 
 
 class ConfigFile(TypedDict, total=False):
@@ -165,10 +163,12 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
         ]
 
     # Telemetry config
+    enable_otlp = config.get("enable_otlp", None)
+    disable_otlp = True if enable_otlp is None else not enable_otlp
     telemetry: TelemetryConfig = {
         "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []},
         "otlp_attributes": config.get("otlp_attributes", {}),
-        "disable_otlp": config.get("disable_otlp", False),
+        "disable_otlp": disable_otlp,
     }
     # For mypy
     assert telemetry["OTLPExporter"] is not None
@@ -265,17 +265,6 @@ def load_config(
         )
     data = cast(Dict[str, Any], data)
 
-    # Load the JSON schema relative to the package root
-    schema_file = resources.files("dbos").joinpath("dbos-config.schema.json")
-    with schema_file.open("r") as f:
-        schema = json.load(f)
-
-    # Validate the data against the schema
-    try:
-        validate(instance=data, schema=schema)
-    except ValidationError as e:
-        raise DBOSInitializationError(f"Validation error: {e}")
-
     # Special case: convert logsEndpoint and tracesEndpoint from strings to lists of strings, if present
     if "telemetry" in data and "OTLPExporter" in data["telemetry"]:
         if "logsEndpoint" in data["telemetry"]["OTLPExporter"]:
@@ -419,39 +408,38 @@ def process_config(
                 url = url.set(database=f"{url.database}{SystemSchema.sysdb_suffix}")
             data["system_database_url"] = url.render_as_string(hide_password=False)
 
-    # If a system database URL is provided but not an application database URL, set the
-    # application database URL to the system database URL.
+    # If a system database URL is provided but not an application database URL,
+    # do not create an application database.
     if data.get("system_database_url") and not data.get("database_url"):
         assert data["system_database_url"]
-        data["database_url"] = data["system_database_url"]
+        data["database_url"] = None
 
-    # If neither URL is provided, use a default SQLite database URL.
+    # If neither URL is provided, use a default SQLite system database URL.
     if not data.get("database_url") and not data.get("system_database_url"):
         _app_db_name = _app_name_to_db_name(data["name"])
-        data["system_database_url"] = data["database_url"] = (
-            f"sqlite:///{_app_db_name}.sqlite"
-        )
+        data["system_database_url"] = f"sqlite:///{_app_db_name}.sqlite"
+        data["database_url"] = None
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
-    assert data["database_url"] is not None
     assert data["system_database_url"] is not None
     # Pretty-print connection information, respecting log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
         printable_sys_db_url = make_url(data["system_database_url"]).render_as_string(
             hide_password=True
         )
-        print(
-            f"[bold blue]DBOS system database URL: {printable_sys_db_url}[/bold blue]"
-        )
-        if data["database_url"].startswith("sqlite"):
-            print(
-                f"[bold blue]Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use.[/bold blue]"
+        print(f"DBOS system database URL: {printable_sys_db_url}")
+        if data["database_url"]:
+            printable_app_db_url = make_url(data["database_url"]).render_as_string(
+                hide_password=True
             )
-        else:
+            print(f"DBOS application database URL: {printable_app_db_url}")
+        if data["system_database_url"].startswith("sqlite"):
             print(
-                f"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
+                f"Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use."
             )
+        else:
+            print(f"Database engine parameters: {data['database']['db_engine_kwargs']}")
 
     # Return data as ConfigFile type
     return data
@@ -563,12 +551,15 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:
         provided_config["telemetry"] = {
             "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []},
+            "disable_otlp": False,
         }
-    elif "OTLPExporter" not in provided_config["telemetry"]:
-        provided_config["telemetry"]["OTLPExporter"] = {
-            "tracesEndpoint": [],
-            "logsEndpoint": [],
-        }
+    else:
+        provided_config["telemetry"]["disable_otlp"] = False
+        if "OTLPExporter" not in provided_config["telemetry"]:
+            provided_config["telemetry"]["OTLPExporter"] = {
+                "tracesEndpoint": [],
+                "logsEndpoint": [],
+            }
 
     # This is a super messy from a typing perspective.
     # Some of ConfigFile keys are optional -- but in practice they'll always be present in hosted environments
@@ -627,12 +618,11 @@ def get_system_database_url(config: ConfigFile) -> str:
         )
 
 
-def get_application_database_url(config: ConfigFile) -> str:
+def get_application_database_url(config: ConfigFile) -> str | None:
     # For backwards compatibility, the application database URL is "database_url"
     if config.get("database_url"):
         assert config["database_url"]
         return config["database_url"]
     else:
-        # If the application database URL is not specified, set it to the system database URL
-        assert config["system_database_url"]
-        return config["system_database_url"]
+        # If the application database URL is not specified, return None
+        return None

dbos/_debouncer.py

@@ -1,6 +1,5 @@
 import asyncio
 import math
-import sys
 import time
 import types
 import uuid
@@ -12,17 +11,12 @@ from typing import (
     Dict,
     Generic,
     Optional,
+    ParamSpec,
     Tuple,
     TypedDict,
     TypeVar,
-    Union,
 )
 
-if sys.version_info < (3, 10):
-    from typing_extensions import ParamSpec
-else:
-    from typing import ParamSpec
-
 from dbos._client import (
     DBOSClient,
     EnqueueOptions,

dbos/_debug.py

@@ -4,8 +4,6 @@ import sys
 from pathlib import Path
 from typing import Union
 
-from fastapi_cli.discover import get_module_data_from_path
-
 from dbos import DBOS
 
 
@@ -34,12 +32,6 @@ def debug_workflow(workflow_id: str, entrypoint: Union[str, PythonModule]) -> No
 
 
 def parse_start_command(command: str) -> Union[str, PythonModule]:
-    match = re.match(r"fastapi\s+run\s+(\.?[\w/]+\.py)", command)
-    if match:
-        # Mirror the logic in fastapi's run command by converting the path argument to a module
-        mod_data = get_module_data_from_path(Path(match.group(1)))
-        sys.path.insert(0, str(mod_data.extra_sys_path))
-        return PythonModule(mod_data.module_import_str)
     match = re.match(r"python3?\s+(\.?[\w/]+\.py)", command)
     if match:
         return match.group(1)