dbos 0.11.0a4__py3-none-any.whl → 0.12.0__py3-none-any.whl

dbos/{dbos.py → _dbos.py}

@@ -25,63 +25,61 @@ from typing import (
 
 from opentelemetry.trace import Span
 
-from dbos.core import (
+from ._classproperty import classproperty
+from ._core import (
     TEMP_SEND_WF_NAME,
-    _execute_workflow_id,
-    _get_event,
-    _recv,
-    _send,
-    _set_event,
-    _start_workflow,
-    _step,
-    _transaction,
-    _workflow,
-    _workflow_wrapper,
-    _WorkflowHandlePolling,
+    WorkflowHandlePolling,
+    decorate_step,
+    decorate_transaction,
+    decorate_workflow,
+    execute_workflow_by_id,
+    get_event,
+    recv,
+    send,
+    set_event,
+    start_workflow,
+    workflow_wrapper,
 )
-from dbos.decorators import classproperty
-from dbos.queue import Queue, queue_thread
-from dbos.recovery import _recover_pending_workflows, _startup_recovery_thread
-from dbos.registrations import (
+from ._queue import Queue, _queue_thread
+from ._recovery import recover_pending_workflows, startup_recovery_thread
+from ._registrations import (
     DEFAULT_MAX_RECOVERY_ATTEMPTS,
     DBOSClassInfo,
     get_or_create_class_info,
     set_dbos_func_name,
     set_temp_workflow_type,
 )
-from dbos.roles import default_required_roles, required_roles
-from dbos.scheduler.scheduler import ScheduledWorkflow, scheduled
-
-from .tracer import dbos_tracer
+from ._roles import default_required_roles, required_roles
+from ._scheduler import ScheduledWorkflow, scheduled
+from ._tracer import dbos_tracer
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
-    from dbos.kafka import KafkaConsumerWorkflow
-    from .request import Request
+    from ._kafka import _KafkaConsumerWorkflow
+    from ._request import Request
     from flask import Flask
 
 from sqlalchemy.orm import Session
 
-from dbos.request import Request
+from ._request import Request
 
 if sys.version_info < (3, 10):
     from typing_extensions import ParamSpec, TypeAlias
 else:
     from typing import ParamSpec, TypeAlias
 
-from dbos.admin_sever import AdminServer
-from dbos.context import (
+from ._admin_sever import AdminServer
+from ._app_db import ApplicationDatabase
+from ._context import (
     EnterDBOSStep,
     TracedAttributes,
     assert_current_dbos_context,
     get_local_dbos_context,
 )
-from dbos.error import DBOSException, DBOSNonExistentWorkflowError
-
-from .application_database import ApplicationDatabase
-from .dbos_config import ConfigFile, load_config, set_env_vars
-from .logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
-from .system_database import SystemDatabase
+from ._dbos_config import ConfigFile, _set_env_vars, load_config
+from ._error import DBOSException, DBOSNonExistentWorkflowError
+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
 # There are cases where the parameters P and return value R should be separate
@@ -112,7 +110,7 @@ IsolationLevel = Literal[
 ]
 
 _dbos_global_instance: Optional[DBOS] = None
-_dbos_global_registry: Optional[_DBOSRegistry] = None
+_dbos_global_registry: Optional[DBOSRegistry] = None
 
 
 def _get_dbos_instance() -> DBOS:
@@ -122,26 +120,26 @@ def _get_dbos_instance() -> DBOS:
     raise DBOSException("No DBOS was created yet")
 
 
-def _get_or_create_dbos_registry() -> _DBOSRegistry:
+def _get_or_create_dbos_registry() -> DBOSRegistry:
     # Currently get / init the global registry
     global _dbos_global_registry
     if _dbos_global_registry is None:
-        _dbos_global_registry = _DBOSRegistry()
+        _dbos_global_registry = DBOSRegistry()
     return _dbos_global_registry
 
 
-_RegisteredJob = Tuple[
+RegisteredJob = Tuple[
     threading.Event, Callable[..., Any], Tuple[Any, ...], dict[str, Any]
 ]
 
 
-class _DBOSRegistry:
+class DBOSRegistry:
     def __init__(self) -> None:
         self.workflow_info_map: dict[str, Workflow[..., Any]] = {}
         self.class_info_map: dict[str, type] = {}
         self.instance_info_map: dict[str, object] = {}
         self.queue_info_map: dict[str, Queue] = {}
-        self.pollers: list[_RegisteredJob] = []
+        self.pollers: list[RegisteredJob] = []
         self.dbos: Optional[DBOS] = None
         self.config: Optional[ConfigFile] = None
 
@@ -263,14 +261,14 @@ class DBOS:
         if config is None:
             config = load_config()
         config_logger(config)
-        set_env_vars(config)
+        _set_env_vars(config)
         dbos_tracer.config(config)
         dbos_logger.info("Initializing DBOS")
         self.config: ConfigFile = config
         self._launched: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
         self._app_db_field: Optional[ApplicationDatabase] = None
-        self._registry: _DBOSRegistry = _get_or_create_dbos_registry()
+        self._registry: DBOSRegistry = _get_or_create_dbos_registry()
         self._registry.dbos = self
         self._admin_server_field: Optional[AdminServer] = None
         self.stop_events: List[threading.Event] = []
@@ -281,13 +279,13 @@ class DBOS:
 
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
-            from dbos.fastapi import setup_fastapi_middleware
+            from ._fastapi import setup_fastapi_middleware
 
             setup_fastapi_middleware(self.fastapi, _get_dbos_instance())
 
         # If using Flask, set up middleware
         if self.flask is not None:
-            from dbos.flask import setup_flask_middleware
+            from ._flask import setup_flask_middleware
 
             setup_flask_middleware(self.flask)
 
@@ -297,7 +295,7 @@ class DBOS:
         ) -> None:
             self.send(destination_id, message, topic)
 
-        temp_send_wf = _workflow_wrapper(self._registry, send_temp_workflow)
+        temp_send_wf = workflow_wrapper(self._registry, send_temp_workflow)
         set_dbos_func_name(send_temp_workflow, TEMP_SEND_WF_NAME)
         set_temp_workflow_type(send_temp_workflow, "send")
         self._registry.register_wf_function(TEMP_SEND_WF_NAME, temp_send_wf)
@@ -356,7 +354,7 @@ class DBOS:
 
             if not os.environ.get("DBOS__VMID"):
                 workflow_ids = self._sys_db.get_pending_workflows("local")
-                self._executor.submit(_startup_recovery_thread, self, workflow_ids)
+                self._executor.submit(startup_recovery_thread, self, workflow_ids)
 
             # Listen to notifications
             notification_listener_thread = threading.Thread(
@@ -378,7 +376,7 @@ class DBOS:
             evt = threading.Event()
             self.stop_events.append(evt)
             bg_queue_thread = threading.Thread(
-                target=queue_thread, args=(evt, self), daemon=True
+                target=_queue_thread, args=(evt, self), daemon=True
             )
             bg_queue_thread.start()
             self._background_threads.append(bg_queue_thread)
@@ -435,7 +433,7 @@ class DBOS:
         cls, *, max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
     ) -> Callable[[F], F]:
         """Decorate a function for use as a DBOS workflow."""
-        return _workflow(_get_or_create_dbos_registry(), max_recovery_attempts)
+        return decorate_workflow(_get_or_create_dbos_registry(), max_recovery_attempts)
 
     @classmethod
     def transaction(
@@ -448,7 +446,7 @@ class DBOS:
             isolation_level(IsolationLevel): Transaction isolation level
 
         """
-        return _transaction(_get_or_create_dbos_registry(), isolation_level)
+        return decorate_transaction(_get_or_create_dbos_registry(), isolation_level)
 
     @classmethod
     def step(
@@ -470,7 +468,7 @@ class DBOS:
 
         """
 
-        return _step(
+        return decorate_step(
             _get_or_create_dbos_registry(),
             retries_allowed=retries_allowed,
             interval_seconds=interval_seconds,
@@ -530,10 +528,10 @@ class DBOS:
         config: dict[str, Any],
         topics: list[str],
         in_order: bool = False,
-    ) -> Callable[[KafkaConsumerWorkflow], KafkaConsumerWorkflow]:
+    ) -> Callable[[_KafkaConsumerWorkflow], _KafkaConsumerWorkflow]:
         """Decorate a function to be used as a Kafka consumer."""
         try:
-            from dbos.kafka import kafka_consumer
+            from ._kafka import kafka_consumer
 
             return kafka_consumer(
                 _get_or_create_dbos_registry(), config, topics, in_order
@@ -551,7 +549,7 @@ class DBOS:
         **kwargs: P.kwargs,
     ) -> WorkflowHandle[R]:
         """Invoke a workflow function in the background, returning a handle to the ongoing execution."""
-        return _start_workflow(_get_dbos_instance(), func, None, True, *args, **kwargs)
+        return start_workflow(_get_dbos_instance(), func, None, True, *args, **kwargs)
 
     @classmethod
     def get_workflow_status(cls, workflow_id: str) -> Optional[WorkflowStatus]:
@@ -594,14 +592,14 @@ class DBOS:
             stat = dbos.get_workflow_status(workflow_id)
             if stat is None:
                 raise DBOSNonExistentWorkflowError(workflow_id)
-        return _WorkflowHandlePolling(workflow_id, dbos)
+        return WorkflowHandlePolling(workflow_id, dbos)
 
     @classmethod
     def send(
         cls, destination_id: str, message: Any, topic: Optional[str] = None
     ) -> None:
         """Send a message to a workflow execution."""
-        return _send(_get_dbos_instance(), destination_id, message, topic)
+        return send(_get_dbos_instance(), destination_id, message, topic)
 
     @classmethod
     def recv(cls, topic: Optional[str] = None, timeout_seconds: float = 60) -> Any:
@@ -611,7 +609,7 @@ class DBOS:
         This function is to be called from within a workflow.
         `recv` will return the message sent on `topic`, waiting if necessary.
         """
-        return _recv(_get_dbos_instance(), topic, timeout_seconds)
+        return recv(_get_dbos_instance(), topic, timeout_seconds)
 
     @classmethod
     def sleep(cls, seconds: float) -> None:
@@ -649,7 +647,7 @@ class DBOS:
             value(Any): A serializable value to associate with the key
 
         """
-        return _set_event(_get_dbos_instance(), key, value)
+        return set_event(_get_dbos_instance(), key, value)
 
     @classmethod
     def get_event(cls, workflow_id: str, key: str, timeout_seconds: float = 60) -> Any:
@@ -664,19 +662,19 @@ class DBOS:
             timeout_seconds(float): The amount of time to wait, in case `set_event` has not yet been called byt the workflow
 
         """
-        return _get_event(_get_dbos_instance(), workflow_id, key, timeout_seconds)
+        return get_event(_get_dbos_instance(), workflow_id, key, timeout_seconds)
 
     @classmethod
     def execute_workflow_id(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Execute a workflow by ID (for recovery)."""
-        return _execute_workflow_id(_get_dbos_instance(), workflow_id)
+        return execute_workflow_by_id(_get_dbos_instance(), workflow_id)
 
     @classmethod
     def recover_pending_workflows(
         cls, executor_ids: List[str] = ["local"]
     ) -> List[WorkflowHandle[Any]]:
         """Find all PENDING workflows and execute them."""
-        return _recover_pending_workflows(_get_dbos_instance(), executor_ids)
+        return recover_pending_workflows(_get_dbos_instance(), executor_ids)
 
     @classproperty
     def logger(cls) -> Logger:
@@ -853,7 +851,7 @@ class DBOSConfiguredInstance:
 
 # Apps that import DBOS probably don't exit.  If they do, let's see if
 #   it looks like startup was abandoned or a call was forgotten...
-def dbos_exit_hook() -> None:
+def _dbos_exit_hook() -> None:
     if _dbos_global_registry is None:
         # Probably used as or for a support module
         return
@@ -872,4 +870,4 @@ def dbos_exit_hook() -> None:
 
 
 # Register the exit hook
-atexit.register(dbos_exit_hook)
+atexit.register(_dbos_exit_hook)

dbos/{dbos_config.py → _dbos_config.py}

@@ -8,8 +8,8 @@ import yaml
 from jsonschema import ValidationError, validate
 from sqlalchemy import URL
 
-from dbos.error import DBOSInitializationError
-from dbos.logger import dbos_logger
+from ._error import DBOSInitializationError
+from ._logger import dbos_logger
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -74,7 +74,7 @@ class ConfigFile(TypedDict, total=False):
     application: Dict[str, Any]
 
 
-def substitute_env_vars(content: str) -> str:
+def _substitute_env_vars(content: str) -> str:
     regex = r"\$\{([^}]+)\}"  # Regex to match ${VAR_NAME} style placeholders
 
     def replace_func(match: re.Match[str]) -> str:
@@ -133,7 +133,7 @@ def load_config(config_file_path: str = "dbos-config.yaml") -> ConfigFile:
 
     with open(config_file_path, "r") as file:
         content = file.read()
-        substituted_content = substitute_env_vars(content)
+        substituted_content = _substitute_env_vars(content)
         data = yaml.safe_load(substituted_content)
 
     # Load the JSON schema relative to the package root
@@ -167,13 +167,13 @@ def load_config(config_file_path: str = "dbos-config.yaml") -> ConfigFile:
 
     data = cast(ConfigFile, data)
 
-    if not is_valid_app_name(data["name"]):
+    if not _is_valid_app_name(data["name"]):
         raise DBOSInitializationError(
             f'Invalid app name {data["name"]}.  App names must be between 3 and 30 characters and contain only alphanumeric characters, dashes, and underscores.'
         )
 
     if "app_db_name" not in data["database"]:
-        data["database"]["app_db_name"] = app_name_to_db_name(data["name"])
+        data["database"]["app_db_name"] = _app_name_to_db_name(data["name"])
 
     if "local_suffix" in data["database"] and data["database"]["local_suffix"]:
         data["database"]["app_db_name"] = f"{data['database']['app_db_name']}_local"
@@ -182,7 +182,7 @@ def load_config(config_file_path: str = "dbos-config.yaml") -> ConfigFile:
     return data  # type: ignore
 
 
-def is_valid_app_name(name: str) -> bool:
+def _is_valid_app_name(name: str) -> bool:
     name_len = len(name)
     if name_len < 3 or name_len > 30:
         return False
@@ -190,12 +190,12 @@ def is_valid_app_name(name: str) -> bool:
     return True if match != None else False
 
 
-def app_name_to_db_name(app_name: str) -> str:
+def _app_name_to_db_name(app_name: str) -> str:
     name = app_name.replace("-", "_")
     return name if not name[0].isdigit() else f"_{name}"
 
 
-def set_env_vars(config: ConfigFile) -> None:
+def _set_env_vars(config: ConfigFile) -> None:
     for env, value in config.get("env", {}).items():
         if value is not None:
             os.environ[env] = value

dbos/{fastapi.py → _fastapi.py}

@@ -6,20 +6,19 @@ from fastapi import Request as FastAPIRequest
 from fastapi.responses import JSONResponse
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from dbos import DBOS
-from dbos.error import DBOSException
-
-from .context import (
+from . import DBOS
+from ._context import (
     EnterDBOSHandler,
     OperationType,
     SetWorkflowID,
     TracedAttributes,
     assert_current_dbos_context,
 )
-from .request import Address, Request, request_id_header
+from ._error import DBOSException
+from ._request import Address, Request, request_id_header
 
 
-def get_or_generate_request_id(request: FastAPIRequest) -> str:
+def _get_or_generate_request_id(request: FastAPIRequest) -> str:
     request_id = request.headers.get(request_id_header, None)
     if request_id is not None:
         return request_id
@@ -27,7 +26,7 @@ def get_or_generate_request_id(request: FastAPIRequest) -> str:
         return str(uuid.uuid4())
 
 
-def make_request(request: FastAPIRequest) -> Request:
+def _make_request(request: FastAPIRequest) -> Request:
     return Request(
         headers=request.headers,
         path_params=request.path_params,
@@ -40,7 +39,7 @@ def make_request(request: FastAPIRequest) -> Request:
     )
 
 
-async def dbos_error_handler(request: FastAPIRequest, gexc: Exception) -> JSONResponse:
+async def _dbos_error_handler(request: FastAPIRequest, gexc: Exception) -> JSONResponse:
     exc: DBOSException = cast(DBOSException, gexc)
     status_code = 500
     if exc.status_code is not None:
@@ -78,7 +77,7 @@ class LifespanMiddleware:
 def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
 
     app.add_middleware(LifespanMiddleware, dbos=dbos)
-    app.add_exception_handler(DBOSException, dbos_error_handler)
+    app.add_exception_handler(DBOSException, _dbos_error_handler)
 
     @app.middleware("http")
     async def dbos_fastapi_middleware(
@@ -86,7 +85,7 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
     ) -> Any:
         attributes: TracedAttributes = {
             "name": str(request.url.path),
-            "requestID": get_or_generate_request_id(request),
+            "requestID": _get_or_generate_request_id(request),
             "requestIP": request.client.host if request.client is not None else None,
             "requestURL": str(request.url),
             "requestMethod": request.method,
@@ -94,7 +93,7 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
         }
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
-            ctx.request = make_request(request)
+            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key", "")
             with SetWorkflowID(workflow_id):
                 response = await call_next(request)

dbos/{flask.py → _flask.py}

@@ -5,15 +5,14 @@ from urllib.parse import urlparse
 from flask import Flask, request
 from werkzeug.wrappers import Request as WRequest
 
-from dbos.context import (
+from ._context import (
     EnterDBOSHandler,
     OperationType,
     SetWorkflowID,
     TracedAttributes,
     assert_current_dbos_context,
 )
-
-from .request import Address, Request, request_id_header
+from ._request import Address, Request, request_id_header
 
 
 class FlaskMiddleware:
@@ -24,7 +23,7 @@ class FlaskMiddleware:
         request = WRequest(environ)
         attributes: TracedAttributes = {
             "name": urlparse(request.url).path,
-            "requestID": get_or_generate_request_id(request),
+            "requestID": _get_or_generate_request_id(request),
             "requestIP": (
                 request.remote_addr if request.remote_addr is not None else None
             ),
@@ -34,14 +33,14 @@ class FlaskMiddleware:
         }
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
-            ctx.request = make_request(request)
+            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key", "")
             with SetWorkflowID(workflow_id):
                 response = self.app(environ, start_response)
         return response
 
 
-def get_or_generate_request_id(request: WRequest) -> str:
+def _get_or_generate_request_id(request: WRequest) -> str:
     request_id = request.headers.get(request_id_header, None)
     if request_id is not None:
         return request_id
@@ -49,7 +48,7 @@ def get_or_generate_request_id(request: WRequest) -> str:
         return str(uuid.uuid4())
 
 
-def make_request(request: WRequest) -> Request:
+def _make_request(request: WRequest) -> Request:
     parsed_url = urlparse(request.url)
     base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
 

dbos/{kafka.py → _kafka.py}

@@ -3,24 +3,24 @@ from typing import TYPE_CHECKING, Any, Callable, NoReturn
 
 from confluent_kafka import Consumer, KafkaError, KafkaException
 
-from dbos.queue import Queue
+from ._queue import Queue
 
 if TYPE_CHECKING:
-    from dbos.dbos import _DBOSRegistry
+    from ._dbos import DBOSRegistry
 
-from .context import SetWorkflowID
-from .error import DBOSInitializationError
-from .kafka_message import KafkaMessage
-from .logger import dbos_logger
+from ._context import SetWorkflowID
+from ._error import DBOSInitializationError
+from ._kafka_message import KafkaMessage
+from ._logger import dbos_logger
 
-KafkaConsumerWorkflow = Callable[[KafkaMessage], None]
+_KafkaConsumerWorkflow = Callable[[KafkaMessage], None]
 
-kafka_queue: Queue
-in_order_kafka_queues: dict[str, Queue] = {}
+_kafka_queue: Queue
+_in_order_kafka_queues: dict[str, Queue] = {}
 
 
 def _kafka_consumer_loop(
-    func: KafkaConsumerWorkflow,
+    func: _KafkaConsumerWorkflow,
     config: dict[str, Any],
     topics: list[str],
     stop_event: threading.Event,
@@ -76,19 +76,19 @@ def _kafka_consumer_loop(
                 ):
                     if in_order:
                         assert msg.topic is not None
-                        queue = in_order_kafka_queues[msg.topic]
+                        queue = _in_order_kafka_queues[msg.topic]
                         queue.enqueue(func, msg)
                     else:
-                        kafka_queue.enqueue(func, msg)
+                        _kafka_queue.enqueue(func, msg)
 
     finally:
         consumer.close()
 
 
 def kafka_consumer(
-    dbosreg: "_DBOSRegistry", config: dict[str, Any], topics: list[str], in_order: bool
-) -> Callable[[KafkaConsumerWorkflow], KafkaConsumerWorkflow]:
-    def decorator(func: KafkaConsumerWorkflow) -> KafkaConsumerWorkflow:
+    dbosreg: "DBOSRegistry", config: dict[str, Any], topics: list[str], in_order: bool
+) -> Callable[[_KafkaConsumerWorkflow], _KafkaConsumerWorkflow]:
+    def decorator(func: _KafkaConsumerWorkflow) -> _KafkaConsumerWorkflow:
         if in_order:
             for topic in topics:
                 if topic.startswith("^"):
@@ -96,10 +96,10 @@ def kafka_consumer(
                         f"Error: in-order processing is not supported for regular expression topic selectors ({topic})"
                     )
                 queue = Queue(f"_dbos_kafka_queue_topic_{topic}", concurrency=1)
-                in_order_kafka_queues[topic] = queue
+                _in_order_kafka_queues[topic] = queue
         else:
-            global kafka_queue
-            kafka_queue = Queue("_dbos_internal_queue")
+            global _kafka_queue
+            _kafka_queue = Queue("_dbos_internal_queue")
         stop_event = threading.Event()
         dbosreg.register_poller(
             stop_event, _kafka_consumer_loop, func, config, topics, stop_event, in_order

dbos/{logger.py → _logger.py}

@@ -9,10 +9,10 @@ from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.resources import Resource
 
 if TYPE_CHECKING:
-    from dbos.dbos_config import ConfigFile
+    from ._dbos_config import ConfigFile
 
 dbos_logger = logging.getLogger("dbos")
-otlp_handler, otlp_transformer = None, None
+_otlp_handler, _otlp_transformer = None, None
 
 
 class DBOSLogTransformer(logging.Filter):
@@ -74,28 +74,28 @@ def config_logger(config: "ConfigFile") -> None:
                 export_timeout_millis=5000,
             )
         )
-        global otlp_handler
-        otlp_handler = LoggingHandler(logger_provider=log_provider)
+        global _otlp_handler
+        _otlp_handler = LoggingHandler(logger_provider=log_provider)
 
         # Attach DBOS-specific attributes to all log entries.
-        global otlp_transformer
-        otlp_transformer = DBOSLogTransformer()
+        global _otlp_transformer
+        _otlp_transformer = DBOSLogTransformer()
 
         # Direct DBOS logs to OTLP
-        dbos_logger.addHandler(otlp_handler)
-        dbos_logger.addFilter(otlp_transformer)
+        dbos_logger.addHandler(_otlp_handler)
+        dbos_logger.addFilter(_otlp_transformer)
 
 
 def add_otlp_to_all_loggers() -> None:
-    if otlp_handler is not None and otlp_transformer is not None:
+    if _otlp_handler is not None and _otlp_transformer is not None:
         root = logging.root
 
-        root.addHandler(otlp_handler)
-        root.addFilter(otlp_transformer)
+        root.addHandler(_otlp_handler)
+        root.addFilter(_otlp_transformer)
 
         for logger_name in root.manager.loggerDict:
             if logger_name != dbos_logger.name:
                 logger = logging.getLogger(logger_name)
                 if not logger.propagate:
-                    logger.addHandler(otlp_handler)
-                logger.addFilter(otlp_transformer)
+                    logger.addHandler(_otlp_handler)
+                logger.addFilter(_otlp_transformer)

dbos/{queue.py → _queue.py}

@@ -2,10 +2,10 @@ import threading
 import traceback
 from typing import TYPE_CHECKING, Optional, TypedDict
 
-from dbos.core import P, R, _execute_workflow_id, _start_workflow
+from ._core import P, R, execute_workflow_by_id, start_workflow
 
 if TYPE_CHECKING:
-    from dbos.dbos import DBOS, Workflow, WorkflowHandle
+    from ._dbos import DBOS, Workflow, WorkflowHandle
 
 
 class QueueRateLimit(TypedDict):
@@ -37,7 +37,7 @@ class Queue:
         self.name = name
         self.concurrency = concurrency
         self.limiter = limiter
-        from dbos.dbos import _get_or_create_dbos_registry
+        from ._dbos import _get_or_create_dbos_registry
 
         registry = _get_or_create_dbos_registry()
         registry.queue_info_map[self.name] = self
@@ -45,13 +45,13 @@ class Queue:
     def enqueue(
         self, func: "Workflow[P, R]", *args: P.args, **kwargs: P.kwargs
     ) -> "WorkflowHandle[R]":
-        from dbos.dbos import _get_dbos_instance
+        from ._dbos import _get_dbos_instance
 
         dbos = _get_dbos_instance()
-        return _start_workflow(dbos, func, self.name, False, *args, **kwargs)
+        return start_workflow(dbos, func, self.name, False, *args, **kwargs)
 
 
-def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
+def _queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
     while not stop_event.is_set():
         if stop_event.wait(timeout=1):
             return
@@ -59,7 +59,7 @@ def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
             try:
                 wf_ids = dbos._sys_db.start_queued_workflows(queue)
                 for id in wf_ids:
-                    _execute_workflow_id(dbos, id)
+                    execute_workflow_by_id(dbos, id)
             except Exception:
                 dbos.logger.warning(
                     f"Exception encountered in queue thread: {traceback.format_exc()}"