dbos 0.11.0a4__py3-none-any.whl → 0.13.0a0__py3-none-any.whl

dbos/{recovery.py → _recovery.py}

@@ -4,15 +4,15 @@ import time
 import traceback
 from typing import TYPE_CHECKING, Any, List
 
-from dbos.context import SetWorkflowRecovery
-from dbos.core import _execute_workflow_id
-from dbos.error import DBOSWorkflowFunctionNotFoundError
+from ._context import SetWorkflowRecovery
+from ._core import execute_workflow_by_id
+from ._error import DBOSWorkflowFunctionNotFoundError
 
 if TYPE_CHECKING:
-    from dbos.dbos import DBOS, WorkflowHandle
+    from ._dbos import DBOS, WorkflowHandle
 
 
-def _startup_recovery_thread(dbos: "DBOS", workflow_ids: List[str]) -> None:
+def startup_recovery_thread(dbos: "DBOS", workflow_ids: List[str]) -> None:
     """Attempt to recover local pending workflows on startup using a background thread."""
     stop_event = threading.Event()
     dbos.stop_events.append(stop_event)
@@ -20,7 +20,7 @@ def _startup_recovery_thread(dbos: "DBOS", workflow_ids: List[str]) -> None:
         try:
             for workflowID in list(workflow_ids):
                 with SetWorkflowRecovery():
-                    _execute_workflow_id(dbos, workflowID)
+                    execute_workflow_by_id(dbos, workflowID)
                 workflow_ids.remove(workflowID)
         except DBOSWorkflowFunctionNotFoundError:
             time.sleep(1)
@@ -31,7 +31,7 @@ def _startup_recovery_thread(dbos: "DBOS", workflow_ids: List[str]) -> None:
             raise e
 
 
-def _recover_pending_workflows(
+def recover_pending_workflows(
     dbos: "DBOS", executor_ids: List[str] = ["local"]
 ) -> List["WorkflowHandle[Any]"]:
     workflow_handles: List["WorkflowHandle[Any]"] = []
@@ -46,7 +46,7 @@ def _recover_pending_workflows(
 
         for workflowID in workflow_ids:
             with SetWorkflowRecovery():
-                handle = _execute_workflow_id(dbos, workflowID)
+                handle = execute_workflow_by_id(dbos, workflowID)
             workflow_handles.append(handle)
 
     dbos.logger.info("Recovered pending workflows")

dbos/{roles.py → _roles.py}

@@ -1,13 +1,13 @@
 from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, List, Optional, Type, TypeVar, cast
 
-from dbos.error import DBOSNotAuthorizedError
+from ._error import DBOSNotAuthorizedError
 
 if TYPE_CHECKING:
-    from dbos.dbos import _DBOSRegistry
+    from ._dbos import DBOSRegistry
 
-from dbos.context import DBOSAssumeRole, get_local_dbos_context
-from dbos.registrations import (
+from ._context import DBOSAssumeRole, get_local_dbos_context
+from ._registrations import (
     DBOSFuncInfo,
     get_class_info_for_func,
     get_or_create_class_info,
@@ -65,7 +65,7 @@ def required_roles(roles: List[str]) -> Callable[[F], F]:
 
 
 def default_required_roles(
-    dbosreg: "_DBOSRegistry", roles: List[str]
+    dbosreg: "DBOSRegistry", roles: List[str]
 ) -> Callable[[Type[T]], Type[T]]:
     def set_roles(cls: Type[T]) -> Type[T]:
         ci = get_or_create_class_info(cls)

dbos/{scheduler/scheduler.py → _scheduler.py}

@@ -2,14 +2,14 @@ import threading
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Callable
 
-from dbos.logger import dbos_logger
-from dbos.queue import Queue
+from ._logger import dbos_logger
+from ._queue import Queue
 
 if TYPE_CHECKING:
-    from dbos.dbos import _DBOSRegistry
+    from ._dbos import DBOSRegistry
 
-from ..context import SetWorkflowID
-from .croniter import croniter  # type: ignore
+from ._context import SetWorkflowID
+from ._croniter import croniter  # type: ignore
 
 ScheduledWorkflow = Callable[[datetime, datetime], None]
 
@@ -31,13 +31,23 @@ def scheduler_loop(
         if stop_event.wait(timeout=sleepTime.total_seconds()):
             return
         with SetWorkflowID(f"sched-{func.__qualname__}-{nextExecTime.isoformat()}"):
-            scheduler_queue.enqueue(func, nextExecTime, datetime.now(timezone.utc))
+            try:
+                scheduler_queue.enqueue(func, nextExecTime, datetime.now(timezone.utc))
+            except Exception as e:
+                dbos_logger.warning(f"Error scheduling workflow: ", e)
 
 
 def scheduled(
-    dbosreg: "_DBOSRegistry", cron: str
+    dbosreg: "DBOSRegistry", cron: str
 ) -> Callable[[ScheduledWorkflow], ScheduledWorkflow]:
     def decorator(func: ScheduledWorkflow) -> ScheduledWorkflow:
+        try:
+            croniter(cron, datetime.now(timezone.utc), second_at_beginning=True)
+        except Exception as e:
+            raise ValueError(
+                f'Invalid crontab "{cron}" for scheduled function function {func.__name__}.'
+            )
+
         global scheduler_queue
         scheduler_queue = Queue("_dbos_internal_queue")
         stop_event = threading.Event()

dbos/{utils.py → _serialization.py}

@@ -9,14 +9,14 @@ class WorkflowInputs(TypedDict):
     kwargs: Dict[str, Any]
 
 
-def validate_item(data: Any) -> None:
+def _validate_item(data: Any) -> None:
     if isinstance(data, (types.FunctionType, types.MethodType)):
         raise TypeError("Serialized data item should not be a function")
 
 
 def serialize(data: Any) -> str:
     """Serialize an object to a JSON string using jsonpickle."""
-    validate_item(data)
+    _validate_item(data)
     encoded_data: str = jsonpickle.encode(data, unpicklable=True)
     return encoded_data
 
@@ -25,9 +25,9 @@ def serialize_args(data: WorkflowInputs) -> str:
     """Serialize args to a JSON string using jsonpickle."""
     arg: Any
     for arg in data["args"]:
-        validate_item(arg)
+        _validate_item(arg)
     for arg in data["kwargs"].values():
-        validate_item(arg)
+        _validate_item(arg)
     encoded_data: str = jsonpickle.encode(data, unpicklable=True)
     return encoded_data
 

dbos/{system_database.py → _sys_db.py}

@@ -25,20 +25,19 @@ from alembic import command
 from alembic.config import Config
 from sqlalchemy.exc import DBAPIError
 
-import dbos.utils as utils
-from dbos.error import (
+from . import _serialization
+from ._dbos_config import ConfigFile
+from ._error import (
     DBOSDeadLetterQueueError,
     DBOSNonExistentWorkflowError,
     DBOSWorkflowConflictIDError,
 )
-from dbos.registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
-
-from .dbos_config import ConfigFile
-from .logger import dbos_logger
-from .schemas.system_database import SystemSchema
+from ._logger import dbos_logger
+from ._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
+from ._schemas.system_database import SystemSchema
 
 if TYPE_CHECKING:
-    from .queue import Queue
+    from ._queue import Queue
 
 
 class WorkflowStatusString(Enum):
@@ -143,15 +142,15 @@ class WorkflowInformation(TypedDict, total=False):
     # The role used to run this workflow.  Empty string if authorization is not required.
     authenticated_roles: List[str]
     # All roles the authenticated user has, if any.
-    input: Optional[utils.WorkflowInputs]
+    input: Optional[_serialization.WorkflowInputs]
     output: Optional[str]
     error: Optional[str]
     request: Optional[str]
 
 
-dbos_null_topic = "__null__topic__"
-buffer_flush_batch_size = 100
-buffer_flush_interval_secs = 1.0
+_dbos_null_topic = "__null__topic__"
+_buffer_flush_batch_size = 100
+_buffer_flush_interval_secs = 1.0
 
 
 class SystemDatabase:
@@ -200,7 +199,7 @@ class SystemDatabase:
 
         # Run a schema migration for the system database
         migration_dir = os.path.join(
-            os.path.dirname(os.path.realpath(__file__)), "migrations"
+            os.path.dirname(os.path.realpath(__file__)), "_migrations"
         )
         alembic_cfg = Config()
         alembic_cfg.set_main_option("script_location", migration_dir)
@@ -395,7 +394,9 @@ class SystemDatabase:
         res = self.check_operation_execution(calling_wf, calling_wf_fn)
         if res is not None:
             if res["output"]:
-                resstat: WorkflowStatusInternal = utils.deserialize(res["output"])
+                resstat: WorkflowStatusInternal = _serialization.deserialize(
+                    res["output"]
+                )
                 return resstat
             return None
         stat = self.get_workflow_status(workflow_uuid)
@@ -403,7 +404,7 @@ class SystemDatabase:
             {
                 "workflow_uuid": calling_wf,
                 "function_id": calling_wf_fn,
-                "output": utils.serialize(stat),
+                "output": _serialization.serialize(stat),
                 "error": None,
             }
         )
@@ -491,9 +492,9 @@ class SystemDatabase:
             return None
         status: str = stat["status"]
         if status == str(WorkflowStatusString.SUCCESS.value):
-            return utils.deserialize(stat["output"])
+            return _serialization.deserialize(stat["output"])
         elif status == str(WorkflowStatusString.ERROR.value):
-            raise utils.deserialize_exception(stat["error"])
+            raise _serialization.deserialize_exception(stat["error"])
         return None
 
     def get_workflow_info(
@@ -533,7 +534,9 @@ class SystemDatabase:
             self._exported_temp_txn_wf_status.discard(workflow_uuid)
             self._temp_txn_wf_ids.discard(workflow_uuid)
 
-    def get_workflow_inputs(self, workflow_uuid: str) -> Optional[utils.WorkflowInputs]:
+    def get_workflow_inputs(
+        self, workflow_uuid: str
+    ) -> Optional[_serialization.WorkflowInputs]:
         with self.engine.begin() as c:
             row = c.execute(
                 sa.select(SystemSchema.workflow_inputs.c.inputs).where(
@@ -542,7 +545,9 @@ class SystemDatabase:
             ).fetchone()
             if row is None:
                 return None
-            inputs: utils.WorkflowInputs = utils.deserialize_args(row[0])
+            inputs: _serialization.WorkflowInputs = _serialization.deserialize_args(
+                row[0]
+            )
             return inputs
 
     def get_workflows(self, input: GetWorkflowsInput) -> GetWorkflowsOutput:
@@ -651,7 +656,7 @@ class SystemDatabase:
         message: Any,
         topic: Optional[str] = None,
     ) -> None:
-        topic = topic if topic is not None else dbos_null_topic
+        topic = topic if topic is not None else _dbos_null_topic
         with self.engine.begin() as c:
             recorded_output = self.check_operation_execution(
                 workflow_uuid, function_id, conn=c
@@ -671,7 +676,7 @@ class SystemDatabase:
                     pg.insert(SystemSchema.notifications).values(
                         destination_uuid=destination_uuid,
                         topic=topic,
-                        message=utils.serialize(message),
+                        message=_serialization.serialize(message),
                     )
                 )
             except DBAPIError as dbapi_error:
@@ -695,14 +700,14 @@ class SystemDatabase:
         topic: Optional[str],
         timeout_seconds: float = 60,
     ) -> Any:
-        topic = topic if topic is not None else dbos_null_topic
+        topic = topic if topic is not None else _dbos_null_topic
 
         # First, check for previous executions.
         recorded_output = self.check_operation_execution(workflow_uuid, function_id)
         if recorded_output is not None:
             dbos_logger.debug(f"Replaying recv, id: {function_id}, topic: {topic}")
             if recorded_output["output"] is not None:
-                return utils.deserialize(recorded_output["output"])
+                return _serialization.deserialize(recorded_output["output"])
             else:
                 raise Exception("No output recorded in the last recv")
         else:
@@ -768,12 +773,12 @@ class SystemDatabase:
             rows = c.execute(delete_stmt).fetchall()
             message: Any = None
             if len(rows) > 0:
-                message = utils.deserialize(rows[0][0])
+                message = _serialization.deserialize(rows[0][0])
             self.record_operation_result(
                 {
                     "workflow_uuid": workflow_uuid,
                     "function_id": function_id,
-                    "output": utils.serialize(
+                    "output": _serialization.serialize(
                         message
                     ),  # None will be serialized to 'null'
                     "error": None,
@@ -851,7 +856,7 @@ class SystemDatabase:
         if recorded_output is not None:
             dbos_logger.debug(f"Replaying sleep, id: {function_id}, seconds: {seconds}")
             assert recorded_output["output"] is not None, "no recorded end time"
-            end_time = utils.deserialize(recorded_output["output"])
+            end_time = _serialization.deserialize(recorded_output["output"])
         else:
             dbos_logger.debug(f"Running sleep, id: {function_id}, seconds: {seconds}")
             end_time = time.time() + seconds
@@ -860,7 +865,7 @@ class SystemDatabase:
                     {
                         "workflow_uuid": workflow_uuid,
                         "function_id": function_id,
-                        "output": utils.serialize(end_time),
+                        "output": _serialization.serialize(end_time),
                         "error": None,
                     }
                 )
@@ -893,11 +898,11 @@ class SystemDatabase:
                 .values(
                     workflow_uuid=workflow_uuid,
                     key=key,
-                    value=utils.serialize(message),
+                    value=_serialization.serialize(message),
                 )
                 .on_conflict_do_update(
                     index_elements=["workflow_uuid", "key"],
-                    set_={"value": utils.serialize(message)},
+                    set_={"value": _serialization.serialize(message)},
                 )
             )
             output: OperationResultInternal = {
@@ -931,7 +936,7 @@ class SystemDatabase:
                     f"Replaying get_event, id: {caller_ctx['function_id']}, key: {key}"
                 )
                 if recorded_output["output"] is not None:
-                    return utils.deserialize(recorded_output["output"])
+                    return _serialization.deserialize(recorded_output["output"])
                 else:
                     raise Exception("No output recorded in the last get_event")
             else:
@@ -951,7 +956,7 @@ class SystemDatabase:
 
         value: Any = None
         if len(init_recv) > 0:
-            value = utils.deserialize(init_recv[0][0])
+            value = _serialization.deserialize(init_recv[0][0])
         else:
             # Wait for the notification
             actual_timeout = timeout_seconds
@@ -969,7 +974,7 @@ class SystemDatabase:
             with self.engine.begin() as c:
                 final_recv = c.execute(get_sql).fetchall()
                 if len(final_recv) > 0:
-                    value = utils.deserialize(final_recv[0][0])
+                    value = _serialization.deserialize(final_recv[0][0])
         condition.release()
         self.workflow_events_map.pop(payload)
 
@@ -979,7 +984,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": caller_ctx["workflow_uuid"],
                     "function_id": caller_ctx["function_id"],
-                    "output": utils.serialize(
+                    "output": _serialization.serialize(
                         value
                     ),  # None will be serialized to 'null'
                     "error": None,
@@ -999,7 +1004,7 @@ class SystemDatabase:
             status_iter = iter(list(self._workflow_status_buffer))
             wf_id: Optional[str] = None
             while (
-                exported < buffer_flush_batch_size
+                exported < _buffer_flush_batch_size
                 and (wf_id := next(status_iter, None)) is not None
             ):
                 # Pop the first key in the buffer (FIFO)
@@ -1029,7 +1034,7 @@ class SystemDatabase:
             input_iter = iter(list(self._workflow_inputs_buffer))
             wf_id: Optional[str] = None
             while (
-                exported < buffer_flush_batch_size
+                exported < _buffer_flush_batch_size
                 and (wf_id := next(input_iter, None)) is not None
             ):
                 if wf_id not in self._exported_temp_txn_wf_status:
@@ -1060,10 +1065,10 @@ class SystemDatabase:
                 self._is_flushing_status_buffer = False
                 if self._is_buffers_empty:
                     # Only sleep if both buffers are empty
-                    time.sleep(buffer_flush_interval_secs)
+                    time.sleep(_buffer_flush_interval_secs)
             except Exception as e:
                 dbos_logger.error(f"Error while flushing buffers: {e}")
-                time.sleep(buffer_flush_interval_secs)
+                time.sleep(_buffer_flush_interval_secs)
                 # Will retry next time
 
     def buffer_workflow_status(self, status: WorkflowStatusInternal) -> None:

dbos/{tracer.py → _tracer.py}

@@ -7,10 +7,10 @@ from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
 from opentelemetry.trace import Span
 
-from dbos.dbos_config import ConfigFile
+from ._dbos_config import ConfigFile
 
 if TYPE_CHECKING:
-    from .context import TracedAttributes
+    from ._context import TracedAttributes
 
 
 class DBOSTracer:

dbos/cli.py

@@ -15,15 +15,15 @@ from rich import print
 from rich.prompt import Prompt
 from typing_extensions import Annotated
 
-from dbos import load_config
-from dbos.application_database import ApplicationDatabase
-from dbos.dbos_config import is_valid_app_name
-from dbos.system_database import SystemDatabase
+from . import load_config
+from ._app_db import ApplicationDatabase
+from ._dbos_config import _is_valid_app_name
+from ._sys_db import SystemDatabase
 
 app = typer.Typer()
 
 
-def on_windows() -> bool:
+def _on_windows() -> bool:
     return platform.system() == "Windows"
 
 
@@ -41,7 +41,7 @@ def start() -> None:
             command,
             shell=True,
             text=True,
-            preexec_fn=os.setsid if not on_windows() else None,
+            preexec_fn=os.setsid if not _on_windows() else None,
         )
 
         def signal_handler(signum: int, frame: Any) -> None:
@@ -70,20 +70,20 @@ def start() -> None:
 
         # Configure the single handler only on Unix-like systems.
         # TODO: Also kill the children on Windows.
-        if not on_windows():
+        if not _on_windows():
             signal.signal(signal.SIGINT, signal_handler)
             signal.signal(signal.SIGTERM, signal_handler)
         process.wait()
 
 
-def get_templates_directory() -> str:
+def _get_templates_directory() -> str:
     import dbos
 
     package_dir = path.abspath(path.dirname(dbos.__file__))
-    return path.join(package_dir, "templates")
+    return path.join(package_dir, "_templates")
 
 
-def copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
+def _copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
     with open(src, "r") as f:
         content = f.read()
 
@@ -94,7 +94,7 @@ def copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
         f.write(content)
 
 
-def copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
+def _copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
 
     for root, dirs, files in os.walk(src_dir, topdown=True):
         dirs[:] = [d for d in dirs if d != "__package"]
@@ -116,12 +116,12 @@ def copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
                 continue
 
             if ext == ".dbos":
-                copy_dbos_template(src, dst, ctx)
+                _copy_dbos_template(src, dst, ctx)
             else:
                 shutil.copy(src, dst)
 
 
-def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
+def _copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
 
     dst_dir = path.abspath(".")
 
@@ -135,19 +135,19 @@ def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
     if config_mode:
         ctx["package_name"] = "."
         ctx["migration_command"] = "echo 'No migrations specified'"
-        copy_dbos_template(
+        _copy_dbos_template(
             os.path.join(src_dir, "dbos-config.yaml.dbos"),
             os.path.join(dst_dir, "dbos-config.yaml"),
             ctx,
         )
     else:
-        copy_template_dir(src_dir, dst_dir, ctx)
-        copy_template_dir(
+        _copy_template_dir(src_dir, dst_dir, ctx)
+        _copy_template_dir(
             path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
         )
 
 
-def get_project_name() -> typing.Union[str, None]:
+def _get_project_name() -> typing.Union[str, None]:
     name = None
     try:
         with open("pyproject.toml", "rb") as file:
@@ -183,13 +183,13 @@ def init(
     try:
         if project_name is None:
             project_name = typing.cast(
-                str, typer.prompt("What is your project's name?", get_project_name())
+                str, typer.prompt("What is your project's name?", _get_project_name())
             )
 
-        if not is_valid_app_name(project_name):
+        if not _is_valid_app_name(project_name):
             raise Exception(f"{project_name} is an invalid DBOS app name")
 
-        templates_dir = get_templates_directory()
+        templates_dir = _get_templates_directory()
         templates = [x.name for x in os.scandir(templates_dir) if x.is_dir()]
         if len(templates) == 0:
             raise Exception(f"no DBOS templates found in {templates_dir} ")
@@ -205,7 +205,7 @@ def init(
             if template not in templates:
                 raise Exception(f"template {template} not found in {templates_dir}")
 
-        copy_template(
+        _copy_template(
             path.join(templates_dir, template), project_name, config_mode=config
         )
     except Exception as e:

{dbos-0.11.0a4.dist-info → dbos-0.13.0a0.dist-info}/METADATA

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

dbos-0.13.0a0.dist-info/RECORD

@@ -0,0 +1,54 @@
+dbos-0.13.0a0.dist-info/METADATA,sha256=8apeZFcAMPz_gwgZNdZliGTyxwVEejmZziEnfD7I7pM,5017
+dbos-0.13.0a0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.13.0a0.dist-info/entry_points.txt,sha256=z6GcVANQV7Uw_82H9Ob2axJX6V3imftyZsljdh-M1HU,54
+dbos-0.13.0a0.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=CxRHBHEthPL4PZoLbZhp3rdm44-KkRTT2-7DkK9d4QQ,724
+dbos/_admin_sever.py,sha256=hnWAILD5hqm_CWUJ6q1pR_kVNFbpymR3licYnviPYUQ,3799
+dbos/_app_db.py,sha256=_tv2vmPjjiaikwgxH3mqxgJ4nUUcG2-0uMXKWCqVu1c,5509
+dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
+dbos/_context.py,sha256=SJZTOB-saxCNNGT2LLop9LasqR-X2MQLTay3rjXRUCw,17748
+dbos/_core.py,sha256=HUteo2HP9C4UvB-y41xwUphLZyYRTdb0sW5XqZ6QPAY,31167
+dbos/_croniter.py,sha256=hbhgfsHBqclUS8VeLnJ9PSE9Z54z6mi4nnrr1aUXn0k,47561
+dbos/_dbos.py,sha256=Or5z_PLwuUOz2wcI4PrBwAQYv7EarGpRU44WbvSU9pw,30986
+dbos/_dbos_config.py,sha256=vUm3_1zMcbp-0D14wwJyt37sGiQP6yTIhxaTkRSnvFA,6362
+dbos/_error.py,sha256=UETk8CoZL-TO2Utn1-E7OSWelhShWmKM-fOlODMR9PE,3893
+dbos/_fastapi.py,sha256=iyefCZq-ZDKRUjN_rgYQmFmyvWf4gPrSlC6CLbfq4a8,3419
+dbos/_flask.py,sha256=z1cijbTi5Dpq6kqikPCx1LcR2YHHv2oc41NehOWjw74,2431
+dbos/_kafka.py,sha256=OmOKfO7_3Z2FUFv_sJaIfebd7xnqtuRRndzNTTufgb8,3654
+dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
+dbos/_logger.py,sha256=iYwbA7DLyXalWa2Yu07HO6Xm301nRuenMU64GgwUMkU,3576
+dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
+dbos/_migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+dbos/_migrations/versions/50f3227f0b4b_fix_job_queue.py,sha256=ZBYrtTdxy64HxIAlOes89fVIk2P1gNaJack7wuC_epg,873
+dbos/_migrations/versions/5c361fc04708_added_system_tables.py,sha256=QMgFMb0aLgC25YicsvPSr6AHRCA6Zd66hyaRUhwKzrQ,6404
+dbos/_migrations/versions/a3b18ad34abe_added_triggers.py,sha256=Rv0ZsZYZ_WdgGEULYsPfnp4YzaO5L198gDTgYY39AVA,2022
+dbos/_migrations/versions/d76646551a6b_job_queue_limiter.py,sha256=8PyFi8rd6CN-mUro43wGhsg5wcQWKZPRHD6jw8R5pVc,986
+dbos/_migrations/versions/d76646551a6c_workflow_queue.py,sha256=G942nophZ2uC2vc4hGBC02Ptng1715roTjY3xiyzZU4,729
+dbos/_migrations/versions/eab0cc1d9a14_job_queue.py,sha256=uvhFOtqbBreCePhAxZfIT0qCAI7BiZTou9wt6QnbY7c,1412
+dbos/_queue.py,sha256=hAXwrfBmtv6BGrlmFq-Ol6b_ED-HDaYqSSxumMJC6Xo,1938
+dbos/_recovery.py,sha256=jbzGYxICA2drzyzlBSy2UiXhKV_16tBVacKQdTkqf-w,2008
+dbos/_registrations.py,sha256=mei6q6_3R5uei8i_Wo_TqGZs85s10shOekDX41sFYD0,6642
+dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
+dbos/_roles.py,sha256=iOsgmIAf1XVzxs3gYWdGRe1B880YfOw5fpU7Jwx8_A8,2271
+dbos/_scheduler.py,sha256=0I3e8Y-OIBG3wiUCIskShd-Sk_eUFCFyRB5u4L7IHXI,1940
+dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbos/_schemas/application_database.py,sha256=KeyoPrF7hy_ODXV7QNike_VFSD74QBRfQ76D7QyE9HI,966
+dbos/_schemas/system_database.py,sha256=7iw7eHJzEvkatHMOaHORoSvtfisF73wW5j8hRt_Ph14,5126
+dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
+dbos/_sys_db.py,sha256=8bPWjrKM7MZSuxbGmC1M9yshG2LqymyedOXUtZedYX8,48538
+dbos/_templates/hello/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
+dbos/_templates/hello/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbos/_templates/hello/__package/main.py,sha256=eI0SS9Nwj-fldtiuSzIlIG6dC91GXXwdRsoHxv6S_WI,2719
+dbos/_templates/hello/__package/schema.py,sha256=7Z27JGC8yy7Z44cbVXIREYxtUhU4JVkLCp5Q7UahVQ0,260
+dbos/_templates/hello/alembic.ini,sha256=VKBn4Gy8mMuCdY7Hip1jmo3wEUJ1VG1aW7EqY0_n-as,3695
+dbos/_templates/hello/dbos-config.yaml.dbos,sha256=7yu1q8FAgOZnwJtU-e_5qgV-wkHRn6cqo-GEmk9rK8U,577
+dbos/_templates/hello/migrations/env.py.dbos,sha256=GUV6sjkDzf9Vl6wkGEd0RSkK-ftRfV6EUwSQdd0qFXg,2392
+dbos/_templates/hello/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+dbos/_templates/hello/migrations/versions/2024_07_31_180642_init.py,sha256=U5thFWGqNN4QLrNXT7wUUqftIFDNE5eSdqD8JNW1mec,942
+dbos/_templates/hello/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
+dbos/_tracer.py,sha256=rvBY1RQU6DO7rL7EnaJJxGcmd4tP_PpGqUEE6imZnhY,2518
+dbos/cli.py,sha256=Ks1jzP0tWju5jIwbLfrJpLXmk5gkU3v18FLJiNi5p8Q,8304
+dbos/dbos-config.schema.json,sha256=tgtiirOTEdIRI27eI75UAER9sAV84CDnv5lRPt0qiuQ,5672
+dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
+version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
+dbos-0.13.0a0.dist-info/RECORD,,

{dbos-0.11.0a4.dist-info → dbos-0.13.0a0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.2)
+Generator: pdm-backend (2.4.3)
 Root-Is-Purelib: true
 Tag: py3-none-any