dj-queue 0.10.6__tar.gz → 0.11.0__tar.gz

{dj_queue-0.10.6 → dj_queue-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.10.6
+Version: 0.11.0
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -323,7 +323,7 @@ across queues. Prefer one primary scheduling mechanism per worker when you can.
 In standalone mode, both `fork` and `async` `python manage.py dj_queue` supervisors own runtime signal handling:
 
 - `SIGTERM` and `SIGINT` request graceful shutdown
-- `SIGQUIT` takes the immediate hard-exit path
+- `SIGQUIT` requests immediate process exit through normal Python cleanup
 - `shutdown_timeout` controls how long the runtime waits for in-flight work to drain
 - `supervisor_pidfile` can prevent duplicate standalone supervisors on one host
 
@@ -397,6 +397,9 @@ TASKS = {
 }
 ```
 
+Static recurring definitions are synced when the scheduler runner starts, then
+normal polling uses the persisted recurring rows and their `next_run_at` cursor.
+
 ### Dynamic recurring tasks
 
 Create, update, and remove recurring tasks at runtime:
@@ -428,6 +431,7 @@ Notes:
 - cron supports five fields or an optional leading seconds field, presets like `@daily`, optional timezone suffixes, wraparound ranges, `L`/`last` and negative monthdays, weekday `#` and `%` extensions, and normal day-of-month/day-of-week OR semantics
 - add `&` to either day field to require day-of-month and day-of-week to both match
 - natural-language schedules support `every`, `at`, `on`, and `from` forms such as `every day at noon`, `every weekday at five`, `every 5 minutes`, `every month on day 2 at 10:00`, `from monday to friday at 9`, and `at minute 5`
+- natural interval counts must fit inside the cron field they map to; misleading forms such as `every 90 seconds`, `every 90 minutes`, and `every 24 hours` are rejected
 - natural-language schedules that expand to multiple cron expressions, such as `every day at 16:15 and 18:30`, are treated as the union of those schedules
 - recurring task keys are scoped per backend alias
 - only dynamic tasks can be unscheduled at runtime; unscheduling a static task returns `0`
@@ -490,6 +494,10 @@ if claimed_jobs:
   execute_claimed_job(claimed_jobs[0])
 ```
 
+`QueueInfo.all()` discovers queues through the same read model as the dashboard
+and reuses that snapshot for `size`, `latency`, and `paused` until a queue
+mutation invalidates it.
+
 Notes:
 
 - pausing a queue stops future claims, not enqueueing or already-claimed work

{dj_queue-0.10.6 → dj_queue-0.11.0}/README.md

@@ -297,7 +297,7 @@ across queues. Prefer one primary scheduling mechanism per worker when you can.
 In standalone mode, both `fork` and `async` `python manage.py dj_queue` supervisors own runtime signal handling:
 
 - `SIGTERM` and `SIGINT` request graceful shutdown
-- `SIGQUIT` takes the immediate hard-exit path
+- `SIGQUIT` requests immediate process exit through normal Python cleanup
 - `shutdown_timeout` controls how long the runtime waits for in-flight work to drain
 - `supervisor_pidfile` can prevent duplicate standalone supervisors on one host
 
@@ -371,6 +371,9 @@ TASKS = {
 }
 ```
 
+Static recurring definitions are synced when the scheduler runner starts, then
+normal polling uses the persisted recurring rows and their `next_run_at` cursor.
+
 ### Dynamic recurring tasks
 
 Create, update, and remove recurring tasks at runtime:
@@ -402,6 +405,7 @@ Notes:
 - cron supports five fields or an optional leading seconds field, presets like `@daily`, optional timezone suffixes, wraparound ranges, `L`/`last` and negative monthdays, weekday `#` and `%` extensions, and normal day-of-month/day-of-week OR semantics
 - add `&` to either day field to require day-of-month and day-of-week to both match
 - natural-language schedules support `every`, `at`, `on`, and `from` forms such as `every day at noon`, `every weekday at five`, `every 5 minutes`, `every month on day 2 at 10:00`, `from monday to friday at 9`, and `at minute 5`
+- natural interval counts must fit inside the cron field they map to; misleading forms such as `every 90 seconds`, `every 90 minutes`, and `every 24 hours` are rejected
 - natural-language schedules that expand to multiple cron expressions, such as `every day at 16:15 and 18:30`, are treated as the union of those schedules
 - recurring task keys are scoped per backend alias
 - only dynamic tasks can be unscheduled at runtime; unscheduling a static task returns `0`
@@ -464,6 +468,10 @@ if claimed_jobs:
   execute_claimed_job(claimed_jobs[0])
 ```
 
+`QueueInfo.all()` discovers queues through the same read model as the dashboard
+and reuses that snapshot for `size`, `latency`, and `paused` until a queue
+mutation invalidates it.
+
 Notes:
 
 - pausing a queue stops future claims, not enqueueing or already-claimed work

{dj_queue-0.10.6 → dj_queue-0.11.0}/dj_queue/admin.py

@@ -1,11 +1,8 @@
 import json
-from datetime import timedelta
 from functools import wraps
 from urllib.parse import parse_qsl, urlencode
 
 from django.contrib import admin, messages
-from django.db.models import Case, Count, IntegerField, OuterRef, Subquery, Value, When
-from django.db.models.functions import Coalesce
 from django.http import HttpResponseNotAllowed, HttpResponseRedirect
 from django.template.response import TemplateResponse
 from django.urls import path, reverse
@@ -13,13 +10,13 @@ from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
 from django.utils import timezone
 
-from dj_queue.config import load_backend_config
 from dj_queue import dashboard
+from dj_queue import dashboard_actions
+from dj_queue import observability
 from dj_queue.api import QueueInfo, unschedule_recurring_task
 from dj_queue.db import get_database_alias
 from dj_queue.exceptions import EnqueueError
 from dj_queue.models import (
-  BlockedExecution,
   Dashboard,
   FailedExecution,
   Job,
@@ -43,37 +40,46 @@ from dj_queue.queue_state import (
   status_rank_expression,
 )
 
+ADMIN_ACTION_ERRORS = (
+  EnqueueError,
+  ImportError,
+  AttributeError,
+  Job.DoesNotExist,
+  FailedExecution.DoesNotExist,
+  RecurringTask.DoesNotExist,
+)
+ADMIN_POST_ACTION_ERRORS = (ValueError, *ADMIN_ACTION_ERRORS)
+
 
-class DjQueueAdminSiteMixin:
-  def _dashboard_app_url(self):
-    return reverse("admin:dj_queue_dashboard_changelist", current_app=self.name)
+def _install_dj_queue_admin_site(site):
+  if getattr(site, "_dj_queue_dashboard_installed", False):
+    return
 
-  def get_app_list(self, request, app_label=None):
-    app_list = super().get_app_list(request, app_label=app_label)
+  original_get_app_list = site.get_app_list
+  original_app_index = site.app_index
+
+  def dashboard_app_url():
+    return reverse("admin:dj_queue_dashboard_changelist", current_app=site.name)
+
+  def get_app_list(request, app_label=None):
+    app_list = original_get_app_list(request, app_label=app_label)
     for app in app_list:
       if app["app_label"] == "dj_queue":
-        app["app_url"] = self._dashboard_app_url()
+        app["app_url"] = dashboard_app_url()
     return sorted(app_list, key=lambda app: app["app_label"] != "dj_queue")
 
-  def app_index(self, request, app_label, extra_context=None):
+  def app_index(request, app_label, extra_context=None):
     if app_label == "dj_queue":
-      url = self._dashboard_app_url()
+      url = dashboard_app_url()
       query = request.GET.urlencode()
       if query:
         url = f"{url}?{query}"
       return HttpResponseRedirect(url)
-    return super().app_index(request, app_label, extra_context=extra_context)
+    return original_app_index(request, app_label, extra_context=extra_context)
 
-
-def _install_dj_queue_admin_site(site):
-  if isinstance(site, DjQueueAdminSiteMixin):
-    return
-
-  site.__class__ = type(
-    f"DjQueue{site.__class__.__name__}",
-    (DjQueueAdminSiteMixin, site.__class__),
-    {"__module__": __name__},
-  )
+  site.get_app_list = get_app_list
+  site.app_index = app_index
+  site._dj_queue_dashboard_installed = True
 
 
 _install_dj_queue_admin_site(admin.site)
@@ -128,16 +134,20 @@ class DashboardAdmin(admin.ModelAdmin):
       return wrapper
 
     return [
-      path("queue/<str:queue_name>/", wrap(self.queue_view), name="dj_queue_dashboard_queue"),
       path(
-        "queue/<str:queue_name>/action/",
+        "queue/<path:queue_name>/jobs/action/",
+        wrap(self.job_action_view),
+        name="dj_queue_dashboard_job_action",
+      ),
+      path(
+        "queue/<path:queue_name>/action/",
         wrap(self.queue_action_view),
         name="dj_queue_dashboard_queue_action",
       ),
       path(
-        "queue/<str:queue_name>/jobs/action/",
-        wrap(self.job_action_view),
-        name="dj_queue_dashboard_job_action",
+        "queue/<path:queue_name>/",
+        wrap(self.queue_view),
+        name="dj_queue_dashboard_queue",
       ),
     ] + super().get_urls()
 
@@ -155,7 +165,7 @@ class DashboardAdmin(admin.ModelAdmin):
     context = {
       **self.admin_site.each_context(request),
       **queue_context,
-      "job_actions": dashboard.job_actions_for_state(state),
+      "job_actions": dashboard_actions.job_actions_for_state(state),
       "title": "dj_queue",
       "subtitle": queue_name,
     }
@@ -165,7 +175,7 @@ class DashboardAdmin(admin.ModelAdmin):
     backend_alias = dashboard.resolve_backend_alias(request.POST.get("backend"))
     return self._post_action_response(
       request,
-      operation=lambda: dashboard.apply_queue_action(
+      operation=lambda: dashboard_actions.apply_queue_action(
         backend_alias=backend_alias,
         queue_name=queue_name,
         action=request.POST.get("action"),
@@ -178,7 +188,7 @@ class DashboardAdmin(admin.ModelAdmin):
     state = request.POST.get("state", "ready")
     return self._post_action_response(
       request,
-      operation=lambda: dashboard.apply_job_action(
+      operation=lambda: dashboard_actions.apply_job_action(
         backend_alias=backend_alias,
         queue_name=queue_name,
         state=state,
@@ -195,7 +205,7 @@ class DashboardAdmin(admin.ModelAdmin):
       return HttpResponseNotAllowed(["POST"])
     try:
       message = operation()
-    except ValueError as exc:
+    except ADMIN_POST_ACTION_ERRORS as exc:
       self.message_user(request, str(exc), level=messages.ERROR)
     else:
       self.message_user(request, message, level=messages.SUCCESS)
@@ -322,6 +332,26 @@ class HiddenSidebarAdminMixin:
   def handle_change_action(self, request, obj, action):
     return HttpResponseRedirect(request.get_full_path())
 
+  def _run_change_operation(
+    self,
+    request,
+    *,
+    operation,
+    success_message,
+    error_message,
+    success_redirect,
+    error_redirect,
+  ):
+    try:
+      result = operation()
+    except ADMIN_ACTION_ERRORS as exc:
+      self.message_user(request, f"{error_message}: {exc}", level=messages.ERROR)
+      return error_redirect()
+
+    message = success_message(result) if callable(success_message) else success_message
+    self.message_user(request, message, level=messages.SUCCESS)
+    return success_redirect(result)
+
   def _change_redirect(self, *, object_id, backend_alias):
     return HttpResponseRedirect(self._change_url(object_id=object_id, backend_alias=backend_alias))
 
@@ -428,16 +458,10 @@ class ProcessStatusListFilter(admin.SimpleListFilter):
     value = self.value()
     if not value:
       return queryset
-    cutoff = timezone.now() - timedelta(
-      seconds=load_backend_config(
-        dashboard.resolve_backend_alias(request.GET.get("backend"))
-      ).process_alive_threshold
+    cutoff = observability.process_cutoff_for_backend(
+      dashboard.resolve_backend_alias(request.GET.get("backend"))
     )
-    if value == "live":
-      return queryset.filter(last_heartbeat_at__gte=cutoff)
-    if value == "stale":
-      return queryset.filter(last_heartbeat_at__lt=cutoff)
-    return queryset
+    return observability.filter_process_status(queryset, value, process_cutoff=cutoff)
 
 
 @admin.register(Job)
@@ -515,8 +539,9 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
   @admin.display(description="queue name", ordering="queue_name")
   def queue_name_link(self, obj):
     query = {"backend": obj.backend_alias}
-    if obj.status is not None:
-      query["state"] = obj.status
+    status = obj.status
+    if is_queue_state(status):
+      query["state"] = status
     url = f"{reverse('admin:dj_queue_dashboard_queue', args=[obj.queue_name])}?{urlencode(query)}"
     return format_html('<a href="{}">{}</a>', url, obj.queue_name)
 
@@ -595,7 +620,7 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
         _job, dispatch_outcome = dispatch_scheduled_job_now(
           obj.pk, backend_alias=obj.backend_alias
         )
-      except (EnqueueError, ImportError, AttributeError) as exc:
+      except ADMIN_ACTION_ERRORS as exc:
         self.message_user(request, f"Could not dispatch job now: {exc}", level=messages.ERROR)
         return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
@@ -610,7 +635,7 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
     if action == "enqueue_copy_now":
       try:
         new_job = enqueue_job_again(obj.pk, backend_alias=obj.backend_alias, run_after=None)
-      except (EnqueueError, ImportError, AttributeError) as exc:
+      except ADMIN_ACTION_ERRORS as exc:
         self.message_user(request, f"Could not enqueue job: {exc}", level=messages.ERROR)
         return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
@@ -628,7 +653,7 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
     if action == "enqueue":
       try:
         new_job = enqueue_job_again(obj.pk, backend_alias=obj.backend_alias)
-      except (EnqueueError, ImportError, AttributeError) as exc:
+      except ADMIN_ACTION_ERRORS as exc:
         self.message_user(request, f"Could not enqueue job: {exc}", level=messages.ERROR)
         return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
@@ -648,14 +673,32 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
     if action == "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)
+      return self._run_change_operation(
+        request,
+        operation=lambda: retry_failed_job(
+          obj.failed_execution.job_id, backend_alias=obj.backend_alias
+        ),
+        success_message="Retried failed job",
+        error_message="Could not retry failed job",
+        success_redirect=lambda _result: self._current_object_redirect(
+          obj, backend_alias=obj.backend_alias
+        ),
+        error_redirect=lambda: self._current_object_redirect(obj, backend_alias=obj.backend_alias),
+      )
 
     if action == "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))
+      return self._run_change_operation(
+        request,
+        operation=lambda: discard_failed_job(
+          obj.failed_execution.job_id, backend_alias=obj.backend_alias
+        ),
+        success_message="Discarded failed job",
+        error_message="Could not discard failed job",
+        success_redirect=lambda _result: HttpResponseRedirect(
+          self._changelist_url(backend_alias=obj.backend_alias)
+        ),
+        error_redirect=lambda: self._current_object_redirect(obj, backend_alias=obj.backend_alias),
+      )
 
     return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
@@ -676,18 +719,28 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
   @admin.action(description="Retry selected failed jobs")
   def retry_jobs(self, request, 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),
-    )
+    try:
+      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),
+      )
+    except ADMIN_ACTION_ERRORS as exc:
+      self.message_user(request, f"Could not retry failed jobs: {exc}", level=messages.ERROR)
+      return
     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 += discard_failed_job(execution.job_id, backend_alias=execution.job.backend_alias)
+    try:
+      discarded = 0
+      for execution in queryset.select_related("job"):
+        discarded += discard_failed_job(
+          execution.job_id, backend_alias=execution.job.backend_alias
+        )
+    except ADMIN_ACTION_ERRORS as exc:
+      self.message_user(request, f"Could not discard failed jobs: {exc}", level=messages.ERROR)
+      return
     self.message_user(request, f"Discarded {discarded} failed jobs", level=messages.SUCCESS)
 
   @admin.display(description="created at", ordering="created_at")
@@ -711,15 +764,28 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
     if action == "retry":
       job_id = obj.job_id
-      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})}")
+      return self._run_change_operation(
+        request,
+        operation=lambda: retry_failed_job(job_id, backend_alias=backend_alias),
+        success_message="Retried failed job",
+        error_message="Could not retry failed job",
+        success_redirect=lambda _result: HttpResponseRedirect(
+          f"{reverse('admin:dj_queue_job_change', args=[job_id])}?{urlencode({'backend': backend_alias})}"
+        ),
+        error_redirect=lambda: self._current_object_redirect(obj, backend_alias=backend_alias),
+      )
 
     if action == "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))
+      return self._run_change_operation(
+        request,
+        operation=lambda: discard_failed_job(obj.job_id, backend_alias=backend_alias),
+        success_message="Discarded failed job",
+        error_message="Could not discard failed job",
+        success_redirect=lambda _result: HttpResponseRedirect(
+          self._changelist_url(backend_alias=backend_alias)
+        ),
+        error_redirect=lambda: self._current_object_redirect(obj, backend_alias=backend_alias),
+      )
 
     return self._current_object_redirect(obj, backend_alias=backend_alias)
 
@@ -752,16 +818,8 @@ class ProcessAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
   def get_queryset(self, request):
     queryset = super().get_queryset(request)
-    cutoff = timezone.now() - timedelta(
-      seconds=load_backend_config(self._backend_alias(request)).process_alive_threshold
-    )
-    return queryset.annotate(
-      live_rank=Case(
-        When(last_heartbeat_at__gte=cutoff, then=Value(0)),
-        default=Value(1),
-        output_field=IntegerField(),
-      )
-    )
+    cutoff = observability.process_cutoff_for_backend(self._backend_alias(request))
+    return queryset.annotate(live_rank=observability.process_live_rank_expression(cutoff))
 
   @admin.display(description="status", ordering="live_rank")
   def display_status(self, obj):
@@ -872,7 +930,11 @@ class PauseAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
   def handle_change_action(self, request, obj, action):
     backend_alias = self._backend_alias(request)
     if action == "resume":
-      QueueInfo(obj.queue_name, backend_alias=backend_alias).resume()
+      try:
+        QueueInfo(obj.queue_name, backend_alias=backend_alias).resume()
+      except ADMIN_ACTION_ERRORS as exc:
+        self.message_user(request, f"Could not resume queue: {exc}", level=messages.ERROR)
+        return self._current_object_redirect(obj, backend_alias=backend_alias)
       self.message_user(
         request,
         format_html(
@@ -896,18 +958,8 @@ class SemaphoreAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
   def get_queryset(self, request):
     queryset = super().get_queryset(request)
     alias = self._backend_database_alias(request)
-    blocked_waiters = (
-      BlockedExecution.objects.using(alias)
-      .filter(concurrency_key=OuterRef("key"))
-      .values("concurrency_key")
-      .annotate(total=Count("id"))
-      .values("total")[:1]
-    )
     return queryset.annotate(
-      blocked_waiter_count=Coalesce(
-        Subquery(blocked_waiters, output_field=IntegerField()),
-        Value(0),
-      )
+      blocked_waiter_count=observability.semaphore_blocked_waiter_count_expression(alias)
     )
 
   @admin.display(description="blocked waiters", ordering="blocked_waiter_count")

{dj_queue-0.10.6 → dj_queue-0.11.0}/dj_queue/api.py

@@ -1,19 +1,15 @@
-from datetime import timedelta
 from functools import partial
 
 from django.db import transaction
-from django.utils import timezone
 
 from dj_queue import observability
-from dj_queue.config import load_backend_config
-from dj_queue.db import get_database_alias
-from dj_queue.models import ReadyExecution
 from dj_queue.operations.jobs import (
   ClaimedJob,
   claim_ready_jobs,
   discard_blocked_jobs,
   discard_failed_job,
   discard_failed_jobs,
+  discard_ready_jobs_for_queue,
   discard_ready_jobs,
   discard_scheduled_jobs,
   execute_claimed_job,
@@ -42,16 +38,28 @@ __all__ = [
 
 
 class QueueInfo:
-  def __init__(self, queue_name, *, backend_alias="default"):
+  def __init__(self, queue_name, *, backend_alias="default", snapshot=None):
     self.queue_name = queue_name
     self.backend_alias = backend_alias
+    self._snapshot = snapshot
 
   @property
   def size(self):
-    return self._ready_queryset().count()
+    if self._snapshot is not None:
+      return self._snapshot["ready_count"]
+    return observability.queue_ready_count(
+      backend_alias=self.backend_alias,
+      queue_name=self.queue_name,
+    )
 
   @property
   def latency(self):
+    if self._snapshot is not None:
+      latency = self._snapshot["latency_seconds"]
+      if latency is None and not self._snapshot["paused"]:
+        return 0.0
+      return latency
+
     paused = observability.queue_is_paused(
       backend_alias=self.backend_alias,
       queue_name=self.queue_name,
@@ -68,6 +76,8 @@ class QueueInfo:
 
   @property
   def paused(self):
+    if self._snapshot is not None:
+      return self._snapshot["paused"]
     return observability.queue_is_paused(
       backend_alias=self.backend_alias,
       queue_name=self.queue_name,
@@ -75,40 +85,29 @@ class QueueInfo:
 
   def pause(self):
     pause_queue(self.queue_name, backend_alias=self.backend_alias)
+    self._snapshot = None
 
   def resume(self):
     resume_queue(self.queue_name, backend_alias=self.backend_alias)
+    self._snapshot = None
 
   def clear(self, *, batch_size=500):
     deleted = 0
     while True:
-      job_ids = list(self._ready_queryset().values_list("job_id", flat=True)[:batch_size])
-      if not job_ids:
-        return deleted
-      deleted += discard_ready_jobs(
-        job_ids=job_ids,
+      batch_deleted = discard_ready_jobs_for_queue(
+        self.queue_name,
         batch_size=batch_size,
         backend_alias=self.backend_alias,
       )
+      if not batch_deleted:
+        self._snapshot = None
+        return deleted
+      deleted += batch_deleted
 
   @classmethod
   def all(cls, *, backend_alias="default"):
-    now = timezone.now()
-    config = load_backend_config(backend_alias)
-    process_cutoff = now - timedelta(seconds=config.process_alive_threshold)
-    queue_rows = observability.queue_rows(
-      backend_alias=backend_alias,
-      now=now,
-      process_cutoff=process_cutoff,
-    )
-    return [cls(row["name"], backend_alias=backend_alias) for row in queue_rows]
-
-  def _ready_queryset(self):
-    alias = get_database_alias(self.backend_alias)
-    return ReadyExecution.objects.using(alias).filter(
-      backend_alias=self.backend_alias,
-      queue_name=self.queue_name,
-    )
+    queue_rows = observability.queue_rows_for_backend(backend_alias=backend_alias)
+    return [cls(row["name"], backend_alias=backend_alias, snapshot=row) for row in queue_rows]
 
 
 def enqueue_on_commit(task, *args, using=None, **kwargs):

{dj_queue-0.10.6 → dj_queue-0.11.0}/dj_queue/config.py

@@ -377,7 +377,7 @@ def _load_toml_options(config_path: Any, *, backend_alias: str) -> dict[str, Any
 
   raw_backends = config_payload.get("backends")
   if raw_backends is None:
-    return config_payload
+    return _json_serializable_options(config_payload, "DJ_QUEUE_CONFIG")
 
   if len(config_payload) != 1:
     raise ImproperlyConfigured(
@@ -391,7 +391,18 @@ def _load_toml_options(config_path: Any, *, backend_alias: str) -> dict[str, Any
     return {}
   if not isinstance(backend_options, Mapping):
     raise ImproperlyConfigured(f"DJ_QUEUE_CONFIG backends[{backend_alias!r}] must be a mapping")
-  return dict(backend_options)
+  return _json_serializable_options(
+    dict(backend_options),
+    f"DJ_QUEUE_CONFIG backends[{backend_alias!r}]",
+  )
+
+
+def _json_serializable_options(options: Mapping[str, Any], setting_name: str) -> dict[str, Any]:
+  try:
+    json.dumps(options, sort_keys=True, separators=(",", ":"), allow_nan=False)
+  except (TypeError, ValueError) as exc:
+    raise ImproperlyConfigured(f"{setting_name} values must be JSON-serializable") from exc
+  return dict(options)
 
 
 def _resolve_skip_recurring(
@@ -550,7 +561,7 @@ def _build_recurring_config(
 
   recurring: dict[str, RecurringTaskConfig] = {}
   for key, raw_entry in raw_recurring.items():
-    key = _string_option(key, "recurring task key")
+    key = _nonempty_string_option(key, "recurring task key")
     if not isinstance(raw_entry, Mapping):
       raise ImproperlyConfigured("recurring entries must be mappings")
 
@@ -558,12 +569,12 @@ def _build_recurring_config(
     raw_schedule = raw_entry.get("schedule")
     if raw_task_path in (None, "") or raw_schedule in (None, ""):
       raise ImproperlyConfigured(f"recurring task {key!r} requires task_path and schedule")
-    task_path = _string_option(raw_task_path, f"recurring task {key!r} task_path")
-    schedule = _string_option(raw_schedule, f"recurring task {key!r} schedule")
+    task_path = _nonempty_string_option(raw_task_path, f"recurring task {key!r} task_path")
+    schedule = _nonempty_string_option(raw_schedule, f"recurring task {key!r} schedule")
     if not is_valid_cron(schedule):
       raise ImproperlyConfigured(f"recurring task {key!r} has an invalid cron schedule")
 
-    queue_name = _string_option(
+    queue_name = _nonempty_string_option(
       raw_entry.get("queue_name", "default"), f"recurring task {key!r} queue_name"
     )
     priority = _priority_int(raw_entry.get("priority", 0), f"recurring task {key!r} priority")
@@ -639,6 +650,13 @@ def _string_option(value: Any, setting_name: str) -> str:
   return value
 
 
+def _nonempty_string_option(value: Any, setting_name: str) -> str:
+  value = _string_option(value, setting_name)
+  if value == "":
+    raise ImproperlyConfigured(f"dj_queue {setting_name} must be a non-empty string")
+  return value
+
+
 def _optional_string_option(value: Any, setting_name: str) -> str | None:
   if value is None:
     return None
@@ -737,6 +755,6 @@ def _integer(value: Any, setting_name: str, expectation: str) -> int:
 
 def _cache_key(value: Any) -> str:
   try:
-    return json.dumps(value, sort_keys=True, separators=(",", ":"))
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
   except (TypeError, ValueError) as exc:
     raise ImproperlyConfigured("dj_queue config values must be JSON-serializable") from exc