beanqueue 0.2.3__tar.gz → 1.1.0__tar.gz

{beanqueue-0.2.3 → beanqueue-1.1.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: beanqueue
-Version: 0.2.3
-Summary: BeanQueue or BQ for short, PostgreSQL SKIP LOCK based worker queue library
+Version: 1.1.0
+Summary: BeanQueue or BQ for short, PostgreSQL SKIP LOCK and SQLAlchemy based worker queue library
 License: MIT
 Author: Fang-Pen Lin
 Author-email: fangpen@launchplatform.com
@@ -14,12 +14,13 @@ Requires-Dist: blinker (>=1.8.2,<2.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: pg-activity (>=3.5.1,<4.0.0)
 Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
 Requires-Dist: sqlalchemy (>=2.0.30,<3.0.0)
 Requires-Dist: venusian (>=3.1.0,<4.0.0)
 Description-Content-Type: text/markdown
 
 # BeanQueue  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/LaunchPlatform/bq/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/LaunchPlatform/beanhub-extract/tree/master)
-BeanQueue, a lightweight worker queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
+BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
 
 **Notice**: Still in its early stage, we built this for [BeanHub](https://beanhub.io)'s internal usage. May change rapidly. Use at your own risk for now.
 
@@ -29,8 +30,10 @@ BeanQueue, a lightweight worker queue framework based on [SQLAlchemy](https://ww
 - **Easy-to-deploy**: Only rely on PostgreSQL
 - **Easy-to-use**: Provide command line tools for processing tasks, also helpers for generating tasks models
 - **Auto-notify**: Notify will automatically be generated and send for inserted or update tasks
+- **Retry**: Built-in and customizable retry-policies
+- **Schedule**: Schedule task to run later
 - **Worker heartbeat and auto-reschedule**: Each worker keeps updating heartbeat, if one is found dead, the others will reschedule the tasks
-- **Customizable**: Use it as an library and build your own worker queue
+- **Customizable**: Use it as an library and build your own work queue
 - **Native DB operations**: Commit your tasks with other db entries altogether without worrying about data inconsistent issue
 
 ## Install
@@ -111,20 +114,92 @@ db.commit()
 To run the worker, you can do this:
 
 ```bash
-BQ_PROCESSOR_PACKAGES='["my_pkgs.processors"]' python -m bq.cmds.process images
+BQ_PROCESSOR_PACKAGES='["my_pkgs.processors"]' bq process images
 ```
 
 The `BQ_PROCESSOR_PACKAGES` is a JSON list contains the Python packages where you define your processors (the functions you decorated with `bq.processors.registry.processor`).
 To submit a task for testing purpose, you can do
 
 ```bash
-python -m bq.cmds.submit images my_pkgs.processors resize_image -k '{"width": 200, "height": 300}'
+bq submit images my_pkgs.processors resize_image -k '{"width": 200, "height": 300}'
 ```
 
 To create tables for BeanQueue, you can run
 
 ```bash
-python -m bq.cmds.create_tables
+bq create_tables
+```
+
+### Schedule
+
+In most cases, a task will be executed as soon as possible after it is created.
+To run a task later, you can set a datetime value to the `scheduled_at` attribute of the task model.
+For example:
+
+```python
+import datetime
+
+db = Session()
+task = resize_image.run(width=200, height=300)
+task.scheduled_at = func.now() + datetime.timedelta(minutes=3)
+db.add(task)
+```
+
+Please note that currently, workers won't wake up at the next exact moment when the scheduled tasks are ready to run.
+It has to wait until the polling times out, and eventually, it will see the task's scheduled_at time exceeds the current datetime.
+Therefore, depending on your `POLL_TIMEOUT` setting and the number of your workers when they started processing, the actual execution may be inaccurate.
+If you set the `POLL_TIMEOUT` to 60 seconds, please expect less than 60 seconds of delay.
+
+### Retry
+
+To automatically retry a task after failure, you can specify a retry policy to the processor.
+
+```python
+import datetime
+import bq
+from sqlalchemy.orm import Session
+
+app = bq.BeanQueue()
+delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
+
+@app.processor(channel="images", retry_policy=delay_retry)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
+```
+
+Currently, we provide some simple common retry policies such as `DelayRetry` and `ExponentialBackoffRetry`.
+Surely, you can define your retry policy easily by making a function that returns an optional object at the next scheduled time for retry.
+
+```python
+def my_retry_policy(task: bq.Task) -> typing.Any:
+    # calculate delay based on task model ...
+    return func.now() + datetime.timedelta(seconds=delay)
+```
+
+To cap how many attempts is allowed, you can also use `LimitAttempt` like this:
+
+```python
+delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
+capped_delay_retry = bq.LimitAttempt(3, delay_retry)
+
+@app.processor(channel="images", retry_policy=capped_delay_retry)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
+```
+
+You can also retry only for specific exception classes with the `retry_exceptions` argument.
+
+```python
+@app.processor(
+    channel="images",
+    retry_policy=delay_retry,
+    retry_exceptions=ValueError,
+)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
 ```
 
 ### Configurations
@@ -145,7 +220,7 @@ container = bq.Container()
 container.wire(packages=[bq])
 config = bq.Config(
     PROCESSOR_PACKAGES=["my_pkgs.processors"],
-    DATABASE_URL=str(config.DATABASE_URL),
+    DATABASE_URL=config.DATABASE_URL,
     BATCH_SIZE=10,
 )
 app = bq.BeanQueue(config=config)
@@ -154,7 +229,7 @@ app = bq.BeanQueue(config=config)
 Then you can pass `--app` argument (or `-a` for short) pointing to the app object to the process command like this:
 
 ```bash
-python -m bq.cmds.process -a my_pkgs.bq.app images
+bq -a my_pkgs.bq.app process images
 ```
 
 Or if you prefer to define your own process command, you can also call `process_tasks` of the `BeanQueue` object directly like this:
@@ -168,12 +243,16 @@ app.process_tasks(channels=("images",))
 BeanQueue is designed to be as customizable as much as possible.
 Of course, you can define your own SQLAlchemy model instead of using the ones we provided. 
 
-To make defining your own `Task` model or `Worker` model much easier, you can use our mixin classes:
+To make defining your own `Task`, `Worker` or `Event` model much easier, you can use our mixin classes:
 
 - `bq.TaskModelMixin`: provides task model columns
 - `bq.TaskModelRefWorkerMixin`: provides foreign key column and relationship to `bq.Worker`
+- `bq.TaskModelRefParentMixin`: provides foreign key column and relationship to children `bq.Task` created during processing
+- `bq.TaskModelRefEventMixin`: provides foreign key column and relationship to `bq.Event`
 - `bq.WorkerModelMixin`: provides worker model columns
 - `bq.WorkerRefMixin`: provides relationship to `bq.Task`
+- `bq.EventModelMixin`: provides event model columns
+- `bq.EventModelRefTaskMixin`: provides foreign key column and relationship to `bq.Task`
 
 Here's an example for defining your own Task model:
 
@@ -232,13 +311,14 @@ class Worker(bq.WorkerModelMixin, Base):
     )
 ```
 
-With the model class ready, you only need to change the `TASK_MODEL` and `WORKER_MODEL` of `Config` to the full Python module name plus the class name like this.
+With the model class ready, you only need to change the `TASK_MODEL`, `WORKER_MODEL` and `EVENT_MODEL` of `Config` to the full Python module name plus the class name like this.
 
 ```python
 import bq
 config = bq.Config(
     TASK_MODEL="my_pkgs.models.Task",
     WORKER_MODEL="my_pkgs.models.Worker",
+    EVENT_MODEL="my_pkgs.models.Event",
     # ... other configs
 )
 app = bq.BeanQueue(config)
@@ -246,21 +326,21 @@ app = bq.BeanQueue(config)
 
 ## Why?
 
-There are countless worker queue projects. Why make yet another one?
-The primary issue with most worker queue tools is their reliance on a standalone broker server.
-Our worker queue tasks frequently interact with the database, and the atomic nature of database transactions is great for data integrity.
-However, integrating an external worker queue into the system presents a risk.
-The worker queue and the database don't share the same data view, potentially compromising data integrity and reliability.
+There are countless work queue projects. Why make yet another one?
+The primary issue with most work queue tools is their reliance on a standalone broker server.
+Our work queue tasks frequently interact with the database, and the atomic nature of database transactions is great for data integrity.
+However, integrating an external work queue into the system presents a risk.
+The work queue and the database don't share the same data view, potentially compromising data integrity and reliability.
 
 For example, you have a table of `images` to keep the user-uploaded images.
-And you have a background worker queue for resizing the uploaded images into different thumbnail sizes.
-So, you will first need to insert a row for the uploaded image about the job into the database before you push the task to the worker queue.
+And you have a background work queue for resizing the uploaded images into different thumbnail sizes.
+So, you will first need to insert a row for the uploaded image about the job into the database before you push the task to the work queue.
 
-Say you push the task to the worker queue immediately after you insert the `images` table then commit like this:
+Say you push the task to the work queue immediately after you insert the `images` table then commit like this:
 
 ```
 1. Insert into the "images" table
-2. Push resizing task to the worker queue
+2. Push resizing task to the work queue
 3. Commit db changes
 ```
 
@@ -268,21 +348,21 @@ While this might seem like the right way to do it, there's a hidden bug.
 If the worker starts too fast before the transaction commits at step 3, it will not be able to see the new row in `images` as it has not been committed yet.
 One may need to make the task retry a few times to ensure that even if the first attempt failed, it could see the image row in the following attempt.
 But this adds complexity to the system and also increases the latency if the first attempt fails.
-Also, if the commit step fails, you will have a failed worker queue job trying to fetch a row from the database that will never exist.
+Also, if the commit step fails, you will have a failed work queue job trying to fetch a row from the database that will never exist.
 
 Another approach is to push the resize task after the database changes are committed. It works like this:
 
 ```
 1. Insert into the "images" table
 2. Commit db changes
-3. Push resizing task to the worker queue
+3. Push resizing task to the work queue
 ```
 
 With this approach, we don't need to worry about workers picking up the task too early.
 However, there's another drawback.
-If step 3 for pushing a new task to the worker queue fails, the newly inserted `images` row will never be processed.
-There are many solutions to this problem, but these are all caused by inconsistent data views between the database and the worker queue storage.
-Things will be much easier if we have a worker queue that shares the same consistent view with the worker queue.
+If step 3 for pushing a new task to the work queue fails, the newly inserted `images` row will never be processed.
+There are many solutions to this problem, but these are all caused by inconsistent data views between the database and the work queue storage.
+Things will be much easier if we have a work queue that shares the same consistent view with the database.
 
 By using a database as the data storage, all the problems are gone.
 You can simply do the following:
@@ -294,15 +374,15 @@ You can simply do the following:
 ```
 
 It's all or nothing!
-By doing so, you don't need to maintain another worker queue backend.
-You are probably using a database anyway, so this worker queue comes for free.
+By doing so, you don't need to maintain another work queue backend.
+You are probably using a database anyway, so this work queue comes for free.
 
-Usually, a database is inefficient as the worker queues data storage because of the potential lock contention and the need for constant querying.
+Usually, a database is inefficient as the work queues data storage because of the potential lock contention and the need for constant querying.
 However, things have changed since the [introduction of the SKIP LOCKED](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) / [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) features in PostgreSQL or other databases.
 
-This project is inspired by many of the SKIP-LOCKED-based worker queue successors.
+This project is inspired by many of the SKIP-LOCKED-based work queue successors.
 Why don't we just use those existing tools?
-Well, because while they work great as worker queue solutions, they don't take advantage of writing tasks and their relative data into the database in a transaction.
+Well, because while they work great as work queue solutions, they don't take advantage of writing tasks and their relative data into the database in a transaction.
 Many provide an abstraction function or gRPC method of pushing tasks into the database instead of opening it up for the user to insert the row directly with other rows and commit altogether.
 
 With BeanQueue, we don't abstract away the logic of publishing a new task into the queue.
@@ -319,6 +399,8 @@ A modern accounting book service based on the most popular open source version c
 ## Alternatives
 
 - [solid_queue](https://github.com/rails/solid_queue)
+- [good_job](https://github.com/bensheldon/good_job)
+- [graphile-worker](https://github.com/graphile/worker)
 - [postgres-tq](https://github.com/flix-tech/postgres-tq)
 - [pq](https://github.com/malthe/pq/)
 - [PgQueuer](https://github.com/janbjorge/PgQueuer)

{beanqueue-0.2.3 → beanqueue-1.1.0}/README.md

@@ -1,5 +1,5 @@
 # BeanQueue  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/LaunchPlatform/bq/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/LaunchPlatform/beanhub-extract/tree/master)
-BeanQueue, a lightweight worker queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
+BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
 
 **Notice**: Still in its early stage, we built this for [BeanHub](https://beanhub.io)'s internal usage. May change rapidly. Use at your own risk for now.
 
@@ -9,8 +9,10 @@ BeanQueue, a lightweight worker queue framework based on [SQLAlchemy](https://ww
 - **Easy-to-deploy**: Only rely on PostgreSQL
 - **Easy-to-use**: Provide command line tools for processing tasks, also helpers for generating tasks models
 - **Auto-notify**: Notify will automatically be generated and send for inserted or update tasks
+- **Retry**: Built-in and customizable retry-policies
+- **Schedule**: Schedule task to run later
 - **Worker heartbeat and auto-reschedule**: Each worker keeps updating heartbeat, if one is found dead, the others will reschedule the tasks
-- **Customizable**: Use it as an library and build your own worker queue
+- **Customizable**: Use it as an library and build your own work queue
 - **Native DB operations**: Commit your tasks with other db entries altogether without worrying about data inconsistent issue
 
 ## Install
@@ -91,20 +93,92 @@ db.commit()
 To run the worker, you can do this:
 
 ```bash
-BQ_PROCESSOR_PACKAGES='["my_pkgs.processors"]' python -m bq.cmds.process images
+BQ_PROCESSOR_PACKAGES='["my_pkgs.processors"]' bq process images
 ```
 
 The `BQ_PROCESSOR_PACKAGES` is a JSON list contains the Python packages where you define your processors (the functions you decorated with `bq.processors.registry.processor`).
 To submit a task for testing purpose, you can do
 
 ```bash
-python -m bq.cmds.submit images my_pkgs.processors resize_image -k '{"width": 200, "height": 300}'
+bq submit images my_pkgs.processors resize_image -k '{"width": 200, "height": 300}'
 ```
 
 To create tables for BeanQueue, you can run
 
 ```bash
-python -m bq.cmds.create_tables
+bq create_tables
+```
+
+### Schedule
+
+In most cases, a task will be executed as soon as possible after it is created.
+To run a task later, you can set a datetime value to the `scheduled_at` attribute of the task model.
+For example:
+
+```python
+import datetime
+
+db = Session()
+task = resize_image.run(width=200, height=300)
+task.scheduled_at = func.now() + datetime.timedelta(minutes=3)
+db.add(task)
+```
+
+Please note that currently, workers won't wake up at the next exact moment when the scheduled tasks are ready to run.
+It has to wait until the polling times out, and eventually, it will see the task's scheduled_at time exceeds the current datetime.
+Therefore, depending on your `POLL_TIMEOUT` setting and the number of your workers when they started processing, the actual execution may be inaccurate.
+If you set the `POLL_TIMEOUT` to 60 seconds, please expect less than 60 seconds of delay.
+
+### Retry
+
+To automatically retry a task after failure, you can specify a retry policy to the processor.
+
+```python
+import datetime
+import bq
+from sqlalchemy.orm import Session
+
+app = bq.BeanQueue()
+delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
+
+@app.processor(channel="images", retry_policy=delay_retry)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
+```
+
+Currently, we provide some simple common retry policies such as `DelayRetry` and `ExponentialBackoffRetry`.
+Surely, you can define your retry policy easily by making a function that returns an optional object at the next scheduled time for retry.
+
+```python
+def my_retry_policy(task: bq.Task) -> typing.Any:
+    # calculate delay based on task model ...
+    return func.now() + datetime.timedelta(seconds=delay)
+```
+
+To cap how many attempts is allowed, you can also use `LimitAttempt` like this:
+
+```python
+delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
+capped_delay_retry = bq.LimitAttempt(3, delay_retry)
+
+@app.processor(channel="images", retry_policy=capped_delay_retry)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
+```
+
+You can also retry only for specific exception classes with the `retry_exceptions` argument.
+
+```python
+@app.processor(
+    channel="images",
+    retry_policy=delay_retry,
+    retry_exceptions=ValueError,
+)
+def resize_image(db: Session, task: bq.Task, width: int, height: int):
+    # resize iamge here ...
+    pass
 ```
 
 ### Configurations
@@ -125,7 +199,7 @@ container = bq.Container()
 container.wire(packages=[bq])
 config = bq.Config(
     PROCESSOR_PACKAGES=["my_pkgs.processors"],
-    DATABASE_URL=str(config.DATABASE_URL),
+    DATABASE_URL=config.DATABASE_URL,
     BATCH_SIZE=10,
 )
 app = bq.BeanQueue(config=config)
@@ -134,7 +208,7 @@ app = bq.BeanQueue(config=config)
 Then you can pass `--app` argument (or `-a` for short) pointing to the app object to the process command like this:
 
 ```bash
-python -m bq.cmds.process -a my_pkgs.bq.app images
+bq -a my_pkgs.bq.app process images
 ```
 
 Or if you prefer to define your own process command, you can also call `process_tasks` of the `BeanQueue` object directly like this:
@@ -148,12 +222,16 @@ app.process_tasks(channels=("images",))
 BeanQueue is designed to be as customizable as much as possible.
 Of course, you can define your own SQLAlchemy model instead of using the ones we provided. 
 
-To make defining your own `Task` model or `Worker` model much easier, you can use our mixin classes:
+To make defining your own `Task`, `Worker` or `Event` model much easier, you can use our mixin classes:
 
 - `bq.TaskModelMixin`: provides task model columns
 - `bq.TaskModelRefWorkerMixin`: provides foreign key column and relationship to `bq.Worker`
+- `bq.TaskModelRefParentMixin`: provides foreign key column and relationship to children `bq.Task` created during processing
+- `bq.TaskModelRefEventMixin`: provides foreign key column and relationship to `bq.Event`
 - `bq.WorkerModelMixin`: provides worker model columns
 - `bq.WorkerRefMixin`: provides relationship to `bq.Task`
+- `bq.EventModelMixin`: provides event model columns
+- `bq.EventModelRefTaskMixin`: provides foreign key column and relationship to `bq.Task`
 
 Here's an example for defining your own Task model:
 
@@ -212,13 +290,14 @@ class Worker(bq.WorkerModelMixin, Base):
     )
 ```
 
-With the model class ready, you only need to change the `TASK_MODEL` and `WORKER_MODEL` of `Config` to the full Python module name plus the class name like this.
+With the model class ready, you only need to change the `TASK_MODEL`, `WORKER_MODEL` and `EVENT_MODEL` of `Config` to the full Python module name plus the class name like this.
 
 ```python
 import bq
 config = bq.Config(
     TASK_MODEL="my_pkgs.models.Task",
     WORKER_MODEL="my_pkgs.models.Worker",
+    EVENT_MODEL="my_pkgs.models.Event",
     # ... other configs
 )
 app = bq.BeanQueue(config)
@@ -226,21 +305,21 @@ app = bq.BeanQueue(config)
 
 ## Why?
 
-There are countless worker queue projects. Why make yet another one?
-The primary issue with most worker queue tools is their reliance on a standalone broker server.
-Our worker queue tasks frequently interact with the database, and the atomic nature of database transactions is great for data integrity.
-However, integrating an external worker queue into the system presents a risk.
-The worker queue and the database don't share the same data view, potentially compromising data integrity and reliability.
+There are countless work queue projects. Why make yet another one?
+The primary issue with most work queue tools is their reliance on a standalone broker server.
+Our work queue tasks frequently interact with the database, and the atomic nature of database transactions is great for data integrity.
+However, integrating an external work queue into the system presents a risk.
+The work queue and the database don't share the same data view, potentially compromising data integrity and reliability.
 
 For example, you have a table of `images` to keep the user-uploaded images.
-And you have a background worker queue for resizing the uploaded images into different thumbnail sizes.
-So, you will first need to insert a row for the uploaded image about the job into the database before you push the task to the worker queue.
+And you have a background work queue for resizing the uploaded images into different thumbnail sizes.
+So, you will first need to insert a row for the uploaded image about the job into the database before you push the task to the work queue.
 
-Say you push the task to the worker queue immediately after you insert the `images` table then commit like this:
+Say you push the task to the work queue immediately after you insert the `images` table then commit like this:
 
 ```
 1. Insert into the "images" table
-2. Push resizing task to the worker queue
+2. Push resizing task to the work queue
 3. Commit db changes
 ```
 
@@ -248,21 +327,21 @@ While this might seem like the right way to do it, there's a hidden bug.
 If the worker starts too fast before the transaction commits at step 3, it will not be able to see the new row in `images` as it has not been committed yet.
 One may need to make the task retry a few times to ensure that even if the first attempt failed, it could see the image row in the following attempt.
 But this adds complexity to the system and also increases the latency if the first attempt fails.
-Also, if the commit step fails, you will have a failed worker queue job trying to fetch a row from the database that will never exist.
+Also, if the commit step fails, you will have a failed work queue job trying to fetch a row from the database that will never exist.
 
 Another approach is to push the resize task after the database changes are committed. It works like this:
 
 ```
 1. Insert into the "images" table
 2. Commit db changes
-3. Push resizing task to the worker queue
+3. Push resizing task to the work queue
 ```
 
 With this approach, we don't need to worry about workers picking up the task too early.
 However, there's another drawback.
-If step 3 for pushing a new task to the worker queue fails, the newly inserted `images` row will never be processed.
-There are many solutions to this problem, but these are all caused by inconsistent data views between the database and the worker queue storage.
-Things will be much easier if we have a worker queue that shares the same consistent view with the worker queue.
+If step 3 for pushing a new task to the work queue fails, the newly inserted `images` row will never be processed.
+There are many solutions to this problem, but these are all caused by inconsistent data views between the database and the work queue storage.
+Things will be much easier if we have a work queue that shares the same consistent view with the database.
 
 By using a database as the data storage, all the problems are gone.
 You can simply do the following:
@@ -274,15 +353,15 @@ You can simply do the following:
 ```
 
 It's all or nothing!
-By doing so, you don't need to maintain another worker queue backend.
-You are probably using a database anyway, so this worker queue comes for free.
+By doing so, you don't need to maintain another work queue backend.
+You are probably using a database anyway, so this work queue comes for free.
 
-Usually, a database is inefficient as the worker queues data storage because of the potential lock contention and the need for constant querying.
+Usually, a database is inefficient as the work queues data storage because of the potential lock contention and the need for constant querying.
 However, things have changed since the [introduction of the SKIP LOCKED](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) / [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) features in PostgreSQL or other databases.
 
-This project is inspired by many of the SKIP-LOCKED-based worker queue successors.
+This project is inspired by many of the SKIP-LOCKED-based work queue successors.
 Why don't we just use those existing tools?
-Well, because while they work great as worker queue solutions, they don't take advantage of writing tasks and their relative data into the database in a transaction.
+Well, because while they work great as work queue solutions, they don't take advantage of writing tasks and their relative data into the database in a transaction.
 Many provide an abstraction function or gRPC method of pushing tasks into the database instead of opening it up for the user to insert the row directly with other rows and commit altogether.
 
 With BeanQueue, we don't abstract away the logic of publishing a new task into the queue.
@@ -299,6 +378,8 @@ A modern accounting book service based on the most popular open source version c
 ## Alternatives
 
 - [solid_queue](https://github.com/rails/solid_queue)
+- [good_job](https://github.com/bensheldon/good_job)
+- [graphile-worker](https://github.com/graphile/worker)
 - [postgres-tq](https://github.com/flix-tech/postgres-tq)
 - [pq](https://github.com/malthe/pq/)
 - [PgQueuer](https://github.com/janbjorge/PgQueuer)

beanqueue-1.1.0/bq/__init__.py

@@ -0,0 +1,19 @@
+from .app import BeanQueue
+from .config import Config  # noqa
+from .models import Event
+from .models import EventModelMixin
+from .models import EventModelRefTaskMixin
+from .models import EventType
+from .models import Task  # noqa
+from .models import TaskModelMixin
+from .models import TaskModelRefEventMixin
+from .models import TaskModelRefParentMixin
+from .models import TaskModelRefWorkerMixin
+from .models import TaskState  # noqa
+from .models import Worker  # noqa
+from .models import WorkerModelMixin  # noqa
+from .models import WorkerRefMixin  # noqa
+from .models import WorkerState  # noqa
+from .processors.retry_policies import DelayRetry
+from .processors.retry_policies import ExponentialBackoffRetry
+from .processors.retry_policies import LimitAttempt

{beanqueue-0.2.3 → beanqueue-1.1.0}/bq/app.py

@@ -7,6 +7,8 @@ import sys
 import threading
 import time
 import typing
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
 from wsgiref.simple_server import make_server
 from wsgiref.simple_server import WSGIRequestHandler
 
@@ -84,6 +86,12 @@ class BeanQueue:
     def worker_model(self) -> typing.Type[models.Worker]:
         return load_module_var(self.config.WORKER_MODEL)
 
+    @property
+    def event_model(self) -> typing.Type[models.Event] | None:
+        if self.config.EVENT_MODEL is None:
+            return
+        return load_module_var(self.config.EVENT_MODEL)
+
     def _make_worker_service(self, session: DBSession):
         return self.worker_service_cls(
             session=session, task_model=self.task_model, worker_model=self.worker_model
@@ -96,7 +104,8 @@ class BeanQueue:
         self,
         channel: str = constants.DEFAULT_CHANNEL,
         auto_complete: bool = True,
-        auto_rollback_on_exc: bool = True,
+        retry_policy: typing.Callable | None = None,
+        retry_exceptions: typing.Type | typing.Tuple[typing.Type, ...] | None = None,
         task_model: typing.Type | None = None,
     ) -> typing.Callable:
         def decorator(wrapped: typing.Callable):
@@ -106,7 +115,8 @@ class BeanQueue:
                 channel=channel,
                 func=wrapped,
                 auto_complete=auto_complete,
-                auto_rollback_on_exc=auto_rollback_on_exc,
+                retry_policy=retry_policy,
+                retry_exceptions=retry_exceptions,
             )
             helper_obj = ProcessorHelper(
                 processor,
@@ -241,6 +251,15 @@ class BeanQueue:
         self,
         channels: tuple[str, ...],
     ):
+        try:
+            bq_version = version(__name__.split(".")[0])
+        except PackageNotFoundError:
+            bq_version = "unknown"
+
+        logger.info(
+            "Starting processing tasks, bq_version=%s",
+            bq_version,
+        )
         db = self.make_session()
         if not channels:
             channels = [constants.DEFAULT_CHANNEL]
@@ -318,7 +337,7 @@ class BeanQueue:
                             task.func_name,
                         )
                         # TODO: support processor pool and other approaches to dispatch the workload
-                        registry.process(task)
+                        registry.process(task, event_cls=self.event_model)
                     if not tasks:
                         # we should try to keep dispatching until we cannot find tasks
                         break

beanqueue-1.1.0/bq/cmds/cli.py

@@ -0,0 +1,39 @@
+import logging
+import os
+
+import click
+from rich.logging import RichHandler
+
+from .environment import Environment
+from .environment import LOG_LEVEL_MAP
+from .environment import LogLevel
+from .environment import pass_env
+from .utils import load_app
+
+
+@click.group(help="Command line tools for BeanQueue")
+@click.option(
+    "-l",
+    "--log-level",
+    type=click.Choice(
+        list(map(lambda key: key.value, LOG_LEVEL_MAP.keys())), case_sensitive=False
+    ),
+    default=lambda: os.environ.get("LOG_LEVEL", "INFO"),
+)
+@click.option(
+    "-a", "--app", type=str, help='BeanQueue app object to use, e.g. "my_pkgs.bq.app"'
+)
+@click.version_option(prog_name="bq", package_name="bq")
+@pass_env
+def cli(env: Environment, log_level: str, app: str):
+    env.log_level = LogLevel(log_level)
+    env.app = load_app(app)
+
+    FORMAT = "%(message)s"
+    logging.basicConfig(
+        level=LOG_LEVEL_MAP[env.log_level],
+        format=FORMAT,
+        datefmt="[%X]",
+        handlers=[RichHandler()],
+        force=True,
+    )

beanqueue-1.1.0/bq/cmds/create_tables.py

@@ -0,0 +1,12 @@
+from .. import models  # noqa
+from ..db.base import Base
+from .cli import cli
+from .environment import Environment
+from .environment import pass_env
+
+
+@cli.command(name="create_tables", help="Create BeanQueue tables")
+@pass_env
+def create_tables(env: Environment):
+    Base.metadata.create_all(bind=env.app.engine)
+    env.logger.info("Done, tables created")