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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.7.1
+Version: 0.8.1
 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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1/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.1}/dj_queue/operations/concurrency.py

@@ -1,6 +1,6 @@
 from datetime import timedelta
 
-from django.db import transaction
+from django.db import connections, transaction
 from django.db.models import F
 from django.utils import timezone
 from django.utils.module_loading import import_string
@@ -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
 
@@ -24,6 +29,16 @@ def semaphore_acquire(
   alias = get_database_alias(backend_alias)
   now = timezone.now()
   expires_at = now + timedelta(seconds=duration_seconds)
+  backend_family = database_capabilities(alias).backend_family
+
+  if backend_family in {"mysql", "mariadb"}:
+    return _mysql_family_semaphore_acquire(
+      alias,
+      key,
+      limit=limit,
+      expires_at=expires_at,
+      now=now,
+    )
 
   with transaction.atomic(using=alias):
     if create_ignore_conflicts(
@@ -36,7 +51,6 @@ def semaphore_acquire(
     ):
       return True
 
-  # mysql-family backends can deadlock if a skipped insert and row lock happen in one tx
   with transaction.atomic(using=alias):
     updated = (
       Semaphore.objects.using(alias)
@@ -50,6 +64,43 @@ def semaphore_acquire(
   return updated > 0
 
 
+def _mysql_family_semaphore_acquire(alias, key, *, limit, expires_at, now):
+  connection = connections[alias]
+  table = connection.ops.quote_name(Semaphore._meta.db_table)
+  key_column = connection.ops.quote_name("key")
+  value_column = connection.ops.quote_name("value")
+  limit_column = connection.ops.quote_name("limit")
+  expires_at_column = connection.ops.quote_name("expires_at")
+  created_at_column = connection.ops.quote_name("created_at")
+  updated_at_column = connection.ops.quote_name("updated_at")
+
+  # one upsert avoids mysql-family deadlocks from mixing ignored inserts and follow-up updates
+  with connection.cursor() as cursor:
+    cursor.execute(
+      f"""
+      INSERT INTO {table} (
+        {key_column},
+        {value_column},
+        {limit_column},
+        {expires_at_column},
+        {created_at_column},
+        {updated_at_column}
+      )
+      VALUES (%s, %s, %s, %s, %s, %s)
+      ON DUPLICATE KEY UPDATE
+        {expires_at_column} = IF({value_column} > 0, %s, {expires_at_column}),
+        {updated_at_column} = IF({value_column} > 0, %s, {updated_at_column}),
+        {value_column} = IF(
+          {value_column} > 0,
+          LAST_INSERT_ID({value_column}) - 1,
+          LAST_INSERT_ID(0) + {value_column}
+        )
+      """,
+      [key, limit - 1, limit, expires_at, now, now, expires_at, now],
+    )
+    return cursor.lastrowid != 0
+
+
 def semaphore_release(key, *, duration_seconds, backend_alias="default"):
   alias = get_database_alias(backend_alias)
   expires_at = timezone.now() + timedelta(seconds=duration_seconds)
@@ -139,16 +190,23 @@ def unblock_next_blocked_job(
 
 def cleanup_expired_semaphores(*, backend_alias="default"):
   alias = get_database_alias(backend_alias)
-  active_concurrency_keys = (
+  claimed_concurrency_keys = (
     ClaimedExecution.objects.using(alias)
     .exclude(job__concurrency_key__isnull=True)
     .exclude(job__concurrency_key="")
     .values_list("job__concurrency_key", flat=True)
   )
+  ready_concurrency_keys = (
+    ReadyExecution.objects.using(alias)
+    .exclude(job__concurrency_key__isnull=True)
+    .exclude(job__concurrency_key="")
+    .values_list("job__concurrency_key", flat=True)
+  )
   queryset = (
     Semaphore.objects.using(alias)
     .filter(expires_at__lte=timezone.now())
-    .exclude(key__in=active_concurrency_keys)
+    .exclude(key__in=claimed_concurrency_keys)
+    .exclude(key__in=ready_concurrency_keys)
   )
   deleted = queryset.count()
   if not deleted:
@@ -230,29 +288,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 +297,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)