PgQueuer 0.0.1__py3-none-any.whl

PgQueuer/__main__.py

@@ -0,0 +1,6 @@
+import asyncio
+
+from PgQueuer import cli
+
+if __name__ == "__main__":
+    asyncio.run(cli.main())

PgQueuer/_version.py

@@ -0,0 +1,17 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = "0.1.dev1+gac06244.d20240420"
+__version_tuple__ = version_tuple = (0, 1, "dev1", "gac06244.d20240420")

PgQueuer/cli.py

@@ -0,0 +1,130 @@
+import argparse
+import os
+
+import asyncpg
+
+from PgQueuer import queries
+
+
+def cliparser() -> argparse.Namespace:
+    common_arguments = argparse.ArgumentParser(
+        add_help=False,
+        prog="PgQueuer",
+    )
+
+    common_arguments.add_argument(
+        "--prefix",
+        default="",
+        help=(
+            "All PgQueuer tables/functions/etc... will start with this prefix. "
+            "(If set, addinal config is required.)"
+        ),
+    )
+
+    common_arguments.add_argument(
+        "--pg-dsn",
+        help=(
+            "Connection string in the libpq URI format, including host, port, user, "
+            "database, password, passfile, and SSL options. Must be properly quoted; "
+            "IPv6 addresses must be in brackets. "
+            "Example: postgres://user:pass@host:port/database. Defaults to PGDSN "
+            "environment variable if set."
+        ),
+        default=os.environ.get("PGDSN"),
+    )
+
+    common_arguments.add_argument(
+        "--pg-host",
+        help=(
+            "Database host address, which can be an IP or domain name. "
+            "Defaults to PGHOST environment variable if set."
+        ),
+        default=os.environ.get("PGHOST"),
+    )
+
+    common_arguments.add_argument(
+        "--pg-port",
+        help=(
+            "Port number for the server host Defaults to PGPORT environment variable "
+            "or 5432 if not set."
+        ),
+        default=os.environ.get("PGPORT", "5432"),
+    )
+
+    common_arguments.add_argument(
+        "--pg-user",
+        help=(
+            "Database role for authentication. Defaults to PGUSER environment "
+            "variable if set."
+        ),
+        default=os.environ.get("PGUSER"),
+    )
+
+    common_arguments.add_argument(
+        "--pg-database",
+        help=(
+            "Name of the database to connect to. Defaults to PGDATABASE environment "
+            "variable if set."
+        ),
+        default=os.environ.get("PGDATABASE"),
+    )
+
+    common_arguments.add_argument(
+        "--pg-password",
+        help=(
+            "Password for authentication. Defaults to PGPASSWORD "
+            "environment variable if set"
+        ),
+        default=os.environ.get("PGPASSWORD"),
+    )
+
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        prog="pgcachewatch",
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+
+    subparsers.add_parser(
+        "install",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        parents=[common_arguments],
+    )
+
+    subparsers.add_parser(
+        "uninstall",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        parents=[common_arguments],
+    )
+
+    return parser.parse_args()
+
+
+async def main() -> None:
+    parsed = cliparser()
+
+    if (
+        "PGQUEUER_PREFIX" not in os.environ
+        and isinstance(prefix := parsed.prefix, str)
+        and prefix
+    ):
+        os.environ["PGQUEUER_PREFIX"] = prefix
+
+    async with asyncpg.create_pool(
+        parsed.pg_dsn,
+        database=parsed.pg_database,
+        password=parsed.pg_password,
+        port=parsed.pg_port,
+        user=parsed.pg_user,
+        host=parsed.pg_host,
+        min_size=0,
+        max_size=1,
+    ) as pool:
+        match parsed.command:
+            case "install":
+                await queries.InstallUninstallQueries(pool=pool).install()
+            case "uninstall":
+                await queries.InstallUninstallQueries(pool=pool).uninstall()

PgQueuer/logconfig.py

@@ -0,0 +1,7 @@
+import logging
+import os
+from typing import Final
+
+logging.basicConfig()
+logger: Final = logging.getLogger("pgqueuer")
+logger.setLevel(level=os.environ.get("LOGLEVEL", "INFO").upper())

PgQueuer/models.py

@@ -0,0 +1,32 @@
+from typing import Literal
+
+from pydantic import AwareDatetime, BaseModel, RootModel
+
+STATUS = Literal[
+    "queued",
+    "picked",
+]
+STATUS_LOG = Literal[
+    "exception",
+    "successful",
+]
+
+
+class Job(BaseModel):
+    """
+    Represents a job with attributes such as ID, priority,
+    creation time, status, entrypoint, and optional payload.
+    """
+
+    id: int
+    priority: int
+    created: AwareDatetime
+    status: STATUS
+    entrypoint: str
+    payload: bytes | None
+
+
+class Jobs(RootModel[list[Job]]):
+    """
+    A collection model that encapsulates a list of Job instances.
+    """

PgQueuer/qm.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+from typing import Awaitable, Callable, TypeAlias, TypeVar
+
+import asyncpg
+from pgcachewatch.listeners import PGEventQueue
+from pgcachewatch.models import PGChannel
+
+from .logconfig import logger
+from .models import Job
+from .queries import PgQueuerLogQueries, PgQueuerQueries
+from .tm import TaskManager
+
+EntrypointFn: TypeAlias = Callable[[bytes | None], Awaitable[None]]
+T = TypeVar("T", bound=EntrypointFn)
+
+
+@dataclasses.dataclass
+class QueueManager:
+    """
+    Manages job queues and dispatches jobs to registered entry points,
+    handling database connections and events.
+    """
+
+    pool: asyncpg.Pool
+    q: PgQueuerQueries = dataclasses.field(init=False)
+    ql: PgQueuerLogQueries = dataclasses.field(init=False)
+
+    channel: PGChannel = dataclasses.field(
+        default=PGChannel("ch_pgqueuer"),
+        init=False,
+    )
+    alive: bool = dataclasses.field(
+        init=False,
+        default=True,
+    )
+    # Should registry be a weakref?
+    registry: dict[str, EntrypointFn] = dataclasses.field(
+        init=False,
+        default_factory=dict,
+    )
+    tm: TaskManager = dataclasses.field(
+        init=False,
+        default_factory=TaskManager,
+    )
+
+    def __post_init__(self) -> None:
+        """
+        Initializes database query handlers and validates pool size upon
+        instance creation.
+        """
+        if self.pool.get_min_size() < 1:
+            raise ValueError("... min size must be gt 1.")
+        self.q = PgQueuerQueries(self.pool)
+        self.ql = PgQueuerLogQueries(self.pool)
+
+    def entrypoint(self, name: str) -> Callable[[T], T]:
+        """
+        Decorator to register a function as an entrypoint for
+        handling specific job types.
+        """
+
+        def register(func: T) -> T:
+            if name in self.registry:
+                raise RuntimeError(f"{name} already in registry, must be unique.")
+            self.registry[name] = func
+            return func
+
+        return register
+
+    async def run(self) -> None:
+        """
+        Starts the event listener and continuously dispatches jobs to
+        registered entry points until stopped.
+        """
+        async with self.pool.acquire() as conn:
+            listener = PGEventQueue()
+            await listener.connect(conn, self.channel)
+
+            while self.alive:
+                while (jobs := await self.q.dequeue()).root:
+                    for job in jobs.root:
+                        self._dispatch(job)
+                await listener.get()
+
+            await asyncio.gather(*self.tm.tasks)
+
+    def _dispatch(self, job: Job) -> None:
+        """
+        Internal method to asynchronously handle job dispatch,
+        including exception logging and job status updates.
+        """
+
+        async def runit() -> None:
+            logger.debug(
+                "Dispatching entrypoint/id: %s/%s",
+                job.entrypoint,
+                job.id,
+            )
+            try:
+                await self.registry[job.entrypoint](job.payload)
+            except Exception:
+                logger.exception(
+                    "Exception while processing entrypoint/id: %s/%s",
+                    job.entrypoint,
+                    job.id,
+                )
+                await self.ql.move_job_log(job, "exception")
+            else:
+                logger.debug(
+                    "Dispatching entrypoint/id: %s/%s - successful",
+                    job.entrypoint,
+                    job.id,
+                )
+                await self.ql.move_job_log(job, "successful")
+
+        self.tm.add(asyncio.create_task(runit()))

PgQueuer/queries.py

@@ -0,0 +1,281 @@
+import dataclasses
+import os
+from typing import Final
+
+import asyncpg
+
+from . import models
+
+
+def add_prefix(string: str) -> str:
+    """
+    Appends a predefined prefix from environment variables to
+    the given string, typically used for database object names.
+    """
+    return f"{os.environ.get('PGQUEUER_PREFIX', '')}{string}"
+
+
+@dataclasses.dataclass
+class DBSettings:
+    """
+    Stores database settings such as table names and SQL
+    function names, dynamically appending prefixes from
+    environment variables.
+    """
+
+    channel: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("ch_pgqueuer"),
+        kw_only=True,
+    )
+    function: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("fn_pgqueuer_changed"),
+        kw_only=True,
+    )
+    log_table: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("pgqueuer_log"),
+        kw_only=True,
+    )
+    log_table_status_type: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("pgqueuer_status_log"),
+        kw_only=True,
+    )
+    queue_status_type: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("pgqueuer_status"),
+        kw_only=True,
+    )
+    queue_table: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("pgqueuer"),
+        kw_only=True,
+    )
+    trigger: Final[str] = dataclasses.field(
+        default_factory=lambda: add_prefix("tg_pgqueuer_changed"),
+        kw_only=True,
+    )
+
+
+@dataclasses.dataclass
+class InstallUninstallQueries:
+    """
+    Provides methods to install (create) and uninstall (drop)
+    database schemas and objects like tables, types, and triggers
+    related to the pgqueuer system.
+    """
+
+    pool: asyncpg.Pool
+    settings: DBSettings = dataclasses.field(default_factory=DBSettings)
+
+    async def install(self) -> None:
+        """
+        Creates necessary database structures such as enums,
+        tables, and triggers for job queuing and logging.
+        """
+        await self.pool.execute(
+            f"""
+    CREATE TYPE {self.settings.queue_status_type} AS ENUM ('queued', 'picked');
+    CREATE TABLE {self.settings.queue_table} (
+        id SERIAL PRIMARY KEY,
+        priority INT NOT NULL,
+        created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        status {self.settings.queue_status_type} NOT NULL,
+        entrypoint TEXT NOT NULL,
+        payload BYTEA
+    );
+    CREATE UNIQUE INDEX ON {self.settings.queue_table} (priority, id) WHERE status != 'picked';
+
+    CREATE TYPE {self.settings.log_table_status_type} AS ENUM ('exception', 'successful');
+    CREATE TABLE {self.settings.log_table} (
+        id SERIAL PRIMARY KEY,
+        priority INT NOT NULL,
+        created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+        duration INTERVAL NOT NULL,
+        status {self.settings.log_table_status_type} NOT NULL,
+        entrypoint TEXT NOT NULL
+    );
+
+
+    CREATE FUNCTION {self.settings.function}() RETURNS TRIGGER AS $$
+    BEGIN
+        PERFORM pg_notify(
+        '{self.settings.channel}',
+        json_build_object(
+            'channel', '{self.settings.channel}',
+            'operation', lower(TG_OP),
+            'sent_at', NOW(),
+            'table', TG_TABLE_NAME
+        )::text);
+        RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+
+    CREATE TRIGGER {self.settings.trigger}
+    AFTER INSERT OR UPDATE OR DELETE OR TRUNCATE ON {self.settings.queue_table}
+    EXECUTE FUNCTION {self.settings.function}();
+    """  # noqa: E501
+        )
+
+    async def uninstall(self) -> None:
+        """
+        Drops all database structures related to job queuing
+        and logging that were created by the install method.
+        """
+        await self.pool.execute(
+            f"""
+    DROP TRIGGER {self.settings.trigger};
+    DROP FUNCTION {self.settings.function};
+    DROP TABLE {self.settings.queue_table};
+    DROP TABLE {self.settings.log_table};
+    DROP TYPE {self.settings.queue_status_type};
+    DROP TYPE {self.settings.log_table_status_type};
+    """
+        )
+
+
+@dataclasses.dataclass
+class PgQueuerQueries:
+    """
+    Handles operations related to job queuing such as
+    enqueueing, dequeueing, and querying the size of the queue.
+    """
+
+    pool: asyncpg.Pool
+    settings: DBSettings = dataclasses.field(default_factory=DBSettings)
+
+    async def dequeue(self) -> models.Jobs:
+        """
+        Retrieves and updates the next 'queued' job to 'picked'
+        status, ensuring no two jobs with the same entrypoint
+        are picked simultaneously.
+        """
+        query = f"""
+            WITH next_job AS (
+                SELECT p1.id
+                FROM {self.settings.queue_table} p1
+                WHERE p1.status = 'queued' AND NOT EXISTS (
+                    SELECT FROM
+                    {self.settings.queue_table} p2
+                    WHERE p1.entrypoint = p2.entrypoint AND p2.status = 'picked')
+                ORDER BY id
+                FOR UPDATE SKIP LOCKED
+                LIMIT 1
+            )
+            UPDATE {self.settings.queue_table}
+            SET status = 'picked'
+            WHERE id = ANY(SELECT id FROM next_job)
+            RETURNING *;
+        """
+
+        return models.Jobs.model_validate(map(dict, await self.pool.fetch(query)))
+
+    async def enqueue(
+        self,
+        entrypoint: str,
+        payload: bytes | None,
+        priority: int = 0,
+    ) -> None:
+        """
+        Inserts a new job into the queue with the specified
+        entrypoint, payload, and priority, marking it as 'queued'.
+        """
+        await self.pool.execute(
+            f"""
+    INSERT INTO {self.settings.queue_table} (priority, status, entrypoint, payload)
+    VALUES ($1, 'queued', $2, $3)""",
+            priority,
+            entrypoint,
+            payload,
+        )
+
+    async def clear(self, entrypoint: str | list[str] | None = None) -> None:
+        """
+        Clears jobs from the queue, optionally filtering by entrypoint if specified.
+        """
+        if entrypoint:
+            await self.pool.execute(
+                f"DELETE FROM {self.settings.queue_table} WHERE entrypoint = ANY($1)",
+                [entrypoint] if isinstance(entrypoint, str) else entrypoint,
+            )
+        else:
+            await self.pool.execute(f"TRUNCATE {self.settings.queue_table}")
+
+    async def qsize(self) -> dict[tuple[str, int], int]:
+        """
+        Returns the number of jobs in the queue grouped by entrypoint and priority.
+        """
+        return {
+            (row["entrypoint"], row["priority"]): row["cnt"]
+            for row in await self.pool.fetch(f"""
+        SELECT
+            count(*) AS cnt,
+            priority,
+            entrypoint
+        FROM
+            {self.settings.queue_table}
+        GROUP BY priority, entrypoint
+        """)
+        }
+
+
+@dataclasses.dataclass
+class PgQueuerLogQueries:
+    """
+    Manages operations related to job logging,
+    including moving jobs to a log table, clearing logs,
+    and querying the size of log entries.
+    """
+
+    pool: asyncpg.Pool
+    settings: DBSettings = dataclasses.field(default_factory=DBSettings)
+
+    async def move_job_log(self, job: models.Job, status: models.STATUS_LOG) -> None:
+        """
+        Moves a completed or failed job from the queue table to the log
+        table, recording its final status and duration.
+        """
+        await self.pool.execute(
+            f"""
+    WITH moved_row AS (
+        DELETE FROM {self.settings.queue_table}
+        WHERE id = $1
+        RETURNING id, priority, created, entrypoint
+    )
+
+    INSERT INTO {self.settings.log_table} (
+        id, priority, created, duration, status, entrypoint
+    )
+        SELECT id, priority, created, NOW() - created, $2, entrypoint
+        FROM moved_row;
+    """,
+            job.id,
+            status,
+        )
+
+    async def clear(self, entrypoint: str | list[str] | None = None) -> None:
+        """
+        Clears entries from the job log table, optionally filtering
+        by entrypoint if specified.
+        """
+        if entrypoint:
+            await self.pool.execute(
+                f"DELETE FROM {self.settings.log_table} WHERE entrypoint = ANY($1)",
+                [entrypoint] if isinstance(entrypoint, str) else entrypoint,
+            )
+        else:
+            await self.pool.execute(f"TRUNCATE {self.settings.log_table}")
+
+    async def qsize(self) -> dict[tuple[str, str, int], int]:
+        """
+        Returns the number of log entries grouped by status, entrypoint, and priority.
+        """
+        return {
+            (row["status"], row["entrypoint"], row["priority"]): row["cnt"]
+            for row in await self.pool.fetch(f"""
+        SELECT
+            count(*) AS cnt,
+            status,
+            priority,
+            entrypoint
+        FROM
+            {self.settings.log_table}
+        GROUP BY status, priority, entrypoint
+        """)
+        }

PgQueuer/tm.py

@@ -0,0 +1,23 @@
+import asyncio
+import dataclasses
+
+
+@dataclasses.dataclass
+class TaskManager:
+    """
+    Manages a collection of asyncio Tasks, keeping track of active
+    tasks and removing them once they are complete.
+    """
+
+    tasks: set[asyncio.Task] = dataclasses.field(
+        default_factory=set,
+        init=False,
+    )
+
+    def add(self, task: asyncio.Task) -> None:
+        """
+        Adds an asyncio Task to the manager and registers a
+        callback to automatically remove the task when it's done.
+        """
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.remove)

PgQueuer-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 janbjorge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PgQueuer-0.0.1.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: PgQueuer
+Version: 0.0.1
+Summary: PgQueuer is a Python library leveraging PostgreSQL for efficient job queuing.
+Author: janbjorge
+License: MIT License
+Project-URL: Documentation, https://github.com/janbjorge/PgQueuer/
+Project-URL: Homepage, https://github.com/janbjorge/PgQueuer/
+Project-URL: Issues, https://github.com/janbjorge/PgQueuer/issues
+Project-URL: Repository, https://github.com/janbjorge/PgQueuer/
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncpg >=0.27.0
+Requires-Dist: pgcachewatch >=0.4
+Requires-Dist: pydantic >=2.0.0
+Provides-Extra: dev
+Requires-Dist: asyncpg-stubs ; extra == 'dev'
+Requires-Dist: mypy-extensions ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pytest-asyncio ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: myst-parser ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+
+## PgQueuer
+
+PgQueuer is a minimalist, high-performance job queue library for Python, leveraging the robustness of PostgreSQL. Designed for simplicity and efficiency, PgQueuer uses PostgreSQL's native features like transactions, row locking, and LISTEN/NOTIFY to manage job queues effortlessly.
+
+### Features
+
+- **Simple Integration**: Easy to integrate with existing Python applications using PostgreSQL.
+- **Efficient Concurrency Handling**: Utilizes PostgreSQL's `FOR UPDATE SKIP LOCKED` for reliable and concurrent job processing.
+- **Real-time Notifications**: Leverages `LISTEN` and `NOTIFY` for real-time updates on job status changes.
+- **Scalable**: Built to efficiently scale with your application's needs.
+
+### Getting Started
+
+#### Installation
+
+To install PgQueuer, simply run the following command:
+
+```bash
+pip install PgQueuer
+```
+
+This command installs PgQueuer along with its dependencies, setting up everything you need to start integrating it into your application.
+
+#### Database Configuration
+
+Configure your database connection settings by setting the appropriate environment variables for your PostgreSQL credentials:
+
+```bash
+export PGHOST='localhost'
+export PGDATABASE='your_database'
+export PGUSER='your_username'
+export PGPASSWORD='your_password'
+```
+
+#### CLI Usage
+
+PgQueuer provides a command-line interface for easy management of installation and uninstallation. Ensure you have configured your environment variables or use the appropriate flags to specify your database credentials.
+
+- **Installing PgQueuer Database Components**:
+  ```bash
+  python -m PgQueuer install 
+  ```
+
+- **Uninstalling PgQueuer Database Components**:
+  ```bash
+  python -m  uninstall 
+  ```
+
+The CLI supports several flags to customize the connection settings. Use `--help` to see all available options.
+
+### Use-Case: Processing Incoming Data Messages
+
+In this scenario, the system is designed to manage a queue of incoming data messages that need to be processed. Each message is encapsulated as a job, and these jobs are then processed by a designated function linked to an entrypoint. This is typical in systems where large volumes of data are collected continuously, such as telemetry data from IoT devices, logs from web servers, or transaction data in financial systems.
+
+#### Function Description:
+The `fetch` function, tied to the `fetch` entrypoint, is responsible for processing each message. It simulates a processing task by printing the content of each message. This function could be adapted to perform more complex operations such as parsing, analyzing, storing, or forwarding the data as required by the application.
+
+```python
+import asyncio
+import time
+
+import asyncpg
+
+from PgQueuer import qm, queries
+
+
+async def main() -> None:
+    # Set up a connection pool with a minimum of 2 connections.
+    pool = await asyncpg.create_pool(min_size=2)
+    # Initialize the QueueManager with the connection pool and query handler.
+    app = qm.QueueManager(
+        pool, 
+        queries.PgQueuerQueries(pool),
+        queries.PgQueuerLogQueries(pool),
+    )
+
+    # Number of messages to simulate.
+    N = 10_000
+
+    # Enqueue messages.
+    for n in range(N):
+        await app.q.enqueue("fetch", f"this is from me: {n}".encode())
+
+    # Define a processing function for each message.
+    @c.entrypoint("fetch")
+    async def process_message(context: bytes) -> None:
+        # Simulate parsing the message.
+        message = context.decode()
+        # Print the message to simulate processing.
+        print(f"Processed message: {message}")
+
+    await app.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

PgQueuer-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+_version.py,sha256=pMnmqZnpVmaqR5nqHztNWzbbtb1oy5bPN_v7uhOH8K8,411
+PgQueuer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PgQueuer/__main__.py,sha256=Dww9T08Xg8kdRFEvHpXpTA2trY7G-lhafwZf1IUqm6c,97
+PgQueuer/_version.py,sha256=YonpGHgj9UzI33RW5RhfA9spxQnBoSxMf0rWyg16ezg,461
+PgQueuer/cli.py,sha256=kri8GI_Zynn93VP7eRcTx2Kzsxze5SWIQoFIT2mkkbc,3529
+PgQueuer/logconfig.py,sha256=nCfcp663CduoBSqcWjZ6nWRkDJDBC-c98erj0hGCvZc,185
+PgQueuer/models.py,sha256=e4r_3RU1soAD-HgFSn-sWeBLqI50cSi4h-4lo-VUetY,594
+PgQueuer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PgQueuer/qm.py,sha256=hys7igBkWDQbW2q41q_9Ye_jVJ0-z4OmyvKc31CHzFc,3659
+PgQueuer/queries.py,sha256=Qovzi_zJXeCEFRMvAuAByEkGJ7CALendcepdcYWT5E4,8967
+PgQueuer/tm.py,sha256=t6qU_-pv94D5XeDXtME5O85JRzS3BnaLTZqg57YED0k,596
+PgQueuer-0.0.1.dist-info/LICENSE,sha256=0lCGUd5Pke2Up1Kqn1kRnHcwLlBz60E8xvR7WL4k_kE,1066
+PgQueuer-0.0.1.dist-info/METADATA,sha256=EgHpTY4L0oJuzKIBM-c4ZrP4LbOdgfJSgYXY7SdM-4E,5376
+PgQueuer-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+PgQueuer-0.0.1.dist-info/top_level.txt,sha256=7mMxIeRADcMrOwkYdxmOC5S5aydHM7PRnauwqqHHCtk,18
+PgQueuer-0.0.1.dist-info/RECORD,,

PgQueuer-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

PgQueuer-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+PgQueuer
+_version

_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)