dbos 0.19.0a4__py3-none-any.whl → 0.20.0__py3-none-any.whl

dbos/cli/cli.py

@@ -0,0 +1,367 @@
+import os
+import platform
+import signal
+import subprocess
+import time
+import typing
+from os import path
+from typing import Any
+
+import jsonpickle  # type: ignore
+import requests
+import sqlalchemy as sa
+import typer
+from rich import print
+from rich.prompt import IntPrompt
+from typing_extensions import Annotated
+
+from .. import load_config
+from .._app_db import ApplicationDatabase
+from .._dbos_config import _is_valid_app_name
+from .._sys_db import SystemDatabase, reset_system_database
+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()
+
+app.add_typer(workflow, name="workflow", help="Manage DBOS workflows")
+
+
+def _on_windows() -> bool:
+    return platform.system() == "Windows"
+
+
+@app.command(
+    help="Start your DBOS application using the start commands in 'dbos-config.yaml'"
+)
+def start() -> None:
+    config = load_config()
+    start_commands = config["runtimeConfig"]["start"]
+    typer.echo("Executing start commands from 'dbos-config.yaml'")
+    for command in start_commands:
+        typer.echo(f"Executing: {command}")
+
+        # Run the command in the child process.
+        # On Unix-like systems, set its process group
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            text=True,
+            preexec_fn=os.setsid if not _on_windows() else None,
+        )
+
+        def signal_handler(signum: int, frame: Any) -> None:
+            """
+            Forward kill signals to children.
+
+            When we receive a signal, send it to the entire process group of the child.
+            If that doesn't work, SIGKILL them then exit.
+            """
+            # Send the signal to the child's entire process group
+            if process.poll() is None:
+                os.killpg(os.getpgid(process.pid), signum)
+
+            # Give some time for the child to terminate
+            for _ in range(10):  # Wait up to 1 second
+                if process.poll() is not None:
+                    break
+                time.sleep(0.1)
+
+            # If the child is still running, force kill it
+            if process.poll() is None:
+                os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+
+            # Exit immediately
+            os._exit(process.returncode if process.returncode is not None else 1)
+
+        # Configure the single handler only on Unix-like systems.
+        # TODO: Also kill the children on Windows.
+        if not _on_windows():
+            signal.signal(signal.SIGINT, signal_handler)
+            signal.signal(signal.SIGTERM, signal_handler)
+        process.wait()
+
+
+@app.command(help="Initialize a new DBOS application from a template")
+def init(
+    project_name: Annotated[
+        typing.Optional[str], typer.Argument(help="Specify application name")
+    ] = None,
+    template: Annotated[
+        typing.Optional[str],
+        typer.Option("--template", "-t", help="Specify template to use"),
+    ] = None,
+    config: Annotated[
+        bool,
+        typer.Option("--config", "-c", help="Only add dbos-config.yaml"),
+    ] = False,
+) -> None:
+    try:
+
+        git_templates = ["dbos-toolbox", "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 config and template is None:
+            template = templates[-1]
+
+        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."
+            )
+
+        if template in git_templates:
+            create_template_from_github(app_name=project_name, template_name=template)
+        else:
+            copy_template(
+                path.join(templates_dir, template), project_name, config_mode=config
+            )
+    except Exception as e:
+        print(f"[red]{e}[/red]")
+
+
+@app.command(
+    help="Run your database schema migrations using the migration commands in 'dbos-config.yaml'"
+)
+def migrate() -> None:
+    config = load_config()
+    if not config["database"]["password"]:
+        typer.echo(
+            "DBOS configuration does not contain database password, please check your config file and retry!"
+        )
+        raise typer.Exit(code=1)
+    app_db_name = config["database"]["app_db_name"]
+
+    typer.echo(f"Starting schema migration for database {app_db_name}")
+
+    # First, run DBOS migrations on the system database and the application database
+    app_db = None
+    sys_db = None
+    try:
+        sys_db = SystemDatabase(config)
+        app_db = ApplicationDatabase(config)
+    except Exception as e:
+        typer.echo(f"DBOS system schema migration failed: {e}")
+    finally:
+        if sys_db:
+            sys_db.destroy()
+        if app_db:
+            app_db.destroy()
+
+    # Next, run any custom migration commands specified in the configuration
+    typer.echo("Executing migration commands from 'dbos-config.yaml'")
+    try:
+        migrate_commands = (
+            config["database"]["migrate"]
+            if "migrate" in config["database"] and config["database"]["migrate"]
+            else []
+        )
+        for command in migrate_commands:
+            typer.echo(f"Executing migration command: {command}")
+            result = subprocess.run(command, shell=True, text=True)
+            if result.returncode != 0:
+                typer.echo(f"Migration command failed: {command}")
+                typer.echo(result.stderr)
+                raise typer.Exit(1)
+            if result.stdout:
+                typer.echo(result.stdout.rstrip())
+    except Exception as e:
+        typer.echo(f"An error occurred during schema migration: {e}")
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Completed schema migration for database {app_db_name}")
+
+
+@app.command(help="Reset the DBOS system database")
+def reset(
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt")
+) -> None:
+    if not yes:
+        confirm = typer.confirm(
+            "This command resets your DBOS system database, deleting metadata about past workflows and steps. Are you sure you want to proceed?"
+        )
+        if not confirm:
+            typer.echo("Operation cancelled.")
+            raise typer.Exit()
+    config = load_config()
+    try:
+        reset_system_database(config)
+    except sa.exc.SQLAlchemyError as e:
+        typer.echo(f"Error resetting system database: {str(e)}")
+        return
+
+
+@workflow.command(help="List workflows for your application")
+def list(
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="Limit the results returned"),
+    ] = 10,
+    user: Annotated[
+        typing.Optional[str],
+        typer.Option("--user", "-u", help="Retrieve workflows run by this user"),
+    ] = None,
+    starttime: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--start-time",
+            "-s",
+            help="Retrieve workflows starting after this timestamp (ISO 8601 format)",
+        ),
+    ] = None,
+    endtime: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--end-time",
+            "-e",
+            help="Retrieve workflows starting before this timestamp (ISO 8601 format)",
+        ),
+    ] = None,
+    status: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--status",
+            "-S",
+            help="Retrieve workflows with this status (PENDING, SUCCESS, ERROR, RETRIES_EXCEEDED, ENQUEUED, or CANCELLED)",
+        ),
+    ] = None,
+    appversion: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--application-version",
+            "-v",
+            help="Retrieve workflows with this application version",
+        ),
+    ] = None,
+    request: Annotated[
+        bool,
+        typer.Option("--request", help="Retrieve workflow request information"),
+    ] = True,
+    appdir: Annotated[
+        typing.Optional[str],
+        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
+    ] = None,
+) -> None:
+    config = load_config()
+    workflows = _list_workflows(
+        config, limit, user, starttime, endtime, status, request, appversion
+    )
+    print(jsonpickle.encode(workflows, unpicklable=False))
+
+
+@workflow.command(help="Retrieve the status of a workflow")
+def get(
+    uuid: Annotated[str, typer.Argument()],
+    appdir: Annotated[
+        typing.Optional[str],
+        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
+    ] = None,
+    request: Annotated[
+        bool,
+        typer.Option("--request", help="Retrieve workflow request information"),
+    ] = True,
+) -> None:
+    config = load_config()
+    print(jsonpickle.encode(_get_workflow(config, uuid, request), unpicklable=False))
+
+
+@workflow.command(
+    help="Cancel a workflow so it is no longer automatically retried or restarted"
+)
+def cancel(
+    uuid: Annotated[str, typer.Argument()],
+    appdir: Annotated[
+        typing.Optional[str],
+        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
+    ] = None,
+) -> None:
+    config = load_config()
+    _cancel_workflow(config, uuid)
+    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.0a4.dist-info → dbos-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.19.0a4
+Version: 0.20.0
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT
@@ -28,14 +28,14 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-# DBOS Transact: Ultra-Lightweight Durable Execution
+# DBOS Transact: A Lightweight Durable Execution Library Built on Postgres
 
 #### [Documentation](https://docs.dbos.dev/) &nbsp;&nbsp;•&nbsp;&nbsp;  [Examples](https://docs.dbos.dev/examples) &nbsp;&nbsp;•&nbsp;&nbsp; [Github](https://github.com/dbos-inc) &nbsp;&nbsp;•&nbsp;&nbsp; [Discord](https://discord.com/invite/jsmC6pXGgX)
 </div>
 
 ---
 
-DBOS Transact is a Python library providing **ultra-lightweight durable execution**.
+DBOS Transact is a Python library for **ultra-lightweight durable execution**.
 For example:
 
 ```python
@@ -55,18 +55,23 @@ def workflow()
 
 Durable execution means your program is **resilient to any failure**.
 If it is ever interrupted or crashes, all your workflows will automatically resume from the last completed step.
-If you want to see durable execution in action, check out [this demo app](https://demo-widget-store.cloud.dbos.dev/) (source code [here](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python/widget-store)).
-No matter how many times you try to crash it, it always resumes from exactly where it left off!
+Durable execution helps solve many common problems:
 
-Under the hood, DBOS Transact works by storing your program's execution state (which workflows are currently executing and which steps they've completed) in a Postgres database.
-So all you need to use it is a Postgres database to connect to&mdash;there's no need for a "workflow server."
-This approach is also incredibly fast, for example [25x faster than AWS Step Functions](https://www.dbos.dev/blog/dbos-vs-aws-step-functions-benchmark).
+- Orchestrating long-running or business-critical workflows so they seamlessly recover from any failure.
+- Running reliable background jobs with no timeouts.
+- Processing incoming events (e.g. from Kafka) exactly once.
+- Running a fault-tolerant distributed task queue.
+- Running a reliable cron scheduler.
+- Operating an AI agent, or anything that connects to an unreliable or non-deterministic API.
 
-Some more cool features include:
+What’s unique about DBOS's implementation of durable execution is that it’s implemented in a **lightweight library** that’s **totally backed by Postgres**.
+To use DBOS, just `pip install` it and annotate your program with DBOS decorators.
+Under the hood, those decorators store your program's execution state (which workflows are currently executing and which steps they've completed) in a Postgres database.
+If your program crashes or is interrupted, they automatically recover its workflows from their stored state.
+So all you need to use DBOS is Postgres&mdash;there are no other dependencies you have to manage, no separate workflow server.
 
-- Scheduled jobs&mdash;run your workflows exactly-once per time interval.
-- Exactly-once event processing&mdash;use workflows to process incoming events (for example, from a Kafka topic) exactly-once.
-- Observability&mdash;all workflows automatically emit [OpenTelemetry](https://opentelemetry.io/) traces.
+One big advantage of this approach is that you can add DBOS to **any** Python application&mdash;**it’s just a library**.
+You can use DBOS to add reliable background jobs or cron scheduling or queues to your app with no external dependencies except Postgres.
 
 ## Getting Started
 
@@ -77,7 +82,7 @@ pip install dbos
 dbos init --config
 ```
 
-Then, try it out with this simple program (requires Postgres):
+Then, try it out with this simple program:
 
 ```python
 from fastapi import FastAPI
@@ -107,14 +112,14 @@ def fastapi_endpoint():
     dbos_workflow()
 ```
 
-Save the program into `main.py`, edit `dbos-config.yaml` to configure your Postgres connection settings, and start it with `fastapi run`.
+Save the program into `main.py` and start it with `fastapi run`.
 Visit `localhost:8000` in your browser to start the workflow.
 When prompted, press `Control + \` to force quit your application.
 It should crash midway through the workflow, having completed step one but not step two.
 Then, restart your app with `fastapi run`.
 It should resume the workflow from where it left off, completing step two without re-executing step one.
 
-To learn how to build more complex workflows, see our [programming guide](https://docs.dbos.dev/python/programming-guide) or [examples](https://docs.dbos.dev/examples).
+To learn how to build more complex workflows, see the [programming guide](https://docs.dbos.dev/python/programming-guide) or [examples](https://docs.dbos.dev/examples).
 
 ## Documentation
 
@@ -125,7 +130,7 @@ To learn how to build more complex workflows, see our [programming guide](https:
 
 - [**AI-Powered Slackbot**](https://docs.dbos.dev/python/examples/rag-slackbot) &mdash; A Slackbot that answers questions about previous Slack conversations, using DBOS to durably orchestrate its RAG pipeline.
 - [**Widget Store**](https://docs.dbos.dev/python/examples/widget-store) &mdash; An online storefront that uses DBOS durable workflows to be resilient to any failure.
-- [**Earthquake Tracker**](https://docs.dbos.dev/python/examples/earthquake-tracker) &mdash; A real-time earthquake dashboard that uses DBOS to stream data from the USGS into Postgres, then visualizes it with Streamlit.
+- [**Scheduled Reminders**](https://docs.dbos.dev/python/examples/scheduled-reminders) &mdash; In just three lines of code, schedule an email to send days, weeks, or months in the future.
 
 More examples [here](https://docs.dbos.dev/examples)!
 

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

@@ -1,24 +1,24 @@
-dbos-0.19.0a4.dist-info/METADATA,sha256=NOwdv7iSopa_WvJkvQ3-AJ-peRmVMFW3E5D7SfxERqI,5144
-dbos-0.19.0a4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.19.0a4.dist-info/entry_points.txt,sha256=z6GcVANQV7Uw_82H9Ob2axJX6V3imftyZsljdh-M1HU,54
-dbos-0.19.0a4.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.20.0.dist-info/METADATA,sha256=4gV-eeocBCalrCoYpN8ryaGJNHvu4clGO7mZfGD-Cco,5307
+dbos-0.20.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.20.0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.20.0.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=KV3fd3-Rv6EWrYDUdHARxltSlNZGNtQtNSqeQ-gkXE8,18049
-dbos/_core.py,sha256=dbG8573iSzB_WITWOh6yOV-w32BM8UbJcOB4Fr0e-lw,34456
+dbos/_context.py,sha256=RH08s_nee95vgxdz6AsYuVWF1LuJSVtOyIifblsa4pw,18760
+dbos/_core.py,sha256=-2oh2-NicMJBwTwrd2EQBQm4Vu0caozFeoS9Kj47DzM,36588
 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=1PG142hzPBFguAbuBXaKS-YwzRdaIUW8087JCi78RmU,36193
 dbos/_dbos_config.py,sha256=h_q1gzudhsAMVkGMD0qQ6kLic6YhdJgzm50YFSIx9Bo,8196
-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/_error.py,sha256=vtaSsG0QW6cRlwfZ4zzZWy_IHCZlomwSlrDyGWuyn8c,4337
+dbos/_fastapi.py,sha256=ke03vqsSYDnO6XeOtOVFXj0-f-v1MGsOxa9McaROvNc,3616
+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
 dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
@@ -31,7 +31,7 @@ dbos/_migrations/versions/d76646551a6b_job_queue_limiter.py,sha256=8PyFi8rd6CN-m
 dbos/_migrations/versions/d76646551a6c_workflow_queue.py,sha256=G942nophZ2uC2vc4hGBC02Ptng1715roTjY3xiyzZU4,729
 dbos/_migrations/versions/eab0cc1d9a14_job_queue.py,sha256=uvhFOtqbBreCePhAxZfIT0qCAI7BiZTou9wt6QnbY7c,1412
 dbos/_outcome.py,sha256=FDMgWVjZ06vm9xO-38H17mTqBImUYQxgKs_bDCSIAhE,6648
-dbos/_queue.py,sha256=VSaF-BTv2tm-44O_690omo0pE31NQAhOT3ARL4VLRzY,2723
+dbos/_queue.py,sha256=o_aczwualJTMoXb0XXL-Y5QH77OEukWzuerogbWi2ho,2779
 dbos/_recovery.py,sha256=jbzGYxICA2drzyzlBSy2UiXhKV_16tBVacKQdTkqf-w,2008
 dbos/_registrations.py,sha256=mei6q6_3R5uei8i_Wo_TqGZs85s10shOekDX41sFYD0,6642
 dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
@@ -41,20 +41,23 @@ 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=rwp4EvCSaXcUoMaRczZCvETCxGp72k3-hvLyGUDkih0,5163
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
-dbos/_sys_db.py,sha256=2W3ta0Q-isESMjyGbXCPfaoll-vyPQg1innBEeNfg2c,50088
-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/_sys_db.py,sha256=eXFXzmw_bq5Qp3s2_OzjkQKQj9HxMbP4AyJ2VQnJ08g,53786
+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/cli.py,sha256=em1uAxrp5yyg53V7ZpmHFtqD6OJp2cMJkG9vGJPoFTA,10904
+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=07TXdfDhImEOjB2-yhWJc1CK07_CSF-xF7TYCtB1kRY,12410
 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.0a4.dist-info/RECORD,,
+dbos-0.20.0.dist-info/RECORD,,

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

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