Quebec

Quebec is a simple background task queue for processing asynchronous tasks. The name is derived from the NATO phonetic alphabet for "Q", representing "Queue".

This project is inspired by Solid Queue.

Warning: This project is in early development stage. Not recommended for production use.

Why Quebec?

Simplified Architecture: No dependencies on Redis or message queues
Database-Powered: Leverages RDBMS capabilities for complex task queries and management
Rust Implementation: High performance and safety with Python compatibility
Framework Agnostic: Works with asyncio, Trio, threading, SQLAlchemy, Django, FastAPI, etc.

Features

Scheduled tasks
Recurring tasks
Concurrency control
Per-queue concurrency limits
Rate limiting
Exclusive (stop-the-world) jobs
Multi-process (fork) mode
Memory-based worker recycling
Web dashboard
Automatic retries
Signal handling & graceful restart
Lifecycle hooks

Control Plane

Built-in web dashboard for monitoring jobs, queues, and workers in real-time.

Control Plane

Database Support

SQLite
PostgreSQL
MySQL

Quick Start

Module Runner (Recommended)

Define jobs in a package:

# jobs/email_job.py
import quebec

class EmailJob(quebec.BaseClass):
    queue_as = "default"

    def perform(self, to, subject):
        self.logger.info(f"Sending email to {to}: {subject}")

Export them in __init__.py:

# jobs/__init__.py
from .email_job import EmailJob

Run with python -m quebec:

DATABASE_URL=sqlite:///demo.db?mode=rwc python -m quebec jobs

All configuration via QUEBEC_* environment variables — no boilerplate entry script needed.

Script Mode

For more control, use Quebec directly in a script:

import logging
from pathlib import Path
from quebec.logger import setup_logging

setup_logging(level=logging.DEBUG)

import quebec

db_path = Path('demo.db')
qc = quebec.Quebec(f'sqlite://{db_path}?mode=rwc')


@qc.register_job
class FakeJob(quebec.BaseClass):
    def perform(self, *args, **kwargs):
        self.logger.info(f"Processing job {self.id}: args={args}, kwargs={kwargs}")


if __name__ == "__main__":
    # Enqueue a job (qc is inferred from @qc.register_job)
    FakeJob.perform_later(123, foo='bar')

    # Start Quebec (handles signal, spawns workers, runs main loop)
    qc.run(
        create_tables=not db_path.exists(),
        control_plane='127.0.0.1:5006',  # Optional: web dashboard
    )

Or run the quickstart script directly:

curl -O https://raw.githubusercontent.com/ratazzi/quebec/refs/heads/master/quickstart.py
uv run quickstart.py

Auto-Discovering Jobs

If your jobs are organized in a package (e.g. app.jobs.*), call Quebec.discover_jobs() instead of decorating each class with @qc.register_job or calling qc.register_job_class(...) one by one:

# app/jobs/cleanup.py
class CleanupJob(quebec.BaseClass):
    def perform(self, *args, **kwargs): ...

# main.py
qc = quebec.Quebec(dsn)
qc.discover_jobs("app.jobs", "worker.tasks")   # recursively scans each
qc.run()

discover_jobs takes one or more dotted package paths as positional arguments (varargs) — no need to wrap a single package in a list.

discover_jobs(*packages, recursive=True, on_error="raise"):

Registers every BaseClass subclass whose __module__ falls under one of the given packages. Classes imported from elsewhere (e.g. from some.lib import JobMixin) are ignored.
Raises ValueError if two discovered classes share the same __qualname__, since Quebec's worker registry is keyed by qualname and the later registration would otherwise silently replace the earlier one.
on_error="raise" (default) propagates submodule ImportError. Pass on_error="warn" to emit a RuntimeWarning and keep scanning — useful when a package contains optional-integration modules that may fail to import in some environments. The top-level package is always imported strictly.

Multiple Quebec Instances

Quebec is designed for one instance per process. Registering a job class (via @qc.register_job, qc.register_job_class, or qc.discover_jobs) binds it to that Quebec instance, so MyJob.perform_later(...) shorthand routes to the binding. If a process holds more than one Quebec instance and registers the same job class to each, the most recent registration wins — pass the target instance explicitly to disambiguate:

MyJob.perform_later(qc2, arg1)                  # route to qc2
MyJob.set(queue='critical').perform_later(qc2, arg1)

`qc.run()` Options

Parameter	Type	Default	Description
`create_tables`	`bool`	`False`	Create database tables (requires DDL permissions)
`control_plane`	`str`	`None`	Web dashboard address, e.g. `'127.0.0.1:5006'`
`spawn`	`list[str]`	`None`	Components to spawn: `['worker', 'dispatcher', 'scheduler']`. `None` = all

Recommended: configure worker thread count in queue.yml via workers.threads. If you need a one-off override, Quebec(..., worker_threads=3) is also supported.

Multi-Process Mode (fork supervisor)

By default qc.run() runs all components as threads in a single process. To scale across CPU cores, set QUEBEC_SUPERVISOR=1 to fork a pool of child processes instead:

QUEBEC_SUPERVISOR=1 python -m quebec your.jobs

# queue.yml (under your environment, e.g. production:)
workers:
  - queues: "*"
    threads: 5
    processes: 4        # fork 4 worker processes
dispatchers:
  - polling_interval: 1
    processes: 1        # fork 1 dispatcher process

The supervisor forks workers[].processes worker children and dispatchers[].processes dispatcher children, each taking its config from the matching yml entry, and reforks any child that dies (matching Solid Queue's process model). Fork mode is opt-in via the env var so an existing config with processes set doesn't silently switch process model on upgrade; spawn is ignored in this mode. Outside supervisor mode the processes keys are ignored and Quebec uses the single-process threaded runtime.

Force Queue Override (multi-branch development)

Set QUEBEC_FORCE_OVERRIDE_QUEUE to pin every enqueue and consumption to one queue — handy when several development branches share a single database:

QUEBEC_FORCE_OVERRIDE_QUEUE=branch_x python -m quebec your.jobs

Every enqueue path rewrites queue_name to this value (ignoring whatever the class, call site, or scheduler specified), and the worker only consumes that queue — so jobs enqueued by one branch are never picked up by another. URL-hostile characters in the name are sanitized to -.

Transactional Enqueue

[!IMPORTANT] Enqueuing is not part of your database transaction — even on the same database. Quebec's enqueue runs through the Rust engine on its own connection pool, completely separate from your Python connection (SQLAlchemy / Django / psycopg). There is no way to atomically commit a business write and a job enqueue together.

This is the deliberate cost of keeping the engine fully decoupled from your ORM and connection — the upside is that Quebec drags no Python database dependencies into your app, but it means the enqueue cannot join your transaction. Two failure windows follow:

The business transaction commits but the enqueue fails → the job is lost.
The enqueue commits but the business transaction rolls back → the job runs against missing or stale data.

Recommendations:

Enqueue after your business transaction commits. This removes the worse direction — a job running for a write that was rolled back.
Make jobs idempotent and tolerant of data that may not be visible yet; lean on retries.
If you genuinely need atomicity, use a transactional outbox: write an outbox row inside your own transaction (business + outbox commit atomically), then relay it into a real job (at-least-once delivery).

Delayed Jobs

from datetime import timedelta

# Run after 1 hour
FakeJob.set(wait=3600).perform_later(arg1)

# Run at specific time
FakeJob.set(wait_until=tomorrow_9am).perform_later(arg1)

# Override queue and priority
FakeJob.set(queue='critical', priority=1).perform_later(arg1)

Automatic Retries

from datetime import timedelta

class PaymentJob(quebec.BaseClass):
    retry_on = [
        quebec.RetryStrategy(
            (ConnectionError, TimeoutError),
            wait=timedelta(seconds=30),
            attempts=3,
        ),
        quebec.RetryStrategy(
            (ValueError,),
            wait=timedelta(seconds=5),
            attempts=1,
            # Called once retries are exhausted; receives (job, error).
            handler=lambda job, error: notify_admin(error),
        ),
    ]

    def perform(self, order_id):
        process_payment(order_id)

Multiple RetryStrategy entries can target different exception types with independent wait/attempts. The optional handler fires only when a strategy's attempts are exhausted (mirroring ActiveJob's retry_on ... do |job, error| block) and is called with (job, error). discard_on and rescue_from handlers use the same (job, error) signature.

Concurrency Control

Limit how many jobs with the same key can run simultaneously:

class ReportJob(quebec.BaseClass):
    concurrency_limit = 3          # max 3 concurrent executions per key
    concurrency_duration = 120     # semaphore TTL in seconds

    def concurrency_key(self, account_id, **kwargs):
        return str(account_id)     # final key: "ReportJob/123"

    def perform(self, account_id):
        generate_report(account_id)

The actual concurrency key is "ClassName/key" (e.g. "ReportJob/123"), so different job classes never conflict. When the limit is reached, new jobs are blocked until a slot becomes available. The concurrency_duration acts as a safety TTL — the semaphore is released automatically if a worker crashes.

Rate Limiting (experimental)

Cap how many jobs run within a sliding time window, scoped per key:

from datetime import timedelta

class ApiCallJob(quebec.BaseClass):
    rate_limit_max = 5                          # at most 5 runs...
    rate_limit_duration = timedelta(seconds=2)  # ...per rolling 2-second window
    rate_limit_on_throttle = quebec.RateLimitConflict.Reschedule  # default

    def rate_limit_key(self, region="us", **kwargs):
        return region                           # bucket key: "ApiCallJob/us"

    def perform(self, region="us"):
        call_external_api(region)

Like concurrency control, the bucket is "ClassName/key", and rate_limit_key defaults to the class name when not overridden. rate_limit_duration must be a datetime.timedelta of at least one second. When the window is exhausted, rate_limit_on_throttle decides what happens: Reschedule (the default) pushes the job to a later run, while Discard drops it.

Exclusive Jobs

Let an occasional memory-heavy job own the whole worker process while it runs:

class RebuildSearchIndexJob(quebec.BaseClass):
    exclusive = True

    def perform(self):
        rebuild_index()                         # runs alone on this worker

When an exclusive job is claimed, the worker stops claiming new jobs, waits for any in-flight siblings to finish, then runs the exclusive job by itself before resuming normal claiming. The scope is the current worker process — it does not coordinate across separate worker processes; pair it with concurrency_limit = 1 and a concurrency_key if you also need cluster-wide single-instance execution.

Graceful Restart (quiet-then-exit)

Drain in-flight work and exit on a quiet signal, for zero-downtime rolling restarts:

qc = quebec.Quebec(database_url="...", quiet_then_exit=True)
qc.run()

Sending SIGUSR1 (or SIGTSTP) puts the worker into quiet mode: it stops claiming new jobs but keeps running until every in-flight job finishes, then exits cleanly — with no time limit (unlike the SIGTERM path, which is bounded by shutdown_timeout). The usual flow is: signal the old instance quiet, start a new instance, and the old one exits once drained. Opt-in (default off), and standalone-only — under the fork supervisor a self-exited child would just be reforked, so use a supervisor-level rolling restart there instead. Also settable via QUEBEC_QUIET_THEN_EXIT=1.

Memory-Based Worker Recycling

Long-lived Python workers tend to hold onto RSS the interpreter never returns to the OS. Quebec can recycle a bloated worker by draining it and exiting with a dedicated code, leaving the actual restart to your process supervisor. It is configured by environment variables — there is no in-process restart:

QUEBEC_WORKER_MAX_RSS_MB=512                  # soft limit; unset = disabled
QUEBEC_WORKER_MEMORY_RECYCLE_CONFIRMATIONS=3  # consecutive over-limit samples before recycling (default)
QUEBEC_WORKER_MEMORY_CHECK_INTERVAL=5s        # how often RSS is sampled (default)

When a worker's RSS stays above the limit for that many consecutive samples, it enters quiet mode, stops claiming, drains its in-flight jobs (no time limit), and exits with code 75 — the planned-recycle code. The supervisor then relaunches a fresh process. Under the built-in fork supervisor (QUEBEC_SUPERVISOR=1) this refork is automatic; under systemd, Restart=on-failure relaunches the worker after the non-zero recycle exit:

# /etc/systemd/system/quebec-worker.service
[Service]
ExecStart=/usr/bin/python -m quebec your.jobs
Environment=QUEBEC_DATABASE_URL=postgresql://localhost/myapp
Environment=QUEBEC_WORKER_MAX_RSS_MB=512
Restart=on-failure

[Install]
WantedBy=multi-user.target

Exit code 75 is non-zero, so Restart=on-failure treats the planned recycle as a failure and relaunches the worker. If you'd rather not have planned recycles show up as failures (in systemctl status or the start-limit counter), add SuccessExitStatus=75 together with RestartForceExitStatus=75 — the former keeps 75 out of the failure tally, the latter still forces the restart.

Per-Queue Concurrency (experimental)

Cap how many jobs run concurrently across the cluster for specific queues, independent of per-class concurrency_key:

qc = quebec.Quebec(
    database_url="...",
    experimental_queue_concurrency={"reports": 2, "exports": 1},
)
qc.run()

Each listed queue acquires a queue:<name> semaphore at claim time; queues not present are unlimited. Useful for isolating a misbehaving queue during remediation. Naming and semantics are experimental and may change.

TLS Configuration (PostgreSQL)

Quebec links sqlx against rustls + webpki-roots. Public CAs (AWS RDS, Neon, Google Cloud SQL, Supabase, etc.) are trusted out of the box — no OS trust store is consulted.

Pass libpq-style SSL options as Quebec(...) kwargs, as DSN query params, or via QUEBEC_SSL* environment variables:

qc = quebec.Quebec(
    "postgresql://user:pass@host:5432/db",
    sslmode="verify-full",             # or QUEBEC_SSLMODE
    sslrootcert="/etc/ssl/certs/ca.pem",  # internal CAs only
)

Priority is kwargs > env > DSN query. Passing any ssl* kwarg/env against a non-postgres URL raises ValueError.

`sslmode`	Transport	Certificate verification	Hostname verification
`disable`	plaintext	—	—
`prefer`	TLS if offered, else plaintext	—	—
`require`	TLS (fails if unsupported)	— (accepts any cert)	—
`verify-ca`	TLS	CA-signed	—
`verify-full`	TLS	CA-signed	hostname matches CN/SAN

For public CAs, verify-full works zero-config. Use sslrootcert for internal/self-signed CAs. sslcert + sslkey enable client certificate (mTLS) auth.

sslmode=allow is rejected with a ValueError. Upstream sqlx-postgres 0.8 treats allow identically to disable (plaintext, marked FIXME in the driver); to avoid a silent downgrade, Quebec refuses it. Use prefer for opportunistic TLS, or require/verify-* to enforce it.

Note: some managed Postgres services (e.g. Neon) terminate TLS at a proxy layer. In those cases pg_stat_ssl.ssl may report false because the backend sees plaintext from the proxy — not the client.

Lifecycle Hooks

Quebec provides several lifecycle hooks that you can use to execute code at different stages of the application lifecycle:

@qc.on_start: Called when Quebec starts
@qc.on_stop: Called when Quebec stops
@qc.on_worker_start: Called when a worker starts
@qc.on_worker_stop: Called when a worker stops
@qc.on_shutdown: Called during graceful shutdown

These hooks are useful for:

Initializing resources
Cleaning up resources
Logging application state
Monitoring worker lifecycle
Graceful shutdown handling

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

quebec-0.3.11.tar.gz (815.9 kB view details)

Uploaded Jul 8, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

quebec-0.3.11-cp314-cp314t-win_arm64.whl (10.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tWindows ARM64

quebec-0.3.11-cp314-cp314t-win_amd64.whl (11.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tWindows x86-64

quebec-0.3.11-cp314-cp314t-win32.whl (9.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tWindows x86

quebec-0.3.11-cp314-cp314t-musllinux_1_2_x86_64.whl (12.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmusllinux: musl 1.2+ x86-64

quebec-0.3.11-cp314-cp314t-musllinux_1_2_i686.whl (12.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmusllinux: musl 1.2+ i686

quebec-0.3.11-cp314-cp314t-musllinux_1_2_armv7l.whl (12.3 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmusllinux: musl 1.2+ ARMv7l

quebec-0.3.11-cp314-cp314t-musllinux_1_2_aarch64.whl (12.4 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmusllinux: musl 1.2+ ARM64

quebec-0.3.11-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ x86-64

quebec-0.3.11-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl (12.2 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ s390x

quebec-0.3.11-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl (13.7 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ ppc64le

quebec-0.3.11-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl (13.1 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ i686

quebec-0.3.11-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl (11.9 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARMv7l

quebec-0.3.11-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (12.3 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARM64

quebec-0.3.11-cp314-cp314t-macosx_11_0_arm64.whl (11.2 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmacOS 11.0+ ARM64

quebec-0.3.11-cp314-cp314t-macosx_10_12_x86_64.whl (11.7 MB view details)

Uploaded Jul 8, 2026 CPython 3.14tmacOS 10.12+ x86-64

quebec-0.3.11-cp39-abi3-win_arm64.whl (10.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+Windows ARM64

quebec-0.3.11-cp39-abi3-win_amd64.whl (11.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+Windows x86-64

quebec-0.3.11-cp39-abi3-win32.whl (9.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+Windows x86

quebec-0.3.11-cp39-abi3-musllinux_1_2_x86_64.whl (12.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+musllinux: musl 1.2+ x86-64

quebec-0.3.11-cp39-abi3-musllinux_1_2_i686.whl (12.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+musllinux: musl 1.2+ i686

quebec-0.3.11-cp39-abi3-musllinux_1_2_armv7l.whl (12.3 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+musllinux: musl 1.2+ ARMv7l

quebec-0.3.11-cp39-abi3-musllinux_1_2_aarch64.whl (12.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+musllinux: musl 1.2+ ARM64

quebec-0.3.11-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.5 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ x86-64

quebec-0.3.11-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl (12.2 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ s390x

quebec-0.3.11-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl (13.7 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ ppc64le

quebec-0.3.11-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl (13.1 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ i686

quebec-0.3.11-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl (11.9 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ ARMv7l

quebec-0.3.11-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (12.3 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+manylinux: glibc 2.17+ ARM64

quebec-0.3.11-cp39-abi3-macosx_11_0_arm64.whl (11.2 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+macOS 11.0+ ARM64

quebec-0.3.11-cp39-abi3-macosx_10_12_x86_64.whl (11.8 MB view details)

Uploaded Jul 8, 2026 CPython 3.9+macOS 10.12+ x86-64

File details

Details for the file quebec-0.3.11.tar.gz.

File metadata

Download URL: quebec-0.3.11.tar.gz
Upload date: Jul 8, 2026
Size: 815.9 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: uv/0.11.28 {"installer":{"name":"uv","version":"0.11.28","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

File hashes

Hashes for quebec-0.3.11.tar.gz
Algorithm	Hash digest
SHA256	`369d77c3af8d17c4c48c2c69604cf16d6304fee461653781fd08f0946aee876d`
MD5	`a3c185a375934601e279b191ee08ee9d`
BLAKE2b-256	`01af7cfd7594e30b18c535cd8db23604dbceca4069acad45f701595e99bdebcd`

Algorithm	Hash digest
SHA256	`12c7337571a3fcb4571f4e5a703569946d1117eddc947f5ac1a44d5e1806ecf2`
MD5	`26e71e17b4f68af0ca2740eccd433dbd`
BLAKE2b-256	`83a6454ad49f371b2598f4e3a3eff78518209213930763e7c88f4af75ef59a6a`

Algorithm	Hash digest
SHA256	`a66eff2aa1dd4363a55b5040f14d7fb48adec8c22081499f96ad11587fe9a93d`
MD5	`d15242ecb8b7081d8ddf0013a89e3b32`
BLAKE2b-256	`b0b84a0ca52ba6ab6483df1ac8d396b4dbd8ad7dc35ef1afa081117658847545`

Algorithm	Hash digest
SHA256	`570587a871aea065b346aa15bd6a2a6ed5fced8254c5c35db0b052a25ef09764`
MD5	`33348032fbea8823c50b4b474f12dd20`
BLAKE2b-256	`ff4a076f6918705199cd665df439dcc25a5eab950185a28630cf8995d06d1369`

Algorithm	Hash digest
SHA256	`f5bbddfb812cb2e723e1ff9f849d3970319e9e639eb43ddb56bd95e08a34a378`
MD5	`3cbcdbb91167d940f6c9d2ad464f31e4`
BLAKE2b-256	`3d2c111f70ebe8907fa0464f65eb4feec3a3e9ae25fded8d76902493b4c9c83c`

Algorithm	Hash digest
SHA256	`7177ed81b23c32ca5fde6324ed8fb403a2212a0e19c7c716d35ac288ade29f09`
MD5	`13255d38ac23ef168137c055014d5c1d`
BLAKE2b-256	`7ae70311f1c549eab55767ba476df64522dd19e042a897280a77a715b621551e`

Algorithm	Hash digest
SHA256	`410d333bc6ba406b7ddb26092cbfcc7e4009ebd825fd5eb37abb592b8120b05f`
MD5	`218dcd8466e6fce9a3f8aca197a8ca5d`
BLAKE2b-256	`e0669132ff241c56ce8496a9922281d3cfa7cf1334792fa56474646ae3453611`

Algorithm	Hash digest
SHA256	`2e1896a3dd4122a90380326f9783630fa777fb69e02ca90382d55c2b97956d3d`
MD5	`313f49c76512f30f28f23ddacec0c892`
BLAKE2b-256	`f3099cb417dcd5b1c140aa1a4be9feb7a70cb733321cd134bd6710c7bd4adc23`

Algorithm	Hash digest
SHA256	`4ae80cb096dbda5d7c35f2184a425e8c57138fbfb7ab65160e7ec0898a400383`
MD5	`a43db883503507e4c2a33aa0c8ea4946`
BLAKE2b-256	`bd94609d649d5473920d939a0d8e655fe728ed6abb20f52e87e2f4f888bfbf89`

Algorithm	Hash digest
SHA256	`0f0724e565df2020d29665f4851186ce5365fbd0398d25d631405175a551400e`
MD5	`377f515df2c379250b7424d596f206aa`
BLAKE2b-256	`b6d22bed277901c37564ed56bd73bfbe60c2a3fe9ed8a76841c4cf2c046d3079`

Algorithm	Hash digest
SHA256	`33f8e65841a63952dfb0ca07e974b273a43c74ba26eb334fb933215dc491a619`
MD5	`c35e4acdfcc0494d237cd45bf931196e`
BLAKE2b-256	`fa11e6f17ce5d4f673741929bbfafc201dfae48f423327b2e28524f4f14b65ce`

Algorithm	Hash digest
SHA256	`3f92534d3e4fdf052c0504575690f1dab75961f2000ddb07599c6b883e500a0f`
MD5	`19cffe6f777bf2040be9f65c79030595`
BLAKE2b-256	`39dac2c13eeb0d65a71d4c7de5df1ec8c7452595e4c73ce10b625ae81b904387`

Algorithm	Hash digest
SHA256	`5f4e8eacfd28665a581d9d952b43147fd33d017044d1b3f174cc353dbc3548a0`
MD5	`cb9d0805055c5fcf0d6203608c99f02c`
BLAKE2b-256	`580c4774bc5b702213f12e62a07ee34df4ba3f37d1f003eebb9a713c80af479b`

Algorithm	Hash digest
SHA256	`3f30984f687a4797dcf258ad9a1319ac69e0573d5f9e68cc601d74332a7aab71`
MD5	`ae6b29ce6bf7557146c75ca29efef54e`
BLAKE2b-256	`a341cadc5ee4f376586a37ee036c349c84b5ce2b604707821c4e9995324cc1c4`

Algorithm	Hash digest
SHA256	`8dd924e8fb0b8c0a9fc96f827377c8c5a9f8f8d5fcd005e737beb341de381cc7`
MD5	`1c6026e865bb5159a33f4ddb856f2019`
BLAKE2b-256	`416462c46b19337d9e8183a9a47796519239ecab05e26fb14656dd241030c469`

Algorithm	Hash digest
SHA256	`ebf2880b5f66e308a0feb4b6a9fa130af82003a4f5f7264e08c1d59b3acfbcc8`
MD5	`3d9a34e3ad2a7a65a95f64b607c0ab8d`
BLAKE2b-256	`bb1cb535746c260b9203a795877567cb9e274a85be78b6164048dc628ceba0ef`

Algorithm	Hash digest
SHA256	`49f194eb2e963a2a776afc2d92edb2f1508dd1c49413c9a5d465c4b7db4a4ab4`
MD5	`72fe3a1e137dec484c2da302bf674b81`
BLAKE2b-256	`9cba42268b5a5bcdfaf442a69a2d1d7eb94212bf97afe5638fd22df6c9e5a098`

Algorithm	Hash digest
SHA256	`c8ee405fdbc6c63afcead67dba571ef03b3c81a506477c48794c6c96f244a1f3`
MD5	`7884f2d5e5cd05aa117ff03ec64e05c0`
BLAKE2b-256	`0abeab2f72493f3222d95596959fd7dc6bfda3d26c61d1d45b8d4f048c9f5d51`

Algorithm	Hash digest
SHA256	`21ed838d9945da8a971e38ddc0c1dfba12458cba3314fc2896844b5b8d6ff113`
MD5	`e44004259a098579035492d750c817cd`
BLAKE2b-256	`b95f2c47a85f33af864d2a0e30519e76fb9d587270870fa58c6655a494454819`

Algorithm	Hash digest
SHA256	`39531dc17c08711ace240b42fcd6acbdf4a23a70a03795d4bb96bdd6bb47035e`
MD5	`f229f11fe89f5ce73ec18bf139e398e3`
BLAKE2b-256	`d7d2d6cf442fc2cf1acc90d63120375dc099e1711ffaa254882c0489da79511e`

Algorithm	Hash digest
SHA256	`39a26751ff8bfabd84a511386f0a0d01d09baadd0d7c9a84062b2a70dcc5af96`
MD5	`e7eec4a274d27e92d676ca6ad2693f00`
BLAKE2b-256	`7fc1e47233a0c6307872dc162a88e2539c996c50082f30a0df2b6a87f7ba2fb2`

quebec 0.3.11

Quebec

Why Quebec?

Features

Control Plane

Database Support

Quick Start

Module Runner (Recommended)

Script Mode

Auto-Discovering Jobs

Multiple Quebec Instances

qc.run() Options

Multi-Process Mode (fork supervisor)

Force Queue Override (multi-branch development)

Transactional Enqueue

Delayed Jobs

Automatic Retries

Concurrency Control

Rate Limiting (experimental)

Exclusive Jobs

Graceful Restart (quiet-then-exit)

Memory-Based Worker Recycling

Per-Queue Concurrency (experimental)

TLS Configuration (PostgreSQL)

Lifecycle Hooks

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License expression

Requires

Provides Extra

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

File details

File metadata

File hashes

`qc.run()` Options

Algorithm	Hash digest
SHA256	`ec0c3d513ef53d74b13785de51490608853898688ad837bd67b73c5c1f1a7d6b`
MD5	`6bb70c64a8e50790959b6b8979310b47`
BLAKE2b-256	`f8c72441fd609e9926dd9d41b97b91abd6c56a87d1e91faf9bb3991c43b52e46`

Algorithm	Hash digest
SHA256	`7c023dc4fe8bb0437c82e3544871f1d96fa2ba8c5d6562f0221bd6443d494661`
MD5	`4480fe2c28e790cbd6fd11f478425894`
BLAKE2b-256	`0efd79e667d892804fb67ef720c04a88be29ed1dd85c3a5e836dbf59071e3a66`

Algorithm	Hash digest
SHA256	`d6117bd45989eb3c366c06c11956560d30b8c8cc567a43fb198d014239819da0`
MD5	`47ae158db0b151c2a6c3dc72a74d6bdb`
BLAKE2b-256	`1613dcbc6e068a3f997236ea4026cadddd7c9e81debec88bf760d508dae71933`

Algorithm	Hash digest
SHA256	`6384ca2c76d1b9911deb675267b828fa724e7546335af43f57ca83ec4302520c`
MD5	`eaff88372d6ab7e8b0f1881825898fa6`
BLAKE2b-256	`8b316f59583f41a5714abeb2f4f4f43a4e3ec548c43a59f3aecec874bc849f5d`

Algorithm	Hash digest
SHA256	`d5d7e30674cee508f14d0c8c85d92f7fc6f67cda991997ff9455a03b8b879e53`
MD5	`d54c7799c1e595c63a77a12ee612fe10`
BLAKE2b-256	`a4d3a45fe5ad420951a6010f54ca9526c371c1cec3a5b4bbd974e6315ef580f7`

Algorithm	Hash digest
SHA256	`c7694296b81770325e345c237948a804425f71b2ba36bf925572201e0e806594`
MD5	`3cb48a1ecb822798b13a82545e25df23`
BLAKE2b-256	`41788a80c47d67a2d57a0b78f9620e7b3316512a7e50e455382e65d19fcee66f`

Algorithm	Hash digest
SHA256	`c81cb76e46d53141e238fea22e62378282d5afb46430dead10ad3ccfb2e5de3e`
MD5	`1025f0b8e08ec602b1e6207c29e72f4b`
BLAKE2b-256	`6456cbbe12355c6ea526337e085c4583cca632707c25b14899c17d36fb894542`

Algorithm	Hash digest
SHA256	`b31398387720fa123eda3935e206595829cc1833c56ad4dc70c439a8848d222f`
MD5	`8c53ad7aa608bdf62d2bd271b9bc5ffb`
BLAKE2b-256	`8c462ca3da712013be83ebc0d81fc779ac9fc27d8f4a8b318c18adbb253b10e1`

Algorithm	Hash digest
SHA256	`424da374029d4b3b6d7211ab590a8784256d97248d32069e50cfc6cc19c251c7`
MD5	`787bdb4f4fe79c9701fe04fbf4beae41`
BLAKE2b-256	`8255fca2368684591bfd748b7c59efa7afae345c972d625789f149bdb90e8670`

Algorithm	Hash digest
SHA256	`82a5ab6d1b71076180dc212aa1f4ac27047e8aad0197629c143a220b5199b962`
MD5	`a815e07adc8c37ae138fd844093c938a`
BLAKE2b-256	`276ce841862d59d6e25141fd08077cbd7afb8db9883de35af6da08fce2064685`