dj-queue 0.14.2__tar.gz → 0.15.0__tar.gz

{dj_queue-0.14.2 → dj_queue-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.14.2
+Version: 0.15.0
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -369,7 +369,7 @@ The database floor follows the selected Django release:
 | 6.1 | 15+ | 8.4+ | 10.11+ | 3.37+ |
 
 CI keeps the floors on Django 6.0 and tests newer database lines through
-PostgreSQL 18, MySQL 9.7 and 26.7, and MariaDB 12.3. Django 6.1 only runs with
+PostgreSQL 18, MySQL 9.7 and 26.10, and MariaDB 12.3 and 13.0. Django 6.1 only runs with
 database versions that it supports.
 
 For MySQL or MariaDB, install and configure a Django-compatible driver following Django's database docs.
@@ -939,13 +939,14 @@ Global options:
 | `default_concurrency_duration` | `180` | default semaphore TTL in seconds |
 | `use_skip_locked` | `true` | use `SKIP LOCKED` when the active backend supports it |
 | `listen_notify` | `true` | PostgreSQL-only worker wakeup optimization layered on top of polling |
-| `silence_polling` | `true` | suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger |
 | `process_heartbeat_interval` | `60` | seconds between process heartbeat writes |
 | `process_alive_threshold` | `300` | seconds before a process row is stale |
 | `shutdown_timeout` | `5` | graceful drain window before standalone shutdown gives up on waiting |
 | `supervisor_pidfile` | `null` | optional pidfile guard for standalone supervisors |
 | `on_thread_error` | `null` | dotted callback path for runtime infrastructure exceptions |
 
+`silence_polling` is deprecated: it never had an effect, still loads with a `FutureWarning`, and will be rejected in a future release, so remove it from settings and TOML overlays.
+
 Worker entry options:
 
 | Option | Default | Meaning |
@@ -1027,7 +1028,6 @@ database_alias = "queue"
 preserve_finished_jobs = true
 clear_finished_jobs_after = 86400
 listen_notify = true
-silence_polling = true
 
 [[workers]]
 queues = ["default", "email*"]

{dj_queue-0.14.2 → dj_queue-0.15.0}/README.md

@@ -342,7 +342,7 @@ The database floor follows the selected Django release:
 | 6.1 | 15+ | 8.4+ | 10.11+ | 3.37+ |
 
 CI keeps the floors on Django 6.0 and tests newer database lines through
-PostgreSQL 18, MySQL 9.7 and 26.7, and MariaDB 12.3. Django 6.1 only runs with
+PostgreSQL 18, MySQL 9.7 and 26.10, and MariaDB 12.3 and 13.0. Django 6.1 only runs with
 database versions that it supports.
 
 For MySQL or MariaDB, install and configure a Django-compatible driver following Django's database docs.
@@ -912,13 +912,14 @@ Global options:
 | `default_concurrency_duration` | `180` | default semaphore TTL in seconds |
 | `use_skip_locked` | `true` | use `SKIP LOCKED` when the active backend supports it |
 | `listen_notify` | `true` | PostgreSQL-only worker wakeup optimization layered on top of polling |
-| `silence_polling` | `true` | suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger |
 | `process_heartbeat_interval` | `60` | seconds between process heartbeat writes |
 | `process_alive_threshold` | `300` | seconds before a process row is stale |
 | `shutdown_timeout` | `5` | graceful drain window before standalone shutdown gives up on waiting |
 | `supervisor_pidfile` | `null` | optional pidfile guard for standalone supervisors |
 | `on_thread_error` | `null` | dotted callback path for runtime infrastructure exceptions |
 
+`silence_polling` is deprecated: it never had an effect, still loads with a `FutureWarning`, and will be rejected in a future release, so remove it from settings and TOML overlays.
+
 Worker entry options:
 
 | Option | Default | Meaning |
@@ -1000,7 +1001,6 @@ database_alias = "queue"
 preserve_finished_jobs = true
 clear_finished_jobs_after = 86400
 listen_notify = true
-silence_polling = true
 
 [[workers]]
 queues = ["default", "email*"]

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/config.py

@@ -62,12 +62,13 @@ DEFAULT_OPTIONS = {
   "database_alias": "default",
   "use_skip_locked": True,
   "listen_notify": True,
-  "silence_polling": True,
   "async_thread_sensitive": False,
   "async_close_connections": False,
   "on_thread_error": None,
 }
 
+DEPRECATED_OPTIONS = ("silence_polling",)
+
 DJ_QUEUE_BACKEND_PATH = "dj_queue.backend.DjQueueBackend"
 
 TRUTHY_ENV_VALUES = {"1", "true", "yes", "on"}
@@ -138,7 +139,6 @@ class BackendConfig(ConfigValue):
   database_alias: str = "default"
   use_skip_locked: bool = True
   listen_notify: bool = True
-  silence_polling: bool = True
   async_thread_sensitive: bool = False
   async_close_connections: bool = False
   on_thread_error: str | None = None
@@ -150,6 +150,14 @@ class BackendConfig(ConfigValue):
   def has_scheduler_work(self) -> bool:
     return self.scheduler is not None
 
+  @property
+  def cleanup_enabled(self) -> bool:
+    return (
+      (self.preserve_finished_jobs and self.clear_finished_jobs_after is not None)
+      or self.clear_failed_jobs_after is not None
+      or self.clear_recurring_executions_after is not None
+    )
+
 
 def resolve_backend_config(
   backend_alias: str = "default", config: BackendConfig | None = None
@@ -293,7 +301,6 @@ def _build_backend_config(
     database_alias=_string_option(resolved_options["database_alias"], "database_alias"),
     use_skip_locked=_bool_option(resolved_options["use_skip_locked"], "use_skip_locked"),
     listen_notify=_bool_option(resolved_options["listen_notify"], "listen_notify"),
-    silence_polling=_bool_option(resolved_options["silence_polling"], "silence_polling"),
     async_thread_sensitive=_bool_option(
       resolved_options["async_thread_sensitive"], "async_thread_sensitive"
     ),
@@ -389,6 +396,7 @@ def _resolved_options(
   settings_options = backend_block.get("OPTIONS", {})
   if not isinstance(settings_options, Mapping):
     raise ImproperlyConfigured("TASKS backend OPTIONS must be a mapping")
+  settings_options = _without_deprecated_options(settings_options, "TASKS backend OPTIONS")
   _reject_unknown_options(settings_options, DEFAULT_OPTIONS, "TASKS backend OPTIONS")
 
   resolved_options = dict(DEFAULT_OPTIONS)
@@ -444,11 +452,27 @@ def _load_toml_options(config_path: Any, *, backend_alias: str) -> dict[str, Any
 
 
 def _validated_toml_options(options: Mapping[str, Any], setting_name: str) -> dict[str, Any]:
-  options = _json_serializable_options(options, setting_name)
+  options = _without_deprecated_options(
+    _json_serializable_options(options, setting_name), setting_name
+  )
   _reject_unknown_options(options, DEFAULT_OPTIONS, setting_name)
   return options
 
 
+def _without_deprecated_options(options: Mapping[str, Any], setting_name: str) -> dict[str, Any]:
+  options = dict(options)
+  for name in DEPRECATED_OPTIONS:
+    if name in options:
+      del options[name]
+      warnings.warn(
+        f"dj_queue {setting_name} option {name!r} has no effect and will be rejected in a "
+        "future release; remove it",
+        FutureWarning,
+        stacklevel=2,
+      )
+  return options
+
+
 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)
@@ -669,12 +693,7 @@ def _build_recurring_config(
 
 
 def _scheduler_has_work(config: BackendConfig) -> bool:
-  has_cleanup = (
-    (config.preserve_finished_jobs and config.clear_finished_jobs_after is not None)
-    or config.clear_failed_jobs_after is not None
-    or config.clear_recurring_executions_after is not None
-  )
-  return config.scheduler.dynamic_tasks_enabled or bool(config.recurring) or has_cleanup
+  return config.scheduler.dynamic_tasks_enabled or bool(config.recurring) or config.cleanup_enabled
 
 
 def _as_queue_selectors(value: Any) -> tuple[str, ...]:

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/contrib/asgi.py

@@ -24,14 +24,9 @@ class DjQueueLifespan:
       self.supervisor is not None and self._poll_stop is not None and not self._poll_stop.is_set()
     ):
       try:
-        poll_once = getattr(self.supervisor, "poll_once_if_running", self.supervisor.poll_once)
-        keep_polling = await asyncio.to_thread(poll_once)
+        keep_polling = await asyncio.to_thread(self.supervisor.poll_once_if_running)
       except Exception as error:
-        handle_thread_error(
-          error,
-          context="supervisor.run",
-          backend_alias=self.supervisor.backend_alias,
-        )
+        handle_thread_error(error, context="supervisor.run", config=self.supervisor.backend_config)
         keep_polling = True
 
       if keep_polling is False:

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/contrib/gunicorn.py

@@ -4,6 +4,7 @@ import tempfile
 import threading
 from pathlib import Path
 
+from dj_queue.config import load_backend_config
 from dj_queue.runtime.errors import handle_thread_error
 
 LOCK_PATH_PREFIX = "dj_queue_gunicorn_supervisor"
@@ -68,15 +69,10 @@ def _start_embedded_supervisor(worker, *, backend_alias="default"):
     stop_event = worker._dj_queue_supervisor_poll_stop
     while stop_event.wait(supervisor.polling_interval) is False:
       try:
-        poll_once = getattr(supervisor, "poll_once_if_running", supervisor.poll_once)
-        if poll_once() is False:
+        if supervisor.poll_once_if_running() is False:
           return
       except Exception as error:
-        handle_thread_error(
-          error,
-          context="supervisor.run",
-          backend_alias=supervisor.backend_alias,
-        )
+        handle_thread_error(error, context="supervisor.run", config=supervisor.backend_config)
 
   poll_thread = threading.Thread(target=poll_supervisor, daemon=True)
   worker._dj_queue_supervisor_poll_thread = poll_thread
@@ -94,7 +90,9 @@ def _start_lock_retry_loop(worker, *, backend_alias="default"):
       try:
         supervisor = _start_embedded_supervisor(worker, backend_alias=backend_alias)
       except Exception as error:
-        handle_thread_error(error, context="gunicorn.supervisor", backend_alias=backend_alias)
+        handle_thread_error(
+          error, context="gunicorn.supervisor", config=load_backend_config(backend_alias)
+        )
         continue
       if supervisor is not None:
         retry_stop.set()

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/dashboard.py

@@ -12,9 +12,9 @@ from dj_queue.dashboard_tables import OVERVIEW_COUNT_LABELS, OVERVIEW_SORTS, QUE
 from dj_queue.db import database_capabilities, get_database_alias
 from dj_queue.observability import backend_choices, configured_backend_aliases
 from dj_queue.queue_state import (
-  QUEUE_STATE_DEFINITIONS,
   QUEUE_STATE_LABELS,
   QUEUE_STATES,
+  SUMMARY_STATE_DEFINITIONS,
   queue_state_count_key,
   queue_state_queryset,
 )
@@ -154,13 +154,13 @@ def queue_page_context(*, backend_alias, queue_name, state, page_number, query_p
   )
   queue_info = QueueInfo(queue_name, backend_alias=backend_alias)
   state_counts = {
-    definition.name: queue_row[definition.count_key] for definition in QUEUE_STATE_DEFINITIONS
+    definition.name: queue_row[definition.count_key] for definition in SUMMARY_STATE_DEFINITIONS
   }
   state_tabs = [
     {
       "name": state_name,
       "label": label,
-      "count": state_counts[state_name],
+      "count": state_counts.get(state_name),
       "selected": state_name == state,
     }
     for state_name, label in QUEUE_STATES
@@ -239,7 +239,6 @@ def _summary_cards(*, backend_alias, queue_rows, process_rows, recurring_count,
   scheduled_count = sum(row[queue_state_count_key("scheduled")] for row in queue_rows)
   failed_count = sum(row[queue_state_count_key("failed")] for row in queue_rows)
   blocked_count = sum(row[queue_state_count_key("blocked")] for row in queue_rows)
-  invalid_count = sum(row[queue_state_count_key("invalid")] for row in queue_rows)
   live_processes = sum(1 for row in process_rows if row["is_live"])
   stale_processes = len(process_rows) - live_processes
 
@@ -256,22 +255,17 @@ def _summary_cards(*, backend_alias, queue_rows, process_rows, recurring_count,
     },
     {
       "label": "attention",
-      "value": failed_count + blocked_count + invalid_count,
+      "value": failed_count + blocked_count,
       "detail_parts": (
         {
           "label": f"{failed_count} failed",
           "url": _job_changelist_url(backend_alias=backend_alias, status="failed"),
         },
-        {"label": ","},
+        {"label": "and"},
         {
           "label": f"{blocked_count} blocked",
           "url": _job_changelist_url(backend_alias=backend_alias, status="blocked"),
         },
-        {"label": "and"},
-        {
-          "label": f"{invalid_count} invalid",
-          "url": _job_changelist_url(backend_alias=backend_alias, status="invalid"),
-        },
       ),
     },
     {

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/dashboard_tables.py

@@ -7,7 +7,7 @@ from django.core.paginator import Paginator
 from django.db.models import F
 
 from dj_queue.queue_state import (
-  QUEUE_STATE_DEFINITIONS,
+  SUMMARY_STATE_DEFINITIONS,
 )
 
 OVERVIEW_COUNT_LABELS = {
@@ -30,7 +30,7 @@ OVERVIEW_SORTS = {
           "key": definition.count_key,
           "default_desc": True,
         }
-        for definition in QUEUE_STATE_DEFINITIONS
+        for definition in SUMMARY_STATE_DEFINITIONS
       },
       "paused": {"label": "paused", "key": "paused", "default_desc": True},
       "latency": {"label": "latency", "key": "latency_seconds", "default_desc": True},

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/db.py

@@ -8,7 +8,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.db import DEFAULT_DB_ALIAS, connections
 from django.db.utils import OperationalError
 
-from dj_queue.config import resolve_backend_config
+from dj_queue.config import load_backend_config
 
 TRANSIENT_DATABASE_RETRY_ATTEMPTS = 3
 TRANSIENT_DATABASE_RETRY_SLEEP_BASE = 0.01
@@ -45,8 +45,8 @@ class DatabaseCapabilities:
   uses_serialized_writes: bool
 
 
-def get_database_alias(backend_alias: str = "default", *, config=None) -> str:
-  return resolve_backend_config(backend_alias, config).database_alias
+def get_database_alias(backend_alias: str = "default") -> str:
+  return load_backend_config(backend_alias).database_alias
 
 
 def locked_queryset(qs, use_skip_locked: bool = True):

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/hooks.py

@@ -67,17 +67,12 @@ def on_scheduler_exit(fn: Callable[..., Any]):
   return register_hook("scheduler.exit", fn)
 
 
-def fire_hooks(event: str, process: Any, *, backend_alias: str = "default", config=None):
+def fire_hooks(event: str, process: Any, *, config):
   for hook in tuple(_hooks.get(event, ())):
     try:
       hook(process)
     except Exception as error:
-      handle_thread_error(
-        error,
-        context=f"hook:{event}",
-        backend_alias=backend_alias,
-        config=config,
-      )
+      handle_thread_error(error, context=f"hook:{event}", config=config)
 
 
 def clear_hooks(event: str | None = None):

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/log.py

@@ -1,19 +1,10 @@
 import logging
 from typing import Any
 
-from dj_queue.config import load_backend_config
-
 logger = logging.getLogger("dj_queue")
 
 
-def event_logging_enabled(
-  level: int = logging.INFO,
-  *,
-  backend_alias: str = "default",
-  polling: bool = False,
-):
-  if polling and load_backend_config(backend_alias).silence_polling:
-    return False
+def event_logging_enabled(level: int = logging.INFO):
   return logger.isEnabledFor(level)
 
 
@@ -22,10 +13,9 @@ def log_event(
   *,
   level: int = logging.INFO,
   backend_alias: str = "default",
-  polling: bool = False,
   **fields: Any,
 ):
-  if not event_logging_enabled(level, backend_alias=backend_alias, polling=polling):
+  if not event_logging_enabled(level):
     return
 
   logger.log(

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/management/commands/dj_queue_prune.py

@@ -1,6 +1,7 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management.base import BaseCommand, CommandError
 
+from dj_queue.config import load_backend_config
 from dj_queue.operations.cleanup import (
   clear_failed_jobs,
   clear_finished_jobs,
@@ -57,23 +58,24 @@ class Command(BaseCommand):
       raise CommandError("--batch-size must be positive")
 
     try:
+      config = load_backend_config(options["backend"])
       finished_deleted = clear_finished_jobs(
         older_than=options["older_than"],
         task_path=options["task_path"],
         batch_size=batch_size,
-        backend_alias=options["backend"],
+        config=config,
       )
       failed_deleted = clear_failed_jobs(
         older_than=options["failed_older_than"],
         task_path=options["task_path"],
         batch_size=batch_size,
-        backend_alias=options["backend"],
+        config=config,
       )
       recurring_deleted = clear_recurring_executions(
         older_than=options["recurring_older_than"],
         task_key=options["task_key"],
         batch_size=batch_size,
-        backend_alias=options["backend"],
+        config=config,
       )
     except ImproperlyConfigured as exc:
       raise CommandError(str(exc)) from exc

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/metrics.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from dj_queue import observability
-from dj_queue.queue_state import QUEUE_STATE_DEFINITIONS
+from dj_queue.queue_state import SUMMARY_STATE_DEFINITIONS
 
 
 @dataclass(frozen=True, slots=True)
@@ -60,7 +60,7 @@ def _queue_metric_families(snapshots):
   for snapshot in snapshots:
     for queue in snapshot.queue_rows:
       labels = (snapshot.backend_alias, queue["name"])
-      for definition in QUEUE_STATE_DEFINITIONS:
+      for definition in SUMMARY_STATE_DEFINITIONS:
         jobs.append(
           MetricSample(labels=(*labels, definition.name), value=queue[definition.count_key])
         )

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/operations/_helpers.py

@@ -155,29 +155,6 @@ def _ready_execution_row(
 
 
 def _create_ready_execution(
-  alias,
-  job,
-  *,
-  backend_alias,
-  queue_name=None,
-  priority=None,
-  ready_at=None,
-  created_at=None,
-):
-  queue_name = _execution_queue_name(job, queue_name)
-  return _create_ready_execution_locked(
-    alias,
-    job,
-    backend_alias=backend_alias,
-    queue_name=queue_name,
-    priority=priority,
-    ready_at=ready_at,
-    created_at=created_at,
-    check_conflicts=True,
-  )
-
-
-def _create_ready_execution_locked(
   alias,
   job,
   *,
@@ -190,7 +167,6 @@ def _create_ready_execution_locked(
 ):
   if check_conflicts:
     _ensure_no_other_execution_state(alias, job)
-  _lock_active_pauses(alias, backend_alias, {queue_name})
   return ReadyExecution.objects.using(alias).create(
     **_ready_execution_fields(
       job,
@@ -203,29 +179,16 @@ def _create_ready_execution_locked(
   )
 
 
-def _bulk_create_ready_executions_locked(alias, ready_rows, *, backend_alias, check_conflicts):
+def _bulk_create_ready_executions(alias, ready_rows, *, check_conflicts):
   ready_rows = tuple(ready_rows)
   if not ready_rows:
     return None
 
   if check_conflicts:
     _ensure_job_ids_have_no_other_execution_state(alias, [row.job_id for row in ready_rows])
-  _lock_active_pauses(alias, backend_alias, {row.queue_name for row in ready_rows})
   return _bulk_create(alias, ReadyExecution, ready_rows)
 
 
-def _ready_execution_rows(jobs, *, backend_alias, ready_at=None, created_at=None):
-  return [
-    _ready_execution_row(
-      job,
-      backend_alias=backend_alias,
-      ready_at=ready_at,
-      created_at=created_at,
-    )
-    for job in jobs
-  ]
-
-
 def _scheduled_execution_row(job, *, backend_alias, scheduled_at=None, created_at=None):
   return ScheduledExecution(
     **_scheduled_execution_fields(

{dj_queue-0.14.2 → dj_queue-0.15.0}/dj_queue/operations/claiming.py

@@ -9,7 +9,6 @@ from django.utils import timezone
 from dj_queue.config import resolve_backend_config
 from dj_queue.db import (
   database_capabilities,
-  get_database_alias,
   locked_queryset,
   retry_transient_database_errors,
 )
@@ -46,29 +45,26 @@ def claim_ready_jobs(
   queues: str | Sequence[str] | None = None,
   process: Process | None = None,
   backend_alias: str = "default",
-  use_skip_locked: bool | None = None,
   config=None,
 ) -> list[ClaimedJob]:
   if limit <= 0:
     return []
 
-  alias = get_database_alias(backend_alias, config=config)
-  if use_skip_locked is None:
-    use_skip_locked = resolve_backend_config(backend_alias, config).use_skip_locked
-
+  config = resolve_backend_config(backend_alias, config)
+  alias = config.database_alias
   claimed_jobs = retry_transient_database_errors(
     lambda: _claim_ready_jobs_once(
       limit=limit,
       queues=queues,
       process=process,
       backend_alias=backend_alias,
-      use_skip_locked=use_skip_locked,
+      use_skip_locked=config.use_skip_locked,
       alias=alias,
     ),
     using=alias,
   )
 
-  if event_logging_enabled(backend_alias=backend_alias):
+  if event_logging_enabled():
     for claimed_job in claimed_jobs:
       log_event(
         "job.claimed",
@@ -174,10 +170,6 @@ def _claim_ready_jobs_once(
   ]
 
 
-def _filter_queue_selectors(queryset, queues):
-  return filter_by_queue_selectors(queryset, queues)
-
-
 def _select_ready_rows(queryset, *, limit, queues, use_skip_locked, alias, backend_alias):
   if selectors_match_all(queues):
     select_ready_row_ids = getattr(backend_sql(alias), "select_ready_row_ids", None)
@@ -195,36 +187,29 @@ def _select_ready_rows(queryset, *, limit, queues, use_skip_locked, alias, backe
 
   selectors = normalize_queue_selectors(queues)
   selected_rows = []
-  selected_ids = set()
 
   star_index = selectors.index("*") if "*" in selectors else None
   ordered_selectors = selectors if star_index is None else selectors[:star_index]
 
   if ordered_selectors:
     if _selectors_are_exact_queues(ordered_selectors):
-      rows = _select_exact_queue_rows(
+      selected_rows = _select_exact_queue_rows(
         queryset,
         ordered_selectors,
         limit=limit,
         use_skip_locked=use_skip_locked,
-        selected_ids=selected_ids,
         alias=alias,
         backend_alias=backend_alias,
       )
     else:
-      ordered = _ordered_selector_rows_queryset(
-        queryset.exclude(pk__in=selected_ids),
-        ordered_selectors,
-      )
-      rows = list(locked_queryset(ordered, use_skip_locked=use_skip_locked)[:limit])
-    selected_rows.extend(rows)
-    selected_ids.update(row.pk for row in rows)
+      ordered = _ordered_selector_rows_queryset(queryset, ordered_selectors)
+      selected_rows = list(locked_queryset(ordered, use_skip_locked=use_skip_locked)[:limit])
 
   remaining = limit - len(selected_rows)
   if remaining <= 0 or star_index is None:
     return selected_rows
 
-  ordered = queryset.exclude(pk__in=selected_ids).order_by("-priority", "id")
+  ordered = queryset.exclude(pk__in=[row.pk for row in selected_rows]).order_by("-priority", "id")
   rows = list(locked_queryset(ordered, use_skip_locked=use_skip_locked)[:remaining])
   selected_rows.extend(rows)
   return selected_rows
@@ -240,22 +225,21 @@ def _select_exact_queue_rows(
   *,
   limit,
   use_skip_locked,
-  selected_ids,
   alias,
   backend_alias,
 ):
-  if not selected_ids:
-    select_ready_rows = getattr(backend_sql(alias), "select_ready_rows_by_exact_queues", None)
-    if select_ready_rows is not None:
-      return select_ready_rows(
-        alias,
-        backend_alias=backend_alias,
-        selectors=selectors,
-        limit=limit,
-        use_skip_locked=use_skip_locked,
-      )
+  select_ready_rows = getattr(backend_sql(alias), "select_ready_rows_by_exact_queues", None)
+  if select_ready_rows is not None:
+    return select_ready_rows(
+      alias,
+      backend_alias=backend_alias,
+      selectors=selectors,
+      limit=limit,
+      use_skip_locked=use_skip_locked,
+    )
 
   selected_rows = []
+  selected_ids = set()
   for selector in selectors:
     remaining = limit - len(selected_rows)
     if remaining <= 0:
@@ -285,7 +269,7 @@ def _create_claimed_executions(alias, jobs, *, process, claimed_at):
 
 
 def _ordered_selector_rows_queryset(queryset, selectors):
-  filtered = _filter_queue_selectors(queryset, selectors)
+  filtered = filter_by_queue_selectors(queryset, selectors)
   selector_rank = Case(
     *[
       When(queue_selector_condition((selector,)), then=Value(index))