django-lambda-tasks 0.1.4__tar.gz → 0.1.5__tar.gz

{django_lambda_tasks-0.1.4 → django_lambda_tasks-0.1.5}/.kiro/steering/product.md

@@ -178,7 +178,7 @@ Statuses: `RUNNING`, `SUCCESS`, `FAILED`, `RETRYING`
 | `LAMBDA_TASKS_MAX_RETRIES` | `2880` | Maximum retry attempts before `MaxRetriesExceededError` is raised (60 × 24 × 2) |
 | `LAMBDA_TASKS_SINGLETON_CACHE` | `"default"` | Django cache backend used for singleton task locks |
 
-`LAMBDA_TASKS_QUEUES` must be set and include a `"default"` key. `soft_timeout` must always be strictly less than `hard_timeout`.
+`LAMBDA_TASKS_QUEUES` must be set and include a `"default"` key. Both timeout values must be greater than zero and at most `900` seconds. `soft_timeout` must always be strictly less than `hard_timeout`.
 
 ## Eager Mode
 

django_lambda_tasks-0.1.4/README.md → django_lambda_tasks-0.1.5/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: django-lambda-tasks
+Version: 0.1.5
+Summary: Run async tasks in a lambda function
+Requires-Python: >=3.10
+Requires-Dist: awslambdaric
+Requires-Dist: boto3
+Requires-Dist: django
+Requires-Dist: pydantic
+Requires-Dist: redis
+Description-Content-Type: text/markdown
+
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler that AWS invokes with SQS message batches. Task results, status, and metadata are persisted in the Django database.
@@ -162,24 +174,6 @@ def my_task(*, arg: str) -> None:
 
 ---
 
-## Per-invocation overrides
-
-Pass override kwargs prefixed with `_` to `.execute_on_commit()` to customise a single invocation:
-
-```python
-send_welcome_email.execute_on_commit(
-    user_id=42,
-    template="welcome",
-    _delay=30,           # SQS message visibility delay in seconds
-)
-```
-
-| Override | Type | Description |
-|---|---|---|
-| `_delay` | `int` | SQS message delay in seconds before the worker can pick it up. |
-
----
-
 ## Serializing a task invocation
 
 `serialize()` builds and validates a task invocation the same way `execute_on_commit()` does, but returns the payload as a plain dict instead of enqueuing it. Useful when you need to inspect, store, or forward the message before deciding to send it.
@@ -196,8 +190,6 @@ payload = send_welcome_email.serialize(user_id=42, template="welcome")
 # }
 ```
 
-Per-invocation overrides (`_delay`) are accepted the same way as in `execute_on_commit()`.
-
 The returned dict matches the `SQSLambdaTask` schema. To reconstruct and enqueue it later:
 
 ```python

django_lambda_tasks-0.1.4/PKG-INFO → django_lambda_tasks-0.1.5/README.md

@@ -1,14 +1,3 @@
-Metadata-Version: 2.4
-Name: django-lambda-tasks
-Version: 0.1.4
-Summary: Run async tasks in a lambda function
-Requires-Python: >=3.10
-Requires-Dist: boto3
-Requires-Dist: django
-Requires-Dist: pydantic
-Requires-Dist: redis
-Description-Content-Type: text/markdown
-
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler that AWS invokes with SQS message batches. Task results, status, and metadata are persisted in the Django database.
@@ -173,24 +162,6 @@ def my_task(*, arg: str) -> None:
 
 ---
 
-## Per-invocation overrides
-
-Pass override kwargs prefixed with `_` to `.execute_on_commit()` to customise a single invocation:
-
-```python
-send_welcome_email.execute_on_commit(
-    user_id=42,
-    template="welcome",
-    _delay=30,           # SQS message visibility delay in seconds
-)
-```
-
-| Override | Type | Description |
-|---|---|---|
-| `_delay` | `int` | SQS message delay in seconds before the worker can pick it up. |
-
----
-
 ## Serializing a task invocation
 
 `serialize()` builds and validates a task invocation the same way `execute_on_commit()` does, but returns the payload as a plain dict instead of enqueuing it. Useful when you need to inspect, store, or forward the message before deciding to send it.
@@ -207,8 +178,6 @@ payload = send_welcome_email.serialize(user_id=42, template="welcome")
 # }
 ```
 
-Per-invocation overrides (`_delay`) are accepted the same way as in `execute_on_commit()`.
-
 The returned dict matches the `SQSLambdaTask` schema. To reconstruct and enqueue it later:
 
 ```python

{django_lambda_tasks-0.1.4 → django_lambda_tasks-0.1.5}/lambda_tasks/decorators.py

@@ -101,7 +101,9 @@ class LambdaTaskWrapper:
         """Return (soft_timeout, hard_timeout) resolved against settings defaults.
 
         Merges decorator-supplied values with settings defaults, then validates
-        the final pair. Result is cached after first access.
+        the final pair.  Each resolved value must be greater than zero and at
+        most ``MAX_TIMEOUT`` (900), and ``soft_timeout`` must be strictly less
+        than ``hard_timeout``.  Result is cached after first access.
         """
         try:
             return self._resolved_timeouts_cache
@@ -120,11 +122,15 @@ class LambdaTaskWrapper:
             else conf.DEFAULT_HARD_TIMEOUT
         )
 
-        # Validate settings-sourced values against the cap (decorator values are checked at decoration time)
+        # Validate settings-sourced values (decorator values are already checked at decoration time)
         for name, value, source in (
             ("soft_timeout", soft, self._soft_timeout),
             ("hard_timeout", hard, self._hard_timeout),
         ):
+            if source is None and value <= 0:
+                raise ValueError(
+                    f"{name} ({value}) from settings must be greater than zero."
+                )
             if source is None and value > MAX_TIMEOUT:
                 raise ValueError(
                     f"{name} ({value}) from settings exceeds the maximum allowed value of {MAX_TIMEOUT} seconds."
@@ -313,15 +319,23 @@ class LambdaTaskWrapper:
     def _validate_timeouts(
         *, soft_timeout: int | None, hard_timeout: int | None
     ) -> None:
-        """Raise ValueError if any timeout exceeds 900s or soft_timeout >= hard_timeout."""
+        """Raise ValueError if any timeout is not in (0, 900] or soft_timeout >= hard_timeout.
+
+        Each timeout, when supplied, must be greater than zero and at most
+        ``MAX_TIMEOUT`` (900).  When both are supplied, ``soft_timeout`` must
+        be strictly less than ``hard_timeout``.
+        """
         for name, value in (
             ("soft_timeout", soft_timeout),
             ("hard_timeout", hard_timeout),
         ):
+            if value is not None and value <= 0:
+                raise ValueError(f"{name} ({value}) must be greater than zero.")
             if value is not None and value > MAX_TIMEOUT:
                 raise ValueError(
                     f"{name} ({value}) exceeds the maximum allowed value of {MAX_TIMEOUT} seconds."
                 )
+
         if soft_timeout is not None and hard_timeout is not None:
             if soft_timeout >= hard_timeout:
                 raise ValueError(

{django_lambda_tasks-0.1.4 → django_lambda_tasks-0.1.5}/lambda_tasks/handler.py

@@ -43,8 +43,7 @@ def handler(*, event: dict, context: object) -> dict:
             ).execute_immediately(message_id=record["messageId"])
         except Exception:
             logger.error(
-                "Failed to process SQS record %s",
-                record.get("messageId"),
+                "Failed to process SQS record",
                 exc_info=True,
             )
             batch_item_failures.append({"itemIdentifier": record["messageId"]})

{django_lambda_tasks-0.1.4 → django_lambda_tasks-0.1.5}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["lambda_tasks"]
 
 [project]
 name = "django-lambda-tasks"
-version = "0.1.4"
+version = "0.1.5"
 description = "Run async tasks in a lambda function"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -16,6 +16,7 @@ dependencies = [
     "django",
     "pydantic",
     "redis",
+    "awslambdaric",
 ]
 
 [dependency-groups]

django_lambda_tasks-0.1.5/tests/test_timeout_validation.py

@@ -0,0 +1,170 @@
+"""
+Tests for timeout > 0 validation in decorators and resolved_timeouts.
+
+Covers:
+- Decorator-time rejection of zero and negative timeouts
+- Settings-sourced rejection of zero and negative timeouts via resolved_timeouts
+- Property-based: any positive timeout pair with soft < hard <= 900 is accepted
+"""
+
+import pytest
+from hypothesis import HealthCheck, given
+from hypothesis import settings as h_settings
+from hypothesis import strategies as st
+
+from lambda_tasks.decorators import LambdaTaskWrapper
+
+
+def _make_func():
+    def _task(*, x: int) -> None:
+        pass
+
+    return _task
+
+
+# ---------------------------------------------------------------------------
+# Decorator-time: zero timeouts rejected
+# ---------------------------------------------------------------------------
+
+
+def test_soft_timeout_zero_raises_value_error():
+    """soft_timeout=0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError, match="soft_timeout"):
+        LambdaTaskWrapper(_make_func(), soft_timeout=0, hard_timeout=10)
+
+
+def test_hard_timeout_zero_raises_value_error():
+    """hard_timeout=0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError, match="hard_timeout"):
+        LambdaTaskWrapper(_make_func(), soft_timeout=None, hard_timeout=0)
+
+
+# ---------------------------------------------------------------------------
+# Decorator-time: negative timeouts rejected
+# ---------------------------------------------------------------------------
+
+
+def test_soft_timeout_negative_raises_value_error():
+    """soft_timeout < 0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError, match="soft_timeout"):
+        LambdaTaskWrapper(_make_func(), soft_timeout=-1, hard_timeout=10)
+
+
+def test_hard_timeout_negative_raises_value_error():
+    """hard_timeout < 0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError, match="hard_timeout"):
+        LambdaTaskWrapper(_make_func(), hard_timeout=-5)
+
+
+# ---------------------------------------------------------------------------
+# Decorator-time: boundary — timeout=1 is the minimum accepted value
+# ---------------------------------------------------------------------------
+
+
+def test_soft_timeout_one_is_accepted():
+    """soft_timeout=1 is the minimum valid value."""
+    wrapper = LambdaTaskWrapper(_make_func(), soft_timeout=1, hard_timeout=2)
+    assert wrapper._soft_timeout == 1
+
+
+def test_hard_timeout_one_is_accepted():
+    """hard_timeout=1 is the minimum valid value (soft left to settings)."""
+    wrapper = LambdaTaskWrapper(_make_func(), hard_timeout=1)
+    assert wrapper._hard_timeout == 1
+
+
+# ---------------------------------------------------------------------------
+# resolved_timeouts: settings-sourced zero rejected
+# ---------------------------------------------------------------------------
+
+
+def test_resolved_soft_timeout_zero_from_settings_raises_value_error(settings):
+    """soft_timeout=0 from settings raises ValueError on resolved_timeouts."""
+    settings.LAMBDA_TASKS_QUEUES = {"default": "https://sqs.example.com/default"}
+    settings.LAMBDA_TASKS_DEFAULT_SOFT_TIMEOUT = 0
+    settings.LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT = 300
+
+    wrapper = LambdaTaskWrapper(_make_func())
+    with pytest.raises(ValueError, match="soft_timeout"):
+        _ = wrapper.resolved_timeouts
+
+
+def test_resolved_hard_timeout_zero_from_settings_raises_value_error(settings):
+    """hard_timeout=0 from settings raises ValueError on resolved_timeouts."""
+    settings.LAMBDA_TASKS_QUEUES = {"default": "https://sqs.example.com/default"}
+    settings.LAMBDA_TASKS_DEFAULT_SOFT_TIMEOUT = 0
+    settings.LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT = 0
+
+    wrapper = LambdaTaskWrapper(_make_func())
+    with pytest.raises(ValueError, match="timeout"):
+        _ = wrapper.resolved_timeouts
+
+
+# ---------------------------------------------------------------------------
+# resolved_timeouts: settings-sourced negative rejected
+# ---------------------------------------------------------------------------
+
+
+def test_resolved_soft_timeout_negative_from_settings_raises_value_error(settings):
+    """soft_timeout < 0 from settings raises ValueError on resolved_timeouts."""
+    settings.LAMBDA_TASKS_QUEUES = {"default": "https://sqs.example.com/default"}
+    settings.LAMBDA_TASKS_DEFAULT_SOFT_TIMEOUT = -10
+    settings.LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT = 300
+
+    wrapper = LambdaTaskWrapper(_make_func())
+    with pytest.raises(ValueError, match="soft_timeout"):
+        _ = wrapper.resolved_timeouts
+
+
+def test_resolved_hard_timeout_negative_from_settings_raises_value_error(settings):
+    """hard_timeout < 0 from settings raises ValueError on resolved_timeouts."""
+    settings.LAMBDA_TASKS_QUEUES = {"default": "https://sqs.example.com/default"}
+    settings.LAMBDA_TASKS_DEFAULT_SOFT_TIMEOUT = -10
+    settings.LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT = -5
+
+    wrapper = LambdaTaskWrapper(_make_func())
+    with pytest.raises(ValueError, match="timeout"):
+        _ = wrapper.resolved_timeouts
+
+
+# ---------------------------------------------------------------------------
+# Property-based: valid timeout pairs (both > 0, soft < hard, hard <= 900)
+# ---------------------------------------------------------------------------
+
+
+_valid_timeout_pair = st.integers(min_value=1, max_value=899).flatmap(
+    lambda soft: st.integers(min_value=soft + 1, max_value=900).map(
+        lambda hard: (soft, hard)
+    )
+)
+
+
+@given(timeout_pair=_valid_timeout_pair)
+@h_settings(max_examples=100, suppress_health_check=[HealthCheck.too_slow])
+def test_property_valid_timeout_pair_accepted(timeout_pair):
+    """Any (soft, hard) with 1 <= soft < hard <= 900 is accepted at decoration time."""
+    soft, hard = timeout_pair
+    wrapper = LambdaTaskWrapper(_make_func(), soft_timeout=soft, hard_timeout=hard)
+    assert wrapper._soft_timeout == soft
+    assert wrapper._hard_timeout == hard
+
+
+# ---------------------------------------------------------------------------
+# Property-based: non-positive timeouts always rejected
+# ---------------------------------------------------------------------------
+
+
+@given(value=st.integers(max_value=0))
+@h_settings(max_examples=100, suppress_health_check=[HealthCheck.too_slow])
+def test_property_non_positive_soft_timeout_rejected(value):
+    """Any soft_timeout <= 0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError):
+        LambdaTaskWrapper(_make_func(), soft_timeout=value, hard_timeout=10)
+
+
+@given(value=st.integers(max_value=0))
+@h_settings(max_examples=100, suppress_health_check=[HealthCheck.too_slow])
+def test_property_non_positive_hard_timeout_rejected(value):
+    """Any hard_timeout <= 0 raises ValueError at decoration time."""
+    with pytest.raises(ValueError):
+        LambdaTaskWrapper(_make_func(), hard_timeout=value)