dbos 0.28.0a1__py3-none-any.whl → 0.28.0a6__py3-none-any.whl

dbos/_sys_db.py

@@ -106,8 +106,6 @@ class WorkflowStatus:
     app_id: Optional[str]
     # The number of times this workflow's execution has been attempted
     recovery_attempts: Optional[int]
-    # The HTTP request that triggered the workflow, if known
-    request: Optional[str]
 
 
 class WorkflowStatusInternal(TypedDict):
@@ -120,7 +118,6 @@ class WorkflowStatusInternal(TypedDict):
     assumed_role: Optional[str]
     authenticated_roles: Optional[str]  # JSON list of roles
     output: Optional[str]  # JSON (jsonpickle)
-    request: Optional[str]  # JSON (jsonpickle)
     error: Optional[str]  # JSON (jsonpickle)
     created_at: Optional[int]  # Unix epoch timestamp in ms
     updated_at: Optional[int]  # Unix epoch timestamp in ms
@@ -138,6 +135,9 @@ class WorkflowStatusInternal(TypedDict):
 
 class EnqueueOptionsInternal(TypedDict):
     deduplication_id: Optional[str]  # Unique ID for deduplication on a queue
+    priority: Optional[
+        int
+    ]  # Priority of the workflow on the queue, starting from 1 ~ 2,147,483,647. Default 0 (highest priority).
 
 
 class RecordedResult(TypedDict):
@@ -369,7 +369,6 @@ class SystemDatabase:
                 executor_id=status["executor_id"],
                 application_version=status["app_version"],
                 application_id=status["app_id"],
-                request=status["request"],
                 authenticated_user=status["authenticated_user"],
                 authenticated_roles=status["authenticated_roles"],
                 assumed_role=status["assumed_role"],
@@ -477,7 +476,6 @@ class SystemDatabase:
                 executor_id=status["executor_id"],
                 application_version=status["app_version"],
                 application_id=status["app_id"],
-                request=status["request"],
                 authenticated_user=status["authenticated_user"],
                 authenticated_roles=status["authenticated_roles"],
                 assumed_role=status["assumed_role"],
@@ -625,7 +623,6 @@ class SystemDatabase:
                         else status["app_version"]
                     ),
                     application_id=status["app_id"],
-                    request=status["request"],
                     authenticated_user=status["authenticated_user"],
                     authenticated_roles=status["authenticated_roles"],
                     assumed_role=status["assumed_role"],
@@ -687,7 +684,6 @@ class SystemDatabase:
                 sa.select(
                     SystemSchema.workflow_status.c.status,
                     SystemSchema.workflow_status.c.name,
-                    SystemSchema.workflow_status.c.request,
                     SystemSchema.workflow_status.c.recovery_attempts,
                     SystemSchema.workflow_status.c.config_name,
                     SystemSchema.workflow_status.c.class_name,
@@ -712,21 +708,20 @@ class SystemDatabase:
                 "error": None,
                 "status": row[0],
                 "name": row[1],
-                "request": row[2],
-                "recovery_attempts": row[3],
-                "config_name": row[4],
-                "class_name": row[5],
-                "authenticated_user": row[6],
-                "authenticated_roles": row[7],
-                "assumed_role": row[8],
-                "queue_name": row[9],
-                "executor_id": row[10],
-                "created_at": row[11],
-                "updated_at": row[12],
-                "app_version": row[13],
-                "app_id": row[14],
-                "workflow_deadline_epoch_ms": row[15],
-                "workflow_timeout_ms": row[16],
+                "recovery_attempts": row[2],
+                "config_name": row[3],
+                "class_name": row[4],
+                "authenticated_user": row[5],
+                "authenticated_roles": row[6],
+                "assumed_role": row[7],
+                "queue_name": row[8],
+                "executor_id": row[9],
+                "created_at": row[10],
+                "updated_at": row[11],
+                "app_version": row[12],
+                "app_id": row[13],
+                "workflow_deadline_epoch_ms": row[14],
+                "workflow_timeout_ms": row[15],
             }
             return status
 
@@ -802,9 +797,7 @@ class SystemDatabase:
             )
             return inputs
 
-    def get_workflows(
-        self, input: GetWorkflowsInput, get_request: bool = False
-    ) -> List[WorkflowStatus]:
+    def get_workflows(self, input: GetWorkflowsInput) -> List[WorkflowStatus]:
         """
         Retrieve a list of workflows result and inputs based on the input criteria. The result is a list of external-facing workflow status objects.
         """
@@ -812,7 +805,6 @@ class SystemDatabase:
             SystemSchema.workflow_status.c.workflow_uuid,
             SystemSchema.workflow_status.c.status,
             SystemSchema.workflow_status.c.name,
-            SystemSchema.workflow_status.c.request,
             SystemSchema.workflow_status.c.recovery_attempts,
             SystemSchema.workflow_status.c.config_name,
             SystemSchema.workflow_status.c.class_name,
@@ -885,27 +877,26 @@ class SystemDatabase:
             info.workflow_id = row[0]
             info.status = row[1]
             info.name = row[2]
-            info.request = row[3] if get_request else None
-            info.recovery_attempts = row[4]
-            info.config_name = row[5]
-            info.class_name = row[6]
-            info.authenticated_user = row[7]
+            info.recovery_attempts = row[3]
+            info.config_name = row[4]
+            info.class_name = row[5]
+            info.authenticated_user = row[6]
             info.authenticated_roles = (
-                json.loads(row[8]) if row[8] is not None else None
+                json.loads(row[7]) if row[7] is not None else None
             )
-            info.assumed_role = row[9]
-            info.queue_name = row[10]
-            info.executor_id = row[11]
-            info.created_at = row[12]
-            info.updated_at = row[13]
-            info.app_version = row[14]
-            info.app_id = row[15]
+            info.assumed_role = row[8]
+            info.queue_name = row[9]
+            info.executor_id = row[10]
+            info.created_at = row[11]
+            info.updated_at = row[12]
+            info.app_version = row[13]
+            info.app_id = row[14]
 
             inputs, output, exception = _serialization.safe_deserialize(
                 info.workflow_id,
-                serialized_input=row[16],
-                serialized_output=row[17],
-                serialized_exception=row[18],
+                serialized_input=row[15],
+                serialized_output=row[16],
+                serialized_exception=row[17],
             )
             info.input = inputs
             info.output = output
@@ -915,7 +906,7 @@ class SystemDatabase:
         return infos
 
     def get_queued_workflows(
-        self, input: GetQueuedWorkflowsInput, get_request: bool = False
+        self, input: GetQueuedWorkflowsInput
     ) -> List[WorkflowStatus]:
         """
         Retrieve a list of queued workflows result and inputs based on the input criteria. The result is a list of external-facing workflow status objects.
@@ -924,7 +915,6 @@ class SystemDatabase:
             SystemSchema.workflow_status.c.workflow_uuid,
             SystemSchema.workflow_status.c.status,
             SystemSchema.workflow_status.c.name,
-            SystemSchema.workflow_status.c.request,
             SystemSchema.workflow_status.c.recovery_attempts,
             SystemSchema.workflow_status.c.config_name,
             SystemSchema.workflow_status.c.class_name,
@@ -993,27 +983,26 @@ class SystemDatabase:
             info.workflow_id = row[0]
             info.status = row[1]
             info.name = row[2]
-            info.request = row[3] if get_request else None
-            info.recovery_attempts = row[4]
-            info.config_name = row[5]
-            info.class_name = row[6]
-            info.authenticated_user = row[7]
+            info.recovery_attempts = row[3]
+            info.config_name = row[4]
+            info.class_name = row[5]
+            info.authenticated_user = row[6]
             info.authenticated_roles = (
-                json.loads(row[8]) if row[8] is not None else None
+                json.loads(row[7]) if row[7] is not None else None
             )
-            info.assumed_role = row[9]
-            info.queue_name = row[10]
-            info.executor_id = row[11]
-            info.created_at = row[12]
-            info.updated_at = row[13]
-            info.app_version = row[14]
-            info.app_id = row[15]
+            info.assumed_role = row[8]
+            info.queue_name = row[9]
+            info.executor_id = row[10]
+            info.created_at = row[11]
+            info.updated_at = row[12]
+            info.app_version = row[13]
+            info.app_id = row[14]
 
             inputs, output, exception = _serialization.safe_deserialize(
                 info.workflow_id,
-                serialized_input=row[16],
-                serialized_output=row[17],
-                serialized_exception=row[18],
+                serialized_input=row[15],
+                serialized_output=row[16],
+                serialized_exception=row[17],
             )
             info.input = inputs
             info.output = output
@@ -1633,12 +1622,19 @@ class SystemDatabase:
                 if enqueue_options is not None
                 else None
             )
+            priority = (
+                enqueue_options["priority"] if enqueue_options is not None else None
+            )
+            # Default to 0 (highest priority) if not provided
+            if priority is None:
+                priority = 0
             query = (
                 pg.insert(SystemSchema.workflow_queue)
                 .values(
                     workflow_uuid=workflow_id,
                     queue_name=queue_name,
                     deduplication_id=deduplication_id,
+                    priority=priority,
                 )
                 .on_conflict_do_nothing(
                     index_elements=SystemSchema.workflow_queue.primary_key.columns
@@ -1747,7 +1743,10 @@ class SystemDatabase:
                 .where(SystemSchema.workflow_queue.c.queue_name == queue.name)
                 .where(SystemSchema.workflow_queue.c.started_at_epoch_ms == None)
                 .where(SystemSchema.workflow_queue.c.completed_at_epoch_ms == None)
-                .order_by(SystemSchema.workflow_queue.c.created_at_epoch_ms.asc())
+                .order_by(
+                    SystemSchema.workflow_queue.c.priority.asc(),
+                    SystemSchema.workflow_queue.c.created_at_epoch_ms.asc(),
+                )
                 .with_for_update(nowait=True)  # Error out early
             )
             # Apply limit only if max_tasks is finite

dbos/_utils.py

@@ -1,8 +1,17 @@
+import importlib.metadata
 import os
 
 INTERNAL_QUEUE_NAME = "_dbos_internal_queue"
 
+request_id_header = "x-request-id"
+
 
 class GlobalParams:
     app_version: str = os.environ.get("DBOS__APPVERSION", "")
     executor_id: str = os.environ.get("DBOS__VMID", "local")
+    try:
+        # Only works on Python >= 3.8
+        dbos_version = importlib.metadata.version("dbos")
+    except importlib.metadata.PackageNotFoundError:
+        # If package is not installed or during development
+        dbos_version = "unknown"

dbos/_workflow_commands.py

@@ -27,7 +27,6 @@ def list_workflows(
     limit: Optional[int] = None,
     offset: Optional[int] = None,
     sort_desc: bool = False,
-    request: bool = False,
     workflow_id_prefix: Optional[str] = None,
 ) -> List[WorkflowStatus]:
     input = GetWorkflowsInput()
@@ -43,7 +42,7 @@ def list_workflows(
     input.sort_desc = sort_desc
     input.workflow_id_prefix = workflow_id_prefix
 
-    infos: List[WorkflowStatus] = sys_db.get_workflows(input, request)
+    infos: List[WorkflowStatus] = sys_db.get_workflows(input)
 
     return infos
 
@@ -59,7 +58,6 @@ def list_queued_workflows(
     limit: Optional[int] = None,
     offset: Optional[int] = None,
     sort_desc: bool = False,
-    request: bool = False,
 ) -> List[WorkflowStatus]:
     input: GetQueuedWorkflowsInput = {
         "queue_name": queue_name,
@@ -72,17 +70,15 @@ def list_queued_workflows(
         "sort_desc": sort_desc,
     }
 
-    infos: List[WorkflowStatus] = sys_db.get_queued_workflows(input, request)
+    infos: List[WorkflowStatus] = sys_db.get_queued_workflows(input)
     return infos
 
 
-def get_workflow(
-    sys_db: SystemDatabase, workflow_id: str, get_request: bool
-) -> Optional[WorkflowStatus]:
+def get_workflow(sys_db: SystemDatabase, workflow_id: str) -> Optional[WorkflowStatus]:
     input = GetWorkflowsInput()
     input.workflow_ids = [workflow_id]
 
-    infos: List[WorkflowStatus] = sys_db.get_workflows(input, get_request)
+    infos: List[WorkflowStatus] = sys_db.get_workflows(input)
     if not infos:
         return None
 

dbos/cli/cli.py

@@ -24,6 +24,7 @@ from .._dbos_config import _is_valid_app_name
 from .._docker_pg_helper import start_docker_pg, stop_docker_pg
 from .._schemas.system_database import SystemSchema
 from .._sys_db import SystemDatabase, reset_system_database
+from .._utils import GlobalParams
 from ..cli._github_init import create_template_from_github
 from ._template_init import copy_template, get_project_name, get_templates_directory
 
@@ -42,6 +43,14 @@ def start_client(db_url: Optional[str] = None) -> DBOSClient:
 
 
 app = typer.Typer()
+
+
+@app.command(help="Show the version and exit")
+def version() -> None:
+    """Display the current version of DBOS CLI."""
+    typer.echo(f"DBOS CLI version: {GlobalParams.dbos_version}")
+
+
 workflow = typer.Typer()
 queue = typer.Typer()
 

dbos-0.28.0a6.dist-info/METADATA

@@ -0,0 +1,312 @@
+Metadata-Version: 2.1
+Name: dbos
+Version: 0.28.0a6
+Summary: Ultra-lightweight durable execution in Python
+Author-Email: "DBOS, Inc." <contact@dbos.dev>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: alembic>=1.13.3
+Requires-Dist: typing-extensions>=4.12.2; python_version < "3.10"
+Requires-Dist: typer>=0.12.5
+Requires-Dist: jsonpickle>=3.3.0
+Requires-Dist: opentelemetry-api>=1.27.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.27.0
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: fastapi[standard]>=0.115.2
+Requires-Dist: tomlkit>=0.13.2
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: docker>=7.1.0
+Requires-Dist: cryptography>=43.0.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: websockets>=15.0
+Description-Content-Type: text/markdown
+
+
+<div align="center">
+
+# DBOS Transact: Lightweight Durable Workflows
+
+#### [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>
+
+---
+
+## What is DBOS?
+
+DBOS provides lightweight durable workflows built on top of Postgres.
+Instead of managing your own workflow orchestrator or task queue system, you can use DBOS to add durable workflows and queues to your program in just a few lines of code.
+
+To get started, follow the [quickstart](https://docs.dbos.dev/quickstart) to install this open-source library and connect it to a Postgres database.
+Then, annotate workflows and steps in your program to make it durable!
+That's all you need to do&mdash;DBOS is entirely contained in this open-source library, there's no additional infrastructure for you to configure or manage.
+
+## When Should I Use DBOS?
+
+You should consider using DBOS if your application needs to **reliably handle failures**.
+For example, you might be building a payments service that must reliably process transactions even if servers crash mid-operation, or a long-running data pipeline that needs to resume seamlessly from checkpoints rather than restart from the beginning when interrupted.
+
+Handling failures is costly and complicated, requiring complex state management and recovery logic as well as heavyweight tools like external orchestration services.
+DBOS makes it simpler: annotate your code to checkpoint it in Postgres and automatically recover from any failure.
+DBOS also provides powerful Postgres-backed primitives that makes it easier to write and operate reliable code, including durable queues, notifications, scheduling, event processing, and programmatic workflow management.
+
+## Features
+
+<details open><summary><strong>💾 Durable Workflows</strong></summary>
+
+####
+
+DBOS workflows make your program **durable** by checkpointing its state in Postgres.
+If your program ever fails, when it restarts all your workflows will automatically resume from the last completed step.
+
+You add durable workflows to your existing Python program by annotating ordinary functions as workflows and steps:
+
+```python
+from dbos import DBOS
+
+@DBOS.step()
+def step_one():
+    ...
+
+@DBOS.step()
+def step_two():
+    ...
+
+@DBOS.workflow()
+def workflow()
+    step_one()
+    step_two()
+```
+
+Workflows are particularly useful for 
+
+- Orchestrating business processes so they seamlessly recover from any failure.
+- Building observable and fault-tolerant data pipelines.
+- Operating an AI agent, or any application that relies on unreliable or non-deterministic APIs.
+
+[Read more ↗️](https://docs.dbos.dev/python/tutorials/workflow-tutorial)
+
+</details>
+
+<details><summary><strong>📒 Durable Queues</strong></summary>
+
+####
+
+DBOS queues help you **durably** run tasks in the background.
+You can enqueue a task (which can be a single step or an entire workflow) from a durable workflow and one of your processes will pick it up for execution.
+DBOS manages the execution of your tasks: it guarantees that tasks complete, and that their callers get their results without needing to resubmit them, even if your application is interrupted.
+
+Queues also provide flow control, so you can limit the concurrency of your tasks on a per-queue or per-process basis.
+You can also set timeouts for tasks, rate limit how often queued tasks are executed, deduplicate tasks, or prioritize tasks.
+
+You can add queues to your workflows in just a couple lines of code.
+They don't require a separate queueing service or message broker&mdash;just Postgres.
+
+```python
+from dbos import DBOS, Queue
+
+queue = Queue("example_queue")
+
+@DBOS.step()
+def process_task(task):
+  ...
+
+@DBOS.workflow()
+def process_tasks(tasks):
+  task_handles = []
+  # Enqueue each task so all tasks are processed concurrently.
+  for task in tasks:
+    handle = queue.enqueue(process_task, task)
+    task_handles.append(handle)
+  # Wait for each task to complete and retrieve its result.
+  # Return the results of all tasks.
+  return [handle.get_result() for handle in task_handles]
+```
+
+[Read more ↗️](https://docs.dbos.dev/python/tutorials/queue-tutorial)
+
+</details>
+
+<details><summary><strong>⚙️ Programmatic Workflow Management</strong></summary>
+
+####
+
+Your workflows are stored as rows in a Postgres table, so you have full programmatic control over them.
+Write scripts to query workflow executions, batch pause or resume workflows, or even restart failed workflows from a specific step.
+Handle bugs or failures that affect thousands of workflows with power and flexibility.
+
+```python
+# Create a DBOS client connected to your Postgres database.
+client = DBOSClient(database_url)
+# Find all workflows that errored between 3:00 and 5:00 AM UTC on 2025-04-22.
+workflows = client.list_workflows(status="ERROR", 
+  start_time="2025-04-22T03:00:00Z", end_time="2025-04-22T05:00:00Z")
+for workflow in workflows:
+    # Check which workflows failed due to an outage in a service called from Step 2.
+    steps = client.list_workflow_steps(workflow)
+    if len(steps) >= 3 and isinstance(steps[2]["error"], ServiceOutage):
+        # To recover from the outage, restart those workflows from Step 2.
+        DBOS.fork_workflow(workflow.workflow_id, 2)
+```
+
+[Read more ↗️](https://docs.dbos.dev/python/reference/client)
+
+</details>
+
+<details><summary><strong>🎫 Exactly-Once Event Processing</strong></summary>
+
+####
+
+Use DBOS to build reliable webhooks, event listeners, or Kafka consumers by starting a workflow exactly-once in response to an event.
+Acknowledge the event immediately while reliably processing it in the background.
+
+For example:
+
+```python
+def handle_message(request: Request) -> None:
+  event_id = request.body["event_id"]
+  # Use the event ID as an idempotency key to start the workflow exactly-once
+  with SetWorkflowID(event_id):
+    # Start the workflow in the background, then acknowledge the event
+    DBOS.start_workflow(message_workflow, request.body["event"])
+```
+
+Or with Kafka:
+
+```python
+@DBOS.kafka_consumer(config,["alerts-topic"])
+@DBOS.workflow()
+def process_kafka_alerts(msg):
+    # This workflow runs exactly-once for each message sent to the topic
+    alerts = msg.value.decode()
+    for alert in alerts:
+        respond_to_alert(alert)
+```
+
+[Read more ↗️](https://docs.dbos.dev/python/tutorials/workflow-tutorial)
+
+</details>
+
+<details><summary><strong>📅 Durable Scheduling</strong></summary>
+
+####
+
+Schedule workflows using cron syntax, or use durable sleep to pause workflows for as long as you like (even days or weeks) before executing.
+
+You can schedule a workflow using a single annotation:
+
+```python
+@DBOS.scheduled('* * * * *') # crontab syntax to run once every minute
+@DBOS.workflow()
+def example_scheduled_workflow(scheduled_time: datetime, actual_time: datetime):
+    DBOS.logger.info("I am a workflow scheduled to run once a minute.")
+```
+
+You can add a durable sleep to any workflow with a single line of code.
+It stores its wakeup time in Postgres so the workflow sleeps through any interruption or restart, then always resumes on schedule.
+
+```python
+@DBOS.workflow()
+def reminder_workflow(email: str, time_to_sleep: int):
+    send_confirmation_email(email)
+    DBOS.sleep(time_to_sleep)
+    send_reminder_email(email)
+```
+
+[Read more ↗️](https://docs.dbos.dev/python/tutorials/scheduled-workflows)
+
+</details>
+
+<details><summary><strong>📫 Durable Notifications</strong></summary>
+
+####
+
+Pause your workflow executions until a notification is received, or emit events from your workflow to send progress updates to external clients.
+All notifications are stored in Postgres, so they can be sent and received with exactly-once semantics.
+Set durable timeouts when waiting for events, so you can wait for as long as you like (even days or weeks) through interruptions or restarts, then resume once a notification arrives or the timeout is reached.
+
+For example, build a reliable billing workflow that durably waits for a notification from a payments service, processing it exactly-once:
+
+```python
+@DBOS.workflow()
+def billing_workflow():
+  ... # Calculate the charge, then submit the bill to a payments service
+  payment_status = DBOS.recv(PAYMENT_STATUS, timeout=payment_service_timeout)
+  if payment_status is not None and payment_status == "paid":
+      ... # Handle a successful payment.
+  else:
+      ... # Handle a failed payment or timeout.
+```
+
+</details>
+
+
+## Getting Started
+
+To get started, follow the [quickstart](https://docs.dbos.dev/quickstart) to install this open-source library and connect it to a Postgres database.
+Then, check out the [programming guide](https://docs.dbos.dev/python/programming-guide) to learn how to build with durable workflows and queues.
+
+## Documentation
+
+[https://docs.dbos.dev](https://docs.dbos.dev)
+
+## Examples
+
+[https://docs.dbos.dev/examples](https://docs.dbos.dev/examples)
+
+## DBOS vs. Other Systems
+
+<details><summary><strong>DBOS vs. Temporal</strong></summary>
+
+####
+
+Both DBOS and Temporal provide durable execution, but DBOS is implemented in a lightweight Postgres-backed library whereas Temporal is implemented in an externally orchestrated server.
+
+You can add DBOS to your program by installing this open-source library, connecting it to Postgres, and annotating workflows and steps.
+By contrast, to add Temporal to your program, you must rearchitect your program to move your workflows and steps (activities) to a Temporal worker, configure a Temporal server to orchestrate those workflows, and access your workflows only through a Temporal client.
+[This blog post](https://www.dbos.dev/blog/durable-execution-coding-comparison) makes the comparison in more detail.
+
+**When to use DBOS:** You need to add durable workflows to your applications with minimal rearchitecting, or you are using Postgres.
+
+**When to use Temporal:** You don't want to add Postgres to your stack, or you need a language DBOS doesn't support yet.
+
+</details>
+
+<details><summary><strong>DBOS vs. Airflow</strong></summary>
+
+####
+
+DBOS and Airflow both provide workflow abstractions.
+Airflow is targeted at data science use cases, providing many out-of-the-box connectors but requiring workflows be written as explicit DAGs and externally orchestrating them from an Airflow cluster.
+Airflow is designed for batch operations and does not provide good performance for streaming or real-time use cases.
+DBOS is general-purpose, but is often used for data pipelines, allowing developers to write workflows as code and requiring no infrastructure except Postgres.
+
+**When to use DBOS:** You need the flexibility of writing workflows as code, or you need higher performance than Airflow is capable of (particularly for streaming or real-time use cases).
+
+**When to use Airflow:** You need Airflow's ecosystem of connectors.
+
+</details>
+
+<details><summary><strong>DBOS vs. Celery/BullMQ</strong></summary>
+
+####
+
+DBOS provides a similar queue abstraction to dedicated queueing systems like Celery or BullMQ: you can declare queues, submit tasks to them, and control their flow with concurrency limits, rate limits, timeouts, prioritization, etc.
+However, DBOS queues are **durable and Postgres-backed** and integrate with durable workflows.
+For example, in DBOS you can write a durable workflow that enqueues a thousand tasks and waits for their results.
+DBOS checkpoints the workflow and each of its tasks in Postgres, guaranteeing that even if failures or interruptions occur, the tasks will complete and the workflow will collect their results.
+By contrast, Celery/BullMQ are Redis-backed and don't provide workflows, so they provide fewer guarantees but better performance.
+
+**When to use DBOS:** You need the reliability of enqueueing tasks from durable workflows.
+
+**When to use Celery/BullMQ**: You don't need durability, or you need very high throughput beyond what your Postgres server can support.
+</details>
+
+## Community
+
+If you want to ask questions or hang out with the community, join us on [Discord](https://discord.gg/fMwQjeW5zg)!
+If you see a bug or have a feature request, don't hesitate to open an issue here on GitHub.
+If you're interested in contributing, check out our [contributions guide](./CONTRIBUTING.md).