dj-queue 0.9.1__tar.gz → 0.9.2__tar.gz

{dj_queue-0.9.1 → dj_queue-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.9.1
+Version: 0.9.2
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -780,26 +780,70 @@ concurrency-maintenance throughput.
 
 The main configuration lives in `TASKS[backend_alias]["OPTIONS"]`.
 
-Start with these options:
-
-- `mode`: `"fork"` or `"async"`
-- `workers`: queue selectors, thread counts, and process counts
-- `dispatchers`: scheduled promotion and concurrency maintenance settings
-- `scheduler`: dynamic recurring polling settings
-- `database_alias`: database alias for queue tables and runtime activity
-- `preserve_finished_jobs` and `clear_finished_jobs_after`: successful result retention and cleanup
-- `clear_failed_jobs_after`: optional failed-job retention window
-- `clear_recurring_executions_after`: optional recurring reservation retention window
-
-Additional operational tuning is available when needed:
-
-- `use_skip_locked`: use `SKIP LOCKED` when the active backend supports it
-- `listen_notify`: PostgreSQL-only worker wakeup optimization layered on top of polling
-- `silence_polling`: suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger
-- `process_heartbeat_interval` and `process_alive_threshold`: process liveness reporting and stale-runner detection
-- `shutdown_timeout`: graceful drain window before standalone shutdown gives up on waiting
-- `supervisor_pidfile`: optional pidfile guard for standalone supervisors
-- `on_thread_error`: dotted callback path for runtime infrastructure exceptions
+No top-level `OPTIONS` key is required. Omit a key to use its default. Static
+`recurring` entries are the exception: each named recurring task requires
+`task_path` and `schedule`.
+
+Global options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `mode` | `"fork"` | standalone runtime mode, either `"fork"` or `"async"` |
+| `workers` | `[{"queues": "*", "threads": 3, "processes": 1, "polling_interval": 0.1}]` | worker topology and queue selectors |
+| `dispatchers` | `[{"batch_size": 500, "polling_interval": 1, "concurrency_maintenance": true, "concurrency_maintenance_interval": 600}]` | scheduled promotion and concurrency maintenance |
+| `scheduler` | `{"dynamic_tasks_enabled": false, "polling_interval": 5}` | dynamic recurring polling; the scheduler only starts when recurring or cleanup work exists |
+| `recurring` | `{}` | static recurring task definitions keyed by name |
+| `database_alias` | `"default"` | database alias for queue tables and runtime activity |
+| `preserve_finished_jobs` | `true` | keep successful jobs for result lookup and retention cleanup |
+| `clear_finished_jobs_after` | `86400` | seconds before finished successful jobs are cleaned up |
+| `clear_failed_jobs_after` | `null` | optional failed-job retention window in seconds |
+| `clear_recurring_executions_after` | `null` | optional recurring reservation retention window in seconds |
+| `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 |
+
+Worker entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `queues` | `"*"` | queue selector or selectors; `"*"` means all queues |
+| `threads` | `3` | worker threads per worker process |
+| `processes` | `1` | worker processes in `fork` mode; normalized to `1` in `async` mode |
+| `polling_interval` | `0.1` | seconds between worker polls |
+
+Dispatcher entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `batch_size` | `500` | maximum scheduled or blocked rows to promote per batch |
+| `polling_interval` | `1` | seconds between dispatcher polls |
+| `concurrency_maintenance` | `true` | run expired semaphore and blocked-job maintenance |
+| `concurrency_maintenance_interval` | `600` | seconds between maintenance passes; `0` means every poll |
+
+Scheduler entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `dynamic_tasks_enabled` | `false` | load dynamic recurring tasks from the database |
+| `polling_interval` | `5` | seconds between scheduler polls |
+
+Recurring entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `task_path` | none | required dotted import path for the task to enqueue |
+| `schedule` | none | required cron or supported Fugit-style cronish schedule |
+| `args` | `[]` | positional arguments for the task |
+| `kwargs` | `{}` | keyword arguments for the task |
+| `queue_name` | `"default"` | queue used for jobs created from this recurring task |
+| `priority` | `0` | priority used for jobs created from this recurring task |
+| `description` | `""` | operator-facing description |
 
 On PostgreSQL, `listen_notify` uses the same Django PostgreSQL driver
 configuration as the main database connection. Install a compatible driver in

{dj_queue-0.9.1 → dj_queue-0.9.2}/README.md

@@ -754,26 +754,70 @@ concurrency-maintenance throughput.
 
 The main configuration lives in `TASKS[backend_alias]["OPTIONS"]`.
 
-Start with these options:
-
-- `mode`: `"fork"` or `"async"`
-- `workers`: queue selectors, thread counts, and process counts
-- `dispatchers`: scheduled promotion and concurrency maintenance settings
-- `scheduler`: dynamic recurring polling settings
-- `database_alias`: database alias for queue tables and runtime activity
-- `preserve_finished_jobs` and `clear_finished_jobs_after`: successful result retention and cleanup
-- `clear_failed_jobs_after`: optional failed-job retention window
-- `clear_recurring_executions_after`: optional recurring reservation retention window
-
-Additional operational tuning is available when needed:
-
-- `use_skip_locked`: use `SKIP LOCKED` when the active backend supports it
-- `listen_notify`: PostgreSQL-only worker wakeup optimization layered on top of polling
-- `silence_polling`: suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger
-- `process_heartbeat_interval` and `process_alive_threshold`: process liveness reporting and stale-runner detection
-- `shutdown_timeout`: graceful drain window before standalone shutdown gives up on waiting
-- `supervisor_pidfile`: optional pidfile guard for standalone supervisors
-- `on_thread_error`: dotted callback path for runtime infrastructure exceptions
+No top-level `OPTIONS` key is required. Omit a key to use its default. Static
+`recurring` entries are the exception: each named recurring task requires
+`task_path` and `schedule`.
+
+Global options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `mode` | `"fork"` | standalone runtime mode, either `"fork"` or `"async"` |
+| `workers` | `[{"queues": "*", "threads": 3, "processes": 1, "polling_interval": 0.1}]` | worker topology and queue selectors |
+| `dispatchers` | `[{"batch_size": 500, "polling_interval": 1, "concurrency_maintenance": true, "concurrency_maintenance_interval": 600}]` | scheduled promotion and concurrency maintenance |
+| `scheduler` | `{"dynamic_tasks_enabled": false, "polling_interval": 5}` | dynamic recurring polling; the scheduler only starts when recurring or cleanup work exists |
+| `recurring` | `{}` | static recurring task definitions keyed by name |
+| `database_alias` | `"default"` | database alias for queue tables and runtime activity |
+| `preserve_finished_jobs` | `true` | keep successful jobs for result lookup and retention cleanup |
+| `clear_finished_jobs_after` | `86400` | seconds before finished successful jobs are cleaned up |
+| `clear_failed_jobs_after` | `null` | optional failed-job retention window in seconds |
+| `clear_recurring_executions_after` | `null` | optional recurring reservation retention window in seconds |
+| `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 |
+
+Worker entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `queues` | `"*"` | queue selector or selectors; `"*"` means all queues |
+| `threads` | `3` | worker threads per worker process |
+| `processes` | `1` | worker processes in `fork` mode; normalized to `1` in `async` mode |
+| `polling_interval` | `0.1` | seconds between worker polls |
+
+Dispatcher entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `batch_size` | `500` | maximum scheduled or blocked rows to promote per batch |
+| `polling_interval` | `1` | seconds between dispatcher polls |
+| `concurrency_maintenance` | `true` | run expired semaphore and blocked-job maintenance |
+| `concurrency_maintenance_interval` | `600` | seconds between maintenance passes; `0` means every poll |
+
+Scheduler entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `dynamic_tasks_enabled` | `false` | load dynamic recurring tasks from the database |
+| `polling_interval` | `5` | seconds between scheduler polls |
+
+Recurring entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `task_path` | none | required dotted import path for the task to enqueue |
+| `schedule` | none | required cron or supported Fugit-style cronish schedule |
+| `args` | `[]` | positional arguments for the task |
+| `kwargs` | `{}` | keyword arguments for the task |
+| `queue_name` | `"default"` | queue used for jobs created from this recurring task |
+| `priority` | `0` | priority used for jobs created from this recurring task |
+| `description` | `""` | operator-facing description |
 
 On PostgreSQL, `listen_notify` uses the same Django PostgreSQL driver
 configuration as the main database connection. Install a compatible driver in

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/admin.py

@@ -29,13 +29,19 @@ from dj_queue.models import (
   Semaphore,
 )
 from dj_queue.operations.jobs import (
+  DispatchOutcome,
   discard_failed_job,
   dispatch_scheduled_job_now,
   enqueue_job_again,
   retry_failed_job,
   retry_failed_jobs,
 )
-from dj_queue.queue_state import status_rank_expression
+from dj_queue.queue_state import (
+  QUEUE_STATES,
+  filter_queue_state,
+  is_queue_state,
+  status_rank_expression,
+)
 
 
 class DjQueueFirstAdminSite(admin.AdminSite):
@@ -328,29 +334,12 @@ class JobStatusListFilter(admin.SimpleListFilter):
   parameter_name = "status"
 
   def lookups(self, request, model_admin):
-    return (
-      ("ready", "ready"),
-      ("scheduled", "scheduled"),
-      ("claimed", "claimed"),
-      ("blocked", "blocked"),
-      ("failed", "failed"),
-      ("finished", "finished"),
-    )
+    return QUEUE_STATES
 
   def queryset(self, request, queryset):
     value = self.value()
-    if value == "ready":
-      return queryset.ready()
-    if value == "scheduled":
-      return queryset.scheduled()
-    if value == "claimed":
-      return queryset.claimed()
-    if value == "blocked":
-      return queryset.blocked()
-    if value == "failed":
-      return queryset.failed()
-    if value == "finished":
-      return queryset.finished()
+    if is_queue_state(value):
+      return filter_queue_state(queryset, value)
     return queryset
 
 
@@ -590,15 +579,17 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
   def handle_change_action(self, request, obj, action):
     if action == "run_now":
       try:
-        _job, dispatched_as = dispatch_scheduled_job_now(obj.pk, backend_alias=obj.backend_alias)
+        _job, dispatch_outcome = dispatch_scheduled_job_now(
+          obj.pk, backend_alias=obj.backend_alias
+        )
       except (EnqueueError, ImportError, AttributeError) 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)
 
       message = "Dispatched scheduled job for immediate execution"
-      if dispatched_as == "blocked":
+      if dispatch_outcome is DispatchOutcome.BLOCKED:
         message = "Dispatched scheduled job immediately and it is now blocked"
-      if dispatched_as == "discarded":
+      if dispatch_outcome is DispatchOutcome.DISCARDED:
         message = "Dispatched scheduled job immediately and it was discarded"
       self.message_user(request, message, level=messages.SUCCESS)
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)

dj_queue-0.9.2/dj_queue/backend.py

@@ -0,0 +1,91 @@
+from asgiref.sync import sync_to_async
+from django.db import close_old_connections, connections
+from django.tasks.backends.base import BaseTaskBackend
+from django.tasks.exceptions import TaskResultDoesNotExist
+
+from dj_queue.db import get_database_alias
+from dj_queue.models import Job
+from dj_queue.operations.jobs import (
+  DispatchOutcome,
+  enqueue_job_with_dispatch,
+  enqueue_jobs_bulk,
+  validate_queue_allowed,
+)
+from dj_queue.task_results import task_result_from_enqueued_job, task_result_from_job
+
+
+class DjQueueBackend(BaseTaskBackend):
+  supports_async_task = True
+  supports_defer = True
+  supports_get_result = True
+  supports_priority = True
+
+  def validate_task(self, task):
+    validate_queue_allowed(task.queue_name, backend_alias=self.alias)
+    return super().validate_task(task)
+
+  def enqueue(self, task, args, kwargs):
+    self.validate_task(task)
+    job, dispatch_outcome = enqueue_job_with_dispatch(task, args, kwargs, backend_alias=self.alias)
+    return task_result_from_enqueued_job(
+      job,
+      task,
+      successful=dispatch_outcome is DispatchOutcome.DISCARDED,
+    )
+
+  async def aenqueue(self, task, args, kwargs):
+    return await sync_to_async(_async_backend_call, thread_sensitive=True)(
+      self.enqueue,
+      task=task,
+      args=args,
+      kwargs=kwargs,
+    )
+
+  def enqueue_all(self, task_calls):
+    jobs = []
+    for task, args, kwargs in task_calls:
+      self.validate_task(task)
+      jobs.append((task, args, kwargs))
+
+    created_jobs = enqueue_jobs_bulk(jobs, backend_alias=self.alias)
+    return [
+      task_result_from_enqueued_job(
+        job,
+        task,
+        successful=dispatch_outcome is DispatchOutcome.DISCARDED,
+      )
+      for job, task, dispatch_outcome in created_jobs
+    ]
+
+  def get_result(self, result_id):
+    alias = get_database_alias(self.alias)
+    try:
+      job = (
+        Job.objects.using(alias)
+        .select_related(
+          "ready_execution",
+          "scheduled_execution",
+          "claimed_execution__process",
+          "blocked_execution",
+          "failed_execution",
+        )
+        .get(pk=result_id, backend_alias=self.alias)
+      )
+    except Job.DoesNotExist as exc:
+      raise TaskResultDoesNotExist(str(result_id)) from exc
+
+    return task_result_from_job(job)
+
+  async def aget_result(self, result_id):
+    return await sync_to_async(_async_backend_call, thread_sensitive=True)(
+      self.get_result,
+      result_id=result_id,
+    )
+
+
+def _async_backend_call(method, /, **kwargs):
+  close_old_connections()
+  try:
+    return method(**kwargs)
+  finally:
+    connections.close_all()

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/dashboard.py

@@ -22,7 +22,13 @@ from dj_queue.operations.jobs import (
   enqueue_job_again,
   retry_failed_jobs,
 )
-from dj_queue.queue_state import QUEUE_STATE_LABELS, QUEUE_STATES, queue_state_queryset
+from dj_queue.queue_state import (
+  QUEUE_STATE_DEFINITIONS,
+  QUEUE_STATE_LABELS,
+  QUEUE_STATES,
+  queue_state_count_key,
+  queue_state_queryset,
+)
 
 
 QUEUE_JOB_ACTIONS = {
@@ -56,12 +62,14 @@ OVERVIEW_SORTS = {
     "default": "name",
     "fields": {
       "name": {"label": "name", "key": "name", "default_desc": False, "css_class": "djq-col-name"},
-      "ready": {"label": "ready", "key": "ready_count", "default_desc": True},
-      "claimed": {"label": "claimed", "key": "claimed_count", "default_desc": True},
-      "scheduled": {"label": "scheduled", "key": "scheduled_count", "default_desc": True},
-      "blocked": {"label": "blocked", "key": "blocked_count", "default_desc": True},
-      "failed": {"label": "failed", "key": "failed_count", "default_desc": True},
-      "finished": {"label": "finished", "key": "finished_count", "default_desc": True},
+      **{
+        definition.name: {
+          "label": definition.label,
+          "key": definition.count_key,
+          "default_desc": True,
+        }
+        for definition in QUEUE_STATE_DEFINITIONS
+      },
       "paused": {"label": "paused", "key": "paused", "default_desc": True},
       "latency": {"label": "latency", "key": "latency_seconds", "default_desc": True},
       "workers": {"label": "workers", "key": "live_worker_count", "default_desc": True},
@@ -368,7 +376,7 @@ def queue_page_context(*, backend_alias, queue_name, state, page_number, query_p
   )
   queue_info = QueueInfo(queue_name, backend_alias=backend_alias)
   state_counts = {
-    state_name: queue_row[f"{state_name}_count"] for state_name, _label in QUEUE_STATES
+    definition.name: queue_row[definition.count_key] for definition in QUEUE_STATE_DEFINITIONS
   }
   state_tabs = [
     {
@@ -529,10 +537,10 @@ def job_actions_for_state(state):
 
 def _summary_cards(*, backend_alias, queue_rows, process_rows, recurring_rows, semaphore_rows):
   paused_count = sum(1 for row in queue_rows if row["paused"])
-  ready_count = sum(row["ready_count"] for row in queue_rows)
-  scheduled_count = sum(row["scheduled_count"] for row in queue_rows)
-  failed_count = sum(row["failed_count"] for row in queue_rows)
-  blocked_count = sum(row["blocked_count"] for row in queue_rows)
+  ready_count = sum(row[queue_state_count_key("ready")] for row in queue_rows)
+  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)
   live_processes = sum(1 for row in process_rows if row["is_live"])
   stale_processes = len(process_rows) - live_processes
 

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/log.py

@@ -6,6 +6,17 @@ 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
+  return logger.isEnabledFor(level)
+
+
 def log_event(
   event: str,
   *,
@@ -14,7 +25,7 @@ def log_event(
   polling: bool = False,
   **fields: Any,
 ):
-  if polling and load_backend_config(backend_alias).silence_polling:
+  if not event_logging_enabled(level, backend_alias=backend_alias, polling=polling):
     return
 
   logger.log(

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/metrics.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 from dj_queue import observability
+from dj_queue.queue_state import QUEUE_STATE_DEFINITIONS
 
 
 @dataclass(frozen=True, slots=True)
@@ -38,11 +39,11 @@ def metric_families(*, snapshots=None):
     runner_metrics = snapshot["runner_metrics"]
 
     for queue in snapshot["queue_rows"]:
-      for state in ("ready", "claimed", "scheduled", "blocked", "failed", "finished"):
+      for definition in QUEUE_STATE_DEFINITIONS:
         queue_jobs.append(
           MetricSample(
-            labels=(backend_alias, queue["name"], state),
-            value=queue[f"{state}_count"],
+            labels=(backend_alias, queue["name"], definition.name),
+            value=queue[definition.count_key],
           )
         )
       queue_paused.append(

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/observability.py

@@ -25,7 +25,8 @@ from dj_queue.models import (
   ScheduledExecution,
   Semaphore,
 )
-from dj_queue.queue_state import queue_state_counts
+from dj_queue.queue_selectors import queue_matches_selectors
+from dj_queue.queue_state import queue_state_count_fields, queue_state_counts
 
 
 @dataclass(frozen=True, slots=True)
@@ -294,14 +295,20 @@ def queue_snapshot(
   if oldest_ready_at is not None and paused is False:
     latency_seconds = max((now - oldest_ready_at).total_seconds(), 0.0)
 
+  state_count_fields = queue_state_count_fields(
+    {
+      "ready": ready_count,
+      "claimed": claimed_count,
+      "scheduled": scheduled_count,
+      "blocked": blocked_count,
+      "failed": failed_count,
+      "finished": finished_count,
+    }
+  )
+
   return {
     "name": queue_name,
-    "ready_count": ready_count,
-    "claimed_count": claimed_count,
-    "scheduled_count": scheduled_count,
-    "blocked_count": blocked_count,
-    "failed_count": failed_count,
-    "finished_count": finished_count,
+    **state_count_fields,
     "paused": paused,
     "latency_seconds": latency_seconds,
     "oldest_scheduled_at": oldest_scheduled_at,
@@ -309,7 +316,7 @@ def queue_snapshot(
     "live_worker_count": sum(
       1
       for worker in live_workers
-      if queue_matches_selectors(queue_name, worker.metadata.get("queues", []))
+      if queue_matches_selectors(queue_name, worker.metadata.get("queues") or ("*",))
     ),
   }
 
@@ -419,21 +426,6 @@ def next_run_at(schedule, now):
   return next_cron_run(schedule, now)
 
 
-def queue_matches_selectors(queue_name, selectors):
-  normalized = tuple(selectors or ())
-  if normalized in ((), ("*",)):
-    return True
-
-  for selector in normalized:
-    if selector == "*":
-      return True
-    if selector.endswith("*") and queue_name.startswith(selector[:-1]):
-      return True
-    if selector == queue_name:
-      return True
-  return False
-
-
 def _live_processes_for_backend(*, alias, backend_alias, kind, process_cutoff):
   return [
     process

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/operations/_helpers.py

@@ -28,6 +28,13 @@ def _lock_active_pauses(alias, backend_alias, queue_names=None):
   return set(queryset.values_list("queue_name", flat=True))
 
 
+def _exclude_active_pauses(queryset, alias, backend_alias):
+  paused_queue_names = (
+    Pause.objects.using(alias).filter(backend_alias=backend_alias).values("queue_name")
+  )
+  return queryset.exclude(queue_name__in=paused_queue_names)
+
+
 def _ready_execution_row(
   job,
   *,

{dj_queue-0.9.1 → dj_queue-0.9.2}/dj_queue/operations/concurrency.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 
 from django.db import connections, transaction
-from django.db.models import F
+from django.db.models import Case, F, IntegerField, When
 from django.utils import timezone
 from django.utils.module_loading import import_string
 
@@ -104,17 +104,23 @@ def _mysql_family_semaphore_acquire(alias, key, *, limit, expires_at, now):
 
 def semaphore_release(key, *, duration_seconds, backend_alias="default"):
   alias = get_database_alias(backend_alias)
-  expires_at = timezone.now() + timedelta(seconds=duration_seconds)
+  now = timezone.now()
+  expires_at = now + timedelta(seconds=duration_seconds)
 
-  with transaction.atomic(using=alias):
-    semaphore = Semaphore.objects.using(alias).select_for_update().filter(key=key).first()
-    if semaphore is None:
-      return False
-
-    semaphore.value = min(semaphore.limit, semaphore.value + 1)
-    semaphore.expires_at = expires_at
-    semaphore.save(using=alias, update_fields=["value", "expires_at", "updated_at"])
-    return True
+  updated = (
+    Semaphore.objects.using(alias)
+    .filter(key=key)
+    .update(
+      value=Case(
+        When(value__gte=F("limit"), then=F("limit")),
+        default=F("value") + 1,
+        output_field=IntegerField(),
+      ),
+      expires_at=expires_at,
+      updated_at=now,
+    )
+  )
+  return updated > 0
 
 
 def concurrency_settings(task, *, backend_alias):