beanqueue 1.1.5__tar.gz → 1.1.7__tar.gz

beanqueue-1.1.7/.gitignore

@@ -0,0 +1,161 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+.idea

{beanqueue-1.1.5 → beanqueue-1.1.7}/PKG-INFO

@@ -1,25 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: beanqueue
-Version: 1.1.5
+Version: 1.1.7
 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
-Requires-Python: >=3.11,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-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)
+Author-email: Fang-Pen Lin <fangpen@launchplatform.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: ~=3.11
+Requires-Dist: blinker<2,>=1.8.2
+Requires-Dist: click<9,>=8.1.7
+Requires-Dist: pydantic-settings<3,>=2.2.1
+Requires-Dist: rich<14,>=13.7.1
+Requires-Dist: sqlalchemy<3,>=2.0.30
+Requires-Dist: venusian<4,>=3.1.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 [![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 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.
@@ -27,14 +23,14 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 ## Features
 
 - **Super lightweight**: Under 1K lines
-- **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
+- **Easy-to-deploy**: Only relies on PostgreSQL
+- **Transactional**: Commit your tasks with other database entries altogether without worrying about data inconsistencies
+- **Easy-to-use**: Built-in command line tools for processing tasks and helpers for generating task models
+- **Auto-notify**: Automatic generation of NOTIFY statements for new or updated tasks, ensuring fast task processing
+- **Retry**: Built-in and customizable retry policies
+- **Schedule**: Schedule tasks 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 work queue
-- **Native DB operations**: Commit your tasks with other db entries altogether without worrying about data inconsistent issue
+- **Customizable**: Custom Task, Worker and Event models. Use it as a library and build your own work queue
 
 ## Install
 
@@ -44,7 +40,7 @@ pip install beanqueue
 
 ## Usage
 
-You can define a task processor like this
+You can define a basic task processor like this
 
 ```python
 from sqlalchemy.orm import Session
@@ -164,20 +160,20 @@ 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 ...
+    # resize image 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.
+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 ...
+    # 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:
+To cap how many attempts are allowed, you can also use `LimitAttempt` like this:
 
 ```python
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
@@ -185,7 +181,7 @@ 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 ...
+    # Resize image here ...
     pass
 ```
 
@@ -198,7 +194,7 @@ You can also retry only for specific exception classes with the `retry_exception
     retry_exceptions=ValueError,
 )
 def resize_image(db: Session, task: bq.Task, width: int, height: int):
-    # resize iamge here ...
+    # resize image here ...
     pass
 ```
 
@@ -216,8 +212,6 @@ For example:
 import bq
 from .my_config import config
 
-container = bq.Container()
-container.wire(packages=[bq])
 config = bq.Config(
     PROCESSOR_PACKAGES=["my_pkgs.processors"],
     DATABASE_URL=config.DATABASE_URL,
@@ -241,9 +235,9 @@ app.process_tasks(channels=("images",))
 ### Define your own tables
 
 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. 
+One of its key features is that you can define your own SQLAlchemy model instead of using the ones we provided.
 
-To make defining your own `Task`, `Worker` or `Event` model much easier, you can use our mixin classes:
+To make defining your own `Task`, `Worker` or `Event` model much easier, use bq's mixin classes:
 
 - `bq.TaskModelMixin`: provides task model columns
 - `bq.TaskModelRefWorkerMixin`: provides foreign key column and relationship to `bq.Worker`
@@ -259,12 +253,13 @@ Here's an example for defining your own Task model:
 ```python
 import uuid
 
-import bq
 from sqlalchemy import ForeignKey
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.orm import Mapped
 from sqlalchemy.orm import mapped_column
 from sqlalchemy.orm import relationship
+import bq
+from bq.models.task import listen_events
 
 from .base_class import Base
 
@@ -281,15 +276,14 @@ class Task(bq.TaskModelMixin, Base):
     worker: Mapped["Worker"] = relationship(
         "Worker", back_populates="tasks", uselist=False
     )
-```
 
-To make task insert and update with state changing to `PENDING` send out NOTIFY "channel" statement automatically, you can also use `bq.models.task.listen_events` helper to register our SQLAlchemy event handlers automatically like this
-
-```python
-from bq.models.task import listen_events
 listen_events(Task)
 ```
 
+For task insertion and updates to notify workers, we need to register any custom task types with `bq.models.task.listen_events`.
+In the example above, this is done right after the Task model definition.
+For more details and advanced usage, see the definition of `bq.models.task.listen_events`.
+
 You just see how easy it is to define your Task model. Now, here's an example for defining your own Worker model:
 
 ```python
@@ -362,7 +356,7 @@ With this approach, we don't need to worry about workers picking up the task too
 However, there's another drawback.
 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.
+Things would be much easier if we had a work queue that shared the same consistent view as the database.
 
 By using a database as the data storage, all the problems are gone.
 You can simply do the following:
@@ -383,10 +377,10 @@ However, things have changed since the [introduction of the SKIP LOCKED](https:/
 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 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.
+Many provide an abstraction function or gRPC method for pushing tasks into the database, rather than allowing users to directly insert rows and commit them together.
 
-With BeanQueue, we don't abstract away the logic of publishing a new task into the queue.
-Instead, we open it up to let the user insert the row and choose when and what to commit to the task.
+BeanQueue doesn't overly abstract the logic of publishing a new task into the queue.
+Instead, you insert rows directly, choosing when and what to commit as tasks.
 
 ## Sponsor
 
@@ -406,4 +400,3 @@ A modern accounting book service based on the most popular open source version c
 - [PgQueuer](https://github.com/janbjorge/PgQueuer)
 - [hatchet](https://github.com/hatchet-dev/hatchet)
 - [procrastinate](https://github.com/procrastinate-org/procrastinate)
-

{beanqueue-1.1.5 → beanqueue-1.1.7}/README.md

@@ -1,4 +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 [![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 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.
@@ -6,14 +7,14 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 ## Features
 
 - **Super lightweight**: Under 1K lines
-- **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
+- **Easy-to-deploy**: Only relies on PostgreSQL
+- **Transactional**: Commit your tasks with other database entries altogether without worrying about data inconsistencies
+- **Easy-to-use**: Built-in command line tools for processing tasks and helpers for generating task models
+- **Auto-notify**: Automatic generation of NOTIFY statements for new or updated tasks, ensuring fast task processing
+- **Retry**: Built-in and customizable retry policies
+- **Schedule**: Schedule tasks 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 work queue
-- **Native DB operations**: Commit your tasks with other db entries altogether without worrying about data inconsistent issue
+- **Customizable**: Custom Task, Worker and Event models. Use it as a library and build your own work queue
 
 ## Install
 
@@ -23,7 +24,7 @@ pip install beanqueue
 
 ## Usage
 
-You can define a task processor like this
+You can define a basic task processor like this
 
 ```python
 from sqlalchemy.orm import Session
@@ -143,20 +144,20 @@ 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 ...
+    # resize image 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.
+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 ...
+    # 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:
+To cap how many attempts are allowed, you can also use `LimitAttempt` like this:
 
 ```python
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
@@ -164,7 +165,7 @@ 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 ...
+    # Resize image here ...
     pass
 ```
 
@@ -177,7 +178,7 @@ You can also retry only for specific exception classes with the `retry_exception
     retry_exceptions=ValueError,
 )
 def resize_image(db: Session, task: bq.Task, width: int, height: int):
-    # resize iamge here ...
+    # resize image here ...
     pass
 ```
 
@@ -195,8 +196,6 @@ For example:
 import bq
 from .my_config import config
 
-container = bq.Container()
-container.wire(packages=[bq])
 config = bq.Config(
     PROCESSOR_PACKAGES=["my_pkgs.processors"],
     DATABASE_URL=config.DATABASE_URL,
@@ -220,9 +219,9 @@ app.process_tasks(channels=("images",))
 ### Define your own tables
 
 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. 
+One of its key features is that you can define your own SQLAlchemy model instead of using the ones we provided.
 
-To make defining your own `Task`, `Worker` or `Event` model much easier, you can use our mixin classes:
+To make defining your own `Task`, `Worker` or `Event` model much easier, use bq's mixin classes:
 
 - `bq.TaskModelMixin`: provides task model columns
 - `bq.TaskModelRefWorkerMixin`: provides foreign key column and relationship to `bq.Worker`
@@ -238,12 +237,13 @@ Here's an example for defining your own Task model:
 ```python
 import uuid
 
-import bq
 from sqlalchemy import ForeignKey
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.orm import Mapped
 from sqlalchemy.orm import mapped_column
 from sqlalchemy.orm import relationship
+import bq
+from bq.models.task import listen_events
 
 from .base_class import Base
 
@@ -260,15 +260,14 @@ class Task(bq.TaskModelMixin, Base):
     worker: Mapped["Worker"] = relationship(
         "Worker", back_populates="tasks", uselist=False
     )
-```
 
-To make task insert and update with state changing to `PENDING` send out NOTIFY "channel" statement automatically, you can also use `bq.models.task.listen_events` helper to register our SQLAlchemy event handlers automatically like this
-
-```python
-from bq.models.task import listen_events
 listen_events(Task)
 ```
 
+For task insertion and updates to notify workers, we need to register any custom task types with `bq.models.task.listen_events`.
+In the example above, this is done right after the Task model definition.
+For more details and advanced usage, see the definition of `bq.models.task.listen_events`.
+
 You just see how easy it is to define your Task model. Now, here's an example for defining your own Worker model:
 
 ```python
@@ -341,7 +340,7 @@ With this approach, we don't need to worry about workers picking up the task too
 However, there's another drawback.
 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.
+Things would be much easier if we had a work queue that shared the same consistent view as the database.
 
 By using a database as the data storage, all the problems are gone.
 You can simply do the following:
@@ -362,10 +361,10 @@ However, things have changed since the [introduction of the SKIP LOCKED](https:/
 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 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.
+Many provide an abstraction function or gRPC method for pushing tasks into the database, rather than allowing users to directly insert rows and commit them together.
 
-With BeanQueue, we don't abstract away the logic of publishing a new task into the queue.
-Instead, we open it up to let the user insert the row and choose when and what to commit to the task.
+BeanQueue doesn't overly abstract the logic of publishing a new task into the queue.
+Instead, you insert rows directly, choosing when and what to commit as tasks.
 
 ## Sponsor
 

{beanqueue-1.1.5 → beanqueue-1.1.7}/bq/app.py

@@ -5,7 +5,6 @@ import logging
 import platform
 import sys
 import threading
-import time
 import typing
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
@@ -63,6 +62,9 @@ class BeanQueue:
         self.worker_service_cls = worker_service_cls
         self.dispatch_service_cls = dispatch_service_cls
         self._engine = engine
+        self._worker_update_shutdown_event: threading.Event = threading.Event()
+        # noop if metrics thread is not started yet, shutdown if it is started
+        self._metrics_server_shutdown: typing.Callable[[], None] = lambda: None
 
     def create_default_engine(self):
         return create_engine(
@@ -184,7 +186,12 @@ class BeanQueue:
                 )
                 sys.exit(0)
 
-            time.sleep(self.config.WORKER_HEARTBEAT_PERIOD)
+            do_shutdown = self._worker_update_shutdown_event.wait(
+                self.config.WORKER_HEARTBEAT_PERIOD
+            )
+            if do_shutdown:
+                return
+
             current_worker.last_heartbeat = func.now()
             db.add(current_worker)
             db.commit()
@@ -244,6 +251,8 @@ class BeanQueue:
             functools.partial(self._serve_http_request, worker_id),
             handler_class=WSGIRequestHandlerWithLogger,
         ) as httpd:
+            # expose graceful shutdown to the main thread
+            self._metrics_server_shutdown = httpd.shutdown
             logger.info("Run metrics HTTP server on %s:%s", host, port)
             httpd.serve_forever()
 
@@ -307,7 +316,7 @@ class BeanQueue:
         events.worker_init.send(self, worker=worker)
 
         logger.info("Processing tasks in channels = %s ...", channels)
-
+        # Graceful shutdown of worker update event on exit of the worker
         worker_update_thread = threading.Thread(
             target=functools.partial(
                 self.update_workers,
@@ -357,9 +366,13 @@ class BeanQueue:
         except (SystemExit, KeyboardInterrupt):
             db.rollback()
             logger.info("Shutting down ...")
+            self._worker_update_shutdown_event.set()
             worker_update_thread.join(5)
             if metrics_server_thread is not None:
-                metrics_server_thread.join(5)
+                # set a threading event, waits until server is shutdown
+                # serve the ongoing requests
+                self._metrics_server_shutdown()
+                metrics_server_thread.join(1)
 
         worker.state = models.WorkerState.SHUTDOWN
         db.add(worker)

{beanqueue-1.1.5 → beanqueue-1.1.7}/bq/config.py

@@ -1,5 +1,6 @@
 import typing
 
+from pydantic import Field
 from pydantic import field_validator
 from pydantic import PostgresDsn
 from pydantic import ValidationInfo
@@ -10,7 +11,7 @@ from pydantic_settings import SettingsConfigDict
 
 class Config(BaseSettings):
     # Packages to scan for processor functions
-    PROCESSOR_PACKAGES: list[str] = []
+    PROCESSOR_PACKAGES: list[str] = Field(default_factory=list)
 
     # Size of tasks batch to fetch each time from the database
     BATCH_SIZE: int = 1
@@ -58,8 +59,18 @@ class Config(BaseSettings):
     ) -> typing.Any:
         if isinstance(v, str):
             return v
-        if isinstance(v, MultiHostUrl):
-            return v
+        # Notice: Older Pydantic version (2.7), PostgresDsn is an annotated MultiHostUrl object,
+        #         we cannot use isinstance with PostgresDsn directly. We need to check and see if PostgresDsn
+        #         is an annotated type or not before we decide how to check if the passed in object is an
+        #         PostgresDsn or not.
+        if typing.get_origin(PostgresDsn) is typing.Annotated:
+            if isinstance(v, MultiHostUrl):
+                return v
+        else:
+            if isinstance(v, PostgresDsn):
+                return v
+        if v is not None:
+            raise ValueError("Unexpected DATABASE_URL type")
         return PostgresDsn.build(
             scheme="postgresql",
             username=info.data.get("POSTGRES_USER"),

beanqueue-1.1.7/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "beanqueue"
+version = "1.1.7"
+description = "BeanQueue or BQ for short, PostgreSQL SKIP LOCK and SQLAlchemy based worker queue library"
+authors = [{ name = "Fang-Pen Lin", email = "fangpen@launchplatform.com" }]
+requires-python = "~=3.11"
+readme = "README.md"
+license = "MIT"
+dependencies = [
+    "sqlalchemy>=2.0.30,<3",
+    "venusian>=3.1.0,<4",
+    "click>=8.1.7,<9",
+    "pydantic-settings>=2.2.1,<3",
+    "blinker>=1.8.2,<2",
+    "rich>=13.7.1,<14",
+]
+
+[project.scripts]
+bq = "bq.cmds.main:cli"
+
+[dependency-groups]
+dev = [
+    "psycopg2-binary>=2.9.9,<3",
+    "pytest-factoryboy>=2.7.0,<3",
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["bq"]
+
+[tool.hatch.build.targets.wheel]
+include = ["bq"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

beanqueue-1.1.5/pyproject.toml

@@ -1,32 +0,0 @@
-[tool.poetry]
-name = "beanqueue"
-version = "1.1.5"
-description = "BeanQueue or BQ for short, PostgreSQL SKIP LOCK and SQLAlchemy based worker queue library"
-authors = ["Fang-Pen Lin <fangpen@launchplatform.com>"]
-license = "MIT"
-readme = "README.md"
-packages = [
-    { include = "bq" },
-]
-
-[tool.poetry.scripts]
-bq = "bq.cmds.main:cli"
-
-[tool.poetry.dependencies]
-python = "^3.11"
-sqlalchemy = "^2.0.30"
-venusian = "^3.1.0"
-click = "^8.1.7"
-pydantic-settings = "^2.2.1"
-pg-activity = "^3.5.1"
-blinker = "^1.8.2"
-rich = "^13.7.1"
-
-
-[tool.poetry.group.dev.dependencies]
-psycopg2-binary = "^2.9.9"
-pytest-factoryboy = "^2.7.0"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"