localqueue 1.0.1__tar.gz → 1.1.0__tar.gz

{localqueue-1.0.1 → localqueue-1.1.0}/.github/workflows/ci.yml

@@ -90,7 +90,10 @@ jobs:
           else
             source .venv/bin/activate
           fi
-          python -m pip install --upgrade "maturin>=1.14,<2" "pytest>=8,<10"
+          python -m pip install --upgrade \
+            "maturin>=1.14,<2" \
+            "pytest>=8,<10" \
+            "pydantic>=2,<3"
           maturin develop --release --locked
           pytest -ra
 

{localqueue-1.0.1 → localqueue-1.1.0}/.github/workflows/wheels.yml

@@ -36,10 +36,6 @@ jobs:
             target: x86_64-pc-windows-msvc
             manylinux: off
     runs-on: ${{ matrix.os }}
-    environment: pypi
-    permissions:
-      contents: read
-      id-token: write
     steps:
       - name: Check out repository
         uses: actions/checkout@v6
@@ -75,7 +71,9 @@ jobs:
       - name: Install one wheel for smoke testing
         if: matrix.name != 'linux-aarch64'
         shell: bash
-        run: python -m pip install --force-reinstall --no-index target/wheels/*cp313*.whl
+        run: |
+          python -m pip install --upgrade "pydantic>=2,<3"
+          python -m pip install --force-reinstall --no-index target/wheels/*cp313*.whl
 
       - name: Smoke-test installed wheel outside the checkout
         if: matrix.name != 'linux-aarch64'
@@ -85,15 +83,36 @@ jobs:
           python - <<'PY'
           import tempfile
 
-          from localqueue import SimpleQueue
+          from localqueue import EnqueueItem, SimpleQueue
+          from localqueue.bus import BaseEvent, BusTopology, EventBus
+
+          class WheelEvent(BaseEvent):
+              value: int
 
           with tempfile.TemporaryDirectory() as path:
               queue = SimpleQueue(path)
-              queue.put({"platform": "wheel"})
+              queue.put_many([
+                  {"platform": "wheel"},
+                  EnqueueItem({"platform": "batch"}, job_id="batch-1"),
+              ])
+              job = queue.get(block=False)
+              queue.ack(job)
               job = queue.get(block=False)
               queue.ack(job)
-              assert queue.stats()["acked"] == 1
+              assert queue.stats()["acked"] == 2
               queue.close()
+
+              topology = BusTopology({"smoke": [WheelEvent]})
+              bus = EventBus(path, topology=topology)
+              smoke = bus.subscription("smoke")
+
+              @smoke.handler(WheelEvent)
+              def handle(event: WheelEvent) -> None:
+                  assert event.value == 1
+
+              receipt = bus.dispatch(WheelEvent(value=1))
+              assert receipt.subscriptions == ("smoke",)
+              bus.close()
           PY
 
       - name: Validate Linux ARM64 wheel artifact
@@ -101,18 +120,54 @@ jobs:
         shell: bash
         run: test -n "$(find target/wheels -name '*cp313*.whl' -print -quit)"
 
-      - name: Install release tools
-        if: startsWith(github.ref, 'refs/tags/v')
-        run: python -m pip install --upgrade "maturin>=1.14,<2" uv
+      - name: Build source distribution
+        if: matrix.name == 'linux-x86_64'
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out target/dist
+          maturin-version: v1.14.1
 
-      - name: Build and publish source distribution
-        if: matrix.name == 'linux-x86_64' && startsWith(github.ref, 'refs/tags/v')
-        shell: bash
-        run: |
-          maturin sdist --out target/dist
-          uv publish target/dist/*.tar.gz
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.name }}
+          path: target/wheels/*.whl
+          if-no-files-found: error
 
-      - name: Publish wheel
-        if: startsWith(github.ref, 'refs/tags/v')
-        shell: bash
-        run: uv publish target/wheels/*.whl
+      - name: Upload source distribution
+        if: matrix.name == 'linux-x86_64'
+        uses: actions/upload-artifact@v4
+        with:
+          name: source-distribution
+          path: target/dist/*.tar.gz
+          if-no-files-found: error
+
+  publish:
+    name: Publish complete release to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: Download all release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: target/dist
+          merge-multiple: true
+
+      - name: Download source distribution
+        uses: actions/download-artifact@v4
+        with:
+          name: source-distribution
+          path: target/dist
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8
+
+      - name: Publish all artifacts
+        run: uv publish --trusted-publishing always target/dist/*

localqueue-1.1.0/CHANGELOG.md

@@ -0,0 +1,85 @@
+# Changelog
+
+All notable changes to `localqueue` are documented here.
+
+## [1.1.0] - 2026-07-21
+
+### Added
+
+- `SimpleQueue.put_many(...)` for atomic batch enqueueing, with optional
+  per-item deduplication through `EnqueueItem`.
+- The optional `localqueue.bus` package, exposing `BaseEvent` and `EventBus`
+  when installed with `localqueue[bus]`.
+- Atomic event fan-out to durable subscriptions, wildcard handlers, consumer
+  groups across processes, lease heartbeats, retries, and dead-letter handling.
+- Fan-out benchmarks and multiprocess coverage for the event bus.
+- Event routing now uses an explicit static `BusTopology`, allowing producers
+  and consumers to run in separate processes without producers importing
+  consumer handlers.
+- Handler registration is separate from subscription declaration through
+  `bus.subscription(...).handler(...)`.
+
+### Changed
+
+- Blocking queue operations and synchronous event handlers are moved off the
+  asyncio event loop.
+- Idle polling avoids repeated SQLite writer transactions while queues are
+  empty, reducing lock contention across many idle subscriptions.
+- Public docstrings, log messages, validation errors, and native queue errors
+  are now consistently written in English.
+- Release wheels cover CPython 3.10 through 3.14 on Linux x86-64/aarch64,
+  macOS x86-64/arm64, and Windows x86-64.
+
+### Fixed
+
+- Reject worker heartbeat intervals that are not shorter than the queue lease,
+  non-positive lease extensions, and negative NACK delays.
+
+### Compatibility
+
+- Existing `SimpleQueue` and `Worker` APIs remain backward compatible.
+- Event bus support is optional and requires Pydantic 2 via the `bus` extra.
+
+## Migrating from 0.5.0
+
+Version 1.0.0 was a complete, backward-incompatible reimplementation of the
+legacy `localqueue` package. Upgrading from 0.5.0 is not an in-place library or
+storage migration:
+
+- Replace `PersistentQueue` with `SimpleQueue` and adapt producers and
+  consumers to the explicit `put` → `get` → `ack`/`nack` lifecycle.
+- The Tenacity-backed persistent retry API and the `cli`, `lmdb`, and `sqlite`
+  extras from 0.5.0 are not part of 1.x. Version 1.x uses its bundled SQLite
+  engine and Rust extension; install `localqueue[bus]` only when the event bus
+  is needed.
+- Do not reuse a 0.5.0 database with 1.x. Drain or export pending work with
+  0.5.0 first, create a new 1.x queue directory, and enqueue any work that must
+  be retained.
+- Imports, configuration, storage layout, and operational commands from 0.5.0
+  are not guaranteed to work in 1.x. Test the migration in a separate virtual
+  environment before replacing a production worker.
+- Version 1.x supports Python 3.10 and newer and is licensed under Apache-2.0;
+  version 0.5.0 required Python 3.11 and used the MIT license.
+
+## [1.0.1] - 2026-07-20
+
+### Changed
+
+- Expanded the public README with installation, delivery guarantees,
+  configuration, API, architecture, and development guidance.
+- Declared and validated support for Python 3.10 through 3.14 across Linux,
+  macOS, and Windows wheels.
+
+## [1.0.0] - 2026-07-20
+
+### Changed
+
+- Reimplemented `localqueue` around `SimpleQueue`, a bundled SQLite database,
+  and a native Rust extension.
+- Replaced the legacy 0.5.0 API and storage model with explicit ACK/NACK,
+  leases, bounded retries, dead-letter handling, receipt fencing, and
+  multiprocess safety on one machine.
+
+[1.1.0]: https://github.com/brunoportis/localqueue/compare/v1.0.1...v1.1.0
+[1.0.1]: https://github.com/brunoportis/localqueue/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/brunoportis/localqueue/releases/tag/v1.0.0

{localqueue-1.0.1 → localqueue-1.1.0}/Cargo.lock

@@ -97,7 +97,7 @@ dependencies = [
 
 [[package]]
 name = "localqueue"
-version = "1.0.1"
+version = "1.1.0"
 dependencies = [
  "pyo3",
  "rusqlite",

{localqueue-1.0.1 → localqueue-1.1.0}/Cargo.toml

@@ -1,8 +1,11 @@
 [package]
 name = "localqueue"
-version = "1.0.1"
+version = "1.1.0"
 edition = "2021"
 rust-version = "1.83"
+description = "A persistent, multiprocess-safe local queue for Python, backed by SQLite and Rust."
+license = "Apache-2.0"
+repository = "https://github.com/brunoportis/localqueue"
 readme = "README.md"
 
 [lib]

localqueue-1.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

localqueue-1.0.1/README.md → localqueue-1.1.0/PKG-INFO

@@ -1,8 +1,35 @@
+Metadata-Version: 2.4
+Name: localqueue
+Version: 1.1.0
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: persist-queue==1.1.0 ; extra == 'benchmark'
+Requires-Dist: pydantic>=2,<3 ; extra == 'bus'
+Requires-Dist: pytest>=8.0 ; extra == 'dev'
+Requires-Dist: maturin>=1.14 ; extra == 'dev'
+Requires-Dist: pydantic>=2,<3 ; extra == 'dev'
+Provides-Extra: benchmark
+Provides-Extra: bus
+Provides-Extra: dev
+License-File: LICENSE
+Summary: A persistent, multiprocess-safe local queue for Python, backed by SQLite and Rust.
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/brunoportis/localqueue
+Project-URL: Issues, https://github.com/brunoportis/localqueue/issues
+Project-URL: Repository, https://github.com/brunoportis/localqueue
+
 # localqueue
 
 [![PyPI](https://img.shields.io/pypi/v/localqueue.svg)](https://pypi.org/project/localqueue/)
 [![Python](https://img.shields.io/pypi/pyversions/localqueue.svg)](https://pypi.org/project/localqueue/)
 [![CI](https://github.com/brunoportis/localqueue/actions/workflows/ci.yml/badge.svg)](https://github.com/brunoportis/localqueue/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](https://github.com/brunoportis/localqueue/blob/main/LICENSE)
 
 A persistent, multiprocess-safe local queue for Python, backed by SQLite and Rust.
 
@@ -19,10 +46,14 @@ service.
   acknowledge a newer delivery.
 - **Flexible:** use multiple named queues, optional job deduplication, automatic
   worker heartbeats, and custom serializers.
+- **Event-driven:** optional durable pub/sub with explicit static topology,
+  atomic fan-out, consumer groups, retries, and dead-letter handling.
 
 [Installation](#installation) · [Quick start](#quick-start) ·
-[Worker](#worker) · [Guarantees](#delivery-guarantees) ·
-[API](#api-overview) · [Development](#development)
+[Worker](#worker) · [Event bus](#event-bus) ·
+[Guarantees](#delivery-guarantees) ·
+[API](#api-overview) · [Changelog](CHANGELOG.md) ·
+[Development](#development)
 
 ## Installation
 
@@ -40,6 +71,10 @@ python -m pip install localqueue
 
 `localqueue` requires Python 3.10 or newer.
 
+Upgrading from 0.5.0 requires code and storage changes because 1.x is a
+backward-incompatible reimplementation. See
+[Migrating from 0.5.0](CHANGELOG.md#migrating-from-050).
+
 ## Quick start
 
 ```python
@@ -93,8 +128,76 @@ with SimpleQueue("./data", lease_seconds=30, max_retries=3) as queue:
 ```
 
 For long-running handlers, `heartbeat_interval` renews the lease in the
-background. A handler can also renew it explicitly with
-`job.extend_lease(seconds)`.
+background. It must be shorter than `lease_seconds`; one-third of the lease is
+recommended. A handler can also renew it explicitly with
+`job.extend_lease(seconds)`, using a positive duration.
+
+## Event bus
+
+Optional pub/sub on top of the same durable queues (requires the `bus` extra):
+
+```bash
+uv add "localqueue[bus]>=1.1.0"
+```
+
+> [!NOTE]
+> The event bus API requires `localqueue` 1.1.0 or newer. If the PyPI badge
+> still shows 1.0.1, the 1.1.0 release rollout has not completed yet.
+
+```python
+# shared.py
+from localqueue.bus import BaseEvent, BusTopology
+
+
+class UserCreated(BaseEvent):
+    event_name = "user.created"
+
+    user_id: str
+
+
+TOPOLOGY = BusTopology({"email": [UserCreated]})
+```
+
+```python
+# producer.py
+from localqueue.bus import EventBus
+
+from shared import TOPOLOGY, UserCreated
+
+
+bus = EventBus("./data", name="app", topology=TOPOLOGY)
+bus.dispatch(UserCreated(user_id="123"))  # atomic fan-out, committed
+bus.close()
+```
+
+```python
+# email_worker.py
+import asyncio
+
+from localqueue.bus import EventBus
+
+from shared import TOPOLOGY, UserCreated
+
+
+bus = EventBus("./data", name="app", topology=TOPOLOGY)
+email = bus.subscription("email")
+
+
+@email.handler(UserCreated)
+async def send_welcome(event: UserCreated) -> None:
+    ...
+
+
+asyncio.run(bus.run())  # consume subscriptions handled by this process
+```
+
+Each subscription is a durable queue (`__bus__:{bus}:{subscription}`), so
+workers in multiple processes act as consumer groups. Handlers get the same
+retry, lease, and dead-letter semantics as regular jobs. The static topology
+decides where events are persisted; local handlers decide what the current
+process consumes. Producers do not import handlers, and workers do not
+participate in dispatch. See
+[docs/event-bus.md](https://github.com/brunoportis/localqueue/blob/main/docs/event-bus.md).
 
 ## Delivery guarantees
 
@@ -158,12 +261,13 @@ queue = SimpleQueue(
 | Method | Purpose |
 | --- | --- |
 | `put(data, job_id=None)` | Enqueue a payload, with optional deduplication. |
+| `put_many(items)` | Atomically enqueue multiple payloads, optionally using `EnqueueItem` for per-item deduplication. |
 | `get(block=True, timeout=None)` | Claim a job and start its lease. |
 | `get_nowait()` | Claim immediately or raise `Empty`. |
 | `ack(job)` | Confirm successful processing. |
-| `nack(job, delay=0, last_error=None)` | Return a transient failure to the queue, optionally with a delay. |
+| `nack(job, delay=0, last_error=None)` | Return a transient failure to the queue, optionally with a non-negative delay. |
 | `fail(job, last_error=None)` | Move a permanent failure to the dead-letter state. |
-| `extend_lease(job, seconds)` | Renew the current delivery lease. |
+| `extend_lease(job, seconds)` | Renew the current delivery lease by a positive duration. |
 | `reclaim_expired_leases()` | Reclaim expired leases explicitly; `get()` also does this automatically. |
 | `stats()` | Return `ready`, `processing`, `acked`, and `failed` counts. |
 | `list_failed(limit=100, offset=0)` | Inspect dead-letter jobs. |
@@ -218,3 +322,8 @@ Build a release wheel:
 ```bash
 uv run maturin build --release --locked
 ```
+
+## License
+
+Licensed under the [Apache License 2.0](https://github.com/brunoportis/localqueue/blob/main/LICENSE).
+