django-tasks-google 0.1.0__tar.gz

django_tasks_google-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 @novucs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_tasks_google-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: django-tasks-google
+Version: 0.1.0
+Summary: Django's Task Framework backends for: Cloud Tasks, Cloud Scheduler, and Cloud Run Jobs
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: django>=6.0.0
+Requires-Dist: google-cloud-run>=0.1.0
+Requires-Dist: google-cloud-scheduler>=2.0.0
+Requires-Dist: google-cloud-tasks>=2.0.0
+Dynamic: license-file

django_tasks_google-0.1.0/README.md

@@ -0,0 +1,120 @@
+# django-tasks-google
+
+**django-tasks-google** provides seamless integration between Django's Task Framework and
+Google Cloud's serverless infrastructure.
+
+### Supported Backends
+
+* **Cloud Tasks:** For asynchronous task execution with retries and rate limiting.
+* **Cloud Scheduler:** For cron-style scheduled jobs and recurring tasks.
+* **Cloud Run Jobs:** For long-running or resource-intensive background processing.
+
+## Installation
+
+Install the package via `pip`:
+
+```bash
+pip install django-tasks-google
+```
+
+## Quick Start
+
+### 1. Register the Application
+
+Add `django_tasks_google` to your `INSTALLED_APPS` in `settings.py`:
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "django_tasks_google",
+]
+```
+
+### 2. Configure Task Backends
+
+Define your task execution strategy within the `TASKS` setting. You can mix and match backends based on your
+architectural needs.
+
+```python
+# settings.py
+TASKS = {
+    "default": {
+        "BACKEND": "django_tasks_google.backends.CloudTasksBackend",
+        "QUEUES": [],
+        "OPTIONS": {
+            "project_id": "YOUR_PROJECT_ID",
+            "location": "us-central1",
+            "target_url": "https://your-app.run.app/tasks/execute/",
+            "oidc_service_account": "task-invoker@YOUR_PROJECT_ID.iam.gserviceaccount.com",
+        },
+    },
+    "jobs": {
+        "BACKEND": "django_tasks_google.backends.CloudRunJobsBackend",
+        "QUEUES": [],
+        "OPTIONS": {
+            "project_id": "YOUR_PROJECT_ID",
+            "location": "us-central1",
+        },
+    },
+    "scheduler": {
+        "BACKEND": "django_tasks_google.backends.CloudSchedulerBackend",
+        "QUEUES": [],
+        "OPTIONS": {
+            "project_id": "YOUR_PROJECT_ID",
+            "location": "us-central1",
+            "target_url": "https://your-app.run.app/tasks/execute/",
+            "oidc_service_account": "task-invoker@YOUR_PROJECT_ID.iam.gserviceaccount.com",
+        },
+    },
+}
+```
+
+No IAM roles are needed for the `oidc_service_account`. The backend is designed
+to work with public Cloud Run services by performing manual OIDC token
+verification. This ensures that even though the endpoint is publicly accessible,
+only requests signed by your specific service account can trigger task execution.
+
+### 3. Register the task execution URLs
+
+```python
+# urls.py
+from django.urls import path, include
+
+urlpatterns = [
+    # ...
+    path('tasks/', include('django_tasks_google.urls')),
+]
+```
+
+### 4. Define tasks
+
+```python
+# tasks.py
+from django.tasks import task
+from django_tasks_google.scheduler import schedule_task
+
+
+@task(queue_name="your-cloud-task-queue")
+def send_notification(user_id):
+    user = User.objects.get(id=user_id)
+    # ...
+    return f"Notification sent to {user.email}"
+
+
+@task(backend="jobs", queue_name="your-cloud-run-job")
+def compute_meaning_of_life():
+    # ... long running process ...
+    return 42
+
+
+@task(backend="scheduler")  # "queue_name" will be populated with the scheduled task job name
+def send_daily_newsletter(email):
+    user = User.objects.get(email=email)
+    # ...
+    return f"Newsletter sent to {user.email}"
+
+
+# Creates a job on Google Cloud Scheduler.
+schedule_task(send_daily_newsletter, "0 */3 * * *", args=["user@example.com"])
+```

django_tasks_google-0.1.0/django_tasks_google/admin.py

@@ -0,0 +1,181 @@
+import importlib
+import inspect
+import re
+
+from django import forms
+from django.apps import apps
+from django.contrib import admin, messages
+from django.core.exceptions import ValidationError
+
+from django_tasks_google.models import ScheduledTask
+from django_tasks_google.scheduler import delete_remote_scheduled_task
+
+
+def get_task_choices():
+    choices = []
+    for app_config in apps.get_app_configs():
+        try:
+            module = importlib.import_module(f"{app_config.name}.tasks")
+            for name, obj in inspect.getmembers(module):
+                is_task_decorated = (
+                    hasattr(obj, "task")
+                    or hasattr(obj, "_is_task")
+                    or type(obj).__name__ == "Task"
+                )
+                if is_task_decorated:
+                    path = f"{app_config.name}.tasks.{name}"
+                    choices.append((path, path))
+        except ImportError:
+            continue
+    return [("", "---------")] + sorted(choices)
+
+
+class ScheduledTaskAdminForm(forms.ModelForm):
+    name = forms.CharField(
+        help_text="Name can only contain alphanumeric characters, hyphens '-' and underscores '_'"
+    )
+    task_selector = forms.ChoiceField(
+        choices=[],
+        required=False,
+        label="Select Task (Optional)",
+        help_text="Pick a task here OR type a custom path below.",
+    )
+    schedule = forms.CharField(
+        help_text=(
+            "Schedules are specified using unix-cron format. "
+            'E.g. every minute: "* * * * *", every 3 hours: "0 */3 * * *", every Monday at 9:00: "0 9 * * 1".'
+        )
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["task_selector"].choices = [
+            ("", "--- Manual Entry ---")
+        ] + get_task_choices()
+        self.fields["module_path"].required = False
+        self.fields["cloud_scheduler_job_name"].required = False
+
+    class Meta:
+        model = ScheduledTask
+        fields = "__all__"
+        widgets = {
+            "name": forms.TextInput(
+                attrs={"style": "width: 400px;", "placeholder": "task-name-here"}
+            ),
+            "module_path": forms.TextInput(attrs={"style": "width: 400px;"}),
+            "backend": forms.TextInput(attrs={"style": "width: 200px;"}),
+            "schedule": forms.TextInput(attrs={"placeholder": "*/5 * * * *"}),
+            "time_zone": forms.TextInput(attrs={"placeholder": "UTC"}),
+            "cloud_scheduler_job_name": forms.TextInput(
+                attrs={"style": "width: 400px;"}
+            ),
+            "description": forms.Textarea(attrs={"rows": 3, "cols": 40}),
+            "args": forms.Textarea(attrs={"rows": 3, "cols": 40}),
+            "kwargs": forms.Textarea(attrs={"rows": 3, "cols": 40}),
+        }
+
+    def clean(self):
+        cleaned_data = super().clean()
+        selector_val = cleaned_data.get("task_selector")
+        if selector_val:
+            cleaned_data["module_path"] = selector_val
+        if not cleaned_data["module_path"]:
+            raise ValidationError("Either task selector or module path must be set")
+        return cleaned_data
+
+    def clean_name(self):
+        name = self.cleaned_data.get("name")
+        if not re.match(r"^[a-zA-Z0-9_-]+$", name):
+            raise ValidationError(
+                "Name can only contain alphanumeric characters, hyphens '-', and underscores '_'."
+            )
+        return name
+
+    def clean_args(self):
+        data = self.cleaned_data.get("args")
+        if data in [None, ""]:
+            return []
+        if not isinstance(data, list):
+            raise ValidationError(
+                "Arguments must be a valid JSON list (e.g., [1, 'test'])."
+            )
+        return data
+
+    def clean_kwargs(self):
+        data = self.cleaned_data.get("kwargs")
+        if data in [None, ""]:
+            return {}
+        if not isinstance(data, dict):
+            raise ValidationError(
+                'Keyword arguments must be a valid JSON object (e.g., {"key": "value"}).'
+            )
+        return data
+
+
+@admin.register(ScheduledTask)
+class ScheduledTaskAdmin(admin.ModelAdmin):
+    form = ScheduledTaskAdminForm
+
+    list_display = ("name", "state", "schedule", "time_zone", "backend")
+    list_filter = ("state", "backend", "time_zone")
+    search_fields = ("name", "module_path", "description")
+    fieldsets = (
+        ("General Info", {"fields": ("name", "description", "state")}),
+        (
+            "Execution Details",
+            {"fields": ("task_selector", "module_path", "backend", "takes_context")},
+        ),
+        (
+            "Parameters",
+            {
+                "fields": ("args", "kwargs"),
+                "description": "JSON formatted arguments for the task.",
+            },
+        ),
+        (
+            "Scheduling",
+            {"fields": ("schedule", "time_zone", "cloud_scheduler_job_name")},
+        ),
+    )
+    actions = ["sync_tasks"]
+
+    @admin.action(description="Sync selected tasks with Cloud Scheduler")
+    def sync_tasks(self, request, queryset):
+        for task in queryset:
+            try:
+                task.sync()
+                self.message_user(
+                    request, f"Successfully synced '{task.name}'", messages.SUCCESS
+                )
+            except Exception as e:
+                self.message_user(
+                    request, f"Failed to sync '{task.name}': {str(e)}", messages.ERROR
+                )
+
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+        try:
+            obj.sync()
+        except Exception as e:
+            self.message_user(
+                request, f"Model saved but sync failed: {e}", messages.WARNING
+            )
+
+    def delete_model(self, request, obj):
+        self._cleanup_cloud_scheduler(request, obj)
+        super().delete_model(request, obj)
+
+    def delete_queryset(self, request, queryset):
+        for obj in queryset:
+            self._cleanup_cloud_scheduler(request, obj)
+        super().delete_queryset(request, queryset)
+
+    def _cleanup_cloud_scheduler(self, request, task):
+        try:
+            delete_remote_scheduled_task(task)
+        except Exception as e:
+            self.message_user(
+                request,
+                f"Cloud Scheduler deletion failed for {task.name}: {e}",
+                messages.WARNING,
+            )

django_tasks_google-0.1.0/django_tasks_google/backends.py

@@ -0,0 +1,150 @@
+import json
+
+from django.core.exceptions import ImproperlyConfigured
+from django.tasks.backends.base import BaseTaskBackend
+from django.tasks.signals import task_enqueued
+
+from django_tasks_google.models import TaskExecution
+
+
+class CloudRunJobsBackend(BaseTaskBackend):
+    supports_defer = False
+    supports_async_task = True
+    supports_get_result = True
+    supports_priority = False
+
+    def __init__(self, alias, params):
+        super().__init__(alias, params)
+        self.project_id = self.options.get("project_id")
+        self.location = self.options.get("location")
+        if not self.project_id:
+            raise ImproperlyConfigured("project_id is required")
+        if not self.location:
+            raise ImproperlyConfigured("location is required")
+
+    def enqueue(self, task, args, kwargs):
+        from google.cloud import run_v2
+
+        self.validate_task(task)
+        execution = TaskExecution.objects.create(
+            priority=task.priority,
+            module_path=task.module_path,
+            backend=self.alias,
+            queue_name=task.queue_name,
+            run_after=task.run_after,
+            takes_context=task.takes_context,
+            args=list(args),
+            kwargs=dict(kwargs),
+        )
+        client = run_v2.JobsClient()
+        request = run_v2.RunJobRequest(
+            name=f"projects/{self.project_id}/locations/{self.location}/jobs/{task.queue_name}",  # type: ignore
+            overrides=run_v2.RunJobRequest.Overrides(  # type: ignore
+                container_overrides=[  # type: ignore
+                    run_v2.RunJobRequest.Overrides.ContainerOverride(
+                        args=["python", "manage.py", "execute_task", str(execution.pk)]  # type: ignore
+                    )
+                ]
+            ),
+        )
+        operation = client.run_job(request=request)
+        execution.cloud_run_job_execution_name = operation.metadata.name
+        execution.save(update_fields=["cloud_run_job_execution_name"])
+        task_result = execution.task_result
+        task_enqueued.send(sender=type(self), task_result=task_result)
+        return task_result
+
+    def get_result(self, result_id):
+        return TaskExecution.objects.get(pk=result_id).task_result
+
+
+class CloudTasksBackend(BaseTaskBackend):
+    supports_defer = True
+    supports_async_task = True
+    supports_get_result = True
+    supports_priority = False
+
+    def __init__(self, alias, params):
+        super().__init__(alias, params)
+        self.project_id = self.options.get("project_id")
+        self.location = self.options.get("location")
+        self.target_url = self.options.get("target_url")
+        self.oidc_service_account = self.options.get("oidc_service_account")
+        if not self.project_id:
+            raise ImproperlyConfigured("project_id is required")
+        if not self.location:
+            raise ImproperlyConfigured("location is required")
+        if not self.target_url:
+            raise ImproperlyConfigured("target_url is required")
+        if not self.oidc_service_account:
+            raise ImproperlyConfigured("oidc_service_account is required")
+
+    def enqueue(self, task, args, kwargs):
+        from google.cloud import tasks_v2
+        from google.protobuf import timestamp_pb2
+
+        self.validate_task(task)
+        execution = TaskExecution.objects.create(
+            priority=task.priority,
+            module_path=task.module_path,
+            backend=self.alias,
+            queue_name=task.queue_name,
+            run_after=task.run_after,
+            takes_context=task.takes_context,
+            args=list(args),
+            kwargs=dict(kwargs),
+        )
+        client = tasks_v2.CloudTasksClient()
+        payload = {"backend": self.alias, "task_execution_id": execution.pk}
+        cloud_task_definition = tasks_v2.Task(
+            http_request=tasks_v2.HttpRequest(  # type: ignore
+                http_method=tasks_v2.HttpMethod.POST,  # type: ignore
+                url=self.target_url,
+                headers={"Content-Type": "application/json"},
+                body=json.dumps(payload).encode(),  # type: ignore
+                oidc_token=tasks_v2.OidcToken(  # type: ignore
+                    service_account_email=self.oidc_service_account,
+                    audience=self.target_url,
+                ),
+            ),
+        )
+
+        if task.run_after:
+            schedule_time = timestamp_pb2.Timestamp()
+            schedule_time.FromDatetime(task.run_after)
+            cloud_task_definition["schedule_time"] = schedule_time
+
+        cloud_task = client.create_task(
+            parent=f"projects/{self.project_id}/locations/{self.location}/queues/{task.queue_name}",
+            task=cloud_task_definition,
+        )
+        execution.cloud_task_name = cloud_task.name
+        execution.save(update_fields=["cloud_task_name"])
+        task_result = execution.task_result
+        task_enqueued.send(sender=type(self), task_result=task_result)
+        return task_result
+
+
+class CloudSchedulerBackend(BaseTaskBackend):
+    supports_defer = False
+    supports_async_task = True
+    supports_get_result = False
+    supports_priority = False
+
+    def __init__(self, alias, params):
+        super().__init__(alias, params)
+        self.project_id = self.options.get("project_id")
+        self.location = self.options.get("location")
+        self.target_url = self.options.get("target_url")
+        self.oidc_service_account = self.options.get("oidc_service_account")
+        if not self.project_id:
+            raise ImproperlyConfigured("project_id is required")
+        if not self.location:
+            raise ImproperlyConfigured("location is required")
+        if not self.target_url:
+            raise ImproperlyConfigured("target_url is required")
+        if not self.oidc_service_account:
+            raise ImproperlyConfigured("oidc_service_account is required")
+
+    def enqueue(self, task, args, kwargs):
+        raise NotImplementedError("This task my only be enqueued by Cloud Scheduler")

django_tasks_google-0.1.0/django_tasks_google/executor.py

@@ -0,0 +1,60 @@
+import logging
+from traceback import format_exception
+
+from django.db import close_old_connections
+from django.tasks import task_backends
+from django.tasks.base import TaskContext, TaskResultStatus
+from django.tasks.signals import task_finished, task_started
+from django.utils import timezone
+
+from django_tasks_google.models import TaskExecution
+
+logger = logging.getLogger("django_tasks_google")
+
+
+def execute_task(execution: TaskExecution):
+    worker_id = timezone.now().isoformat()
+
+    logger.info(f"Running {execution}")
+    sender = type(task_backends[execution.backend])
+    execution.last_attempted_at = timezone.now()
+    execution.status = TaskResultStatus.RUNNING
+    execution.worker_ids.append(worker_id)
+
+    if not execution.started_at:
+        execution.started_at = execution.last_attempted_at
+        execution.save()
+        task_started.send(sender=sender, task_result=execution.task_result)
+    else:
+        execution.save()
+
+    try:
+        args = execution.args
+        if execution.takes_context:
+            args = (TaskContext(task_result=execution.task_result), *args)
+        return_value = execution.task.call(*args, **execution.kwargs)
+
+        close_old_connections()
+        execution.finished_at = timezone.now()
+        execution.status = TaskResultStatus.SUCCESSFUL
+        execution.return_value = return_value
+        execution.save()
+        logger.info(f"Completed {execution}")
+        task_finished.send(sender=sender, task_result=execution.task_result)
+        return True
+
+    except Exception as e:
+        close_old_connections()
+        execution.finished_at = timezone.now()
+        execution.status = TaskResultStatus.FAILED
+        exception_type = type(e)
+        execution.errors.append(
+            {
+                "exception_class_path": f"{exception_type.__module__}.{exception_type.__qualname__}",
+                "traceback": "".join(format_exception(e)),
+            }
+        )
+        execution.save()
+        logger.exception(f"An error occurred during {execution}")
+        task_finished.send(sender=sender, task_result=execution.task_result)
+        return False

django_tasks_google-0.1.0/django_tasks_google/management/commands/execute_task.py

@@ -0,0 +1,14 @@
+from django.core.management.base import BaseCommand, CommandError
+
+from django_tasks_google.executor import execute_task
+from django_tasks_google.models import TaskExecution
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument("task_execution_id", type=str)
+
+    def handle(self, *args, **options):
+        execution = TaskExecution.objects.get(pk=options["task_execution_id"])
+        if not execute_task(execution):
+            raise CommandError("Task execution failed")

django_tasks_google-0.1.0/django_tasks_google/management/commands/sync_scheduled_tasks.py

@@ -0,0 +1,8 @@
+from django.core.management.base import BaseCommand
+
+from django_tasks_google.scheduler import sync_scheduled_tasks
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        sync_scheduled_tasks()

django_tasks_google-0.1.0/django_tasks_google/migrations/0001_initial.py

@@ -0,0 +1,92 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="ScheduledTask",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.TextField(unique=True)),
+                ("description", models.TextField(blank=True, default="")),
+                ("module_path", models.TextField()),
+                ("backend", models.TextField(default="scheduler")),
+                ("takes_context", models.BooleanField(default=False)),
+                ("args", models.JSONField(blank=True, default=list)),
+                ("kwargs", models.JSONField(blank=True, default=dict)),
+                ("schedule", models.TextField()),
+                ("time_zone", models.TextField(default="UTC")),
+                ("cloud_scheduler_job_name", models.TextField(null=True, unique=True)),
+                (
+                    "state",
+                    models.TextField(
+                        choices=[("enabled", "Enabled"), ("disabled", "Disabled")],
+                        default="enabled",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="TaskExecution",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("priority", models.IntegerField(default=0)),
+                ("module_path", models.TextField()),
+                ("backend", models.TextField(default="default")),
+                ("queue_name", models.TextField(default="default")),
+                ("run_after", models.DateTimeField(null=True)),
+                ("takes_context", models.BooleanField(default=False)),
+                ("args", models.JSONField(default=list)),
+                ("kwargs", models.JSONField(default=dict)),
+                (
+                    "status",
+                    models.TextField(
+                        choices=[
+                            ("READY", "Ready"),
+                            ("RUNNING", "Running"),
+                            ("FAILED", "Failed"),
+                            ("SUCCESSFUL", "Successful"),
+                        ],
+                        default="READY",
+                    ),
+                ),
+                ("enqueued_at", models.DateTimeField(auto_now_add=True)),
+                ("started_at", models.DateTimeField(null=True)),
+                ("finished_at", models.DateTimeField(null=True)),
+                ("last_attempted_at", models.DateTimeField(null=True)),
+                ("errors", models.JSONField(default=list)),
+                ("worker_ids", models.JSONField(default=list)),
+                ("return_value", models.JSONField(null=True)),
+                ("cancelled_at", models.DateTimeField(null=True)),
+                (
+                    "cloud_run_job_execution_name",
+                    models.TextField(null=True, unique=True),
+                ),
+                ("cloud_task_name", models.TextField(null=True, unique=True)),
+                (
+                    "cloud_scheduler_idempotency_key",
+                    models.TextField(null=True, unique=True),
+                ),
+            ],
+        ),
+    ]

django_tasks_google-0.1.0/django_tasks_google/models.py

@@ -0,0 +1,133 @@
+from django.db import models
+from django.tasks import (
+    TaskResultStatus,
+    Task,
+    TaskResult,
+    DEFAULT_TASK_QUEUE_NAME,
+    task_backends,
+    DEFAULT_TASK_BACKEND_ALIAS,
+)
+from django.tasks.base import TaskError, DEFAULT_TASK_PRIORITY
+from django.utils import timezone
+from django.utils.module_loading import import_string
+
+
+class ScheduledTask(models.Model):
+    class State(models.TextChoices):
+        ENABLED = "enabled"
+        DISABLED = "disabled"
+
+    name = models.TextField(unique=True)
+    description = models.TextField(blank=True, default="")
+    module_path = models.TextField()
+    backend = models.TextField(default="scheduler")
+    takes_context = models.BooleanField(default=False)
+    args = models.JSONField(default=list, blank=True)
+    kwargs = models.JSONField(default=dict, blank=True)
+
+    schedule = models.TextField()
+    time_zone = models.TextField(default="UTC")
+    cloud_scheduler_job_name = models.TextField(null=True, unique=True)
+    state = models.TextField(choices=State, default=State.ENABLED)
+
+    def sync(self):
+        from django_tasks_google.scheduler import sync_scheduled_task
+
+        sync_scheduled_task(self)
+
+
+class TaskExecution(models.Model):
+    priority = models.IntegerField(default=DEFAULT_TASK_PRIORITY)
+    module_path = models.TextField()
+    backend = models.TextField(default=DEFAULT_TASK_BACKEND_ALIAS)
+    queue_name = models.TextField(default=DEFAULT_TASK_QUEUE_NAME)
+    run_after = models.DateTimeField(null=True)
+    takes_context = models.BooleanField(default=False)
+
+    args = models.JSONField(default=list)
+    kwargs = models.JSONField(default=dict)
+
+    status = models.TextField(
+        choices=TaskResultStatus,
+        default=TaskResultStatus.READY.value,
+    )
+    enqueued_at = models.DateTimeField(auto_now_add=True)
+    started_at = models.DateTimeField(null=True)
+    finished_at = models.DateTimeField(null=True)
+    last_attempted_at = models.DateTimeField(null=True)
+    errors = models.JSONField(default=list)
+    worker_ids = models.JSONField(default=list)
+
+    return_value = models.JSONField(null=True)
+
+    cancelled_at = models.DateTimeField(null=True)
+    cloud_run_job_execution_name = models.TextField(null=True, unique=True)
+    cloud_task_name = models.TextField(null=True, unique=True)
+    cloud_scheduler_idempotency_key = models.TextField(null=True, unique=True)
+
+    def __str__(self):
+        idempotency_key = (
+            self.cloud_run_job_execution_name
+            or self.cloud_task_name
+            or self.cloud_scheduler_idempotency_key
+        )
+        return f"[{self.status.upper()}] {idempotency_key} (#{self.pk}) at {self.enqueued_at:%Y-%m-%d %H:%M}"
+
+    @property
+    def task(self) -> Task:
+        return Task(
+            priority=DEFAULT_TASK_PRIORITY,
+            func=import_string(self.module_path).func,
+            backend=self.backend,
+            queue_name=self.queue_name,
+            run_after=self.run_after,
+            takes_context=self.takes_context,
+        )
+
+    @property
+    def task_result(self) -> TaskResult:
+        task_result = TaskResult(
+            task=self.task,
+            id=str(self.pk),
+            status=self.status,
+            enqueued_at=self.enqueued_at,
+            started_at=self.started_at,
+            finished_at=self.finished_at,
+            last_attempted_at=self.last_attempted_at,
+            args=self.args,
+            kwargs=self.kwargs,
+            backend=self.backend,
+            errors=self.task_errors,
+            worker_ids=self.worker_ids,
+        )
+        object.__setattr__(task_result, "_return_value", self.return_value)
+        return task_result
+
+    @property
+    def task_errors(self) -> list[TaskError]:
+        return [
+            TaskError(
+                exception_class_path=error["exception_class_path"],
+                traceback=error["traceback"],
+            )
+            for error in self.errors
+        ]
+
+    @property
+    def backend_class(self):
+        return task_backends[self.backend]
+
+    def cancel(self):
+        if not self.cloud_run_job_execution_name:
+            raise NotImplementedError("Only Cloud Run Jobs may be cancelled")
+
+        from google.cloud import run_v2
+
+        client = run_v2.ExecutionsClient()
+        client.cancel_execution(
+            run_v2.CancelExecutionRequest(name=self.cloud_run_job_execution_name)
+        )
+        self.cancelled_at = timezone.now()
+        self.finished_at = self.cancelled_at
+        self.status = TaskResultStatus.FAILED
+        self.save(update_fields=["cancelled_at", "finished_at", "status"])

django_tasks_google-0.1.0/django_tasks_google/scheduler.py

@@ -0,0 +1,103 @@
+import json
+
+from django.db import transaction
+from django.tasks import Task, task_backends
+
+from django_tasks_google.models import ScheduledTask
+
+
+def schedule_task(
+    task: Task,
+    schedule: str,
+    *,
+    name: str = "",
+    description: str = "",
+    backend: str = "scheduler",
+    takes_context: bool = False,
+    args: list | None = None,
+    kwargs: dict | None = None,
+    time_zone: str = "UTC",
+    enabled: bool = True,
+) -> ScheduledTask:
+    with transaction.atomic():
+        scheduled_task = ScheduledTask.objects.create(
+            name=name,
+            description=description,
+            module_path=task.module_path,
+            backend=task_backends[backend].alias,
+            takes_context=takes_context,
+            args=args or [],
+            kwargs=kwargs or {},
+            schedule=schedule,
+            time_zone=time_zone,
+            state=ScheduledTask.State.ENABLED
+            if enabled
+            else ScheduledTask.State.DISABLED,
+        )
+        scheduled_task.sync()
+    return scheduled_task
+
+
+def sync_scheduled_tasks():
+    for task in ScheduledTask.objects.all():
+        sync_scheduled_task(task)
+
+
+def sync_scheduled_task(task: ScheduledTask):
+    from google.api_core.exceptions import NotFound
+    from google.cloud import scheduler_v1
+
+    client = scheduler_v1.CloudSchedulerClient()
+    backend = task_backends[task.backend]
+    parent = f"projects/{backend.project_id}/locations/{backend.location}"
+    job_name = f"{parent}/jobs/{task.name}"
+    payload = {"backend": task.backend}
+    job = scheduler_v1.Job(
+        name=job_name,  # type: ignore
+        description=task.description,
+        schedule=task.schedule,
+        time_zone=task.time_zone,
+        http_target=scheduler_v1.HttpTarget(  # type: ignore
+            http_method=scheduler_v1.HttpMethod.POST,  # type: ignore
+            uri=backend.target_url,
+            headers={"Content-Type": "application/json"},
+            body=json.dumps(payload).encode(),  # type: ignore
+            oidc_token=scheduler_v1.OidcToken(  # type: ignore
+                service_account_email=backend.oidc_service_account,
+                audience=backend.target_url,
+            ),
+        ),
+    )
+
+    job_exists = False
+    try:
+        client.get_job(name=job_name)
+        job_exists = True
+    except NotFound:
+        pass
+
+    if job_exists:
+        update_mask = {"paths": ["description", "schedule", "time_zone", "http_target"]}
+        job = client.update_job(job=job, update_mask=update_mask)  # type: ignore
+    else:
+        job = client.create_job(parent=parent, job=job)
+
+    if job_name != task.cloud_scheduler_job_name:
+        task.cloud_scheduler_job_name = job_name
+        task.save(update_fields=["cloud_scheduler_job_name"])
+    if job.state != job.State.ENABLED and task.state == task.State.ENABLED:
+        client.resume_job(name=job_name)
+    if job.state != job.State.DISABLED and task.state == task.State.DISABLED:
+        client.pause_job(name=job_name)
+
+
+def delete_remote_scheduled_task(task: ScheduledTask):
+    from google.api_core.exceptions import NotFound
+    from google.cloud import scheduler_v1
+
+    client = scheduler_v1.CloudSchedulerClient()
+    if task.cloud_scheduler_job_name:
+        try:
+            client.delete_job(name=task.cloud_scheduler_job_name)
+        except NotFound:
+            pass

django_tasks_google-0.1.0/django_tasks_google/tasks.py

@@ -0,0 +1,6 @@
+from django.tasks import task
+
+
+@task
+def do_stuff():
+    pass

django_tasks_google-0.1.0/django_tasks_google/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from django_tasks_google.views import execute_task_view
+
+app_name = "django_tasks_google"
+
+urlpatterns = [
+    path("execute/", execute_task_view, name="execute_task"),
+]

django_tasks_google-0.1.0/django_tasks_google/views.py

@@ -0,0 +1,106 @@
+import json
+import logging
+from json import JSONDecodeError
+
+from django.db import transaction
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404
+from django.tasks import task_backends, InvalidTaskBackend
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
+
+from django_tasks_google.executor import execute_task
+from django_tasks_google.models import TaskExecution, ScheduledTask
+
+
+logger = logging.getLogger("django_tasks_google")
+
+
+def handle_oidc_auth(request, audience, email):
+    from google.auth.transport import requests as google_requests
+    from google.oauth2 import id_token
+
+    auth_header = request.headers.get("Authorization", "")
+    if not auth_header.startswith("Bearer "):
+        return False, "Missing or invalid Authorization header"
+
+    token = auth_header[7:]
+    try:
+        claims = id_token.verify_oauth2_token(
+            token, google_requests.Request(), audience=audience
+        )
+        if claims.get("email") != email:
+            return False, f"Unexpected caller email: {claims.get('email')}"
+        if claims.get("email_verified") is not True:
+            return False, "Caller email is not verified"
+        return True, None
+    except Exception as e:
+        logger.error(f"OIDC token verification failed: {e}")
+        return False, str(e)
+
+
+@require_POST
+@csrf_exempt
+@transaction.non_atomic_requests
+def execute_task_view(request):
+    try:
+        data = json.loads(request.body)
+        backend = task_backends[data["backend"]]
+    except (JSONDecodeError, KeyError, InvalidTaskBackend) as e:
+        logger.warning(f"Cannot verify backend: {e}")
+        return JsonResponse(
+            {
+                "error": "Unauthorized",
+                "detail": f"Cannot verify backend: {request.body}",
+            },
+            status=401,
+        )
+    is_valid, error_message = handle_oidc_auth(
+        request,
+        audience=backend.target_url,
+        email=backend.oidc_service_account,
+    )
+    if not is_valid:
+        logger.warning(f"Authentication failed: {error_message}")
+        return JsonResponse(
+            {"error": "Unauthorized", "detail": error_message},
+            status=401,
+        )
+
+    if request.headers.get("X-CloudScheduler"):
+        job_name = request.headers["X-CloudScheduler-JobName"]
+        schedule_time = request.headers["X-CloudScheduler-ScheduleTime"]
+        cloud_scheduler_idempotency_key = f"{job_name}:{schedule_time}"
+        execution = TaskExecution.objects.filter(
+            cloud_scheduler_idempotency_key=cloud_scheduler_idempotency_key,
+        ).first()
+        if not execution:
+            task = get_object_or_404(
+                ScheduledTask, name=job_name, backend=backend.alias
+            )
+            execution = TaskExecution.objects.create(
+                module_path=task.module_path,
+                backend=task.backend,
+                queue_name=task.name,
+                takes_context=task.takes_context,
+                args=task.args,
+                kwargs=task.kwargs,
+                cloud_scheduler_idempotency_key=cloud_scheduler_idempotency_key,
+            )
+    else:
+        execution = get_object_or_404(
+            TaskExecution, pk=data["task_execution_id"], backend=backend.alias
+        )
+
+    ok = execute_task(execution)
+    return JsonResponse(
+        {
+            "id": execution.pk,
+            "status": execution.status.value,
+            "errors": execution.errors,
+            "args": execution.args,
+            "kwargs": execution.kwargs,
+            "return_value": execution.return_value,
+        },
+        status=200 if ok else 500,
+    )

django_tasks_google-0.1.0/django_tasks_google.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: django-tasks-google
+Version: 0.1.0
+Summary: Django's Task Framework backends for: Cloud Tasks, Cloud Scheduler, and Cloud Run Jobs
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: django>=6.0.0
+Requires-Dist: google-cloud-run>=0.1.0
+Requires-Dist: google-cloud-scheduler>=2.0.0
+Requires-Dist: google-cloud-tasks>=2.0.0
+Dynamic: license-file

django_tasks_google-0.1.0/django_tasks_google.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+django_tasks_google/__init__.py
+django_tasks_google/admin.py
+django_tasks_google/backends.py
+django_tasks_google/executor.py
+django_tasks_google/models.py
+django_tasks_google/scheduler.py
+django_tasks_google/tasks.py
+django_tasks_google/urls.py
+django_tasks_google/views.py
+django_tasks_google.egg-info/PKG-INFO
+django_tasks_google.egg-info/SOURCES.txt
+django_tasks_google.egg-info/dependency_links.txt
+django_tasks_google.egg-info/requires.txt
+django_tasks_google.egg-info/top_level.txt
+django_tasks_google/management/__init__.py
+django_tasks_google/management/commands/__init__.py
+django_tasks_google/management/commands/execute_task.py
+django_tasks_google/management/commands/sync_scheduled_tasks.py
+django_tasks_google/migrations/0001_initial.py
+django_tasks_google/migrations/__init__.py

django_tasks_google-0.1.0/django_tasks_google.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_tasks_google-0.1.0/django_tasks_google.egg-info/requires.txt

@@ -0,0 +1,4 @@
+django>=6.0.0
+google-cloud-run>=0.1.0
+google-cloud-scheduler>=2.0.0
+google-cloud-tasks>=2.0.0

django_tasks_google-0.1.0/django_tasks_google.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_tasks_google

django_tasks_google-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "django-tasks-google"
+version = "0.1.0"
+description = "Django's Task Framework backends for: Cloud Tasks, Cloud Scheduler, and Cloud Run Jobs"
+requires-python = ">=3.12"
+dependencies = [
+    "django>=6.0.0",
+    "google-cloud-run>=0.1.0",
+    "google-cloud-scheduler>=2.0.0",
+    "google-cloud-tasks>=2.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.7",
+]

django_tasks_google-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+