dj-queue 0.7.1__tar.gz → 0.8.0__tar.gz

{dj_queue-0.7.1 → dj_queue-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.7.1
+Version: 0.8.0
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -461,7 +461,7 @@ expecting one semaphore namespace per backend alias.
 tables:
 
 ```python
-from dj_queue.api import QueueInfo
+from dj_queue.api import QueueInfo, claim_ready_jobs, execute_claimed_job
 
 orders = QueueInfo("orders")
 
@@ -472,6 +472,10 @@ print(orders.paused)
 orders.pause()
 orders.resume()
 orders.clear()
+
+claimed_jobs = claim_ready_jobs(limit=1, queues=["orders"])
+if claimed_jobs:
+  execute_claimed_job(claimed_jobs[0])
 ```
 
 Notes:
@@ -480,6 +484,8 @@ Notes:
 - pause rows are scoped per backend alias
 - `clear()` discards ready jobs only
 - pass `backend_alias=` when you want to target a non-default `TASKS` alias
+- `claim_ready_jobs()` returns `ClaimedJob` objects, so inspect `claimed_job.job` for the persisted row
+- the low-level claim/execute helpers are exposed on `dj_queue.api` for scripts and examples
 
 Operational commands:
 
@@ -506,32 +512,26 @@ queue database, including the exception class, message, and traceback.
 
 You can retry and discard failed jobs through Django admin, and any raw job
 detail page can enqueue a fresh copy of that stored job. The failed-job actions
-also stay available directly through the operations layer:
+also stay available through the public API:
 
 ```python
-from dj_queue.operations.jobs import discard_failed_job, retry_failed_job
+from dj_queue.api import (
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 retry_failed_job(job_id)
 discard_failed_job(job_id)
-```
-
-Model helpers are available too:
-
-```python
-from dj_queue.exceptions import UndiscardableError
-from dj_queue.models import ClaimedExecution, FailedExecution
-
-failed = FailedExecution.objects.get(job_id=job_id)
-failed.retry()
-failed.discard()
-
-FailedExecution.retry_all(FailedExecution.objects.order_by("job_id"))
-FailedExecution.discard_all_in_batches()
-
-try:
-  ClaimedExecution.discard_all_in_batches()
-except UndiscardableError:
-  pass
+retry_failed_jobs(job_ids=[job_id_a, job_id_b], batch_size=2)
+discard_ready_jobs(job_ids=[ready_job_id], batch_size=1)
+discard_failed_jobs(batch_size=500)
+discard_scheduled_jobs(job_ids=[scheduled_job_id], batch_size=1)
+discard_blocked_jobs(job_ids=[blocked_job_id], batch_size=1)
 ```
 
 Failures stay inspectable until you act on them.

{dj_queue-0.7.1 → dj_queue-0.8.0}/README.md

@@ -433,7 +433,7 @@ expecting one semaphore namespace per backend alias.
 tables:
 
 ```python
-from dj_queue.api import QueueInfo
+from dj_queue.api import QueueInfo, claim_ready_jobs, execute_claimed_job
 
 orders = QueueInfo("orders")
 
@@ -444,6 +444,10 @@ print(orders.paused)
 orders.pause()
 orders.resume()
 orders.clear()
+
+claimed_jobs = claim_ready_jobs(limit=1, queues=["orders"])
+if claimed_jobs:
+  execute_claimed_job(claimed_jobs[0])
 ```
 
 Notes:
@@ -452,6 +456,8 @@ Notes:
 - pause rows are scoped per backend alias
 - `clear()` discards ready jobs only
 - pass `backend_alias=` when you want to target a non-default `TASKS` alias
+- `claim_ready_jobs()` returns `ClaimedJob` objects, so inspect `claimed_job.job` for the persisted row
+- the low-level claim/execute helpers are exposed on `dj_queue.api` for scripts and examples
 
 Operational commands:
 
@@ -478,32 +484,26 @@ queue database, including the exception class, message, and traceback.
 
 You can retry and discard failed jobs through Django admin, and any raw job
 detail page can enqueue a fresh copy of that stored job. The failed-job actions
-also stay available directly through the operations layer:
+also stay available through the public API:
 
 ```python
-from dj_queue.operations.jobs import discard_failed_job, retry_failed_job
+from dj_queue.api import (
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 retry_failed_job(job_id)
 discard_failed_job(job_id)
-```
-
-Model helpers are available too:
-
-```python
-from dj_queue.exceptions import UndiscardableError
-from dj_queue.models import ClaimedExecution, FailedExecution
-
-failed = FailedExecution.objects.get(job_id=job_id)
-failed.retry()
-failed.discard()
-
-FailedExecution.retry_all(FailedExecution.objects.order_by("job_id"))
-FailedExecution.discard_all_in_batches()
-
-try:
-  ClaimedExecution.discard_all_in_batches()
-except UndiscardableError:
-  pass
+retry_failed_jobs(job_ids=[job_id_a, job_id_b], batch_size=2)
+discard_ready_jobs(job_ids=[ready_job_id], batch_size=1)
+discard_failed_jobs(batch_size=500)
+discard_scheduled_jobs(job_ids=[scheduled_job_id], batch_size=1)
+discard_blocked_jobs(job_ids=[blocked_job_id], batch_size=1)
 ```
 
 Failures stay inspectable until you act on them.

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/admin.py

@@ -28,7 +28,13 @@ from dj_queue.models import (
   RecurringTask,
   Semaphore,
 )
-from dj_queue.operations.jobs import dispatch_scheduled_job_now, enqueue_job_again
+from dj_queue.operations.jobs import (
+  discard_failed_job,
+  dispatch_scheduled_job_now,
+  enqueue_job_again,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 
 class DjQueueFirstAdminSite(admin.AdminSite):
@@ -648,12 +654,12 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
     if action == "retry":
-      obj.failed_execution.retry()
+      retry_failed_job(obj.failed_execution.job_id, backend_alias=obj.backend_alias)
       self.message_user(request, "Retried failed job", level=messages.SUCCESS)
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
     if action == "discard":
-      obj.failed_execution.discard()
+      discard_failed_job(obj.failed_execution.job_id, backend_alias=obj.backend_alias)
       self.message_user(request, "Discarded failed job", level=messages.SUCCESS)
       return HttpResponseRedirect(self._changelist_url(backend_alias=obj.backend_alias))
 
@@ -676,14 +682,18 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
   @admin.action(description="Retry selected failed jobs")
   def retry_jobs(self, request, queryset):
-    retried = FailedExecution.retry_all(queryset)
+    retried = retry_failed_jobs(
+      job_ids=list(queryset.values_list("job_id", flat=True)),
+      batch_size=queryset.count() or 1,
+      backend_alias=self._backend_alias(request),
+    )
     self.message_user(request, f"Retried {retried} failed jobs", level=messages.SUCCESS)
 
   @admin.action(description="Discard selected failed jobs")
   def discard_jobs(self, request, queryset):
     discarded = 0
     for execution in queryset.select_related("job"):
-      discarded += execution.discard()
+      discarded += discard_failed_job(execution.job_id, backend_alias=execution.job.backend_alias)
     self.message_user(request, f"Discarded {discarded} failed jobs", level=messages.SUCCESS)
 
   @admin.display(description="created at", ordering="created_at")
@@ -707,13 +717,13 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
     if action == "retry":
       job_id = obj.job_id
-      obj.retry()
+      retry_failed_job(job_id, backend_alias=backend_alias)
       self.message_user(request, "Retried failed job", level=messages.SUCCESS)
       url = reverse("admin:dj_queue_job_change", args=[job_id])
       return HttpResponseRedirect(f"{url}?{urlencode({'backend': backend_alias})}")
 
     if action == "discard":
-      obj.discard()
+      discard_failed_job(obj.job_id, backend_alias=backend_alias)
       self.message_user(request, "Discarded failed job", level=messages.SUCCESS)
       return HttpResponseRedirect(self._changelist_url(backend_alias=backend_alias))
 

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/api.py

@@ -3,10 +3,40 @@ from functools import partial
 from django.db.models.functions import Coalesce
 from django.db import transaction
 from django.utils import timezone
-from django.utils.module_loading import import_string
 
 from dj_queue.db import get_database_alias
 from dj_queue.models import Pause, ReadyExecution
+from dj_queue.operations.jobs import (
+  ClaimedJob,
+  claim_ready_jobs,
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  execute_claimed_job,
+  retry_failed_job,
+  retry_failed_jobs,
+)
+from dj_queue.operations.queues import pause_queue, resume_queue
+from dj_queue.operations.recurring import schedule_recurring_task, unschedule_recurring_task
+
+__all__ = [
+  "ClaimedJob",
+  "QueueInfo",
+  "claim_ready_jobs",
+  "discard_blocked_jobs",
+  "discard_failed_job",
+  "discard_failed_jobs",
+  "discard_ready_jobs",
+  "discard_scheduled_jobs",
+  "enqueue_on_commit",
+  "execute_claimed_job",
+  "retry_failed_job",
+  "retry_failed_jobs",
+  "schedule_recurring_task",
+  "unschedule_recurring_task",
+]
 
 
 class QueueInfo:
@@ -44,11 +74,9 @@ class QueueInfo:
     )
 
   def pause(self):
-    pause_queue = import_string("dj_queue.operations.queues.pause_queue")
     pause_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def resume(self):
-    resume_queue = import_string("dj_queue.operations.queues.resume_queue")
     resume_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def clear(self, *, batch_size=500):
@@ -57,7 +85,7 @@ class QueueInfo:
       job_ids = list(self._ready_queryset().values_list("job_id", flat=True)[:batch_size])
       if not job_ids:
         return deleted
-      deleted += _discard_ready_jobs(
+      deleted += discard_ready_jobs(
         job_ids=job_ids,
         batch_size=batch_size,
         backend_alias=self.backend_alias,
@@ -86,41 +114,5 @@ class QueueInfo:
     )
 
 
-def _discard_ready_jobs(*, job_ids, batch_size, backend_alias):
-  discard_ready_jobs = import_string("dj_queue.operations.jobs.discard_ready_jobs")
-  return discard_ready_jobs(job_ids=job_ids, batch_size=batch_size, backend_alias=backend_alias)
-
-
 def enqueue_on_commit(task, *args, using=None, **kwargs):
   transaction.on_commit(partial(task.enqueue, *args, **kwargs), using=using)
-
-
-def schedule_recurring_task(
-  *,
-  key,
-  task_path,
-  schedule,
-  args=(),
-  kwargs=None,
-  queue_name="default",
-  priority=0,
-  description="",
-  backend_alias="default",
-):
-  operation = import_string("dj_queue.operations.recurring.schedule_recurring_task")
-  return operation(
-    key=key,
-    task_path=task_path,
-    schedule=schedule,
-    args=args,
-    kwargs=kwargs,
-    queue_name=queue_name,
-    priority=priority,
-    description=description,
-    backend_alias=backend_alias,
-  )
-
-
-def unschedule_recurring_task(key, *, backend_alias="default"):
-  operation = import_string("dj_queue.operations.recurring.unschedule_recurring_task")
-  return operation(key, backend_alias=backend_alias)

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/dashboard.py

@@ -13,13 +13,14 @@ from dj_queue import observability
 from dj_queue.api import QueueInfo
 from dj_queue.config import load_backend_config
 from dj_queue.db import database_capabilities, get_database_alias
-from dj_queue.models import FailedExecution, Job
+from dj_queue.models import Job
 from dj_queue.operations.jobs import (
   discard_blocked_jobs,
   discard_failed_jobs,
   discard_ready_jobs,
   discard_scheduled_jobs,
   enqueue_job_again,
+  retry_failed_jobs,
 )
 
 QUEUE_STATE_CONFIG = {
@@ -521,13 +522,11 @@ def apply_job_action(*, backend_alias, queue_name, state, action, job_ids):
     return f"discarded {deleted} blocked jobs from {queue_name}"
 
   if state == "failed" and action == "retry":
-    alias = get_database_alias(backend_alias)
-    queryset = FailedExecution.objects.using(alias).filter(
-      job_id__in=job_ids,
-      job__backend_alias=backend_alias,
-      job__queue_name=queue_name,
+    retried = retry_failed_jobs(
+      job_ids=job_ids,
+      batch_size=max(len(job_ids), 1),
+      backend_alias=backend_alias,
     )
-    retried = FailedExecution.retry_all(queryset.select_related("job"))
     return f"retried {retried} failed jobs from {queue_name}"
 
   if state == "failed" and action == "discard":

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/exceptions.py

@@ -6,10 +6,6 @@ class EnqueueError(DjQueueError):
   pass
 
 
-class UndiscardableError(DjQueueError):
-  pass
-
-
 class AlreadyRecorded(DjQueueError):
   pass
 

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/models/jobs.py

@@ -3,10 +3,6 @@ import uuid
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.db.models import Q
-from django.utils.module_loading import import_string
-
-from dj_queue.db import get_database_alias
-from dj_queue.exceptions import UndiscardableError
 
 JOB_STATUS_RELATIONS = (
   ("ready", "ready_execution"),
@@ -140,16 +136,6 @@ class ReadyExecution(models.Model):
       ),
     ]
 
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_ready_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
 
 class ScheduledExecution(models.Model):
   job = models.OneToOneField(
@@ -196,10 +182,6 @@ class ClaimedExecution(models.Model):
     db_table = "dj_queue_claimed_executions"
     indexes = [models.Index(fields=["process", "job"])]
 
-  @classmethod
-  def discard_all_in_batches(cls, **_kwargs):
-    raise UndiscardableError("cannot discard in-progress jobs")
-
 
 class BlockedExecution(models.Model):
   job = models.OneToOneField(
@@ -235,16 +217,6 @@ class BlockedExecution(models.Model):
       ),
     ]
 
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_blocked_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
 
 class FailedExecution(models.Model):
   job = models.OneToOneField(
@@ -260,56 +232,3 @@ class FailedExecution(models.Model):
   class Meta:
     db_table = "dj_queue_failed_executions"
     indexes = [models.Index(fields=["created_at", "job"])]
-
-  def retry(self):
-    return _retry_failed_job(self.job_id, backend_alias=self.job.backend_alias)
-
-  def discard(self):
-    return _discard_failed_job(self.job_id, backend_alias=self.job.backend_alias)
-
-  @classmethod
-  def retry_all(cls, queryset):
-    retried = 0
-    for execution in queryset.select_related("job"):
-      execution.retry()
-      retried += 1
-    return retried
-
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_failed_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
-
-def _retry_failed_job(job_id, *, backend_alias):
-  operation = import_string("dj_queue.operations.jobs.retry_failed_job")
-  return operation(job_id, backend_alias=backend_alias)
-
-
-def _discard_failed_job(job_id, *, backend_alias):
-  operation = import_string("dj_queue.operations.jobs.discard_failed_job")
-  return operation(job_id, backend_alias=backend_alias)
-
-
-def _discard_jobs_for_state(model, operation, *, batch_size, backend_alias):
-  alias = get_database_alias(backend_alias)
-  deleted = 0
-  while True:
-    filter_kwargs = (
-      {"backend_alias": backend_alias}
-      if any(field.name == "backend_alias" for field in model._meta.fields)
-      else {"job__backend_alias": backend_alias}
-    )
-    job_ids = list(
-      model.objects.using(alias)
-      .filter(**filter_kwargs)
-      .values_list("job_id", flat=True)[:batch_size]
-    )
-    if not job_ids:
-      return deleted
-    deleted += operation(job_ids=job_ids, batch_size=batch_size, backend_alias=backend_alias)

dj_queue-0.8.0/dj_queue/operations/_helpers.py

@@ -0,0 +1,41 @@
+import json
+
+from dj_queue.db import database_capabilities
+from dj_queue.exceptions import EnqueueError
+from dj_queue.models import Pause
+
+
+def _normalize_payload(args, kwargs):
+  try:
+    return json.loads(json.dumps({"args": list(args), "kwargs": dict(kwargs)}))
+  except (TypeError, ValueError) as exc:
+    raise EnqueueError("payload must be JSON round-trippable") from exc
+
+
+def _task_option(task, name, default=None):
+  if hasattr(task, name):
+    return getattr(task, name)
+  return getattr(task.func, name, default)
+
+
+def _lock_active_pauses(alias, backend_alias, queue_names=None):
+  queryset = Pause.objects.using(alias).select_for_update().filter(backend_alias=backend_alias)
+  if queue_names is not None:
+    active_queue_names = tuple(queue_name for queue_name in queue_names if queue_name)
+    if not active_queue_names:
+      return set()
+    queryset = queryset.filter(queue_name__in=active_queue_names)
+  return set(queryset.values_list("queue_name", flat=True))
+
+
+def _consume_selected_rows(alias, model, rows):
+  if not database_capabilities(alias).uses_serialized_writes:
+    model.objects.using(alias).filter(pk__in=[row.pk for row in rows]).delete()
+    return rows
+
+  consumed_rows = []
+  for row in rows:
+    deleted, _ = model.objects.using(alias).filter(pk=row.pk).delete()
+    if deleted:
+      consumed_rows.append(row)
+  return consumed_rows

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/operations/concurrency.py

@@ -9,7 +9,12 @@ from dj_queue.config import load_backend_config
 from dj_queue.db import database_capabilities, get_database_alias, locked_queryset
 from dj_queue.exceptions import EnqueueError
 from dj_queue.log import log_event
-from dj_queue.models import BlockedExecution, ClaimedExecution, Pause, ReadyExecution, Semaphore
+from dj_queue.models import BlockedExecution, ClaimedExecution, ReadyExecution, Semaphore
+from dj_queue.operations._helpers import (
+  _consume_selected_rows,
+  _lock_active_pauses,
+  _task_option,
+)
 from dj_queue.operations._insert import create_ignore_conflicts
 from dj_queue.runtime import notify as runtime_notify
 
@@ -230,29 +235,6 @@ def promote_expired_blocked_jobs(*, batch_size=500, backend_alias="default", use
   return promoted_jobs
 
 
-def _lock_active_pauses(alias, backend_alias, queue_names):
-  active_queue_names = tuple(queue_name for queue_name in queue_names if queue_name)
-  if not active_queue_names:
-    return None
-
-  list(
-    Pause.objects.using(alias)
-    .select_for_update()
-    .filter(backend_alias=backend_alias, queue_name__in=active_queue_names)
-    .values_list("queue_name", flat=True)
-  )
-  return None
-
-
-def _consume_selected_rows(alias, model, rows):
-  consumed_rows = []
-  for row in rows:
-    deleted, _ = model.objects.using(alias).filter(pk=row.pk).delete()
-    if deleted:
-      consumed_rows.append(row)
-  return consumed_rows
-
-
 def _positive_int_option(value, name):
   try:
     number = int(value)
@@ -262,9 +244,3 @@ def _positive_int_option(value, name):
   if number <= 0:
     raise EnqueueError(f"{name} must be a positive integer")
   return number
-
-
-def _task_option(task, name, default=None):
-  if hasattr(task, name):
-    return getattr(task, name)
-  return getattr(task.func, name, default)

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/operations/jobs.py

@@ -2,6 +2,7 @@ import inspect
 import json
 import time
 import traceback
+from dataclasses import dataclass
 from datetime import timedelta
 
 from django.db import connections, transaction
@@ -12,7 +13,7 @@ from django.utils import timezone
 from django.utils.module_loading import import_string
 
 from dj_queue.config import load_backend_config
-from dj_queue.db import database_capabilities, get_database_alias, locked_queryset
+from dj_queue.db import get_database_alias, locked_queryset
 from dj_queue.exceptions import EnqueueError
 from dj_queue.log import log_event
 from dj_queue.models import (
@@ -20,11 +21,16 @@ from dj_queue.models import (
   ClaimedExecution,
   FailedExecution,
   Job,
-  Pause,
   ReadyExecution,
   Semaphore,
   ScheduledExecution,
 )
+from dj_queue.operations._helpers import (
+  _consume_selected_rows,
+  _lock_active_pauses,
+  _normalize_payload,
+  _task_option,
+)
 from dj_queue.operations.concurrency import (
   concurrency_settings,
   semaphore_acquire,
@@ -44,6 +50,13 @@ TRANSIENT_CLAIM_ERROR_MESSAGES = (
 )
 
 
+@dataclass(frozen=True)
+class ClaimedJob:
+  job: Job
+  claimed_at: object
+  worker_ids: tuple[str, ...]
+
+
 def enqueue_job(task, args, kwargs, *, backend_alias="default"):
   job, _ = enqueue_job_with_dispatch(task, args, kwargs, backend_alias=backend_alias)
   return job
@@ -233,7 +246,7 @@ def claim_ready_jobs(
 
   for attempt in range(CLAIM_READY_JOBS_RETRY_ATTEMPTS):
     try:
-      jobs = _claim_ready_jobs_once(
+      claimed_jobs = _claim_ready_jobs_once(
         limit=limit,
         queues=queues,
         process=process,
@@ -247,9 +260,14 @@ def claim_ready_jobs(
         raise
       time.sleep(0.01 * (attempt + 1))
 
-  for job in jobs:
-    log_event("job.claimed", job_id=str(job.id), queue_name=job.queue_name, priority=job.priority)
-  return jobs
+  for claimed_job in claimed_jobs:
+    log_event(
+      "job.claimed",
+      job_id=str(claimed_job.job.id),
+      queue_name=claimed_job.job.queue_name,
+      priority=claimed_job.job.priority,
+    )
+  return claimed_jobs
 
 
 def _claim_ready_jobs_once(
@@ -295,33 +313,33 @@ def _claim_ready_jobs_once(
     jobs = [row.job for row in ready_rows]
 
     claimed_at = timezone.now()
+    worker_ids = (process.name,) if process is not None else ()
     _bulk_create(
       alias,
       ClaimedExecution,
       [ClaimedExecution(job=job, process=process, created_at=claimed_at) for job in jobs],
     )
-    _attach_claim_metadata(jobs, process=process, claimed_at=claimed_at)
 
-  return jobs
+  return [ClaimedJob(job=job, claimed_at=claimed_at, worker_ids=worker_ids) for job in jobs]
 
 
 def execute_claimed_job(job, *, backend_alias="default"):
-  if not isinstance(job, Job):
-    alias = get_database_alias(backend_alias)
-    claimed = (
-      ClaimedExecution.objects.using(alias)
-      .select_related("job", "process")
-      .get(job_id=job, job__backend_alias=backend_alias)
-    )
-    job = claimed.job
-    _attach_claim_metadata([job], process=claimed.process, claimed_at=claimed.created_at)
+  claimed_job = None
+  if isinstance(job, ClaimedJob):
+    claimed_job = job
+    job = claimed_job.job
+  elif not isinstance(job, Job):
+    claimed_job = _load_claimed_job(job, backend_alias=backend_alias)
+    job = claimed_job.job
 
   try:
     task = import_string(job.task_path)
     args = list(job.payload.get("args", []))
     kwargs = dict(job.payload.get("kwargs", {}))
     if task.takes_context:
-      context = TaskContext(task_result=_task_result_for_claimed_job(task, job))
+      if claimed_job is None:
+        claimed_job = _load_claimed_job(job.id, backend_alias=job.backend_alias)
+      context = TaskContext(task_result=_task_result_for_claimed_job(task, claimed_job))
       return_value = task.call(context, *args, **kwargs)
     else:
       return_value = task.call(*args, **kwargs)
@@ -339,6 +357,8 @@ def execute_claimed_job(job, *, backend_alias="default"):
 
 def complete_claimed_job(job, return_value, *, backend_alias="default"):
   alias = get_database_alias(backend_alias)
+  if isinstance(job, ClaimedJob):
+    job = job.job
   job_id = job.id if isinstance(job, Job) else job
 
   with transaction.atomic(using=alias):
@@ -366,6 +386,8 @@ def complete_claimed_job(job, return_value, *, backend_alias="default"):
 
 def fail_claimed_job(job, error, *, traceback_text="", backend_alias="default"):
   alias = get_database_alias(backend_alias)
+  if isinstance(job, ClaimedJob):
+    job = job.job
   job_id = job.id if isinstance(job, Job) else job
 
   with transaction.atomic(using=alias):
@@ -509,6 +531,49 @@ def retry_failed_job(job_id, *, backend_alias="default"):
   return job
 
 
+def retry_failed_jobs(*, job_ids=None, batch_size=500, backend_alias="default"):
+  alias = get_database_alias(backend_alias)
+  config = load_backend_config(backend_alias)
+
+  with transaction.atomic(using=alias):
+    queryset = (
+      FailedExecution.objects.using(alias).filter(job__backend_alias=backend_alias).order_by("id")
+    )
+    if job_ids is not None:
+      queryset = queryset.filter(job_id__in=job_ids)
+    failed_rows = list(
+      locked_queryset(
+        queryset.select_related("job"),
+        use_skip_locked=config.use_skip_locked,
+      )[:batch_size]
+    )
+    if not failed_rows:
+      return 0
+
+    jobs = []
+    ready_queue_names = []
+    for failed in failed_rows:
+      job = failed.job
+      failed.delete(using=alias)
+      job.return_value = None
+      job.finished_at = None
+      job.save(using=alias, update_fields=["return_value", "finished_at", "updated_at"])
+      dispatched_as = _dispatch_existing_job(job)
+      jobs.append(job)
+      if dispatched_as == "ready":
+        ready_queue_names.append(job.queue_name)
+
+  if ready_queue_names:
+    runtime_notify.notify_ready_queues(
+      tuple(dict.fromkeys(ready_queue_names)),
+      backend_alias=backend_alias,
+    )
+
+  for job in jobs:
+    log_event("job.retried", job_id=str(job.id), queue_name=job.queue_name, priority=job.priority)
+  return len(jobs)
+
+
 _KEEP_RUN_AFTER = object()
 
 
@@ -795,13 +860,6 @@ def _filter_queue_selectors(queryset, queues):
   return queryset.filter(condition)
 
 
-def _attach_claim_metadata(jobs, *, process, claimed_at):
-  worker_ids = [process.name] if process is not None else []
-  for job in jobs:
-    job._dj_queue_claimed_at = claimed_at
-    job._dj_queue_worker_ids = worker_ids
-
-
 def _select_ready_rows(queryset, *, limit, queues, use_skip_locked):
   if queues in (None, (), "*", ["*"], ("*",)):
     ordered = queryset.order_by("-priority", "id")
@@ -830,13 +888,6 @@ def _is_transient_claim_error(error):
   return any(marker in message for marker in TRANSIENT_CLAIM_ERROR_MESSAGES)
 
 
-def _normalize_payload(args, kwargs):
-  try:
-    return json.loads(json.dumps({"args": list(args), "kwargs": dict(kwargs)}))
-  except (TypeError, ValueError) as exc:
-    raise EnqueueError("payload must be JSON round-trippable") from exc
-
-
 def _normalize_return_value(return_value):
   try:
     return json.loads(json.dumps(return_value))
@@ -844,33 +895,18 @@ def _normalize_return_value(return_value):
     raise ValueError("return value must be JSON round-trippable") from exc
 
 
-def _task_option(task, name, default=None):
-  if hasattr(task, name):
-    return getattr(task, name)
-  return getattr(task.func, name, default)
-
-
-def _lock_active_pauses(alias, backend_alias, queue_names=None):
-  queryset = Pause.objects.using(alias).select_for_update().filter(backend_alias=backend_alias)
-  if queue_names is not None:
-    active_queue_names = tuple(queue_name for queue_name in queue_names if queue_name)
-    if not active_queue_names:
-      return set()
-    queryset = queryset.filter(queue_name__in=active_queue_names)
-  return set(queryset.values_list("queue_name", flat=True))
-
-
-def _consume_selected_rows(alias, model, rows):
-  if not database_capabilities(alias).uses_serialized_writes:
-    model.objects.using(alias).filter(pk__in=[row.pk for row in rows]).delete()
-    return rows
-
-  consumed_rows = []
-  for row in rows:
-    deleted, _ = model.objects.using(alias).filter(pk=row.pk).delete()
-    if deleted:
-      consumed_rows.append(row)
-  return consumed_rows
+def _load_claimed_job(job_id, *, backend_alias):
+  alias = get_database_alias(backend_alias)
+  claimed = (
+    ClaimedExecution.objects.using(alias)
+    .select_related("job", "process")
+    .get(job_id=job_id, job__backend_alias=backend_alias)
+  )
+  return ClaimedJob(
+    job=claimed.job,
+    claimed_at=claimed.created_at,
+    worker_ids=(claimed.process.name,) if claimed.process is not None else (),
+  )
 
 
 def _bulk_create(alias, model, objects):
@@ -889,21 +925,21 @@ def _exception_path(error):
   return f"{error.__class__.__module__}.{error.__class__.__qualname__}"
 
 
-def _task_result_for_claimed_job(task, job):
-  claimed_at = getattr(job, "_dj_queue_claimed_at", timezone.now())
-  worker_ids = getattr(job, "_dj_queue_worker_ids", [])
+def _task_result_for_claimed_job(task, claimed_job):
+  if not isinstance(claimed_job, ClaimedJob):
+    raise RuntimeError("ClaimedJob is required for task context execution")
 
   return TaskResult(
     task=task,
-    id=str(job.id),
+    id=str(claimed_job.job.id),
     status=TaskResultStatus.RUNNING,
-    enqueued_at=job.created_at,
-    started_at=claimed_at,
+    enqueued_at=claimed_job.job.created_at,
+    started_at=claimed_job.claimed_at,
     finished_at=None,
-    last_attempted_at=claimed_at,
-    args=job.payload.get("args", []),
-    kwargs=job.payload.get("kwargs", {}),
-    backend=job.backend_alias,
+    last_attempted_at=claimed_job.claimed_at,
+    args=claimed_job.job.payload.get("args", []),
+    kwargs=claimed_job.job.payload.get("kwargs", {}),
+    backend=claimed_job.job.backend_alias,
     errors=[],
-    worker_ids=worker_ids,
+    worker_ids=list(claimed_job.worker_ids),
   )

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/operations/recurring.py

@@ -1,4 +1,3 @@
-import json
 from datetime import timedelta
 
 from croniter import croniter
@@ -9,6 +8,7 @@ from django.utils.module_loading import import_string
 from dj_queue.db import get_database_alias
 from dj_queue.exceptions import EnqueueError
 from dj_queue.models import RecurringExecution, RecurringTask
+from dj_queue.operations._helpers import _normalize_payload
 from dj_queue.operations._insert import create_ignore_conflicts
 from dj_queue.operations.jobs import enqueue_job, validate_queue_allowed
 
@@ -174,17 +174,15 @@ def _next_run_after(schedule, run_at):
   return croniter(schedule, run_at + timedelta(seconds=1)).get_next(type(run_at))
 
 
-def _normalize_payload(args, kwargs):
-  try:
-    return json.loads(json.dumps({"args": list(args), "kwargs": dict(kwargs)}))
-  except (TypeError, ValueError) as exc:
-    raise EnqueueError("payload must be JSON round-trippable") from exc
-
-
 def _advance_next_run_at(recurring_task, next_run_at, *, using):
-  RecurringTask.objects.using(using).filter(
-    Q(next_run_at__isnull=True) | Q(next_run_at__lt=next_run_at),
-    pk=recurring_task.pk,
-    backend_alias=recurring_task.backend_alias,
-  ).update(next_run_at=next_run_at)
-  recurring_task.next_run_at = next_run_at
+  updated = (
+    RecurringTask.objects.using(using)
+    .filter(
+      Q(next_run_at__isnull=True) | Q(next_run_at__lt=next_run_at),
+      pk=recurring_task.pk,
+      backend_alias=recurring_task.backend_alias,
+    )
+    .update(next_run_at=next_run_at)
+  )
+  if updated:
+    recurring_task.next_run_at = next_run_at

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/runtime/dispatcher.py

@@ -57,9 +57,6 @@ class Dispatcher(BaseRunner):
         self._last_maintenance_at = timezone.now()
     return promoted_jobs
 
-  def stop(self):
-    return super().stop()
-
   def process_metadata(self):
     return {
       "batch_size": self.config.batch_size,

{dj_queue-0.7.1 → dj_queue-0.8.0}/dj_queue/runtime/worker.py

@@ -69,8 +69,8 @@ class Worker(BaseRunner):
         backend_alias=self.backend_alias,
       )
 
-    for job in claimed_jobs:
-      future = self.pool.submit(self._execute_job, job)
+    for claimed_job in claimed_jobs:
+      future = self.pool.submit(self._execute_job, claimed_job)
       future.add_done_callback(self._handle_future)
     return claimed_jobs
 
@@ -106,9 +106,9 @@ class Worker(BaseRunner):
       "polling_interval": self.config.polling_interval,
     }
 
-  def _execute_job(self, job):
+  def _execute_job(self, claimed_job):
     with app_executor():
-      return execute_claimed_job(job, backend_alias=self.backend_alias)
+      return execute_claimed_job(claimed_job, backend_alias=self.backend_alias)
 
   def _handle_future(self, future):
     try:

{dj_queue-0.7.1 → dj_queue-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "dj-queue"
-version = "0.7.1"
+version = "0.8.0"
 description = "Database-backed task queue backend for Django’s Tasks framework."
 readme = "README.md"
 license = "MIT"