django-lambda-tasks 0.4.10__tar.gz → 0.4.11__tar.gz

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/.kiro/steering/product.md

@@ -24,10 +24,9 @@ Key modules:
 
 ```python
 # Always kwargs-only — positional args raise TypeError at decoration time
-@lambda_task(delay=0, retry_delay=30, soft_timeout=60, hard_timeout=120, queue="default",
-             ignore_errors=(SomeExpectedException,),
+@lambda_task(retry_delay=30, soft_timeout=60, hard_timeout=120, queue="default",
              retry_on=(TransientError,),
-             singleton=True)
+             singleton=True, retry_singleton=True)
 def my_task(*, user_id: int, action: str) -> None:
     ...
 ```
@@ -39,34 +38,14 @@ def my_task(*, user_id: int, action: str) -> None:
 
 ## Enqueuing
 
-`execute_on_commit()` uses the decorator `delay` value by default. Pass `_delay=<seconds>` at call time to override the delay for that specific enqueue:
+`execute_on_commit()` defaults to delay 0. Pass `_delay=<seconds>` at call time to set the SQS delay for that specific enqueue:
 
 ```python
-my_task.execute_on_commit(user_id=1, action="x")            # uses decorator delay
-my_task.execute_on_commit(user_id=1, action="x", _delay=60) # overrides with 60s
+my_task.execute_on_commit(user_id=1, action="x")            # delay 0
+my_task.execute_on_commit(user_id=1, action="x", _delay=60) # 60s delay
 ```
 
-The `_delay` override is validated against the same range `[0, 900]` as the decorator `delay`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
-
-## ignore_errors
-
-Pass a tuple of exception types to `ignore_errors` on `@lambda_task`. If the task raises an instance of any of those types (or a subclass), the executor treats it as a non-fatal outcome:
-
-- `TaskRecord.status` is set to `SUCCESS`
-- The exception traceback is saved to `TaskRecord.traceback` for observability
-- Task-side ORM writes inside the `transaction.atomic()` block are still rolled back
-- The `TaskRecord` update itself is committed outside the atomic block
-
-Exceptions not listed in `ignore_errors` continue to produce `FAILED` with a rollback. Omitting `ignore_errors` (or passing `()`) preserves the existing behaviour.
-
-```python
-@lambda_task(ignore_errors=(RecordNotFound,))
-def sync_user(*, user_id: int) -> None:
-    # RecordNotFound → SUCCESS + traceback recorded; anything else → FAILED
-    ...
-```
-
-`ignore_errors` is validated at decoration time — passing a non-exception type raises `TypeError` immediately. It is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
+The `_delay` override is validated against the range `[0, 900]`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
 
 ## retry_on
 
@@ -75,8 +54,6 @@ Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task rai
 - `TaskRecord.status` is set to `RETRYING` and the traceback is recorded
 - The retry is a new invocation — the current record is terminal at `RETRYING`
 - Retries continue until `n_retries` reaches `LAMBDA_TASKS_MAX_RETRIES`, at which point `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
-- `ignore_errors` is checked first — a type in both `ignore_errors` and `retry_on` is treated as ignored (SUCCESS), not retried
-- `retry_on` and `ignore_errors` must not overlap (exact match or subclass relationship); overlapping raises `TypeError` at decoration time
 
 ```python
 @lambda_task(retry_on=(RateLimitError, ConnectionError))
@@ -97,7 +74,8 @@ Pass `singleton=True` on `@lambda_task` to prevent concurrent execution of the s
 
 - Lock key format: `lambda_tasks.singleton_lock.{task_name}`
 - The lock is acquired with `blocking_timeout=0` (fail immediately if held) and `timeout=hard_timeout` (auto-expire if the worker crashes)
-- If the lock cannot be acquired (`LockError`), the executor treats it as a retryable exception — same code path as `retry_on`. The `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If the lock cannot be acquired (`LockError`) and `retry_singleton=True` (default), the executor treats it as a retryable exception — same code path as `retry_on`. The `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If `retry_singleton=False`, lock contention is treated as a successful no-op — `TaskRecord` is set to `SUCCESS` with the traceback recorded, and no retry is enqueued
 - If `n_retries` has reached `LAMBDA_TASKS_MAX_RETRIES`, `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
 - The cache backend used for locks is controlled by `LAMBDA_TASKS_SINGLETON_CACHE` (default `"default"`)
 
@@ -106,9 +84,14 @@ Pass `singleton=True` on `@lambda_task` to prevent concurrent execution of the s
 def sync_inventory(*, warehouse_id: int) -> None:
     # Only one instance runs at a time; LockError → RETRYING + re-enqueued
     ...
+
+@lambda_task(singleton=True, retry_singleton=False)
+def sync_inventory(*, warehouse_id: int) -> None:
+    # Only one instance runs at a time; LockError → SUCCESS + traceback (no retry)
+    ...
 ```
 
-`singleton` is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
+`singleton` and `retry_singleton` are stored on `LambdaTaskWrapper` and read by the executor at execution time; they are never serialised into the SQS message.
 
 ## SQS Message Schema (`SQSLambdaTaskMessage`)
 
@@ -130,8 +113,8 @@ class SQSLambdaTaskMessage(BaseModel):
 4. If `wrapper.singleton` is `True`, acquires a Redis lock via `caches[SINGLETON_CACHE].lock(lock_key)` wrapping the atomic block; if `False`, no lock is acquired
 5. Runs task inside `transaction.atomic()` + `TimeoutContext`
 6. On success: updates record to `SUCCESS` with result and `end_time`
-7. On ignored exception (type matches `ignore_errors`): rolls back task-side writes, commits record as `SUCCESS` with traceback and `end_time`
-8. On retryable exception (type matches `retry_on` or `LockError` for singleton tasks, `n_retries < MAX_RETRIES`): rolls back task-side writes, enqueues retry via `execute_on_commit` with `n_retries + 1`, commits record as `RETRYING` with traceback and `end_time`
+7. On `LockError` when `singleton=True` and `retry_singleton=False`: rolls back task-side writes, commits record as `SUCCESS` with traceback and `end_time`
+8. On retryable exception (type matches `retry_on` or `LockError` for singleton tasks with `retry_singleton=True`, `n_retries < MAX_RETRIES`): rolls back task-side writes, enqueues retry via `execute_on_commit` with `n_retries + 1`, commits record as `RETRYING` with traceback and `end_time`
 9. On retryable exception with `n_retries >= MAX_RETRIES`: commits record as `FAILED` with traceback, raises `MaxRetriesExceededError`
 10. On any other exception: rolls back atomic block, updates record to `FAILED` with traceback and `end_time`
 

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.4.10
+Version: 0.4.11
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: awslambdaric
@@ -74,7 +74,7 @@ def register(request):
 You can override the delay for a specific enqueue by passing `_delay`:
 
 ```python
-# Delay this particular invocation by 60 seconds instead of the decorator default
+# Delay this particular invocation by 60 seconds
 send_welcome_email.execute_on_commit(user_id=user.id, template="welcome", _delay=60)
 ```
 
@@ -207,10 +207,10 @@ Key characteristics:
     soft_timeout=60,       # seconds — overrides global default for this task
     hard_timeout=90,       # seconds — overrides global default for this task
     queue="default",       # named queue from LAMBDA_TASKS_QUEUES
-    ignore_errors=(),      # exception types treated as non-fatal
     retry_on=(),           # exception types that trigger automatic retry
     retry_delay=0,         # base retry delay in seconds (jitter always added, capped at 900)
     singleton=False,       # prevent concurrent execution via Redis lock
+    retry_singleton=True,  # retry on LockError for singleton tasks (or treat as success if False)
 )
 def my_task(*, arg: str) -> None:
     ...
@@ -218,32 +218,31 @@ def my_task(*, arg: str) -> None:
 
 | Parameter | Type | Default | Description |
 |---|---|---|---|
-| `delay` | `int` | `0` | Seconds to delay the SQS message before it becomes visible to consumers (max 900). |
 | `soft_timeout` | `int \| None` | `None` (uses global default) | Per-task soft timeout in seconds (max 900). |
 | `hard_timeout` | `int \| None` | `None` (uses global default) | Per-task hard timeout in seconds (max 900). |
 | `queue` | `str` | `"default"` | Named queue to route this task to. |
-| `ignore_errors` | `tuple[type[BaseException], ...]` | `()` | Exception types to treat as non-fatal (see [Ignored exceptions](#ignored-exceptions)). |
 | `retry_on` | `tuple[type[BaseException], ...]` | `()` | Exception types that trigger an automatic retry (see [Automatic retries](#automatic-retries)). |
 | `retry_delay` | `int` | `0` | Base delay in seconds when enqueuing a retry. Jitter (1–5s) is always added; result capped at 900. Requires `retry_on` to be non-empty. |
 | `singleton` | `bool` | `False` | Prevent concurrent execution via a Redis lock (see [Singleton tasks](#singleton-tasks)). |
+| `retry_singleton` | `bool` | `True` | When `True`, `LockError` on a singleton task triggers a retry. When `False`, lock contention is treated as a successful no-op (traceback recorded). |
 
 ### Per-call delay override
 
-The `delay` decorator parameter sets the default SQS `DelaySeconds` for all invocations of a task. To override it for a specific call, pass `_delay` to `execute_on_commit()` or `serialize()`:
+By default, `execute_on_commit()` uses a delay of 0 seconds. To set the SQS `DelaySeconds` for a specific call, pass `_delay` to `execute_on_commit()` or `serialize()`:
 
 ```python
-@lambda_task(delay=0)
+@lambda_task
 def notify_user(*, user_id: int) -> None:
     ...
 
-# Uses the decorator default (0 seconds)
+# Default (0 seconds delay)
 notify_user.execute_on_commit(user_id=1)
 
-# Override: delay this specific invocation by 120 seconds
+# Delay this specific invocation by 120 seconds
 notify_user.execute_on_commit(user_id=1, _delay=120)
 ```
 
-`_delay` is validated against the same `[0, 900]` range as the decorator `delay`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
+`_delay` is validated against the range `[0, 900]`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
 
 ---
 
@@ -386,35 +385,6 @@ fields @timestamp, @message
 
 ---
 
-## Ignored exceptions
-
-Pass a tuple of exception types to `ignore_errors` on `@lambda_task`. If the task raises an instance of any listed type (or a subclass), the executor treats it as a non-fatal outcome:
-
-- `TaskRecord.status` is set to `SUCCESS`
-- The exception traceback is saved to `TaskRecord.traceback` for observability
-- Task-side ORM writes inside the `transaction.atomic()` block are still rolled back
-- The `TaskRecord` update is committed outside the atomic block
-
-Exceptions not in `ignore_errors` continue to produce `FAILED` with a rollback. The default (`()`) preserves existing behaviour.
-
-```python
-from lambda_tasks.decorators import lambda_task
-
-class RecordNotFound(Exception):
-    pass
-
-@lambda_task(ignore_errors=(RecordNotFound,))
-def sync_user(*, user_id: int) -> None:
-    user = fetch_user(user_id)   # raises RecordNotFound if already deleted
-    update_profile(user)
-```
-
-If `sync_user` raises `RecordNotFound`, the `TaskRecord` will have `status=SUCCESS` and the traceback recorded in `traceback`. Any ORM writes made before the exception are rolled back.
-
-`ignore_errors` is validated at decoration time — passing a non-exception type raises `TypeError` immediately. It is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
-
----
-
 ## Automatic retries
 
 Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task raises an instance of any listed type (or a subclass), the executor re-enqueues the task with an incremented retry counter:
@@ -422,8 +392,6 @@ Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task rai
 - `TaskRecord.status` is set to `RETRYING` and the traceback is recorded
 - The retry is a new invocation — the current record is terminal at `RETRYING`
 - Retries continue until `n_retries` reaches `LAMBDA_TASKS_MAX_RETRIES` (default `2880`), at which point `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
-- `ignore_errors` is checked first — a type in both `ignore_errors` and `retry_on` is treated as ignored (SUCCESS), not retried
-- `retry_on` and `ignore_errors` must not overlap; overlapping raises `TypeError` at decoration time
 
 ```python
 from lambda_tasks.decorators import lambda_task
@@ -450,19 +418,27 @@ from lambda_tasks.decorators import lambda_task
 
 @lambda_task(singleton=True)
 def sync_inventory(*, warehouse_id: int) -> None:
-    # Only one instance runs at a time
+    # Only one instance runs at a time; LockError → RETRYING + re-enqueued
     ...
 ```
 
 - Lock key format: `lambda_tasks.singleton_lock.{task_name}`
 - The lock is acquired with `blocking_timeout=0` (fail immediately if held) and `timeout=hard_timeout` (auto-expire if the worker crashes)
-- If the lock cannot be acquired (`LockError`), the task is retried via the existing retry mechanism — `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If the lock cannot be acquired (`LockError`) and `retry_singleton=True` (the default), the task is retried — `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If `retry_singleton=False`, lock contention is treated as a successful no-op — `TaskRecord` is set to `SUCCESS` with the traceback recorded, and no retry is enqueued
 - If `n_retries` reaches `LAMBDA_TASKS_MAX_RETRIES`, `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
 - The cache backend used for locks is controlled by `LAMBDA_TASKS_SINGLETON_CACHE` (default `"default"`)
 
-`LockError` is retried automatically for singleton tasks — do not include it in `retry_on` (doing so raises `TypeError` at decoration time). You may include `LockError` in `ignore_errors` if you want lock contention to be treated as a non-fatal outcome instead of triggering a retry.
+`LockError` is handled automatically for singleton tasks — do not include it in `retry_on` (doing so raises `TypeError` at decoration time).
+
+`singleton` and `retry_singleton` are stored on `LambdaTaskWrapper` and read by the executor at execution time; they are never serialised into the SQS message.
 
-`singleton` is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
+```python
+@lambda_task(singleton=True, retry_singleton=False)
+def sync_inventory(*, warehouse_id: int) -> None:
+    # Lock contention → SUCCESS with traceback (no retry)
+    ...
+```
 
 ---
 
@@ -470,8 +446,6 @@ def sync_inventory(*, warehouse_id: int) -> None:
 
 Each task runs inside a `django.db.transaction.atomic` block. If the task raises an unhandled exception, all ORM writes made inside the task are rolled back. The `TaskRecord` failure update is always written outside the atomic block so it survives the rollback.
 
-When an exception matches `ignore_errors`, the same rollback applies to task-side writes — the atomic block still exits via exception. Only the `TaskRecord` update (written outside the block) is committed, recording the `SUCCESS` outcome and traceback.
-
 ---
 
 ## Error handling

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/README.md

@@ -62,7 +62,7 @@ def register(request):
 You can override the delay for a specific enqueue by passing `_delay`:
 
 ```python
-# Delay this particular invocation by 60 seconds instead of the decorator default
+# Delay this particular invocation by 60 seconds
 send_welcome_email.execute_on_commit(user_id=user.id, template="welcome", _delay=60)
 ```
 
@@ -195,10 +195,10 @@ Key characteristics:
     soft_timeout=60,       # seconds — overrides global default for this task
     hard_timeout=90,       # seconds — overrides global default for this task
     queue="default",       # named queue from LAMBDA_TASKS_QUEUES
-    ignore_errors=(),      # exception types treated as non-fatal
     retry_on=(),           # exception types that trigger automatic retry
     retry_delay=0,         # base retry delay in seconds (jitter always added, capped at 900)
     singleton=False,       # prevent concurrent execution via Redis lock
+    retry_singleton=True,  # retry on LockError for singleton tasks (or treat as success if False)
 )
 def my_task(*, arg: str) -> None:
     ...
@@ -206,32 +206,31 @@ def my_task(*, arg: str) -> None:
 
 | Parameter | Type | Default | Description |
 |---|---|---|---|
-| `delay` | `int` | `0` | Seconds to delay the SQS message before it becomes visible to consumers (max 900). |
 | `soft_timeout` | `int \| None` | `None` (uses global default) | Per-task soft timeout in seconds (max 900). |
 | `hard_timeout` | `int \| None` | `None` (uses global default) | Per-task hard timeout in seconds (max 900). |
 | `queue` | `str` | `"default"` | Named queue to route this task to. |
-| `ignore_errors` | `tuple[type[BaseException], ...]` | `()` | Exception types to treat as non-fatal (see [Ignored exceptions](#ignored-exceptions)). |
 | `retry_on` | `tuple[type[BaseException], ...]` | `()` | Exception types that trigger an automatic retry (see [Automatic retries](#automatic-retries)). |
 | `retry_delay` | `int` | `0` | Base delay in seconds when enqueuing a retry. Jitter (1–5s) is always added; result capped at 900. Requires `retry_on` to be non-empty. |
 | `singleton` | `bool` | `False` | Prevent concurrent execution via a Redis lock (see [Singleton tasks](#singleton-tasks)). |
+| `retry_singleton` | `bool` | `True` | When `True`, `LockError` on a singleton task triggers a retry. When `False`, lock contention is treated as a successful no-op (traceback recorded). |
 
 ### Per-call delay override
 
-The `delay` decorator parameter sets the default SQS `DelaySeconds` for all invocations of a task. To override it for a specific call, pass `_delay` to `execute_on_commit()` or `serialize()`:
+By default, `execute_on_commit()` uses a delay of 0 seconds. To set the SQS `DelaySeconds` for a specific call, pass `_delay` to `execute_on_commit()` or `serialize()`:
 
 ```python
-@lambda_task(delay=0)
+@lambda_task
 def notify_user(*, user_id: int) -> None:
     ...
 
-# Uses the decorator default (0 seconds)
+# Default (0 seconds delay)
 notify_user.execute_on_commit(user_id=1)
 
-# Override: delay this specific invocation by 120 seconds
+# Delay this specific invocation by 120 seconds
 notify_user.execute_on_commit(user_id=1, _delay=120)
 ```
 
-`_delay` is validated against the same `[0, 900]` range as the decorator `delay`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
+`_delay` is validated against the range `[0, 900]`. It only affects the SQS `DelaySeconds` — it has no effect in eager or async-local mode.
 
 ---
 
@@ -374,35 +373,6 @@ fields @timestamp, @message
 
 ---
 
-## Ignored exceptions
-
-Pass a tuple of exception types to `ignore_errors` on `@lambda_task`. If the task raises an instance of any listed type (or a subclass), the executor treats it as a non-fatal outcome:
-
-- `TaskRecord.status` is set to `SUCCESS`
-- The exception traceback is saved to `TaskRecord.traceback` for observability
-- Task-side ORM writes inside the `transaction.atomic()` block are still rolled back
-- The `TaskRecord` update is committed outside the atomic block
-
-Exceptions not in `ignore_errors` continue to produce `FAILED` with a rollback. The default (`()`) preserves existing behaviour.
-
-```python
-from lambda_tasks.decorators import lambda_task
-
-class RecordNotFound(Exception):
-    pass
-
-@lambda_task(ignore_errors=(RecordNotFound,))
-def sync_user(*, user_id: int) -> None:
-    user = fetch_user(user_id)   # raises RecordNotFound if already deleted
-    update_profile(user)
-```
-
-If `sync_user` raises `RecordNotFound`, the `TaskRecord` will have `status=SUCCESS` and the traceback recorded in `traceback`. Any ORM writes made before the exception are rolled back.
-
-`ignore_errors` is validated at decoration time — passing a non-exception type raises `TypeError` immediately. It is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
-
----
-
 ## Automatic retries
 
 Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task raises an instance of any listed type (or a subclass), the executor re-enqueues the task with an incremented retry counter:
@@ -410,8 +380,6 @@ Pass a tuple of exception types to `retry_on` on `@lambda_task`. If the task rai
 - `TaskRecord.status` is set to `RETRYING` and the traceback is recorded
 - The retry is a new invocation — the current record is terminal at `RETRYING`
 - Retries continue until `n_retries` reaches `LAMBDA_TASKS_MAX_RETRIES` (default `2880`), at which point `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
-- `ignore_errors` is checked first — a type in both `ignore_errors` and `retry_on` is treated as ignored (SUCCESS), not retried
-- `retry_on` and `ignore_errors` must not overlap; overlapping raises `TypeError` at decoration time
 
 ```python
 from lambda_tasks.decorators import lambda_task
@@ -438,19 +406,27 @@ from lambda_tasks.decorators import lambda_task
 
 @lambda_task(singleton=True)
 def sync_inventory(*, warehouse_id: int) -> None:
-    # Only one instance runs at a time
+    # Only one instance runs at a time; LockError → RETRYING + re-enqueued
     ...
 ```
 
 - Lock key format: `lambda_tasks.singleton_lock.{task_name}`
 - The lock is acquired with `blocking_timeout=0` (fail immediately if held) and `timeout=hard_timeout` (auto-expire if the worker crashes)
-- If the lock cannot be acquired (`LockError`), the task is retried via the existing retry mechanism — `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If the lock cannot be acquired (`LockError`) and `retry_singleton=True` (the default), the task is retried — `TaskRecord` is set to `RETRYING`, the traceback is recorded, and the task is re-enqueued with `n_retries + 1`
+- If `retry_singleton=False`, lock contention is treated as a successful no-op — `TaskRecord` is set to `SUCCESS` with the traceback recorded, and no retry is enqueued
 - If `n_retries` reaches `LAMBDA_TASKS_MAX_RETRIES`, `MaxRetriesExceededError` is raised and the record is saved as `FAILED`
 - The cache backend used for locks is controlled by `LAMBDA_TASKS_SINGLETON_CACHE` (default `"default"`)
 
-`LockError` is retried automatically for singleton tasks — do not include it in `retry_on` (doing so raises `TypeError` at decoration time). You may include `LockError` in `ignore_errors` if you want lock contention to be treated as a non-fatal outcome instead of triggering a retry.
+`LockError` is handled automatically for singleton tasks — do not include it in `retry_on` (doing so raises `TypeError` at decoration time).
+
+`singleton` and `retry_singleton` are stored on `LambdaTaskWrapper` and read by the executor at execution time; they are never serialised into the SQS message.
 
-`singleton` is stored on `LambdaTaskWrapper` and read by the executor at execution time; it is never serialised into the SQS message.
+```python
+@lambda_task(singleton=True, retry_singleton=False)
+def sync_inventory(*, warehouse_id: int) -> None:
+    # Lock contention → SUCCESS with traceback (no retry)
+    ...
+```
 
 ---
 
@@ -458,8 +434,6 @@ def sync_inventory(*, warehouse_id: int) -> None:
 
 Each task runs inside a `django.db.transaction.atomic` block. If the task raises an unhandled exception, all ORM writes made inside the task are rolled back. The `TaskRecord` failure update is always written outside the atomic block so it survives the rollback.
 
-When an exception matches `ignore_errors`, the same rollback applies to task-side writes — the atomic block still exits via exception. Only the `TaskRecord` update (written outside the block) is committed, recording the `SUCCESS` outcome and traceback.
-
 ---
 
 ## Error handling

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/lambda_tasks/decorators.py

@@ -11,7 +11,6 @@ Also provides the lambda_task decorator factory.
 import functools
 import inspect
 import types
-import uuid
 from collections.abc import Callable
 from typing import Any, overload
 
@@ -65,35 +64,30 @@ class LambdaTaskWrapper:
         self,
         func: types.FunctionType,
         *,
-        delay: int = 0,
         retry_delay: int = 0,
         soft_timeout: int | None = None,
         hard_timeout: int | None = None,
         queue: str = "default",
-        ignore_errors: tuple[type[BaseException], ...] = (),
         retry_on: tuple[type[BaseException], ...] = (),
         singleton: bool = False,
+        retry_singleton: bool = True,
     ) -> None:
         self._validate_func(func=func)
         self._validate_timeouts(soft_timeout=soft_timeout, hard_timeout=hard_timeout)
-        self._validate_delay(delay=delay)
         self._validate_retry_delay(retry_delay=retry_delay, retry_on=retry_on)
-        self._validate_ignore_errors(ignore_errors=ignore_errors)
         self._validate_retry_on(retry_on=retry_on)
-        self._validate_no_overlap(retry_on=retry_on, ignore_errors=ignore_errors)
         self._validate_singleton(singleton=singleton, retry_on=retry_on)
 
         functools.update_wrapper(self, func)
 
         self._func: types.FunctionType = func
-        self._delay = delay
         self._retry_delay = retry_delay
         self._soft_timeout = soft_timeout
         self._hard_timeout = hard_timeout
         self._queue = queue
-        self._ignore_errors = ignore_errors
         self._retry_on = retry_on
         self._singleton = singleton
+        self._retry_singleton = retry_singleton
         self._kwargs_model: type[pydantic.BaseModel] = _build_kwargs_model(func)
 
     @property
@@ -162,7 +156,7 @@ class LambdaTaskWrapper:
             ValueError: if ``_delay`` is outside the allowed range [0, 900].
         """
         n_retries = kwargs.pop("_n_retries", 0)
-        delay = kwargs.pop("_delay", self._delay)
+        delay = kwargs.pop("_delay", 0)
 
         self._validate_delay(delay=delay)
 
@@ -240,11 +234,6 @@ class LambdaTaskWrapper:
         """The SQS queue name this task is routed to."""
         return self._queue
 
-    @property
-    def ignore_errors(self) -> tuple[type[BaseException], ...]:
-        """Exception types that are treated as non-fatal during task execution."""
-        return self._ignore_errors
-
     @property
     def retry_on(self) -> tuple[type[BaseException], ...]:
         """Exception types that trigger an automatic retry."""
@@ -255,6 +244,11 @@ class LambdaTaskWrapper:
         """Whether this task enforces single-concurrency via a Redis lock."""
         return self._singleton
 
+    @property
+    def retry_singleton(self) -> bool:
+        """Whether LockError on a singleton task triggers an automatic retry."""
+        return self._retry_singleton
+
     @staticmethod
     def _validate_delay(*, delay: int) -> None:
         """Raise ValueError if delay is outside the allowed range [0, MAX_DELAY]."""
@@ -279,18 +273,6 @@ class LambdaTaskWrapper:
                 f"retry_delay only applies when the task is configured to retry."
             )
 
-    @staticmethod
-    def _validate_ignore_errors(
-        *, ignore_errors: tuple[type[BaseException], ...]
-    ) -> None:
-        """Raise TypeError if any element is not a subclass of BaseException."""
-        for item in ignore_errors:
-            if not (isinstance(item, type) and issubclass(item, BaseException)):
-                raise TypeError(
-                    f"ignore_errors must contain only exception types (subclasses of "
-                    f"BaseException); got {item!r}."
-                )
-
     @staticmethod
     def _validate_retry_on(*, retry_on: tuple[type[BaseException], ...]) -> None:
         """Raise TypeError if any element is not a subclass of BaseException."""
@@ -301,24 +283,6 @@ class LambdaTaskWrapper:
                     f"BaseException); got {item!r}."
                 )
 
-    @staticmethod
-    def _validate_no_overlap(
-        *,
-        retry_on: tuple[type[BaseException], ...],
-        ignore_errors: tuple[type[BaseException], ...],
-    ) -> None:
-        """Raise TypeError if any type in retry_on and ignore_errors overlap via subclass."""
-        for retry_type in retry_on:
-            for ignore_type in ignore_errors:
-                if issubclass(retry_type, ignore_type) or issubclass(
-                    ignore_type, retry_type
-                ):
-                    raise TypeError(
-                        f"retry_on and ignore_errors must not overlap: "
-                        f"{retry_type.__name__!r} and {ignore_type.__name__!r} conflict "
-                        f"(one is a subclass of the other)."
-                    )
-
     @staticmethod
     def _validate_timeouts(
         *, soft_timeout: int | None, hard_timeout: int | None
@@ -368,14 +332,13 @@ class LambdaTaskWrapper:
 def lambda_task(
     func: types.FunctionType,
     *,
-    delay: int = ...,
     retry_delay: int = ...,
     soft_timeout: int | None = ...,
     hard_timeout: int | None = ...,
     queue: str = ...,
-    ignore_errors: tuple[type[BaseException], ...] = ...,
     retry_on: tuple[type[BaseException], ...] = ...,
     singleton: bool = ...,
+    retry_singleton: bool = ...,
 ) -> LambdaTaskWrapper: ...
 
 
@@ -383,28 +346,26 @@ def lambda_task(
 def lambda_task(
     func: None = None,
     *,
-    delay: int = ...,
     retry_delay: int = ...,
     soft_timeout: int | None = ...,
     hard_timeout: int | None = ...,
     queue: str = ...,
-    ignore_errors: tuple[type[BaseException], ...] = ...,
     retry_on: tuple[type[BaseException], ...] = ...,
     singleton: bool = ...,
+    retry_singleton: bool = ...,
 ) -> Callable[[types.FunctionType], LambdaTaskWrapper]: ...
 
 
 def lambda_task(
     func: types.FunctionType | None = None,
     *,
-    delay: int = 0,
     retry_delay: int = 0,
     soft_timeout: int | None = None,
     hard_timeout: int | None = None,
     queue: str = "default",
-    ignore_errors: tuple[type[BaseException], ...] = (),
     retry_on: tuple[type[BaseException], ...] = (),
     singleton: bool = False,
+    retry_singleton: bool = True,
 ) -> LambdaTaskWrapper | Callable[[types.FunctionType], LambdaTaskWrapper]:
     """Decorator factory that registers a function as a background task.
 
@@ -413,21 +374,20 @@ def lambda_task(
         @lambda_task
         def my_task(*, x: int): ...
 
-        @lambda_task(delay=5, soft_timeout=60, hard_timeout=120)
+        @lambda_task(soft_timeout=60, hard_timeout=120)
         def my_task(*, x: int): ...
     """
 
     def _decorate(f: types.FunctionType) -> LambdaTaskWrapper:
         wrapper = LambdaTaskWrapper(
             f,
-            delay=delay,
             retry_delay=retry_delay,
             soft_timeout=soft_timeout,
             hard_timeout=hard_timeout,
             queue=queue,
-            ignore_errors=ignore_errors,
             retry_on=retry_on,
             singleton=singleton,
+            retry_singleton=retry_singleton,
         )
         return wrapper
 

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/lambda_tasks/models.py

@@ -139,7 +139,10 @@ class SQSLambdaTaskMessage(BaseModel):
                     blocking_timeout=0,
                     timeout=hard_timeout,
                 )
-                effective_retry_on = (LockError, *wrapper.retry_on)
+                if wrapper.retry_singleton:
+                    effective_retry_on = (LockError, *wrapper.retry_on)
+                else:
+                    effective_retry_on = wrapper.retry_on
             else:
                 lock_ctx = contextlib.nullcontext()
                 effective_retry_on = wrapper.retry_on
@@ -152,7 +155,11 @@ class SQSLambdaTaskMessage(BaseModel):
                         ):
                             result = wrapper(**self.kwargs)
             except Exception as error:
-                if wrapper.ignore_errors and isinstance(error, wrapper.ignore_errors):
+                if (
+                    wrapper.singleton
+                    and not wrapper.retry_singleton
+                    and isinstance(error, LockError)
+                ):
                     ignored_exception = error
                     ignored_traceback = traceback.format_exc()
                 elif effective_retry_on and isinstance(error, effective_retry_on):

{django_lambda_tasks-0.4.10 → django_lambda_tasks-0.4.11}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["lambda_tasks"]
 
 [project]
 name = "django-lambda-tasks"
-version = "0.4.10"
+version = "0.4.11"
 description = "Run async tasks in a lambda function"
 readme = "README.md"
 requires-python = ">=3.10"