django-lambda-tasks 0.2.5__tar.gz → 0.3.0__tar.gz

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.2.5
+Version: 0.3.0
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: awslambdaric

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/lambda_tasks/admin.py

@@ -22,6 +22,17 @@ class TaskRecordAdmin(admin.ModelAdmin):
     list_filter = ("status", "task_name")
     date_hierarchy = "start_time"
     search_fields = ("pk", "kwargs")
+    readonly_fields = (
+        "pk",
+        "task_name",
+        "kwargs",
+        "n_retries",
+        "status",
+        "start_time",
+        "end_time",
+        "result",
+        "traceback",
+    )
 
     def get_queryset(self, request: HttpRequest) -> QuerySet:
         return (

django_lambda_tasks-0.3.0/lambda_tasks/migrations/0002_alter_taskrecord_status.py

@@ -0,0 +1,60 @@
+"""Rename SUCCESS → SUCCEEDED and RETRYING → RETRIED status values."""
+
+from django.db import migrations, models
+
+
+def rename_statuses_forward(apps, schema_editor):
+    TaskRecord = apps.get_model("lambda_tasks", "TaskRecord")
+    TaskRecord.objects.filter(status="SUCCESS").update(status="SUCCEEDED")
+    TaskRecord.objects.filter(status="RETRYING").update(status="RETRIED")
+
+
+def rename_statuses_backward(apps, schema_editor):
+    TaskRecord = apps.get_model("lambda_tasks", "TaskRecord")
+    TaskRecord.objects.filter(status="SUCCEEDED").update(status="SUCCESS")
+    TaskRecord.objects.filter(status="RETRIED").update(status="RETRYING")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("lambda_tasks", "0001_initial"),
+    ]
+
+    operations = [
+        # First, drop the existing check constraint so we can update data
+        migrations.RemoveConstraint(
+            model_name="taskrecord",
+            name="taskrecord_status_valid",
+        ),
+        # Run data migration to rename existing rows
+        migrations.RunPython(
+            rename_statuses_forward,
+            rename_statuses_backward,
+        ),
+        # Alter the field with new choices
+        migrations.AlterField(
+            model_name="taskrecord",
+            name="status",
+            field=models.CharField(
+                choices=[
+                    ("RUNNING", "Running"),
+                    ("SUCCEEDED", "Succeeded"),
+                    ("FAILED", "Failed"),
+                    ("RETRIED", "Retried"),
+                ],
+                editable=False,
+                max_length=10,
+            ),
+        ),
+        # Re-add the check constraint with updated values
+        migrations.AddConstraint(
+            model_name="taskrecord",
+            constraint=models.CheckConstraint(
+                condition=models.Q(
+                    ("status__in", ["RUNNING", "SUCCEEDED", "FAILED", "RETRIED"])
+                ),
+                name="taskrecord_status_valid",
+            ),
+        ),
+    ]

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/lambda_tasks/models.py

@@ -30,9 +30,9 @@ class MaxRetriesExceededError(Exception):
 
 class TaskStatus(models.TextChoices):
     RUNNING = "RUNNING"
-    SUCCESS = "SUCCESS"
+    SUCCEEDED = "SUCCEEDED"
     FAILED = "FAILED"
-    RETRYING = "RETRYING"
+    RETRIED = "RETRIED"
 
 
 class TaskRecord(models.Model):
@@ -115,7 +115,7 @@ class SQSLambdaTaskMessage(BaseModel):
                         "task_name": self.task_name,
                         "kwargs": self.model_dump(mode="json")["kwargs"],
                         "n_retries": self.n_retries,
-                        "status": TaskRecord.TaskStatus.RUNNING,
+                        "status": TaskStatus.RUNNING,
                         "start_time": now(),
                     },
                 )
@@ -157,7 +157,7 @@ class SQSLambdaTaskMessage(BaseModel):
                 elif effective_retry_on and isinstance(error, effective_retry_on):
                     conf = LambdaTasksSettings()
                     if self.n_retries >= conf.MAX_RETRIES:
-                        record.status = TaskRecord.TaskStatus.FAILED
+                        record.status = TaskStatus.FAILED
                         record.traceback = traceback.format_exc()
                         record.end_time = now()
                         record.save(update_fields=["status", "traceback", "end_time"])
@@ -170,7 +170,7 @@ class SQSLambdaTaskMessage(BaseModel):
                             task_name=self.task_name, n_retries=self.n_retries
                         )
                     else:
-                        record.status = TaskRecord.TaskStatus.RETRYING
+                        record.status = TaskStatus.RETRIED
                         record.traceback = traceback.format_exc()
                         record.end_time = now()
                         record.save(update_fields=["status", "traceback", "end_time"])
@@ -198,7 +198,7 @@ class SQSLambdaTaskMessage(BaseModel):
                 else:
                     task_logger.error(error, exc_info=True)
 
-                    record.status = TaskRecord.TaskStatus.FAILED
+                    record.status = TaskStatus.FAILED
                     record.traceback = traceback.format_exc()
                     record.end_time = now()
                     record.save(update_fields=["status", "traceback", "end_time"])
@@ -207,14 +207,14 @@ class SQSLambdaTaskMessage(BaseModel):
                     return
 
             if ignored_exception is None:
-                record.status = TaskRecord.TaskStatus.SUCCESS
+                record.status = TaskStatus.SUCCEEDED
                 record.result = result
                 record.end_time = now()
                 record.save(update_fields=["status", "result", "end_time"])
 
                 task_logger.info(f"Succeeded in {record.duration}")
             else:
-                record.status = TaskRecord.TaskStatus.SUCCESS
+                record.status = TaskStatus.SUCCEEDED
                 record.traceback = ignored_traceback
                 record.end_time = now()
                 record.save(update_fields=["status", "traceback", "end_time"])

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/pyproject.toml

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

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/tests/test_decorator.py

@@ -666,7 +666,7 @@ def test_property_3_eager_mode_writes_task_record(value):
     assert TaskRecord.objects.filter(
         task_name=task_name,
         kwargs={"n": value},
-        status__in=[TaskRecord.TaskStatus.SUCCESS, TaskRecord.TaskStatus.FAILED],
+        status__in=[TaskRecord.TaskStatus.SUCCEEDED, TaskRecord.TaskStatus.FAILED],
     ).exists()
 
 

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/tests/test_models.py

@@ -66,9 +66,9 @@ class TestTaskRecordStatusChoices:
         "status",
         [
             TaskRecord.TaskStatus.RUNNING,
-            TaskRecord.TaskStatus.SUCCESS,
+            TaskRecord.TaskStatus.SUCCEEDED,
             TaskRecord.TaskStatus.FAILED,
-            TaskRecord.TaskStatus.RETRYING,
+            TaskRecord.TaskStatus.RETRIED,
         ],
     )
     def test_valid_status_choices(self, status):
@@ -83,21 +83,20 @@ class TestTaskRecordStatusChoices:
 
     def test_status_choice_values(self):
         assert TaskRecord.TaskStatus.RUNNING == "RUNNING"
-        assert TaskRecord.TaskStatus.SUCCESS == "SUCCESS"
+        assert TaskRecord.TaskStatus.SUCCEEDED == "SUCCEEDED"
         assert TaskRecord.TaskStatus.FAILED == "FAILED"
-        assert TaskRecord.TaskStatus.RETRYING == "RETRYING"
+        assert TaskRecord.TaskStatus.RETRIED == "RETRIED"
 
-    def test_retrying_status_can_be_saved(self):
+    def test_retried_status_can_be_saved(self):
         record = TaskRecord.objects.create(
             task_name="myapp.tasks.job",
             pk=uuid.uuid4(),
             kwargs={},
             n_retries=0,
-            status=TaskRecord.TaskStatus.RETRYING,
+            status=TaskRecord.TaskStatus.RETRIED,
         )
         assert (
-            TaskRecord.objects.get(pk=record.pk).status
-            == TaskRecord.TaskStatus.RETRYING
+            TaskRecord.objects.get(pk=record.pk).status == TaskRecord.TaskStatus.RETRIED
         )
 
 
@@ -179,7 +178,7 @@ class TestTaskRecordOrmQueryable:
             pk=uuid.uuid4(),
             kwargs={},
             n_retries=0,
-            status=TaskRecord.TaskStatus.SUCCESS,
+            status=TaskRecord.TaskStatus.SUCCEEDED,
         )
         TaskRecord.objects.create(
             task_name="myapp.tasks.job",
@@ -189,7 +188,8 @@ class TestTaskRecordOrmQueryable:
             status=TaskRecord.TaskStatus.FAILED,
         )
         assert (
-            TaskRecord.objects.filter(status=TaskRecord.TaskStatus.SUCCESS).count() == 1
+            TaskRecord.objects.filter(status=TaskRecord.TaskStatus.SUCCEEDED).count()
+            == 1
         )
         assert (
             TaskRecord.objects.filter(status=TaskRecord.TaskStatus.FAILED).count() == 1
@@ -359,7 +359,7 @@ class TestExecuteTaskSuccess:
         with patch("lambda_tasks.models.TimeoutContext"):
             msg.execute_immediately(message_id=message_id)
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
 
     def test_successful_task_record_has_result(self):
         msg = _make_message(_task_name(_task_returns_value), {"x": 7})
@@ -611,7 +611,7 @@ def test_property_13_task_record_lifecycle_success(return_value):
     assert _lifecycle_captured[0]["status"] == TaskRecord.TaskStatus.RUNNING
     assert _lifecycle_captured[0]["start_time"] is not None
     record = TaskRecord.objects.get(pk=inv_id)
-    assert record.status == TaskRecord.TaskStatus.SUCCESS
+    assert record.status == TaskRecord.TaskStatus.SUCCEEDED
     assert record.end_time is not None
     assert record.result == return_value
 
@@ -649,7 +649,7 @@ class TestExecuteTaskDuplicateDelivery:
             msg.execute_immediately(message_id=message_id)  # duplicate
         assert TaskRecord.objects.filter(pk=message_id).count() == 1
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
 
     def test_duplicate_of_failed_is_skipped(self):
         msg = _make_message(_task_name(_task_raises), {"msg": "boom"})
@@ -1081,7 +1081,7 @@ def test_property_ignored_exc_produces_success(exc_type_name):
     with patch("lambda_tasks.models.TimeoutContext"):
         msg.execute_immediately(message_id=message_id)
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.SUCCESS
+    assert record.status == TaskRecord.TaskStatus.SUCCEEDED
     assert record.traceback is not None
     assert exc_type_name in record.traceback
     assert record.end_time is not None
@@ -1106,7 +1106,7 @@ def test_property_ignored_exc_commits_record(label):
     ).exists()
     # TaskRecord itself must be committed as SUCCESS
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.SUCCESS
+    assert record.status == TaskRecord.TaskStatus.SUCCEEDED
 
 
 # Feature: ignore-errors-decorator-option, Property 5: Subclass of ignored exception type is also ignored
@@ -1128,7 +1128,7 @@ def test_property_subclass_of_ignored_is_ignored(base_exc):
         with patch("lambda_tasks.models.TimeoutContext"):
             msg.execute_immediately(message_id=message_id)
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.SUCCESS
+    assert record.status == TaskRecord.TaskStatus.SUCCEEDED
 
 
 # Feature: ignore-errors-decorator-option, Property 6: Non-ignored exception produces FAILED with rollback
@@ -1179,7 +1179,7 @@ class TestIgnoreErrorsRegressionGuard:
         with patch("lambda_tasks.models.TimeoutContext"):
             msg.execute_immediately(message_id=message_id)
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
         assert record.traceback is None
 
     def test_non_ignored_exception_produces_failed(self):
@@ -1227,7 +1227,7 @@ def test_property_eager_mode_ignore_errors_parity(exc_type_name):
     with patch("lambda_tasks.models.import_string", return_value=_task_raises_ignored):
         msg.execute_immediately(message_id=message_id)
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.SUCCESS
+    assert record.status == TaskRecord.TaskStatus.SUCCEEDED
     assert record.traceback is not None
 
 
@@ -1379,7 +1379,7 @@ def test_property_6_retrying_status_and_traceback(exc_type_name):
             with patch.object(SQSLambdaTask, "execute_on_commit"):
                 msg.execute_immediately(message_id=message_id)
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.RETRYING
+    assert record.status == TaskRecord.TaskStatus.RETRIED
     assert record.traceback is not None
     assert record.end_time is not None
 
@@ -1855,7 +1855,7 @@ def test_property_singleton_lockerror_retry(
 
     # TaskRecord should be RETRYING with LockError in traceback
     record = TaskRecord.objects.get(pk=message_id)
-    assert record.status == TaskRecord.TaskStatus.RETRYING
+    assert record.status == TaskRecord.TaskStatus.RETRIED
     assert record.traceback is not None
     assert "LockError" in record.traceback
 
@@ -1959,7 +1959,7 @@ class TestSingletonExecutionUnit:
         mock_cache.lock.assert_not_called()
 
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
         assert record.result == 42
 
     def test_singleton_uses_singleton_cache_backend(self, settings: object) -> None:
@@ -2050,7 +2050,7 @@ class TestSingletonIgnoreErrorsPrecedence:
             msg.execute_immediately(message_id=message_id)
 
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
         assert record.traceback is not None
         assert "LockError" in record.traceback
         mock_eoc.assert_not_called()
@@ -2086,7 +2086,7 @@ class TestSingletonIgnoreErrorsPrecedence:
             msg.execute_immediately(message_id=message_id)
 
         record = TaskRecord.objects.get(pk=message_id)
-        assert record.status == TaskRecord.TaskStatus.SUCCESS
+        assert record.status == TaskRecord.TaskStatus.SUCCEEDED
         assert record.traceback is not None
         assert "SoftTimeLimitExceeded" in record.traceback
         mock_eoc.assert_not_called()

{django_lambda_tasks-0.2.5 → django_lambda_tasks-0.3.0}/tests/test_tasks.py

@@ -13,7 +13,7 @@ from lambda_tasks.tasks import cleanup_task_records
 @pytest.mark.django_db
 class TestCleanupTaskRecordsDeletesOldRecords:
     def _create_record(
-        self, *, age_days: int, status: str = TaskStatus.SUCCESS
+        self, *, age_days: int, status: str = TaskStatus.SUCCEEDED
     ) -> uuid.UUID:
         record_id = uuid.uuid4()
         TaskRecord.objects.create(
@@ -54,7 +54,7 @@ class TestCleanupTaskRecordsDeletesOldRecords:
             task_name="some.task",
             kwargs={},
             n_retries=0,
-            status=TaskStatus.SUCCESS,
+            status=TaskStatus.SUCCEEDED,
             start_time=cutoff_time + timedelta(seconds=1),
             end_time=cutoff_time + timedelta(seconds=2),
         )
@@ -65,10 +65,10 @@ class TestCleanupTaskRecordsDeletesOldRecords:
 
     def test_deletes_all_statuses(self) -> None:
         ids = [
-            self._create_record(age_days=10, status=TaskStatus.SUCCESS),
+            self._create_record(age_days=10, status=TaskStatus.SUCCEEDED),
             self._create_record(age_days=10, status=TaskStatus.FAILED),
             self._create_record(age_days=10, status=TaskStatus.RUNNING),
-            self._create_record(age_days=10, status=TaskStatus.RETRYING),
+            self._create_record(age_days=10, status=TaskStatus.RETRIED),
         ]
 
         cleanup_task_records(retention_days=7)