dbos 1.14.0a8__py3-none-any.whl → 1.15.0a1__py3-none-any.whl

dbos/_client.py

@@ -1,5 +1,4 @@
 import asyncio
-import sys
 import time
 import uuid
 from typing import (
@@ -15,17 +14,11 @@ 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
 
@@ -58,14 +51,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:

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,

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
@@ -558,7 +550,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 +1289,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"]:
@@ -441,17 +430,13 @@ def process_config(
         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]"
-        )
+        print(f"DBOS system database URL: {printable_sys_db_url}")
         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]"
+                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"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
-            )
+            print(f"Database engine parameters: {data['database']['db_engine_kwargs']}")
 
     # Return data as ConfigFile type
     return data
@@ -563,12 +548,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

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,
@@ -147,7 +141,6 @@ class Debouncer(Generic[P, R]):
         self,
         workflow_name: str,
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ):
@@ -157,13 +150,11 @@ class Debouncer(Generic[P, R]):
             "queue_name": queue.name if queue else None,
             "workflow_name": workflow_name,
         }
-        self.debounce_key = debounce_key
 
     @staticmethod
     def create(
         workflow: Callable[P, R],
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ) -> "Debouncer[P, R]":
@@ -172,7 +163,6 @@ class Debouncer(Generic[P, R]):
             raise TypeError("Only workflow functions may be debounced, not methods")
         return Debouncer[P, R](
             get_dbos_func_name(workflow),
-            debounce_key=debounce_key,
             debounce_timeout_sec=debounce_timeout_sec,
             queue=queue,
         )
@@ -181,7 +171,6 @@ class Debouncer(Generic[P, R]):
     def create_async(
         workflow: Callable[P, Coroutine[Any, Any, R]],
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ) -> "Debouncer[P, R]":
@@ -190,13 +179,16 @@ class Debouncer(Generic[P, R]):
             raise TypeError("Only workflow functions may be debounced, not methods")
         return Debouncer[P, R](
             get_dbos_func_name(workflow),
-            debounce_key=debounce_key,
             debounce_timeout_sec=debounce_timeout_sec,
             queue=queue,
         )
 
     def debounce(
-        self, debounce_period_sec: float, *args: P.args, **kwargs: P.kwargs
+        self,
+        debounce_key: str,
+        debounce_period_sec: float,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> "WorkflowHandle[R]":
         from dbos._dbos import DBOS, _get_dbos_instance
 
@@ -232,9 +224,7 @@ class Debouncer(Generic[P, R]):
         while True:
             try:
                 # Attempt to enqueue a debouncer for this workflow.
-                deduplication_id = (
-                    f"{self.options['workflow_name']}-{self.debounce_key}"
-                )
+                deduplication_id = f"{self.options['workflow_name']}-{debounce_key}"
                 with SetEnqueueOptions(deduplication_id=deduplication_id):
                     with SetWorkflowTimeout(None):
                         internal_queue.enqueue(
@@ -284,6 +274,7 @@ class Debouncer(Generic[P, R]):
 
     async def debounce_async(
         self,
+        debounce_key: str,
         debounce_period_sec: float,
         *args: P.args,
         **kwargs: P.kwargs,
@@ -292,7 +283,7 @@ class Debouncer(Generic[P, R]):
 
         dbos = _get_dbos_instance()
         handle = await asyncio.to_thread(
-            self.debounce, debounce_period_sec, *args, **kwargs
+            self.debounce, debounce_key, debounce_period_sec, *args, **kwargs
         )
         return WorkflowHandleAsyncPolling(handle.workflow_id, dbos)
 
@@ -304,7 +295,6 @@ class DebouncerClient:
         client: DBOSClient,
         workflow_options: EnqueueOptions,
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ):
@@ -314,11 +304,10 @@ class DebouncerClient:
             "queue_name": queue.name if queue else None,
             "workflow_name": workflow_options["workflow_name"],
         }
-        self.debounce_key = debounce_key
         self.client = client
 
     def debounce(
-        self, debounce_period_sec: float, *args: Any, **kwargs: Any
+        self, debounce_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
     ) -> "WorkflowHandle[R]":
 
         ctxOptions: ContextOptions = {
@@ -337,7 +326,7 @@ class DebouncerClient:
             try:
                 # Attempt to enqueue a debouncer for this workflow.
                 deduplication_id = (
-                    f"{self.debouncer_options['workflow_name']}-{self.debounce_key}"
+                    f"{self.debouncer_options['workflow_name']}-{debounce_key}"
                 )
                 debouncer_options: EnqueueOptions = {
                     "workflow_name": DEBOUNCER_WORKFLOW_NAME,
@@ -390,10 +379,10 @@ class DebouncerClient:
                     )
 
     async def debounce_async(
-        self, debounce_period_sec: float, *args: Any, **kwargs: Any
+        self, deboucne_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
     ) -> "WorkflowHandleAsync[R]":
         handle: "WorkflowHandle[R]" = await asyncio.to_thread(
-            self.debounce, debounce_period_sec, *args, **kwargs
+            self.debounce, deboucne_key, debounce_period_sec, *args, **kwargs
         )
         return WorkflowHandleClientAsyncPolling[R](
             handle.workflow_id, self.client._sys_db

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)

dbos/_docker_pg_helper.py

@@ -1,11 +1,10 @@
+import json
 import logging
 import os
 import subprocess
 import time
 
-import docker
 import psycopg
-from docker.errors import APIError, NotFound
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 from typing import Any, Dict, Optional, Tuple
@@ -86,48 +85,71 @@ def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
     image_name = "pgvector/pgvector:pg16"
 
     try:
-        client = docker.from_env()
-
         # Check if the container already exists
         try:
-            container = client.containers.get(container_name)
-            if container.status == "running":
-                logging.info(f"Container '{container_name}' is already running.")
-                return True
-            elif container.status == "exited":
-                container.start()
-                logging.info(
-                    f"Container '{container_name}' was stopped and has been restarted."
-                )
-                return True
-        except NotFound:
-            # Container doesn't exist, proceed with creation
+            result = subprocess.run(
+                f"docker inspect {container_name}",
+                shell=True,
+                text=True,
+                capture_output=True,
+            )
+
+            if result.returncode == 0:
+                # Container exists, check its status
+                container_info = json.loads(result.stdout)
+                status = container_info[0]["State"]["Status"]
+
+                if status == "running":
+                    logging.info(f"Container '{container_name}' is already running.")
+                    return True
+                elif status == "exited":
+                    subprocess.run(
+                        f"docker start {container_name}", shell=True, check=True
+                    )
+                    logging.info(
+                        f"Container '{container_name}' was stopped and has been restarted."
+                    )
+                    return True
+        except (
+            subprocess.CalledProcessError,
+            json.JSONDecodeError,
+            KeyError,
+            IndexError,
+        ):
+            # Container doesn't exist or error parsing, proceed with creation
             pass
 
-        # Pull the image if it doesn't exist
-        imgs = client.images.list(name=image_name)
-        if len(imgs) == 0:
+        # Check if the image exists locally
+        result = subprocess.run(
+            f"docker images -q {image_name}", shell=True, text=True, capture_output=True
+        )
+
+        if not result.stdout.strip():
             logging.info(f"Pulling Docker image {image_name}...")
-            client.images.pull(image_name)
+            subprocess.run(f"docker pull {image_name}", shell=True, check=True)
 
         # Create and start the container
-        container = client.containers.run(
-            image=image_name,
-            name=container_name,
-            detach=True,
-            environment={
-                "POSTGRES_PASSWORD": pool_config["password"],
-                "PGDATA": pg_data,
-            },
-            ports={"5432/tcp": pool_config["port"]},
-            volumes={pg_data: {"bind": pg_data, "mode": "rw"}},
-            remove=True,  # Equivalent to --rm
+        cmd = [
+            "docker run",
+            "-d",
+            f"--name {container_name}",
+            f"-e POSTGRES_PASSWORD={pool_config['password']}",
+            f"-e PGDATA={pg_data}",
+            f"-p {pool_config['port']}:5432",
+            f"-v {pg_data}:{pg_data}",
+            "--rm",
+            image_name,
+        ]
+
+        result = subprocess.run(
+            " ".join(cmd), shell=True, text=True, capture_output=True, check=True
         )
 
-        logging.info(f"Created container: {container.id}")
+        container_id = result.stdout.strip()
+        logging.info(f"Created container: {container_id}")
 
-    except APIError as e:
-        raise Exception(f"Docker API error: {str(e)}")
+    except subprocess.CalledProcessError as e:
+        raise Exception(f"Docker command error: {e.stderr if e.stderr else str(e)}")
 
     # Wait for PostgreSQL to be ready
     attempts = 30
@@ -148,15 +170,16 @@ def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
 
 def check_docker_installed() -> bool:
     """
-    Check if Docker is installed and running using the docker library.
+    Check if Docker is installed and running using the Docker CLI.
 
     Returns:
         bool: True if Docker is installed and running, False otherwise.
     """
     try:
-        client = docker.from_env()
-        client.ping()  # type: ignore
-        return True
+        result = subprocess.run(
+            "docker version --format json", shell=True, capture_output=True, text=True
+        )
+        return result.returncode == 0
     except Exception:
         return False
 
@@ -176,22 +199,41 @@ def stop_docker_pg() -> None:
     try:
         logger.info(f"Stopping Docker Postgres container {container_name}...")
 
-        client = docker.from_env()
-
-        try:
-            container = client.containers.get(container_name)
-
-            if container.status == "running":
-                container.stop()
-                logger.info(
-                    f"Successfully stopped Docker Postgres container {container_name}."
-                )
-            else:
-                logger.info(f"Container {container_name} exists but is not running.")
+        # Check if container exists
+        result = subprocess.run(
+            f"docker inspect {container_name}",
+            shell=True,
+            text=True,
+            capture_output=True,
+        )
 
-        except docker.errors.NotFound:
+        if result.returncode == 0:
+            # Container exists, check its status
+            try:
+                container_info = json.loads(result.stdout)
+                status = container_info[0]["State"]["Status"]
+
+                if status == "running":
+                    subprocess.run(
+                        f"docker stop {container_name}", shell=True, check=True
+                    )
+                    logger.info(
+                        f"Successfully stopped Docker Postgres container {container_name}."
+                    )
+                else:
+                    logger.info(
+                        f"Container {container_name} exists but is not running."
+                    )
+            except (json.JSONDecodeError, KeyError, IndexError) as e:
+                logger.error(f"Error parsing container info: {e}")
+                raise
+        else:
             logger.info(f"Container {container_name} does not exist.")
 
+    except subprocess.CalledProcessError as error:
+        error_message = error.stderr if error.stderr else str(error)
+        logger.error(f"Failed to stop Docker Postgres container: {error_message}")
+        raise
     except Exception as error:
         error_message = str(error)
         logger.error(f"Failed to stop Docker Postgres container: {error_message}")

dbos/_fastapi.py

@@ -83,6 +83,10 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
                     response = await call_next(request)
             else:
                 response = await call_next(request)
-            if hasattr(response, "status_code"):
+            if (
+                dbos._config["telemetry"]
+                and not dbos._config["telemetry"]["disable_otlp"]
+                and hasattr(response, "status_code")
+            ):
                 DBOS.span.set_attribute("responseCode", response.status_code)
         return response