django-database-task 0.1.0__py3-none-any.whl

django_database_task/locale/ja/LC_MESSAGES/django.po

@@ -0,0 +1,170 @@
+# Japanese translations for django-database-task.
+# Copyright (C) 2025 Shinya Okano
+# This file is distributed under the same license as the django-database-task package.
+# Shinya Okano <tokibito@gmail.com>, 2025.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: django-database-task 0.1.0\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-12-27 07:13+0000\n"
+"PO-Revision-Date: 2025-12-27 00:00+0000\n"
+"Last-Translator: Shinya Okano <tokibito@gmail.com>\n"
+"Language-Team: Japanese\n"
+"Language: ja\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#: django_database_task/admin.py:116
+msgid "Run selected tasks"
+msgstr "選択したタスクを実行"
+
+#: django_database_task/admin.py:159
+msgid "Retry failed tasks"
+msgstr "失敗したタスクを再実行"
+
+#: django_database_task/models.py:14
+msgid "task path"
+msgstr "タスクパス"
+
+#: django_database_task/models.py:15
+msgid "Module path of the task function"
+msgstr "タスク関数のモジュールパス"
+
+#: django_database_task/models.py:20
+msgid "queue name"
+msgstr "キュー名"
+
+#: django_database_task/models.py:21
+msgid "Queue name"
+msgstr "キュー名"
+
+#: django_database_task/models.py:25
+msgid "priority"
+msgstr "優先度"
+
+#: django_database_task/models.py:26
+msgid "Priority (-100 to 100)"
+msgstr "優先度 (-100 から 100)"
+
+#: django_database_task/models.py:30
+msgid "arguments"
+msgstr "引数"
+
+#: django_database_task/models.py:31
+msgid "Arguments (JSON format)"
+msgstr "引数 (JSON形式)"
+
+#: django_database_task/models.py:35
+msgid "keyword arguments"
+msgstr "キーワード引数"
+
+#: django_database_task/models.py:36
+msgid "Keyword arguments (JSON format)"
+msgstr "キーワード引数 (JSON形式)"
+
+#: django_database_task/models.py:42
+msgid "status"
+msgstr "ステータス"
+
+#: django_database_task/models.py:43
+msgid "Task status"
+msgstr "タスクのステータス"
+
+#: django_database_task/models.py:48
+msgid "run after"
+msgstr "実行開始日時"
+
+#: django_database_task/models.py:49
+msgid "Earliest execution time"
+msgstr "最も早い実行日時"
+
+#: django_database_task/models.py:52
+msgid "enqueued at"
+msgstr "キュー登録日時"
+
+#: django_database_task/models.py:53
+msgid "Time when task was enqueued"
+msgstr "タスクがキューに登録された日時"
+
+#: django_database_task/models.py:58
+msgid "started at"
+msgstr "開始日時"
+
+#: django_database_task/models.py:59
+msgid "Execution start time"
+msgstr "実行開始日時"
+
+#: django_database_task/models.py:64
+msgid "finished at"
+msgstr "終了日時"
+
+#: django_database_task/models.py:65
+msgid "Execution end time"
+msgstr "実行終了日時"
+
+#: django_database_task/models.py:70
+msgid "last attempted at"
+msgstr "最終試行日時"
+
+#: django_database_task/models.py:71
+msgid "Last attempt time"
+msgstr "最終試行日時"
+
+#: django_database_task/models.py:76
+msgid "return value"
+msgstr "戻り値"
+
+#: django_database_task/models.py:77
+msgid "Return value (JSON format)"
+msgstr "戻り値 (JSON形式)"
+
+#: django_database_task/models.py:81
+msgid "errors"
+msgstr "エラー"
+
+#: django_database_task/models.py:82
+msgid "Error information (JSON format)"
+msgstr "エラー情報 (JSON形式)"
+
+#: django_database_task/models.py:86
+msgid "worker IDs"
+msgstr "ワーカーID"
+
+#: django_database_task/models.py:87
+msgid "List of worker IDs (JSON format)"
+msgstr "ワーカーIDのリスト (JSON形式)"
+
+#: django_database_task/models.py:91
+msgid "backend name"
+msgstr "バックエンド名"
+
+#: django_database_task/models.py:92
+msgid "Backend name"
+msgstr "バックエンド名"
+
+#: django_database_task/models.py:96
+msgid "created at"
+msgstr "作成日時"
+
+#: django_database_task/models.py:97
+msgid "Record creation time"
+msgstr "レコード作成日時"
+
+#: django_database_task/models.py:101
+msgid "updated at"
+msgstr "更新日時"
+
+#: django_database_task/models.py:102
+msgid "Record update time"
+msgstr "レコード更新日時"
+
+#: django_database_task/models.py:116
+msgid "database task"
+msgstr "データベースタスク"
+
+#: django_database_task/models.py:117
+msgid "database tasks"
+msgstr "データベースタスク"

django_database_task/management/commands/purge_completed_database_tasks.py

@@ -0,0 +1,88 @@
+from datetime import timedelta
+
+from django.core.management.base import BaseCommand
+from django.tasks.base import TaskResultStatus
+from django.utils import timezone
+
+from django_database_task.models import DatabaseTask
+
+
+class Command(BaseCommand):
+    help = "Delete completed task records from the database"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--days",
+            type=int,
+            default=0,
+            help="Delete tasks completed more than N days ago (0=all, default: 0)",
+        )
+        parser.add_argument(
+            "--status",
+            type=str,
+            default="SUCCESSFUL,FAILED",
+            help="Target statuses, comma-separated (default: SUCCESSFUL,FAILED)",
+        )
+        parser.add_argument(
+            "--batch-size",
+            type=int,
+            default=1000,
+            help="Number of tasks to delete at once (default: 1000)",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show count only without deleting",
+        )
+
+    def handle(self, *args, **options):
+        days = options["days"]
+        status_str = options["status"]
+        batch_size = options["batch_size"]
+        dry_run = options["dry_run"]
+
+        # Parse statuses
+        statuses = [s.strip().upper() for s in status_str.split(",")]
+        valid_statuses = [TaskResultStatus.SUCCESSFUL, TaskResultStatus.FAILED]
+        statuses = [s for s in statuses if s in [v.value for v in valid_statuses]]
+
+        if not statuses:
+            self.stdout.write(self.style.ERROR("No valid statuses specified"))
+            return
+
+        self.stdout.write(f"Target statuses: {', '.join(statuses)}")
+
+        # Build query
+        queryset = DatabaseTask.objects.filter(status__in=statuses)
+
+        if days > 0:
+            cutoff_date = timezone.now() - timedelta(days=days)
+            queryset = queryset.filter(finished_at__lt=cutoff_date)
+            self.stdout.write(f"Cutoff date: {cutoff_date}")
+
+        total_count = queryset.count()
+        self.stdout.write(f"Found {total_count} tasks to delete")
+
+        if dry_run:
+            self.stdout.write(self.style.WARNING("Dry run mode - no tasks deleted"))
+            return
+
+        if total_count == 0:
+            self.stdout.write("No tasks to delete")
+            return
+
+        # Batch delete
+        deleted_total = 0
+        while True:
+            # Get batch of IDs and delete
+            task_ids = list(queryset.values_list("id", flat=True)[:batch_size])
+            if not task_ids:
+                break
+
+            deleted_count, _ = DatabaseTask.objects.filter(id__in=task_ids).delete()
+            deleted_total += deleted_count
+            self.stdout.write(f"Deleted {deleted_total}/{total_count} tasks...")
+
+        self.stdout.write(
+            self.style.SUCCESS(f"Successfully deleted {deleted_total} tasks")
+        )

django_database_task/management/commands/run_database_tasks.py

@@ -0,0 +1,98 @@
+import socket
+import time
+import uuid
+
+from django.core.management.base import BaseCommand
+from django.tasks import task_backends
+from django.tasks.base import TaskResultStatus
+
+from django_database_task.executor import fetch_task
+
+
+class Command(BaseCommand):
+    help = "Execute tasks queued in the database"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--queue",
+            type=str,
+            default=None,
+            help="Queue name to process (all queues if not specified)",
+        )
+        parser.add_argument(
+            "--backend",
+            type=str,
+            default="default",
+            help="Backend name (default: default)",
+        )
+        parser.add_argument(
+            "--continuous",
+            action="store_true",
+            help="Continuous mode (keep polling even when no tasks)",
+        )
+        parser.add_argument(
+            "--interval",
+            type=float,
+            default=5.0,
+            help="Polling interval in seconds for continuous mode (default: 5)",
+        )
+        parser.add_argument(
+            "--max-tasks",
+            type=int,
+            default=0,
+            help="Maximum number of tasks to process (0=unlimited, default: 0)",
+        )
+
+    def handle(self, *args, **options):
+        queue_name = options["queue"]
+        backend_name = options["backend"]
+        continuous = options["continuous"]
+        interval = options["interval"]
+        max_tasks = options["max_tasks"]
+
+        worker_id = f"{socket.gethostname()}-{uuid.uuid4().hex[:8]}"
+        self.stdout.write(f"Worker ID: {worker_id}")
+        self.stdout.write(f"Backend: {backend_name}")
+        if queue_name:
+            self.stdout.write(f"Queue: {queue_name}")
+        if continuous:
+            self.stdout.write(f"Continuous mode: interval={interval}s")
+        if max_tasks:
+            self.stdout.write(f"Max tasks: {max_tasks}")
+
+        backend = task_backends[backend_name]
+        tasks_processed = 0
+
+        while True:
+            task = fetch_task(queue_name=queue_name, backend_name=backend_name)
+
+            if task is None:
+                if continuous:
+                    self.stdout.write(".", ending="")
+                    self.stdout.flush()
+                    time.sleep(interval)
+                    continue
+                else:
+                    self.stdout.write("No more tasks to process.")
+                    break
+
+            self.stdout.write(f"\nProcessing task: {task.id} ({task.task_path})")
+
+            try:
+                result = backend.run_task(task, worker_id=worker_id)
+                if result.status == TaskResultStatus.SUCCESSFUL:
+                    self.stdout.write(
+                        self.style.SUCCESS("  Task completed successfully")
+                    )
+                else:
+                    self.stdout.write(self.style.ERROR("  Task failed"))
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"  Error running task: {e}"))
+
+            tasks_processed += 1
+
+            if max_tasks and tasks_processed >= max_tasks:
+                self.stdout.write(f"\nReached max tasks limit: {max_tasks}")
+                break
+
+        self.stdout.write(f"\nTotal tasks processed: {tasks_processed}")

django_database_task/migrations/0001_initial.py

@@ -0,0 +1,190 @@
+# Generated by Django 6.0 on 2025-12-27 06:51
+
+import uuid
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="DatabaseTask",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                (
+                    "task_path",
+                    models.CharField(
+                        help_text="Module path of the task function",
+                        max_length=512,
+                        verbose_name="task path",
+                    ),
+                ),
+                (
+                    "queue_name",
+                    models.CharField(
+                        default="default",
+                        help_text="Queue name",
+                        max_length=255,
+                        verbose_name="queue name",
+                    ),
+                ),
+                (
+                    "priority",
+                    models.IntegerField(
+                        default=0,
+                        help_text="Priority (-100 to 100)",
+                        verbose_name="priority",
+                    ),
+                ),
+                (
+                    "args_json",
+                    models.JSONField(
+                        default=list,
+                        help_text="Arguments (JSON format)",
+                        verbose_name="arguments",
+                    ),
+                ),
+                (
+                    "kwargs_json",
+                    models.JSONField(
+                        default=dict,
+                        help_text="Keyword arguments (JSON format)",
+                        verbose_name="keyword arguments",
+                    ),
+                ),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("READY", "Ready"),
+                            ("RUNNING", "Running"),
+                            ("FAILED", "Failed"),
+                            ("SUCCESSFUL", "Successful"),
+                        ],
+                        default="READY",
+                        help_text="Task status",
+                        max_length=20,
+                        verbose_name="status",
+                    ),
+                ),
+                (
+                    "run_after",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Earliest execution time",
+                        null=True,
+                        verbose_name="run after",
+                    ),
+                ),
+                (
+                    "enqueued_at",
+                    models.DateTimeField(
+                        help_text="Time when task was enqueued",
+                        verbose_name="enqueued at",
+                    ),
+                ),
+                (
+                    "started_at",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Execution start time",
+                        null=True,
+                        verbose_name="started at",
+                    ),
+                ),
+                (
+                    "finished_at",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Execution end time",
+                        null=True,
+                        verbose_name="finished at",
+                    ),
+                ),
+                (
+                    "last_attempted_at",
+                    models.DateTimeField(
+                        blank=True,
+                        help_text="Last attempt time",
+                        null=True,
+                        verbose_name="last attempted at",
+                    ),
+                ),
+                (
+                    "return_value_json",
+                    models.JSONField(
+                        blank=True,
+                        help_text="Return value (JSON format)",
+                        null=True,
+                        verbose_name="return value",
+                    ),
+                ),
+                (
+                    "errors_json",
+                    models.JSONField(
+                        default=list,
+                        help_text="Error information (JSON format)",
+                        verbose_name="errors",
+                    ),
+                ),
+                (
+                    "worker_ids_json",
+                    models.JSONField(
+                        default=list,
+                        help_text="List of worker IDs (JSON format)",
+                        verbose_name="worker IDs",
+                    ),
+                ),
+                (
+                    "backend_name",
+                    models.CharField(
+                        help_text="Backend name",
+                        max_length=255,
+                        verbose_name="backend name",
+                    ),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        auto_now_add=True,
+                        help_text="Record creation time",
+                        verbose_name="created at",
+                    ),
+                ),
+                (
+                    "updated_at",
+                    models.DateTimeField(
+                        auto_now=True,
+                        help_text="Record update time",
+                        verbose_name="updated at",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "database task",
+                "verbose_name_plural": "database tasks",
+                "ordering": ["-priority", "enqueued_at"],
+                "indexes": [
+                    models.Index(
+                        fields=["status", "run_after", "priority"],
+                        name="ddt_status_run_priority_idx",
+                    ),
+                    models.Index(fields=["queue_name"], name="ddt_queue_name_idx"),
+                    models.Index(fields=["status"], name="ddt_status_idx"),
+                    models.Index(fields=["created_at"], name="ddt_created_at_idx"),
+                ],
+            },
+        ),
+    ]

django_database_task/models.py

@@ -0,0 +1,120 @@
+import uuid
+
+from django.db import models
+from django.tasks.base import TaskResultStatus
+from django.utils.translation import gettext_lazy as _
+
+
+class DatabaseTask(models.Model):
+    """Task model persisted in the database."""
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    task_path = models.CharField(
+        max_length=512,
+        verbose_name=_("task path"),
+        help_text=_("Module path of the task function"),
+    )
+    queue_name = models.CharField(
+        max_length=255,
+        default="default",
+        verbose_name=_("queue name"),
+        help_text=_("Queue name"),
+    )
+    priority = models.IntegerField(
+        default=0,
+        verbose_name=_("priority"),
+        help_text=_("Priority (-100 to 100)"),
+    )
+    args_json = models.JSONField(
+        default=list,
+        verbose_name=_("arguments"),
+        help_text=_("Arguments (JSON format)"),
+    )
+    kwargs_json = models.JSONField(
+        default=dict,
+        verbose_name=_("keyword arguments"),
+        help_text=_("Keyword arguments (JSON format)"),
+    )
+    status = models.CharField(
+        max_length=20,
+        choices=TaskResultStatus.choices,
+        default=TaskResultStatus.READY,
+        verbose_name=_("status"),
+        help_text=_("Task status"),
+    )
+    run_after = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name=_("run after"),
+        help_text=_("Earliest execution time"),
+    )
+    enqueued_at = models.DateTimeField(
+        verbose_name=_("enqueued at"),
+        help_text=_("Time when task was enqueued"),
+    )
+    started_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name=_("started at"),
+        help_text=_("Execution start time"),
+    )
+    finished_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name=_("finished at"),
+        help_text=_("Execution end time"),
+    )
+    last_attempted_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name=_("last attempted at"),
+        help_text=_("Last attempt time"),
+    )
+    return_value_json = models.JSONField(
+        null=True,
+        blank=True,
+        verbose_name=_("return value"),
+        help_text=_("Return value (JSON format)"),
+    )
+    errors_json = models.JSONField(
+        default=list,
+        verbose_name=_("errors"),
+        help_text=_("Error information (JSON format)"),
+    )
+    worker_ids_json = models.JSONField(
+        default=list,
+        verbose_name=_("worker IDs"),
+        help_text=_("List of worker IDs (JSON format)"),
+    )
+    backend_name = models.CharField(
+        max_length=255,
+        verbose_name=_("backend name"),
+        help_text=_("Backend name"),
+    )
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        verbose_name=_("created at"),
+        help_text=_("Record creation time"),
+    )
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        verbose_name=_("updated at"),
+        help_text=_("Record update time"),
+    )
+
+    class Meta:
+        ordering = ["-priority", "enqueued_at"]
+        indexes = [
+            models.Index(
+                fields=["status", "run_after", "priority"],
+                name="ddt_status_run_priority_idx",
+            ),
+            models.Index(fields=["queue_name"], name="ddt_queue_name_idx"),
+            models.Index(fields=["status"], name="ddt_status_idx"),
+            models.Index(fields=["created_at"], name="ddt_created_at_idx"),
+        ]
+        verbose_name = _("database task")
+        verbose_name_plural = _("database tasks")
+
+    def __str__(self):
+        return f"{self.task_path} ({self.status}) - {self.id}"