dbos 0.19.0a9__py3-none-any.whl → 0.20.0a3__py3-none-any.whl

dbos/_admin_server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 import threading
 from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
@@ -15,6 +16,9 @@ if TYPE_CHECKING:
 _health_check_path = "/dbos-healthz"
 _workflow_recovery_path = "/dbos-workflow-recovery"
 _deactivate_path = "/deactivate"
+# /workflows/:workflow_id/cancel
+# /workflows/:workflow_id/resume
+# /workflows/:workflow_id/restart
 
 
 class AdminServer:
@@ -79,12 +83,51 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
             self.wfile.write(json.dumps(workflow_ids).encode("utf-8"))
         else:
-            self.send_response(404)
-            self._end_headers()
+
+            restart_match = re.match(
+                r"^/workflows/(?P<workflow_id>[^/]+)/restart$", self.path
+            )
+            resume_match = re.match(
+                r"^/workflows/(?P<workflow_id>[^/]+)/resume$", self.path
+            )
+            cancel_match = re.match(
+                r"^/workflows/(?P<workflow_id>[^/]+)/cancel$", self.path
+            )
+
+            if restart_match:
+                workflow_id = restart_match.group("workflow_id")
+                self._handle_restart(workflow_id)
+            elif resume_match:
+                workflow_id = resume_match.group("workflow_id")
+                self._handle_resume(workflow_id)
+            elif cancel_match:
+                workflow_id = cancel_match.group("workflow_id")
+                self._handle_cancel(workflow_id)
+            else:
+                self.send_response(404)
+                self._end_headers()
 
     def log_message(self, format: str, *args: Any) -> None:
         return  # Disable admin server request logging
 
+    def _handle_restart(self, workflow_id: str) -> None:
+        self.dbos.restart_workflow(workflow_id)
+        print("Restarting workflow", workflow_id)
+        self.send_response(204)
+        self._end_headers()
+
+    def _handle_resume(self, workflow_id: str) -> None:
+        print("Resuming workflow", workflow_id)
+        self.dbos.resume_workflow(workflow_id)
+        self.send_response(204)
+        self._end_headers()
+
+    def _handle_cancel(self, workflow_id: str) -> None:
+        print("Cancelling workflow", workflow_id)
+        self.dbos.cancel_workflow(workflow_id)
+        self.send_response(204)
+        self._end_headers()
+
 
 # Be consistent with DBOS-TS response.
 class PerfUtilization(TypedDict):

dbos/_core.py

@@ -266,7 +266,9 @@ def _execute_workflow_wthread(
                 raise
 
 
-def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[Any]":
+def execute_workflow_by_id(
+    dbos: "DBOS", workflow_id: str, startNew: bool = False
+) -> "WorkflowHandle[Any]":
     status = dbos._sys_db.get_workflow_status(workflow_id)
     if not status:
         raise DBOSRecoveryError(workflow_id, "Workflow status not found")
@@ -293,7 +295,8 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
                     workflow_id,
                     f"Cannot execute workflow because instance '{iname}' is not registered",
                 )
-            with SetWorkflowID(workflow_id):
+
+            if startNew:
                 return start_workflow(
                     dbos,
                     wf_func,
@@ -303,6 +306,17 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
                     *inputs["args"],
                     **inputs["kwargs"],
                 )
+            else:
+                with SetWorkflowID(workflow_id):
+                    return start_workflow(
+                        dbos,
+                        wf_func,
+                        status["queue_name"],
+                        True,
+                        dbos._registry.instance_info_map[iname],
+                        *inputs["args"],
+                        **inputs["kwargs"],
+                    )
         elif status["class_name"] is not None:
             class_name = status["class_name"]
             if class_name not in dbos._registry.class_info_map:
@@ -310,7 +324,8 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
                     workflow_id,
                     f"Cannot execute workflow because class '{class_name}' is not registered",
                 )
-            with SetWorkflowID(workflow_id):
+
+            if startNew:
                 return start_workflow(
                     dbos,
                     wf_func,
@@ -320,8 +335,19 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
                     *inputs["args"],
                     **inputs["kwargs"],
                 )
+            else:
+                with SetWorkflowID(workflow_id):
+                    return start_workflow(
+                        dbos,
+                        wf_func,
+                        status["queue_name"],
+                        True,
+                        dbos._registry.class_info_map[class_name],
+                        *inputs["args"],
+                        **inputs["kwargs"],
+                    )
         else:
-            with SetWorkflowID(workflow_id):
+            if startNew:
                 return start_workflow(
                     dbos,
                     wf_func,
@@ -330,6 +356,16 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
                     *inputs["args"],
                     **inputs["kwargs"],
                 )
+            else:
+                with SetWorkflowID(workflow_id):
+                    return start_workflow(
+                        dbos,
+                        wf_func,
+                        status["queue_name"],
+                        True,
+                        *inputs["args"],
+                        **inputs["kwargs"],
+                    )
 
 
 @overload

dbos/_dbos.py

@@ -56,6 +56,7 @@ from ._registrations import (
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
+from ._sys_db import WorkflowStatusString
 from ._tracer import dbos_tracer
 
 if TYPE_CHECKING:
@@ -231,6 +232,7 @@ class DBOS:
                         f"DBOS configured multiple times with conflicting information"
                     )
                 config = _dbos_global_registry.config
+
             _dbos_global_instance = super().__new__(cls)
             _dbos_global_instance.__init__(fastapi=fastapi, config=config, flask=flask)  # type: ignore
         else:
@@ -767,6 +769,11 @@ class DBOS:
         """Execute a workflow by ID (for recovery)."""
         return execute_workflow_by_id(_get_dbos_instance(), workflow_id)
 
+    @classmethod
+    def restart_workflow(cls, workflow_id: str) -> None:
+        """Execute a workflow by ID (for recovery)."""
+        execute_workflow_by_id(_get_dbos_instance(), workflow_id, True)
+
     @classmethod
     def recover_pending_workflows(
         cls, executor_ids: List[str] = ["local"]
@@ -774,6 +781,18 @@ class DBOS:
         """Find all PENDING workflows and execute them."""
         return recover_pending_workflows(_get_dbos_instance(), executor_ids)
 
+    @classmethod
+    def cancel_workflow(cls, workflow_id: str) -> None:
+        """Cancel a workflow by ID."""
+        _get_dbos_instance()._sys_db.set_workflow_status(
+            workflow_id, WorkflowStatusString.CANCELLED, False
+        )
+
+    @classmethod
+    def resume_workflow(cls, workflow_id: str) -> None:
+        """Resume a workflow by ID."""
+        execute_workflow_by_id(_get_dbos_instance(), workflow_id, False)
+
     @classproperty
     def logger(cls) -> Logger:
         """Return the DBOS `Logger` for the current context."""

dbos/_fastapi.py

@@ -94,7 +94,11 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
             ctx.request = _make_request(request)
-            workflow_id = request.headers.get("dbos-idempotency-key", "")
-            with SetWorkflowID(workflow_id):
+            workflow_id = request.headers.get("dbos-idempotency-key")
+            if workflow_id is not None:
+                # Set the workflow ID for the handler
+                with SetWorkflowID(workflow_id):
+                    response = await call_next(request)
+            else:
                 response = await call_next(request)
         return response

dbos/_flask.py

@@ -34,8 +34,12 @@ class FlaskMiddleware:
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
             ctx.request = _make_request(request)
-            workflow_id = request.headers.get("dbos-idempotency-key", "")
-            with SetWorkflowID(workflow_id):
+            workflow_id = request.headers.get("dbos-idempotency-key")
+            if workflow_id is not None:
+                # Set the workflow ID for the handler
+                with SetWorkflowID(workflow_id):
+                    response = self.app(environ, start_response)
+            else:
                 response = self.app(environ, start_response)
         return response
 

dbos/_workflow_commands.py

@@ -1,3 +1,6 @@
+import importlib
+import os
+import sys
 from typing import Any, List, Optional, cast
 
 import typer
@@ -6,6 +9,7 @@ from rich import print
 from dbos import DBOS
 
 from . import _serialization, load_config
+from ._core import execute_workflow_by_id
 from ._dbos_config import ConfigFile, _is_valid_app_name
 from ._sys_db import (
     GetWorkflowsInput,
@@ -123,11 +127,6 @@ def _cancel_workflow(config: ConfigFile, uuid: str) -> None:
             sys_db.destroy()
 
 
-def _reattempt_workflow(uuid: str, startNewWorkflow: bool) -> None:
-    print(f"Reattempt workflow info for {uuid} not implemented")
-    return
-
-
 def _get_workflow_info(
     sys_db: SystemDatabase, workflowUUID: str, getRequest: bool
 ) -> Optional[WorkflowInformation]:

dbos/cli/_github_init.py

@@ -0,0 +1,107 @@
+import os
+from base64 import b64decode
+from typing import List, TypedDict
+
+import requests
+
+DEMO_REPO_API = "https://api.github.com/repos/dbos-inc/dbos-demo-apps"
+PY_DEMO_PATH = "python/"
+BRANCH = "main"
+
+
+class GitHubTreeItem(TypedDict):
+    path: str
+    mode: str
+    type: str
+    sha: str
+    url: str
+    size: int
+
+
+class GitHubTree(TypedDict):
+    sha: str
+    url: str
+    tree: List[GitHubTreeItem]
+    truncated: bool
+
+
+class GitHubItem(TypedDict):
+    sha: str
+    node_id: str
+    url: str
+    content: str
+    encoding: str
+    size: int
+
+
+def _fetch_github(url: str) -> requests.Response:
+    headers = {}
+    github_token = os.getenv("GITHUB_TOKEN")
+    if github_token:
+        headers["Authorization"] = f"Bearer {github_token}"
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        if response.headers.get("x-ratelimit-remaining") == "0":
+            raise Exception(
+                "Error fetching from GitHub API: rate limit exceeded.\n"
+                "Please wait a few minutes and try again.\n"
+                "To increase the limit, you can create a personal access token and set it in the GITHUB_TOKEN environment variable.\n"
+                "Details: https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api"
+            )
+        elif response.status_code == 401:
+            raise Exception(
+                f"Error fetching content from GitHub {url}: {response.status_code} {response.reason}.\n"
+                "Please ensure your GITHUB_TOKEN environment variable is set to a valid personal access token."
+            )
+        raise Exception(
+            f"Error fetching content from GitHub {url}: {response.status_code} {response.reason}"
+        )
+
+    return response
+
+
+def _fetch_github_tree(tag: str) -> List[GitHubTreeItem]:
+    response = _fetch_github(f"{DEMO_REPO_API}/git/trees/{tag}?recursive=1")
+    tree_data: GitHubTree = response.json()
+    return tree_data["tree"]
+
+
+def _fetch_github_item(url: str) -> str:
+    response = _fetch_github(url)
+    item: GitHubItem = response.json()
+    return b64decode(item["content"]).decode("utf-8")
+
+
+def create_template_from_github(app_name: str, template_name: str) -> None:
+    print(
+        f"Creating a new application named {app_name} from the template {template_name}"
+    )
+
+    tree = _fetch_github_tree(BRANCH)
+    template_path = f"{PY_DEMO_PATH}{template_name}/"
+
+    files_to_download = [
+        item
+        for item in tree
+        if item["path"].startswith(template_path) and item["type"] == "blob"
+    ]
+
+    # Download every file from the template
+    for item in files_to_download:
+        raw_content = _fetch_github_item(item["url"])
+        file_path = item["path"].replace(template_path, "")
+        target_path = os.path.join(".", file_path)
+
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+
+        # Write file with proper permissions
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(raw_content)
+        os.chmod(target_path, int(item["mode"], 8))
+
+    print(
+        f"Downloaded {len(files_to_download)} files from the template GitHub repository"
+    )

dbos/cli/_template_init.py

@@ -0,0 +1,98 @@
+import os
+import shutil
+import typing
+from os import path
+from typing import Any
+
+import tomlkit
+from rich import print
+
+
+def get_templates_directory() -> str:
+    import dbos
+
+    package_dir = path.abspath(path.dirname(dbos.__file__))
+    return path.join(package_dir, "_templates")
+
+
+def _copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
+    with open(src, "r") as f:
+        content = f.read()
+
+    for key, value in ctx.items():
+        content = content.replace(f"${{{key}}}", value)
+
+    with open(dst, "w") as f:
+        f.write(content)
+
+
+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"]
+
+        dst_root = path.join(dst_dir, path.relpath(root, src_dir))
+        if len(dirs) == 0:
+            os.makedirs(dst_root, exist_ok=True)
+        else:
+            for dir in dirs:
+                os.makedirs(path.join(dst_root, dir), exist_ok=True)
+
+        for file in files:
+            src = path.join(root, file)
+            base, ext = path.splitext(file)
+
+            dst = path.join(dst_root, base if ext == ".dbos" else file)
+            if path.exists(dst):
+                print(f"[yellow]File {dst} already exists, skipping[/yellow]")
+                continue
+
+            if ext == ".dbos":
+                _copy_dbos_template(src, dst, ctx)
+            else:
+                shutil.copy(src, dst)
+
+
+def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
+
+    dst_dir = path.abspath(".")
+
+    package_name = project_name.replace("-", "_")
+    ctx = {
+        "project_name": project_name,
+        "package_name": package_name,
+        "migration_command": "alembic upgrade head",
+    }
+
+    if config_mode:
+        ctx["package_name"] = "."
+        ctx["migration_command"] = "echo 'No migrations specified'"
+        _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(
+            path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
+        )
+
+
+def get_project_name() -> typing.Union[str, None]:
+    name = None
+    try:
+        with open("pyproject.toml", "rb") as file:
+            pyproj = typing.cast(dict[str, Any], tomlkit.load(file))
+            name = typing.cast(str, pyproj["project"]["name"])
+    except:
+        pass
+
+    if name == None:
+        try:
+            _, parent = path.split(path.abspath("."))
+            name = parent
+        except:
+            pass
+
+    return name

dbos/{cli.py → cli/cli.py}

@@ -1,6 +1,5 @@
 import os
 import platform
-import shutil
 import signal
 import subprocess
 import time
@@ -9,25 +8,21 @@ from os import path
 from typing import Any
 
 import jsonpickle  # type: ignore
+import requests
 import sqlalchemy as sa
-import tomlkit
 import typer
 from rich import print
-from rich.prompt import Prompt
+from rich.prompt import IntPrompt
 from typing_extensions import Annotated
 
-from dbos._schemas.system_database import SystemSchema
-
-from . import _serialization, load_config
-from ._app_db import ApplicationDatabase
-from ._dbos_config import _is_valid_app_name
-from ._sys_db import SystemDatabase
-from ._workflow_commands import (
-    _cancel_workflow,
-    _get_workflow,
-    _list_workflows,
-    _reattempt_workflow,
-)
+from .. import load_config
+from .._app_db import ApplicationDatabase
+from .._dbos_config import _is_valid_app_name
+from .._schemas.system_database import SystemSchema
+from .._sys_db import SystemDatabase
+from .._workflow_commands import _cancel_workflow, _get_workflow, _list_workflows
+from ..cli._github_init import create_template_from_github
+from ._template_init import copy_template, get_project_name, get_templates_directory
 
 app = typer.Typer()
 workflow = typer.Typer()
@@ -90,96 +85,6 @@ def start() -> None:
         process.wait()
 
 
-def _get_templates_directory() -> str:
-    import dbos
-
-    package_dir = path.abspath(path.dirname(dbos.__file__))
-    return path.join(package_dir, "_templates")
-
-
-def _copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
-    with open(src, "r") as f:
-        content = f.read()
-
-    for key, value in ctx.items():
-        content = content.replace(f"${{{key}}}", value)
-
-    with open(dst, "w") as f:
-        f.write(content)
-
-
-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"]
-
-        dst_root = path.join(dst_dir, path.relpath(root, src_dir))
-        if len(dirs) == 0:
-            os.makedirs(dst_root, exist_ok=True)
-        else:
-            for dir in dirs:
-                os.makedirs(path.join(dst_root, dir), exist_ok=True)
-
-        for file in files:
-            src = path.join(root, file)
-            base, ext = path.splitext(file)
-
-            dst = path.join(dst_root, base if ext == ".dbos" else file)
-            if path.exists(dst):
-                print(f"[yellow]File {dst} already exists, skipping[/yellow]")
-                continue
-
-            if ext == ".dbos":
-                _copy_dbos_template(src, dst, ctx)
-            else:
-                shutil.copy(src, dst)
-
-
-def _copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
-
-    dst_dir = path.abspath(".")
-
-    package_name = project_name.replace("-", "_")
-    ctx = {
-        "project_name": project_name,
-        "package_name": package_name,
-        "migration_command": "alembic upgrade head",
-    }
-
-    if config_mode:
-        ctx["package_name"] = "."
-        ctx["migration_command"] = "echo 'No migrations specified'"
-        _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(
-            path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
-        )
-
-
-def _get_project_name() -> typing.Union[str, None]:
-    name = None
-    try:
-        with open("pyproject.toml", "rb") as file:
-            pyproj = typing.cast(dict[str, Any], tomlkit.load(file))
-            name = typing.cast(str, pyproj["project"]["name"])
-    except:
-        pass
-
-    if name == None:
-        try:
-            _, parent = path.split(path.abspath("."))
-            name = parent
-        except:
-            pass
-
-    return name
-
-
 @app.command(help="Initialize a new DBOS application from a template")
 def init(
     project_name: Annotated[
@@ -195,35 +100,60 @@ def init(
     ] = False,
 ) -> None:
     try:
-        if project_name is None:
-            project_name = typing.cast(
-                str, typer.prompt("What is your project's name?", _get_project_name())
-            )
+        git_templates = ["dbos-app-starter", "dbos-cron-starter"]
+        templates_dir = get_templates_directory()
+        templates = git_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} ")
+
+        if template:
+            if template not in templates:
+                raise Exception(f"Template {template} not found in {templates_dir}")
+        else:
+            print("\n[bold]Available templates:[/bold]")
+            for idx, template_name in enumerate(templates, 1):
+                print(f"  {idx}. {template_name}")
+            while True:
+                try:
+                    choice = IntPrompt.ask(
+                        "\nSelect template number",
+                        show_choices=False,
+                        show_default=False,
+                    )
+                    if 1 <= choice <= len(templates):
+                        template = templates[choice - 1]
+                        break
+                    else:
+                        print(
+                            "[red]Invalid selection. Please choose a number from the list.[/red]"
+                        )
+                except (KeyboardInterrupt, EOFError):
+                    raise typer.Abort()
+                except ValueError:
+                    print("[red]Please enter a valid number.[/red]")
+
+        if template in git_templates:
+            project_name = template
+        else:
+            if project_name is None:
+                project_name = typing.cast(
+                    str,
+                    typer.prompt("What is your project's name?", get_project_name()),
+                )
 
         if not _is_valid_app_name(project_name):
             raise Exception(
                 f"{project_name} is an invalid DBOS app name. App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores."
             )
 
-        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} ")
-
-        if template == None:
-            if len(templates) == 1:
-                template = templates[0]
-            else:
-                template = Prompt.ask(
-                    "Which project template do you want to use?", choices=templates
-                )
+        if template in git_templates:
+            create_template_from_github(app_name=project_name, template_name=template)
         else:
-            if template not in templates:
-                raise Exception(f"template {template} not found in {templates_dir}")
-
-        _copy_template(
-            path.join(templates_dir, template), project_name, config_mode=config
-        )
+            copy_template(
+                path.join(templates_dir, template), project_name, config_mode=config
+            )
     except Exception as e:
         print(f"[red]{e}[/red]")
 
@@ -432,5 +362,49 @@ def cancel(
     print(f"Workflow {uuid} has been cancelled")
 
 
+@workflow.command(help="Resume a workflow that has been cancelled")
+def resume(
+    uuid: Annotated[str, typer.Argument()],
+    host: Annotated[
+        typing.Optional[str],
+        typer.Option("--host", "-h", help="Specify the admin host"),
+    ] = "localhost",
+    port: Annotated[
+        typing.Optional[int],
+        typer.Option("--port", "-p", help="Specify the admin port"),
+    ] = 3001,
+) -> None:
+    response = requests.post(
+        f"http://{host}:{port}/workflows/{uuid}/resume", json=[], timeout=5
+    )
+
+    if response.status_code == 200:
+        print(f"Workflow {uuid} has been resumed")
+    else:
+        print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
+
+
+@workflow.command(help="Restart a workflow from the beginning with a new id")
+def restart(
+    uuid: Annotated[str, typer.Argument()],
+    host: Annotated[
+        typing.Optional[str],
+        typer.Option("--host", "-h", help="Specify the admin host"),
+    ] = "localhost",
+    port: Annotated[
+        typing.Optional[int],
+        typer.Option("--port", "-p", help="Specify the admin port"),
+    ] = 3001,
+) -> None:
+    response = requests.post(
+        f"http://{host}:{port}/workflows/{uuid}/restart", json=[], timeout=5
+    )
+
+    if response.status_code == 200:
+        print(f"Workflow {uuid} has been restarted")
+    else:
+        print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
+
+
 if __name__ == "__main__":
     app()

{dbos-0.19.0a9.dist-info → dbos-0.20.0a3.dist-info}/METADATA

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

{dbos-0.19.0a9.dist-info → dbos-0.20.0a3.dist-info}/RECORD

@@ -1,23 +1,23 @@
-dbos-0.19.0a9.dist-info/METADATA,sha256=5CSu4x-YJTciUZxrw786SNQb6SxB0aM7If4BlrwgG0U,5309
-dbos-0.19.0a9.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.19.0a9.dist-info/entry_points.txt,sha256=z6GcVANQV7Uw_82H9Ob2axJX6V3imftyZsljdh-M1HU,54
-dbos-0.19.0a9.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.20.0a3.dist-info/METADATA,sha256=M10g-HyLq73c09DjlRVp2bLp3EvbC57W0TkPDpjUeoc,5309
+dbos-0.20.0a3.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.20.0a3.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.20.0a3.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=CxRHBHEthPL4PZoLbZhp3rdm44-KkRTT2-7DkK9d4QQ,724
-dbos/_admin_server.py,sha256=DOgzVp9kmwiebQqmJB1LcrZnGTxSMbZiGXdenc1wZDg,3163
+dbos/_admin_server.py,sha256=PJgneZG9-64TapZrPeJtt73puAswRImCE5uce2k2PKU,4750
 dbos/_app_db.py,sha256=_tv2vmPjjiaikwgxH3mqxgJ4nUUcG2-0uMXKWCqVu1c,5509
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
 dbos/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh01vKW4,5007
 dbos/_cloudutils/cloudutils.py,sha256=5e3CW1deSW-dI5G3QN0XbiVsBhyqT8wu7fuV2f8wtGU,7688
 dbos/_cloudutils/databases.py,sha256=x4187Djsyoa-QaG3Kog8JT2_GERsnqa93LIVanmVUmg,8393
 dbos/_context.py,sha256=RH08s_nee95vgxdz6AsYuVWF1LuJSVtOyIifblsa4pw,18760
-dbos/_core.py,sha256=lonD_iSnZtxhwetDcDlCV3HLr40jjqxUS2Q0TFaIOt0,34784
+dbos/_core.py,sha256=dmVve1YZyQmAfwKsxqz6N3bXBowsMBmLxBDsymoWKsA,35956
 dbos/_croniter.py,sha256=hbhgfsHBqclUS8VeLnJ9PSE9Z54z6mi4nnrr1aUXn0k,47561
 dbos/_db_wizard.py,sha256=xgKLna0_6Xi50F3o8msRosXba8NScHlpJR5ICVCkHDQ,7534
-dbos/_dbos.py,sha256=LWFa48CPt7bsNAnMZrNDzHHTFCyMrY-nKbMZwCG_dqY,34710
+dbos/_dbos.py,sha256=Kgnity6JxjThIf1L8CQbeobQMiJqUUeWlRf36_eGu2g,35385
 dbos/_dbos_config.py,sha256=h_q1gzudhsAMVkGMD0qQ6kLic6YhdJgzm50YFSIx9Bo,8196
 dbos/_error.py,sha256=vtaSsG0QW6cRlwfZ4zzZWy_IHCZlomwSlrDyGWuyn8c,4337
-dbos/_fastapi.py,sha256=iyefCZq-ZDKRUjN_rgYQmFmyvWf4gPrSlC6CLbfq4a8,3419
-dbos/_flask.py,sha256=z1cijbTi5Dpq6kqikPCx1LcR2YHHv2oc41NehOWjw74,2431
+dbos/_fastapi.py,sha256=yRHrCwul2iYBxAAYuBQLcn9LMYUS6PE4CU9y1vUSPR8,3587
+dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
 dbos/_kafka.py,sha256=o6DbwnsYRDtvVTZVsN7BAK8cdP79AfoWX3Q7CGY2Yuo,4199
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/_logger.py,sha256=iYwbA7DLyXalWa2Yu07HO6Xm301nRuenMU64GgwUMkU,3576
@@ -42,20 +42,22 @@ dbos/_schemas/application_database.py,sha256=KeyoPrF7hy_ODXV7QNike_VFSD74QBRfQ76
 dbos/_schemas/system_database.py,sha256=rwp4EvCSaXcUoMaRczZCvETCxGp72k3-hvLyGUDkih0,5163
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
 dbos/_sys_db.py,sha256=ha5E11P83oi78L4R7cX_OL_N1Tf2Ir0Xr30GK1_27SA,52290
-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=OMlcpdYUJKjyAme7phOz3pbn9upcIRjm42iwEThWUEQ,495
-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/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
+dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbos/_templates/dbos-db-starter/__package/main.py,sha256=eI0SS9Nwj-fldtiuSzIlIG6dC91GXXwdRsoHxv6S_WI,2719
+dbos/_templates/dbos-db-starter/__package/schema.py,sha256=7Z27JGC8yy7Z44cbVXIREYxtUhU4JVkLCp5Q7UahVQ0,260
+dbos/_templates/dbos-db-starter/alembic.ini,sha256=VKBn4Gy8mMuCdY7Hip1jmo3wEUJ1VG1aW7EqY0_n-as,3695
+dbos/_templates/dbos-db-starter/dbos-config.yaml.dbos,sha256=OMlcpdYUJKjyAme7phOz3pbn9upcIRjm42iwEThWUEQ,495
+dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=GUV6sjkDzf9Vl6wkGEd0RSkK-ftRfV6EUwSQdd0qFXg,2392
+dbos/_templates/dbos-db-starter/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sha256=U5thFWGqNN4QLrNXT7wUUqftIFDNE5eSdqD8JNW1mec,942
+dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
 dbos/_tracer.py,sha256=rvBY1RQU6DO7rL7EnaJJxGcmd4tP_PpGqUEE6imZnhY,2518
-dbos/_workflow_commands.py,sha256=25mLcPifaaQtX_Wzrf2LVq4CtXGDjmLHABimTcOeQuw,4691
-dbos/cli.py,sha256=0E_QDJm3aGjjauUnmrsdZkqc8U49L6j2uPEtA0QRaZE,13946
+dbos/_workflow_commands.py,sha256=tj-gJARjDJ5aYo0ii2udTAU4l36vbeXwmOYh8Q4y_ac,4625
+dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
+dbos/cli/_template_init.py,sha256=AfuMaO8bmr9WsPNHr6j2cp7kjVVZDUpH7KpbTg0hhFs,2722
+dbos/cli/cli.py,sha256=4YRwY9fIOPAP7CS1OhTOZvLeyihK6ddn0KcYRDvX0E8,13928
 dbos/dbos-config.schema.json,sha256=X5TpXNcARGceX0zQs0fVgtZW_Xj9uBbY5afPt9Rz9yk,5741
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.19.0a9.dist-info/RECORD,,
+dbos-0.20.0a3.dist-info/RECORD,,

{dbos-0.19.0a9.dist-info → dbos-0.20.0a3.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
-dbos = dbos.cli:app
+dbos = dbos.cli.cli:app
 
 [gui_scripts]