django-admin-background-task 0.4.1__tar.gz → 0.4.4__tar.gz

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-admin-background-task
-Version: 0.4.1
+Version: 0.4.4
 Summary: A set of tools for django apps to persist and monitor the status of background tasks
 Home-page: https://github.com/daphtdazz/django-bgtask
 License: Apache-2.0

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/bgtask/model_admin.py

@@ -103,7 +103,7 @@ class BGTaskModelAdmin(admin.ModelAdmin):
         if not task_name_to_desc:
             return BackgroundTask.objects.none()
 
-        bgts = list(
+        bgts = (
             BackgroundTask.objects.filter(
                 name__in=task_name_to_desc, namespace=self._bgtask_namespace
             )
@@ -123,6 +123,7 @@ class BGTaskModelAdmin(admin.ModelAdmin):
             )
             .order_by("-started_at", "-queued_at")
         )
+        bgts.add_position_in_queue()
         for bgt in bgts:
             bgt.admin_description = task_name_to_desc[bgt.name]
 

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/bgtask/models.py

@@ -1,4 +1,4 @@
-import functools
+import collections
 import logging
 import os
 import time
@@ -8,63 +8,52 @@ from contextlib import contextmanager
 
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
-from django.db import models, transaction
+from django.db import models
 from django.forms.models import model_to_dict
 from django.utils import timezone
 
 from model_utils import Choices
 
-
-log = logging.getLogger(__name__)
+from .utils import locked, only_if_state, q_or
 
 
-def locked(meth):
-    @functools.wraps(meth)
-    def _locked_meth(self, *args, **kwargs):
-        if getattr(self, "_locked", False):
-            return meth(self, *args, **kwargs)
+log = logging.getLogger(__name__)
 
-        with transaction.atomic():
-            BackgroundTask.objects.filter(id=self.id).select_for_update().only("id").get()
-            self.refresh_from_db()
 
-            # Mark as locked in case we are called recursively
-            self._locked = True
-            try:
-                return meth(self, *args, **kwargs)
-            finally:
-                self._locked = False
+class BackgroundTaskQuerySet(models.QuerySet):
+    def add_position_in_queue(self):
+        """This evaluates the queryset and adds position_in_queue to each one (which requires
+        more DB queries).
+        """
+        recent_unqueued_task_by_nsn = {(task.namespace, task.name): None for task in self}
+        for ns, name in recent_unqueued_task_by_nsn:
+            recent_unqueued_task_by_nsn[(ns, name)] = BackgroundTask.most_recently_unqueued_task(
+                ns, name
+            )
 
-    return _locked_meth
+        queued_tasks_by_nsn = BackgroundTask.queued_tasks_in_order_by_nsn_like(self)
 
+        for task in self:
+            if task.state != task.STATES.queued:
+                continue
 
-def only_if_state(state, no_op_states=frozenset()):
-    def only_if_state_decorator(meth):
-        def only_if_state_wrapper(self, *args, no_op_if_already_in_state=False, **kwargs):
-            if self.state in no_op_states:
-                return
-            states = (state,) if isinstance(state, str) else tuple(state)
-            if self.state not in states:
-                raise RuntimeError(
-                    "%s cannot execute %s as in state %s not one of %s"
-                    % (self, meth.__name__, self.state, states)
-                )
-            return meth(self, *args, **kwargs)
+            unqueued_task = recent_unqueued_task_by_nsn[(task.namespace, task.name)]
+            if unqueued_task is not None and task.queued_at < unqueued_task.queued_at:
+                # More recently queued task has already been dispatched so we should be going...
+                task.position_in_queue = 0
+                continue
 
-        return only_if_state_wrapper
+            task.position_in_queue = 0
+            for queued_task in queued_tasks_by_nsn[(task.namespace, task.name)]:
+                if queued_task.queued_at >= task.queued_at:
+                    break
+                task.position_in_queue += 1
 
-    return only_if_state_decorator
+        return self
 
 
 class BackgroundTask(models.Model):
     id = models.UUIDField(primary_key=True, editable=False, default=uuid.uuid4)
-    name = models.CharField(
-        max_length=1000,
-        help_text=(
-            "Name (or type) of this task, is not unique "
-            "per task instance but generally per task functionality"
-        ),
-    )
     namespace = models.CharField(
         max_length=1000,
         default="",
@@ -74,6 +63,13 @@ class BackgroundTask(models.Model):
             "entire codebase, allowing them to be shorter and human readable"
         ),
     )
+    name = models.CharField(
+        max_length=1000,
+        help_text=(
+            "Name (or type) of this task, is not unique "
+            "per task instance but generally per task functionality"
+        ),
+    )
 
     STATES = Choices("not_started", "queued", "running", "success", "partial_success", "failed")
     state = models.CharField(max_length=16, default=STATES.not_started, choices=STATES)
@@ -102,16 +98,22 @@ class BackgroundTask(models.Model):
     created = models.DateTimeField(auto_now_add=True)
     updated = models.DateTimeField(auto_now=True)
 
+    objects = models.Manager.from_queryset(BackgroundTaskQuerySet)()
+
     class Meta:
         ordering = ["created", "id"]
 
+    # This needs to be added dynamically to model instances, and is done by
+    # BackgroundTaskQuerySet.add_position_in_queue()
+    position_in_queue = None
+
     @property
     def task_dict(self):
         task_dict = model_to_dict(self)
         return {
             "id": str(self.id),
             "updated": self.updated.isoformat(),
-            "position_in_queue": self.get_position_in_queue(),
+            "position_in_queue": self.position_in_queue,
             **task_dict,
         }
 
@@ -123,27 +125,27 @@ class BackgroundTask(models.Model):
     def incomplete(self):
         return self.state in [self.STATES.not_started, self.STATES.running]
 
-    def get_position_in_queue(self):
-        if self.state != self.STATES.queued:
-            return None
+    @classmethod
+    def most_recently_unqueued_task(cls, namespace, name):
+        return (
+            cls.objects.filter(queued_at__isnull=False, namespace=namespace, name=name)
+            .exclude(state=cls.STATES.not_started)
+            .exclude(state=cls.STATES.queued)
+            .order_by("-queued_at")
+            .first()
+        )
 
-        if (
-            BackgroundTask.objects.filter(
-                queued_at__gt=self.queued_at,
-            )
-            .exclude(state=self.STATES.not_started)
-            .exclude(state=self.STATES.queued)
-            .exists()
+    @classmethod
+    def queued_tasks_in_order_by_nsn_like(cls, tasks):
+        queued_by_nsn = collections.defaultdict(list)
+        nsns = {(task.namespace, task.name) for task in tasks}
+        for task in (
+            cls.objects.filter(queued_at__isnull=False, state=cls.STATES.queued)
+            .filter(q_or(models.Q(namespace=nsn[0], name=nsn[1]) for nsn in nsns))
+            .order_by("queued_at")
         ):
-            # More recent tasks have started, assume we're next (either that or we're stuck)
-            return 0
-
-        # Otherwise approximate queue position as the number of tasks that were queued before us
-        # and are still in the queue. So if there is nothing in front of us we are 0 in the queue.
-        assert self.queued_at
-        return BackgroundTask.objects.filter(
-            queued_at__lt=self.queued_at, state=self.STATES.queued
-        ).count()
+            queued_by_nsn[(task.namespace, task.name)].append(task)
+        return queued_by_nsn
 
     def set_steps_to_complete(self, steps_to_complete):
         self.steps_to_complete = steps_to_complete
@@ -199,7 +201,7 @@ class BackgroundTask(models.Model):
         self.save()
 
     @locked
-    @only_if_state(STATES.running)
+    @only_if_state((STATES.queued, STATES.running))
     def fail(self, exc):
         """Call to indicate a complete and final failure of the task"""
         log.info("Background Task failed: %s %s", self.id, exc)

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/bgtask/templates/bgtask/admin/change_list.html

@@ -12,7 +12,7 @@
   {% if not admin_bg_tasks|length %}
   <p class="help" style="font-style: italic;">No recent background tasks</p>
   {% else %}
-  <table>
+  <table style="max-height: 300px; display: block; overflow-y: scroll;">
     <thead>
       <tr><th>Task name</th><th>Started</th><th>Finished</th><th>Status</th></tr>
     </thead>

django_admin_background_task-0.4.4/bgtask/utils.py

@@ -0,0 +1,56 @@
+import functools
+import operator
+from typing import Iterable
+
+from django.db import models, transaction
+
+
+# https://stackoverflow.com/questions/29900386/how-to-construct-django-q-object-matching-none
+Q_NONE = models.Q(pk__in=[])
+
+
+def q_or(q_objects: Iterable[models.Q]):
+    """Chain an iterable of Q with OR.
+
+    The more Q()s are passed, the more things are filtered in, so it
+    makes sense if nothing is passed nothing is filtered in.
+    """
+    return functools.reduce(operator.or_, q_objects, models.Q()) or Q_NONE
+
+
+def locked(meth):
+    @functools.wraps(meth)
+    def _locked_meth(self, *args, **kwargs):
+        if getattr(self, "_locked", False):
+            return meth(self, *args, **kwargs)
+
+        with transaction.atomic():
+            type(self).objects.filter(id=self.id).select_for_update().only("id").get()
+            self.refresh_from_db()
+
+            # Mark as locked in case we are called recursively
+            self._locked = True
+            try:
+                return meth(self, *args, **kwargs)
+            finally:
+                self._locked = False
+
+    return _locked_meth
+
+
+def only_if_state(state, no_op_states=frozenset()):
+    def only_if_state_decorator(meth):
+        def only_if_state_wrapper(self, *args, no_op_if_already_in_state=False, **kwargs):
+            if self.state in no_op_states:
+                return
+            states = (state,) if isinstance(state, str) else tuple(state)
+            if self.state not in states:
+                raise RuntimeError(
+                    "%s cannot execute %s as in state %s not one of %s"
+                    % (self, meth.__name__, self.state, states)
+                )
+            return meth(self, *args, **kwargs)
+
+        return only_if_state_wrapper
+
+    return only_if_state_decorator

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/bgtask/views.py

@@ -1,6 +1,5 @@
 from django.core.exceptions import ValidationError
 from django.db.models import Q
-from django.forms.models import model_to_dict
 from django.http import Http404, HttpResponseBadRequest, JsonResponse
 from django.shortcuts import render
 
@@ -31,18 +30,12 @@ def background_tasks_view(request):
     tasks = request.GET.get("tasks", "")
     object_id = request.GET.get("object_id", None)
     if tasks is None and object_id is None:
-        return HttpResponseBadRequest(
-            "Must pass 'tasks' or 'object_id' as a query parameter"
-        )
+        return HttpResponseBadRequest("Must pass 'tasks' or 'object_id' as a query parameter")
+    task_ids = tasks.split(",")
+    task_ids_q = Q(id__in=task_ids) if tasks else Q_NONE
+    object_id_q = Q(acted_on_object_id=object_id) if object_id is not None else Q_NONE
+    tasks = BackgroundTask.objects.filter(task_ids_q | object_id_q).order_by("-created")
     try:
-        task_ids = tasks.split(",")
-        task_ids_q = Q(id__in=task_ids) if tasks else Q_NONE
-        object_id_q = (
-            Q(acted_on_object_id=object_id) if object_id is not None else Q_NONE
-        )
-        tasks = BackgroundTask.objects.filter(task_ids_q | object_id_q).order_by(
-            "-created"
-        )
         if len(tasks) == 0:
             raise ValidationError("Unfound tasks")
     except ValidationError:
@@ -52,6 +45,8 @@ def background_tasks_view(request):
 
     accepts = request.headers.get("Accept", "").split(",")
 
+    tasks.add_position_in_queue()
+
     if "application/json" in accepts:
         return background_tasks_view_json(tasks)
 

{django_admin_background_task-0.4.1 → django_admin_background_task-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "django-admin-background-task"
-version = "0.4.1"
+version = "0.4.4"
 description = "A set of tools for django apps to persist and monitor the status of background tasks"
 authors = [
     "David Park <david@greenparksoftware.co.uk>",
@@ -38,6 +38,7 @@ sphinx = ">=7.1.2"
 sphinx-rtd-theme = ">=1.3.0"
 psycopg2 = ">=2.9.10"
 colorlog = ">=6.9.0"
+flake8 = ">=7.1.1"
 
 [tool.poetry.extras]
 # ℹ️ if you update any of these, be sure to update "all = [...]" as well, so that it's easy to get