django-lambda-tasks 0.1.0__tar.gz

django_lambda_tasks-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_call:
+
+env:
+  MINIMUM_PYTHON_VERSION: '3.10'
+
+concurrency:
+  group: ${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+
+  precommit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ env.MINIMUM_PYTHON_VERSION }}
+      - name: Run static code inspections
+        run: uv run pre-commit run --all-files
+
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Run uv
+        run: |
+          uv run pytest --cov-branch --cov-report term-missing --cov=tests/ --cov=lambda_tasks/

django_lambda_tasks-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,51 @@
+name: Publish Package
+
+on:
+  release:
+    types:
+      - published
+
+env:
+  MINIMUM_PYTHON_VERSION: '3.10'
+
+jobs:
+  ci:
+    uses: ./.github/workflows/ci.yml
+
+  build-for-pypi:
+    needs: ci
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Python ${{ env.MINIMUM_PYTHON_VERSION }}
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ env.MINIMUM_PYTHON_VERSION }}
+      - name: Build the package
+        run: uv build
+      - name: 'Upload Artifact'
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-dist
+          path: dist/
+          if-no-files-found: error
+          retention-days: 1
+
+  deploy-to-pypi:
+    # IMPORTANT: use a separate job for this as each step has access to the tokens
+    needs: build-for-pypi
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+    # IMPORTANT: this permission is mandatory for Trusted Publishing
+      id-token: write
+    steps:
+    - name: Download build artifacts
+      uses: actions/download-artifact@v4
+      with:
+        name: python-dist
+        path: dist
+    - name: Publish package distributions
+      uses: pypa/gh-action-pypi-publish@release/v1

django_lambda_tasks-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.idea/
+.hypothesis/
+/example/db.sqlite3
+
+.python-version
+uv.lock

django_lambda_tasks-0.1.0/.kiro/specs/deferred-task-enqueue/.config.kiro

@@ -0,0 +1 @@
+{"specId": "607aa163-ef89-4b0c-b886-6b6d0a53b02b", "workflowType": "requirements-first", "specType": "feature"}

django_lambda_tasks-0.1.0/.kiro/specs/deferred-task-enqueue/design.md

@@ -0,0 +1,298 @@
+# Design Document: deferred-task-enqueue
+
+## Overview
+
+This feature adds deferred task enqueuing to `django-lambda-tasks`. A task invocation can be
+serialized into a plain JSON-compatible dict (suitable for a Django `JSONField`), stored, and
+later enqueued from any context — a management command, a scheduled job, another task, etc.
+
+`SQSLambdaSQSLambdaTaskMessage` wraps a `SQSLambdaTaskMessage` as an attribute alongside `delay` and `queue`. This
+avoids field duplication and means the deferred path can serialize the embedded `SQSLambdaTaskMessage`
+directly — no changes to `serialize()` or `enqueue()` are needed.
+
+`on_commit` and `enqueue_from_json` share a private `_do_enqueue` helper on
+`LambdaTaskWrapper`. `enqueue_deferred` in `enqueuer.py` calls the same lower-level
+`_send_message` function that `enqueue()` already delegates to after serialization.
+
+---
+
+## Architecture
+
+```
+Developer code
+    │
+    ├─ wrapper.to_json(**kwargs)
+    │       └─ SQSLambdaSQSLambdaTaskMessage(message=SQSLambdaTaskMessage(...), delay=..., queue=...)
+    │          stored as dict in JSONField
+    │
+    ├─ wrapper.on_commit(**kwargs)       ─┐
+    │                                     ├─ wrapper._do_enqueue(message, delay, queue)
+    └─ wrapper.enqueue_from_json(dict)   ─┘         │
+                                                     └─ enqueuer._send_message(body, delay, queue)
+                                                                  │
+    enqueue_deferred(dict) ─────────────────────────────────────►│
+                                                                  │
+                                                      ┌───────────┴───────────┐
+                                                 EAGER=True             EAGER=False
+                                              execute_message()       boto3 SQS send
+```
+
+---
+
+## Components and Interfaces
+
+### `serializer.py` — `SQSLambdaSQSLambdaTaskMessage`
+
+New Pydantic model added alongside `SQSLambdaTaskMessage`. No field duplication — `SQSLambdaTaskMessage` is stored
+as a nested attribute:
+
+```python
+class SQSLambdaSQSLambdaTaskMessage(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    message: SQSLambdaTaskMessage
+    delay: int
+    queue: str
+```
+
+`message` is a full `SQSLambdaTaskMessage` (with `task_name`, `invocation_id`, `kwargs`) generated at
+serialization time by `to_json`. The `invocation_id` is stable — the same stored dict always
+carries the same ID, enabling deduplication via `TaskRecord.get_or_create`.
+
+`serialize()` and `deserialize()` are unchanged.
+
+### `enqueuer.py` — refactor to extract `_send_message`
+
+`enqueue()` is refactored to extract a private `_send_message(body, delay, queue)` helper that
+owns the SQS send (and eager execution). `enqueue()` continues to call `serialize()` then
+`_send_message()`. `enqueue_deferred` calls `_send_message()` directly with the pre-serialized
+body from the embedded `SQSLambdaTaskMessage`:
+
+```python
+def _send_message(*, body: str, delay: int, queue: str) -> None:
+    conf = LambdaTasksSettings()
+    if conf.EAGER:
+        execute_message(message_body=body)
+    else:
+        queue_url = conf.QUEUES[queue]  # raises ImproperlyConfigured if missing
+        boto3.client("sqs").send_message(
+            QueueUrl=queue_url, MessageBody=body, DelaySeconds=delay
+        )
+
+def enqueue(*, task_name, kwargs, delay, queue) -> None:
+    body = serialize(task_name=task_name, kwargs=kwargs)
+    _send_message(body=body, delay=delay, queue=queue)
+
+def enqueue_deferred(*, deferred: dict) -> None:
+    msg = SQSLambdaSQSLambdaTaskMessage.model_validate(deferred)
+    _send_message(body=msg.message.model_dump_json(), delay=msg.delay, queue=msg.queue)
+```
+
+### `decorators.py` — `LambdaTaskWrapper`
+
+Three additions:
+
+**`to_json(**kwargs) -> dict`**
+- Pops `_delay` / `_queue` overrides (same resolution logic as `on_commit`).
+- Validates remaining kwargs against `_kwargs_model`.
+- Builds a `SQSLambdaTaskMessage` with a fresh UUID4 `invocation_id`.
+- Returns `SQSLambdaSQSLambdaTaskMessage(message=task_message, delay=..., queue=...).model_dump()`.
+
+**`_do_enqueue(message: SQSLambdaTaskMessage, delay: int, queue: str) -> None`** (private)
+- Single call site for `enqueuer._send_message(body=message.model_dump_json(), delay=delay, queue=queue)`.
+- Both `on_commit` and `enqueue_from_json` delegate here.
+
+**`enqueue_from_json(*, data: dict) -> None`**
+- Validates `data` against `SQSLambdaSQSLambdaTaskMessage` (raises `pydantic.ValidationError` on failure).
+- Calls `self._do_enqueue(msg.message, msg.delay, msg.queue)`.
+
+`on_commit` is refactored to build a `SQSLambdaTaskMessage` and call `self._do_enqueue(...)` instead of
+calling `enqueuer.enqueue()` directly.
+
+---
+
+## Data Models
+
+### `SQSLambdaSQSLambdaTaskMessage` schema (as stored in JSONField)
+
+```json
+{
+  "message": {
+    "task_name": "myapp.tasks.my_task",
+    "invocation_id": "550e8400-e29b-41d4-a716-446655440000",
+    "kwargs": {"user_id": 42}
+  },
+  "delay": 0,
+  "queue": "default"
+}
+```
+
+Extra fields are forbidden at the top level. `message` is validated as a full `SQSLambdaTaskMessage`.
+
+---
+
+## Correctness Properties
+
+### Property 1: `to_json` structural invariant
+
+*For any* `LambdaTaskWrapper` and any valid task kwargs (with optional `_delay` / `_queue`
+overrides), `to_json` returns a dict that round-trips through `SQSLambdaSQSLambdaTaskMessage.model_validate`
+and contains a nested `message` dict with `task_name`, `invocation_id`, and `kwargs`, plus
+top-level `delay` and `queue` reflecting the resolved overrides or decorator defaults.
+
+**Validates: Requirements 1.1, 1.4, 1.5, 1.6, 1.7, 1.8**
+
+---
+
+### Property 2: `to_json` rejects invalid kwargs
+
+*For any* kwargs that fail the task's declared type annotations (wrong type, missing required
+field, or extra field), `to_json` raises `pydantic.ValidationError` and returns no dict.
+
+**Validates: Requirements 1.2, 1.3**
+
+---
+
+### Property 3: `SQSLambdaSQSLambdaTaskMessage` round-trip
+
+*For any* valid `SQSLambdaSQSLambdaTaskMessage` instance `m`, constructing a new instance from
+`m.model_dump()` produces an object equal to `m`.
+
+**Validates: Requirements 2.4**
+
+---
+
+### Property 4: `SQSLambdaSQSLambdaTaskMessage` rejects invalid and extra fields
+
+*For any* dict that is missing a required field, has a field with the wrong type, or contains
+extra top-level keys, `SQSLambdaSQSLambdaTaskMessage.model_validate` raises `pydantic.ValidationError`.
+
+**Validates: Requirements 2.2, 2.3**
+
+---
+
+### Property 5: `enqueue_from_json` passes stable `invocation_id` to `_send_message`
+
+*For any* valid deferred dict `d`, calling `enqueue_from_json(d)` passes the `invocation_id`
+from `d["message"]` to `_send_message` unchanged, so two calls with the same dict produce the
+same `invocation_id` in the SQS body.
+
+**Validates: Requirements 3.4, 3.5, 6.1**
+
+---
+
+### Property 6: `enqueue_from_json` rejects invalid dicts
+
+*For any* dict that fails `SQSLambdaSQSLambdaTaskMessage` validation, `enqueue_from_json` raises
+`pydantic.ValidationError` without calling `_send_message`.
+
+**Validates: Requirements 3.2, 3.3**
+
+---
+
+### Property 7: `enqueue_from_json` eager mode executes synchronously
+
+*For any* valid deferred dict, when `LAMBDA_TASKS_EAGER=True`, `enqueue_from_json` executes
+the task in-process without sending to SQS, identical to the eager behaviour of `on_commit`.
+
+**Validates: Requirements 3.6**
+
+---
+
+### Property 8: `on_commit` and `enqueue_from_json` share the same send path
+
+*For any* valid task kwargs, both `on_commit(**kwargs)` and `enqueue_from_json(to_json(**kwargs))`
+call `_send_message` with the same `task_name`, `kwargs`, `delay`, and `queue`.
+
+**Validates: Requirements 4.1, 4.2**
+
+---
+
+### Property 9: `enqueue_deferred` passes all fields including stable `invocation_id`
+
+*For any* valid `SQSLambdaSQSLambdaTaskMessage` dict `d`, `enqueue_deferred(d)` calls `_send_message` with
+a body whose `task_name`, `invocation_id`, and `kwargs` match `d["message"]`, and `delay` and
+`queue` match the top-level fields of `d`.
+
+**Validates: Requirements 5.1, 5.3, 5.4, 6.2**
+
+---
+
+### Property 10: `enqueue_deferred` rejects invalid dicts
+
+*For any* dict that fails `SQSLambdaSQSLambdaTaskMessage` validation, `enqueue_deferred` raises
+`pydantic.ValidationError` without calling `_send_message`.
+
+**Validates: Requirements 5.2**
+
+---
+
+### Property 11: `enqueue_deferred` eager mode executes synchronously
+
+*For any* valid deferred dict, when `LAMBDA_TASKS_EAGER=True`, `enqueue_deferred` executes
+the task in-process without sending to SQS.
+
+**Validates: Requirements 5.5**
+
+---
+
+## Error Handling
+
+| Situation | Behaviour |
+|---|---|
+| `to_json` called with wrong-type or missing kwargs | `pydantic.ValidationError` raised; no dict returned |
+| `enqueue_from_json` called with invalid dict | `pydantic.ValidationError` raised; `_send_message` not called |
+| `enqueue_deferred` called with invalid dict | `pydantic.ValidationError` raised; `_send_message` not called |
+| Queue name not in `LAMBDA_TASKS_QUEUES` | `ImproperlyConfigured` raised by `_send_message` (same as current `enqueue()` behaviour) |
+| boto3 / SQS error | Exception propagates from `_send_message` (unchanged) |
+
+No new exception types are introduced.
+
+---
+
+## Testing Strategy
+
+Tests follow red/green TDD: failing tests are written first, then the implementation makes them
+pass. One new test file: `tests/test_deferred_enqueue.py`. Existing files `test_decorator.py`,
+`test_enqueuer.py`, and `test_serializer.py` receive targeted additions for the touched code.
+
+### Unit tests
+
+- `to_json` returns a dict that validates as `SQSLambdaSQSLambdaTaskMessage` with correct fields
+- `to_json` uses decorator defaults when `_delay` / `_queue` are omitted
+- `to_json` uses call-site overrides when `_delay` / `_queue` are provided
+- `to_json` raises `ValidationError` for wrong-type kwargs
+- `to_json` raises `ValidationError` for missing required kwargs
+- `SQSLambdaSQSLambdaTaskMessage` accepts a valid dict with nested `message`
+- `SQSLambdaSQSLambdaTaskMessage` rejects a dict missing `message`
+- `SQSLambdaSQSLambdaTaskMessage` rejects a dict with extra top-level fields
+- `enqueue_from_json` passes the stored `invocation_id` through to `_send_message`
+- `enqueue_from_json` raises `ValidationError` for an invalid dict without calling `_send_message`
+- `on_commit` and `enqueue_from_json` both call `_do_enqueue`
+- `enqueue_deferred` calls `_send_message` with all correct fields including `invocation_id`
+- `enqueue_deferred` raises `ValidationError` for an invalid dict without calling `_send_message`
+- `enqueue()` still works correctly after `_send_message` extraction
+- Eager mode: `enqueue_from_json` executes task in-process
+- Eager mode: `enqueue_deferred` executes task in-process
+
+### Property-based tests
+
+Using `hypothesis` with a minimum of 100 iterations per property.
+
+Tag format: `# Feature: deferred-task-enqueue, Property {N}: {property_text}`
+
+| Property | Test description | Hypothesis strategy |
+|---|---|---|
+| P1 | `to_json` always returns a valid `SQSLambdaSQSLambdaTaskMessage` dict with correct fields | `st.fixed_dictionaries` for valid kwargs |
+| P2 | `to_json` always raises `ValidationError` for wrong-type kwargs | `st.one_of` wrong types per field |
+| P3 | `SQSLambdaSQSLambdaTaskMessage` round-trip | `st.builds(SQSLambdaSQSLambdaTaskMessage, ...)` |
+| P4 | `SQSLambdaSQSLambdaTaskMessage` rejects missing/wrong-type/extra fields | `st.fixed_dictionaries` with dropped/mutated fields |
+| P5 | `enqueue_from_json` always passes stable `invocation_id` to `_send_message` | `st.fixed_dictionaries` for valid dicts |
+| P6 | `enqueue_from_json` always raises for invalid dicts | `st.fixed_dictionaries` with missing fields |
+| P7 | `enqueue_from_json` with `EAGER=True` always executes in-process | `st.fixed_dictionaries` for valid dicts |
+| P8 | `on_commit` and `enqueue_from_json` always call `_send_message` with same task/kwargs/delay/queue | `st.fixed_dictionaries` for valid kwargs |
+| P9 | `enqueue_deferred` always passes all fields including `invocation_id` to `_send_message` | `st.builds(SQSLambdaSQSLambdaTaskMessage, ...)` |
+| P10 | `enqueue_deferred` always raises for invalid dicts | `st.fixed_dictionaries` with missing fields |
+| P11 | `enqueue_deferred` with `EAGER=True` always executes in-process | `st.builds(SQSLambdaSQSLambdaTaskMessage, ...)` |
+
+Each property-based test must run a minimum of 100 iterations (`@settings(max_examples=100)`).
+Each correctness property is implemented by exactly one property-based test.

django_lambda_tasks-0.1.0/.kiro/specs/deferred-task-enqueue/requirements.md

@@ -0,0 +1,101 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds support for deferred task enqueuing in the `django-lambda-tasks` library. Currently, tasks can only be enqueued immediately after a transaction commits via `LambdaTaskWrapper.on_commit()`. This feature allows a task invocation to be serialized into a plain JSON-compatible dict (suitable for storage in a Django `JSONField`), and later loaded and enqueued — from any context (management command, scheduled job, another task, etc.).
+
+`on_commit` and `enqueue_from_json` share the same underlying enqueue path. This means eager mode, queue resolution, and SQS sending all behave identically regardless of how the task was triggered. The refactor extracts a shared `_do_enqueue(task_name, kwargs, delay, queue)` helper that both methods call.
+
+The serialized form captures the task name, kwargs, enqueue-time options (delay, queue), and a stable `invocation_id` generated at serialization time. Using a stable ID means the same stored invocation can be enqueued multiple times and the second delivery will be deduplicated by `TaskRecord.get_or_create` — the same guarantee the existing SQS path provides.
+
+## Glossary
+
+- **LambdaTaskWrapper**: The wrapper object produced by `@lambda_task`; exposes `__call__`, `on_commit`, `to_json`, and `enqueue_from_json` methods.
+- **SQSLambdaTask**: A JSON-compatible dict representing a serialized task invocation, including `task_name`, `invocation_id`, `kwargs`, `delay`, and `queue`.
+- **Enqueuer**: The `enqueuer.enqueue()` function in `enqueuer.py` that serializes a `SQSLambdaTaskMessage` and sends it to SQS (or runs eagerly).
+- **Serializer**: The `serializer.py` module containing `SQSLambdaTaskMessage`, `serialize()`, and `deserialize()`.
+- **JSONField**: A Django model field that stores Python dicts as JSON in the database.
+- **SQSLambdaSQSLambdaTaskMessage**: A new Pydantic model in `serializer.py` representing the schema of a serialized deferred task invocation.
+- **`_do_enqueue`**: A private helper on `LambdaTaskWrapper` that performs the actual enqueue call; shared by `on_commit` and `enqueue_from_json`.
+
+## Requirements
+
+### Requirement 1: Serialize a Task Invocation to a JSON-Compatible Dict
+
+**User Story:** As a developer, I want to serialize a task invocation (with its kwargs and enqueue options) into a plain dict, so that I can store it in a Django `JSONField` for later enqueuing.
+
+#### Acceptance Criteria
+
+1. THE `LambdaTaskWrapper` SHALL expose a `to_json` method that accepts task kwargs plus optional `_delay` and `_queue` override kwargs and returns a JSON-compatible dict.
+2. WHEN `to_json` is called, THE `LambdaTaskWrapper` SHALL validate the provided kwargs against the task's declared parameter types before producing the dict.
+3. WHEN `to_json` is called with invalid kwargs, THE `LambdaTaskWrapper` SHALL raise a `pydantic.ValidationError`.
+4. THE dict returned by `to_json` SHALL contain the fields `task_name`, `invocation_id`, `kwargs`, `delay`, and `queue`.
+5. THE `invocation_id` field in the returned dict SHALL be a freshly generated UUID4 string.
+6. THE `task_name` field in the returned dict SHALL be the fully-qualified dotted name of the wrapped function (e.g. `"myapp.tasks.my_task"`).
+7. WHEN `_delay` is not provided to `to_json`, THE `LambdaTaskWrapper` SHALL use the decorator-level `delay` default for the `delay` field in the returned dict.
+8. WHEN `_queue` is not provided to `to_json`, THE `LambdaTaskWrapper` SHALL use the decorator-level `queue` default for the `queue` field in the returned dict.
+
+---
+
+### Requirement 2: Validate and Parse a Deferred Task Dict
+
+**User Story:** As a developer, I want the library to validate a dict loaded from a `JSONField` before enqueuing it, so that corrupt or tampered data is rejected with a clear error.
+
+#### Acceptance Criteria
+
+1. THE `Serializer` SHALL expose a `SQSLambdaSQSLambdaTaskMessage` Pydantic model with required fields: `task_name: str`, `invocation_id: str`, `kwargs: dict`, `delay: int`, `queue: str`.
+2. WHEN a dict is validated against `SQSLambdaSQSLambdaTaskMessage`, THE `Serializer` SHALL raise `pydantic.ValidationError` if any required field is missing or has the wrong type.
+3. THE `SQSLambdaSQSLambdaTaskMessage` model SHALL reject extra fields not in its schema.
+4. FOR ALL valid `SQSLambdaSQSLambdaTaskMessage` instances `m`, constructing `m` from `m.model_dump()` SHALL produce an equivalent object (round-trip property).
+
+---
+
+### Requirement 3: Enqueue a Deferred Task from a Stored Dict
+
+**User Story:** As a developer, I want to load a dict from a `JSONField` and enqueue the represented task, so that I can defer task enqueuing to a later point in time (e.g. from a management command or scheduled job).
+
+#### Acceptance Criteria
+
+1. THE `LambdaTaskWrapper` SHALL expose an `enqueue_from_json` method that accepts a dict (as produced by `to_json`) and enqueues the task by calling the same underlying enqueue path as `on_commit`.
+2. WHEN `enqueue_from_json` is called with a valid dict, THE `LambdaTaskWrapper` SHALL validate the dict against `SQSLambdaSQSLambdaTaskMessage` before enqueuing.
+3. WHEN `enqueue_from_json` is called with an invalid dict, THE `LambdaTaskWrapper` SHALL raise `pydantic.ValidationError` without enqueuing.
+4. WHEN `enqueue_from_json` is called, THE `Enqueuer` SHALL use the `invocation_id`, `delay`, and `queue` values from the dict.
+5. WHEN the same dict is passed to `enqueue_from_json` twice, THE second call SHALL be deduplicated by `TaskRecord.get_or_create` because both calls use the same `invocation_id`.
+6. WHEN `LAMBDA_TASKS_EAGER` is `True`, `enqueue_from_json` SHALL execute the task synchronously in-process, identical to the eager behaviour of `on_commit`.
+
+---
+
+### Requirement 4: Shared Enqueue Path
+
+**User Story:** As a developer, I want `on_commit` and `enqueue_from_json` to use the same underlying enqueue logic, so that eager mode, queue resolution, and SQS behaviour are always consistent between the two call sites.
+
+#### Acceptance Criteria
+
+1. THE `LambdaTaskWrapper` SHALL extract a private `_do_enqueue(task_name, kwargs, delay, queue)` method that contains the call to `enqueuer.enqueue()`.
+2. BOTH `on_commit` and `enqueue_from_json` SHALL delegate to `_do_enqueue` rather than calling `enqueuer.enqueue()` directly.
+3. ANY change to enqueue behaviour (e.g. adding a new SQS parameter) SHALL only require a change in `_do_enqueue`.
+
+---
+
+### Requirement 5: Module-Level Standalone Enqueue Function
+
+**User Story:** As a developer, I want a standalone function to enqueue a deferred task dict without needing a reference to the original `LambdaTaskWrapper`, so that I can enqueue from contexts where the wrapper is not easily accessible (e.g. a generic scheduler).
+
+#### Acceptance Criteria
+
+1. THE `Enqueuer` SHALL expose an `enqueue_deferred(deferred: dict) -> None` function that validates the dict against `SQSLambdaSQSLambdaTaskMessage` and calls `enqueuer.enqueue()`.
+2. WHEN `enqueue_deferred` is called with an invalid dict, THE `Enqueuer` SHALL raise `pydantic.ValidationError` without calling `enqueuer.enqueue()`.
+3. WHEN `enqueue_deferred` is called, THE `Enqueuer` SHALL use the `invocation_id`, `delay`, and `queue` values from the validated dict.
+4. WHEN the same dict is passed to `enqueue_deferred` twice, THE second execution SHALL be deduplicated by `TaskRecord.get_or_create` because both calls use the same `invocation_id`.
+5. WHEN `LAMBDA_TASKS_EAGER` is `True`, `enqueue_deferred` SHALL execute the task synchronously in-process, identical to the eager behaviour of `enqueue()`.
+
+---
+
+### Requirement 6: Round-Trip Consistency
+
+**User Story:** As a developer, I want the serialization and enqueuing path to be consistent, so that a dict produced by `to_json` can always be enqueued without modification.
+
+#### Acceptance Criteria
+
+1. FOR ALL valid task invocations, calling `to_json(**kwargs)` followed by `enqueue_from_json(result)` SHALL enqueue a `SQSLambdaTaskMessage` with the same `task_name`, `invocation_id`, `kwargs`, `delay`, and `queue` as stored in the dict.
+2. FOR ALL valid `SQSLambdaSQSLambdaTaskMessage` dicts `d`, calling `enqueue_deferred(d)` SHALL enqueue a `SQSLambdaTaskMessage` with `task_name`, `invocation_id`, `kwargs`, `delay`, and `queue` matching the fields of `d`.