django-qstash 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

django_qstash/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.0.5"
+__version__ = "0.0.7"
 
 from .tasks import shared_task
 

django_qstash/callbacks.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from django_qstash.settings import DJANGO_QSTASH_DOMAIN
+from django_qstash.settings import DJANGO_QSTASH_WEBHOOK_PATH
+
+
+def get_callback_url() -> str:
+    """
+    Get the callback URL based on the settings.
+    """
+    callback_domain = DJANGO_QSTASH_DOMAIN.rstrip("/")
+    if not callback_domain.startswith(("http://", "https://")):
+        callback_domain = f"https://{callback_domain}"
+    webhook_path = DJANGO_QSTASH_WEBHOOK_PATH.strip("/")
+    return f"{callback_domain}/{webhook_path}/"

django_qstash/client.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from qstash import QStash
+
+from django_qstash.settings import QSTASH_TOKEN
+
+qstash_client = QStash(QSTASH_TOKEN)

django_qstash/discovery/fields.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from django import forms
+
+from django_qstash.discovery.utils import discover_tasks
+from django_qstash.discovery.validators import task_exists_validator
+
+
+class TaskChoiceField(forms.ChoiceField):
+    """
+    A form field that provides choices from discovered QStash tasks
+    """
+
+    def __init__(self, *args, **kwargs):
+        # Remove max_length if it's present since ChoiceField doesn't use it
+        kwargs.pop("max_length", None)
+
+        # Get tasks before calling parent to set choices
+        tasks = discover_tasks()
+
+        # Convert tasks to choices using (task_name, task_name) format
+        task_choices = [(task_value, task_label) for task_value, task_label in tasks]
+
+        kwargs["choices"] = task_choices
+        kwargs["validators"] = [task_exists_validator] + kwargs.get("validators", [])
+        super().__init__(*args, **kwargs)
+
+    def get_task(self):
+        """
+        Returns the actual task dot notation path for the selected value
+        """
+        if self.data:
+            tasks = discover_tasks()
+
+            for task_value, task_label in tasks:
+                if task_label == self.data:
+                    return task_value
+        return None

django_qstash/discovery/models.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from django.db import models
+
+from django_qstash.discovery.fields import TaskChoiceField
+
+
+class TaskField(models.CharField):
+    """
+    A model field for storing QStash task references
+    """
+
+    def __init__(self, *args, **kwargs):
+        # Set a reasonable max_length for task names if not provided
+        if "max_length" not in kwargs:
+            kwargs["max_length"] = 255
+        super().__init__(*args, **kwargs)
+
+    def formfield(self, **kwargs):
+        # Use our custom form field
+        defaults = {
+            "form_class": TaskChoiceField,
+        }
+        defaults.update(kwargs)
+        return super().formfield(**defaults)

django_qstash/discovery/utils.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import logging
+import os
+import warnings
+from functools import lru_cache
+from importlib import import_module
+
+from django.apps import apps
+from django.conf import settings
+from django.core.signals import request_started
+from django.utils.module_loading import module_has_submodule
+
+logger = logging.getLogger(__name__)
+
+DJANGO_QSTASH_DISCOVER_INCLUDE_SETTINGS_DIR = getattr(
+    settings, "DJANGO_QSTASH_DISCOVER_INCLUDE_SETTINGS_DIR", True
+)
+
+
+@lru_cache(maxsize=None)
+def discover_tasks() -> list[tuple[str, str]]:
+    """
+    Automatically discover tasks in Django apps and return them as a list of tuples.
+    Each tuple contains (dot_notation_path, task_name).
+    If no custom task name is specified, both values will be the dot notation path.
+
+    Returns:
+        List of tuples: [(dot_notation_path, task_name), ...]
+        Example: [
+            ('example_app.tasks.my_task', 'example_app.tasks.my_task'),
+            ('other_app.tasks.custom_task', 'special_name')
+        ]
+    """
+    from django_qstash.tasks import QStashTask
+
+    discovered_tasks = []
+    packages = []
+
+    # Add Django apps that contain tasks.py
+    for app_config in apps.get_app_configs():
+        if module_has_submodule(app_config.module, "tasks"):
+            packages.append(app_config.name)
+
+    # Add the directory containing settings.py if it has a tasks.py module
+    if DJANGO_QSTASH_DISCOVER_INCLUDE_SETTINGS_DIR:
+        settings_module = os.environ.get("DJANGO_SETTINGS_MODULE", "")
+        if settings_module:
+            settings_package = settings_module.rsplit(".", 1)[0]
+            try:
+                settings_module_obj = import_module(settings_package)
+                if module_has_submodule(settings_module_obj, "tasks"):
+                    packages.append(settings_package)
+            except ImportError:
+                warnings.warn(
+                    f"Could not import settings package {settings_package} for task discovery",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+
+    # Rest of the discovery logic
+    for package in packages:
+        try:
+            tasks_module = import_module(f"{package}.tasks")
+            # Find all attributes that are QstashTask instances
+            for attr_name in dir(tasks_module):
+                attr = getattr(tasks_module, attr_name)
+
+                if isinstance(attr, QStashTask):
+                    value = f"{package}.tasks.{attr_name}"
+                    if attr.name == attr_name:
+                        label = value
+                    else:
+                        label = f"{attr.name} ({value})"
+                    discovered_tasks.append((value, label))
+        except Exception as e:
+            warnings.warn(
+                f"Failed to import tasks from {package}: {str(e)}",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+    return discovered_tasks
+
+
+def clear_discover_tasks_cache(sender, **kwargs):
+    logger.info("Clearing Django QStash discovered tasks cache")
+    discover_tasks.cache_clear()
+
+
+request_started.connect(
+    clear_discover_tasks_cache,
+    dispatch_uid="clear_django_qstash_discovered_tasks_cache",
+)

django_qstash/discovery/validators.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django.core.exceptions import ValidationError
+
+from django_qstash.discovery.utils import discover_tasks
+
+
+def task_exists_validator(task_name):
+    """
+    Validates that a task name exists in the discovered tasks
+
+    Args:
+        task_name: The name of the task to validate
+
+    Raises:
+        ValidationError: If the task cannot be found
+    """
+    tasks = discover_tasks()
+    available_tasks = [task[0] for task in tasks]
+
+    if task_name not in available_tasks:
+        raise ValidationError(
+            f"Task '{task_name}' not found. Available tasks: {', '.join(available_tasks)}"
+        )

django_qstash/management/commands/task_schedules.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+import logging
+
+from django.apps import apps
+from django.core.management.base import BaseCommand
+from django.db import models
+
+from django_qstash.callbacks import get_callback_url
+from django_qstash.client import qstash_client
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """Management command to list and sync QStash schedules."""
+
+    help = "List and sync schedules from QStash"
+
+    def add_arguments(self, parser) -> None:
+        parser.add_argument(
+            "--list",
+            action="store_true",
+            help="List schedules from QStash",
+        )
+        parser.add_argument(
+            "--sync",
+            action="store_true",
+            help="Sync schedules from QStash to local database",
+        )
+        parser.add_argument(
+            "--no-input",
+            action="store_true",
+            help="Do not ask for confirmation",
+        )
+
+    def get_task_schedule_model(self) -> models.Model | None:
+        """Get the TaskSchedule model if available."""
+        try:
+            return apps.get_model("django_qstash_schedules", "TaskSchedule")
+        except LookupError:
+            self.stdout.write(
+                self.style.ERROR(
+                    "Django QStash Schedules not installed.\n"
+                    "Add `django_qstash.schedules` to INSTALLED_APPS and run migrations."
+                )
+            )
+
+    def sync_schedules(self, schedules: list) -> None:
+        """Sync remote schedules to local database."""
+        TaskSchedule = self.get_task_schedule_model()
+
+        for schedule in schedules:
+            try:
+                body = json.loads(schedule.body)
+                task_name = body.get("task_name", "Unnamed Task")
+                function = f"{body['module']}.{body['function']}"
+
+                obj, created = TaskSchedule.objects.update_or_create(
+                    schedule_id=schedule.schedule_id,
+                    defaults={
+                        "name": task_name,
+                        "task": function,
+                        "cron": schedule.cron,
+                        "args": body.get("args", []),
+                        "kwargs": body.get("kwargs", {}),
+                    },
+                )
+                status = "Created" if created else "Updated"
+                logger.info(
+                    "%s schedule: %s (%s)", status, task_name, schedule.schedule_id
+                )
+            except Exception:
+                logger.exception("Failed to sync schedule %s", schedule.schedule_id)
+
+    def handle(self, *args, **options) -> None:
+        auto_confirm = options.get("no_input")
+        if not (options.get("sync") or options.get("list")):
+            self.stdout.write(
+                self.style.ERROR("Please specify either --list or --sync option")
+            )
+            return
+
+        try:
+            destination = get_callback_url()
+            schedules = qstash_client.schedule.list()
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Found {len(schedules)} remote schedules based on destination: {destination}"
+                )
+            )
+
+            for schedule in schedules:
+                body = json.loads(schedule.body)
+                task_name = body.get("task_name", "Unnamed Task")
+                function = f"{body['module']}.{body['function']}"
+
+                self.stdout.write(
+                    f"\nSchedule ID: {schedule.schedule_id}"
+                    f"\n  Task: {task_name} ({function})"
+                    f"\n  Cron: {schedule.cron}"
+                    f"\n  Destination: {schedule.destination}"
+                    f"\n  Retries: {schedule.retries}"
+                    f"\n  Status: {'Paused' if schedule.paused else 'Active'}"
+                )
+
+            if options.get("sync"):
+                user_input = input("Do you want to sync remote schedules? (y/n): ")
+                if user_input.lower() == "y" or auto_confirm:
+                    self.sync_schedules(schedules)
+                else:
+                    self.stdout.write(self.style.ERROR("Sync cancelled"))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"An error occurred: {str(e)}"))

django_qstash/schedules/admin.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from django.contrib import admin
+
+from django_qstash.schedules import services
+from django_qstash.schedules.forms import TaskScheduleForm
+from django_qstash.schedules.models import TaskSchedule
+
+
+@admin.register(TaskSchedule)
+class TaskScheduleAdmin(admin.ModelAdmin):
+    list_display = ["schedule_id", "task_name"]
+    readonly_fields = [
+        "schedule_id",
+        "task_name",
+        "get_qstash_schedule_details",
+        "paused_at",
+        "resumed_at",
+        "active_at",
+    ]
+    form = TaskScheduleForm
+
+    fieldsets = [
+        (
+            "Name",
+            {
+                "fields": ["name", "schedule_id", "is_active"],
+            },
+        ),
+        (
+            "Task Selection",
+            {
+                "fields": ["task", "task_name"],
+            },
+        ),
+        (
+            "Arguments",
+            {
+                "fields": ["args", "kwargs"],
+            },
+        ),
+        (
+            "Schedule",
+            {
+                "fields": ["cron", "retries", "timeout"],
+            },
+        ),
+        (
+            "QStash Metadata",
+            {
+                "fields": [
+                    "paused_at",
+                    "resumed_at",
+                    "active_at",
+                    "get_qstash_schedule_details",
+                ],
+                "classes": ["collapse"],
+            },
+        ),
+    ]
+
+    @admin.display(description="Raw")
+    def get_qstash_schedule_details(self, obj: TaskSchedule) -> dict:
+        if not obj.schedule_id:
+            return "No schedule ID yet"
+        return services.get_task_schedule_from_qstash(obj, as_dict=True)

django_qstash/schedules/apps.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+
+class SchedulesConfig(AppConfig):
+    name = "django_qstash.schedules"
+    label = "django_qstash_schedules"
+    verbose_name = "django_qstash_schedules"
+    default_auto_field = "django.db.models.BigAutoField"
+
+    def ready(self):
+        import django_qstash.schedules.signals  # noqa

django_qstash/schedules/exceptions.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from django.core.exceptions import ValidationError
+
+
+class InvalidDurationStringValidationError(ValidationError):
+    """Invalid duration string."""
+
+    pass

django_qstash/schedules/formatters.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from django_qstash.callbacks import get_callback_url
+from django_qstash.schedules.models import TaskSchedule
+
+
+def prepare_qstash_payload(instance: TaskSchedule) -> dict[str, Any]:
+    """Prepare the task payload for QStash"""
+    return {
+        "function": instance.task_name.split(".")[-1],  # Get function name
+        "module": ".".join(instance.task_name.split(".")[:-1]),  # Get module path
+        "args": instance.args,
+        "kwargs": instance.kwargs,
+        "task_name": instance.name,
+        "options": {
+            "max_retries": instance.retries,
+            "timeout": instance.timeout,
+        },
+    }
+
+
+def format_task_schedule_for_qstash(instance: TaskSchedule) -> dict[str, Any]:
+    payload = prepare_qstash_payload(instance)
+    callback_url = get_callback_url()
+    data = {
+        "destination": callback_url,
+        "body": json.dumps(payload),
+        "cron": instance.cron,
+        "retries": instance.retries,
+        "timeout": instance.timeout,
+    }
+    if instance.schedule_id:
+        data["schedule_id"] = instance.schedule_id
+    return data

django_qstash/schedules/forms.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django import forms
+
+from django_qstash.discovery.fields import TaskChoiceField
+from django_qstash.schedules.models import TaskSchedule
+
+
+class TaskScheduleForm(forms.ModelForm):
+    task = TaskChoiceField()
+
+    class Meta:
+        model = TaskSchedule
+        fields = [
+            "name",
+            "task",
+            "task_name",
+            "args",
+            "kwargs",
+            "schedule_id",
+            "cron",
+            "retries",
+            "timeout",
+        ]

django_qstash/schedules/migrations/0001_initial.py

@@ -0,0 +1,122 @@
+# Generated by Django 5.1.4 on 2025-01-02 06:28
+
+from __future__ import annotations
+
+import django.core.validators
+import django.utils.timezone
+from django.db import migrations
+from django.db import models
+
+import django_qstash.discovery.models
+import django_qstash.schedules.validators
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="TaskSchedule",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "schedule_id",
+                    models.CharField(
+                        blank=True,
+                        db_index=True,
+                        help_text="The schedule ID stored in QStash",
+                        max_length=255,
+                        null=True,
+                        unique=True,
+                        verbose_name="Schedule ID",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        help_text="Short Description For This Task Schedule",
+                        max_length=200,
+                        verbose_name="Name",
+                    ),
+                ),
+                ("task", django_qstash.discovery.models.TaskField(max_length=255)),
+                (
+                    "task_name",
+                    models.CharField(
+                        blank=True,
+                        help_text="Original Python location of task",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "args",
+                    models.JSONField(
+                        blank=True,
+                        default=list,
+                        help_text='JSON encoded positional arguments (Example: ["arg1", "arg2"])',
+                        verbose_name="Positional Arguments",
+                    ),
+                ),
+                (
+                    "kwargs",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        help_text='JSON encoded keyword arguments (Example: {"argument": "value"})',
+                        verbose_name="Keyword Arguments",
+                    ),
+                ),
+                (
+                    "cron",
+                    models.CharField(
+                        default="*/5 * * * *",
+                        help_text="Cron expression for scheduling the task",
+                        max_length=255,
+                        verbose_name="Cron Expression",
+                    ),
+                ),
+                (
+                    "retries",
+                    models.IntegerField(
+                        default=3,
+                        help_text="Number of times to retry the task if it fails",
+                        validators=[django.core.validators.MaxValueValidator(5)],
+                        verbose_name="Retries",
+                    ),
+                ),
+                (
+                    "timeout",
+                    models.CharField(
+                        default="60s",
+                        help_text="Duration string for task timeout (e.g., '1s', '5m', '2h'). See Max HTTP Connection Timeout on QStash pricing page for allowed values for your Upstash account.",
+                        max_length=10,
+                        validators=[
+                            django_qstash.schedules.validators.validate_duration_string
+                        ],
+                        verbose_name="Timeout",
+                    ),
+                ),
+                ("is_active", models.BooleanField(default=True)),
+                (
+                    "active_at",
+                    models.DateTimeField(
+                        blank=True, default=django.utils.timezone.now, null=True
+                    ),
+                ),
+                ("is_paused", models.BooleanField(default=False)),
+                ("paused_at", models.DateTimeField(blank=True, null=True)),
+                ("is_resumed", models.BooleanField(default=False)),
+                ("resumed_at", models.DateTimeField(blank=True, null=True)),
+            ],
+        ),
+    ]

django_qstash/schedules/migrations/0002_taskschedule_updated_at.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.4 on 2025-01-02 07:44
+
+from __future__ import annotations
+
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("django_qstash_schedules", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="taskschedule",
+            name="updated_at",
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

django_qstash/schedules/models.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from datetime import timedelta
+
+from django.conf import settings
+from django.core.validators import MaxValueValidator
+from django.db import models
+from django.utils import timezone
+
+from django_qstash.discovery.models import TaskField
+from django_qstash.schedules.validators import validate_duration_string
+
+DJANGO_QSTASH_DOMAIN = getattr(settings, "DJANGO_QSTASH_DOMAIN", None)
+DJANGO_QSTASH_WEBHOOK_PATH = getattr(
+    settings, "DJANGO_QSTASH_WEBHOOK_PATH", "/qstash/webhook/"
+)
+
+
+class TaskSchedule(models.Model):
+    """
+    A model that represents a QStash Schedule for any given django-qstash Task.
+    """
+
+    schedule_id = models.CharField(
+        max_length=255,
+        unique=True,
+        blank=True,
+        null=True,
+        verbose_name="Schedule ID",
+        help_text="The schedule ID stored in QStash",
+        db_index=True,
+    )
+    name = models.CharField(
+        max_length=200,
+        verbose_name="Name",
+        help_text="Short Description For This Task Schedule",
+    )
+    task = TaskField()
+    task_name = models.CharField(
+        max_length=255, help_text="Original Python location of task", blank=True
+    )
+    args = models.JSONField(
+        blank=True,
+        default=list,
+        verbose_name="Positional Arguments",
+        help_text='JSON encoded positional arguments (Example: ["arg1", "arg2"])',
+    )
+    kwargs = models.JSONField(
+        blank=True,
+        default=dict,
+        verbose_name="Keyword Arguments",
+        help_text='JSON encoded keyword arguments (Example: {"argument": "value"})',
+    )
+    # Configured for Upstash Cron
+    # https://upstash.com/docs/qstash/api/schedules/create#param-upstash-cron
+    cron = models.CharField(
+        max_length=255,
+        default="*/5 * * * *",
+        verbose_name="Cron Expression",
+        help_text="Cron expression for scheduling the task",
+    )
+    # Configured for Upstash Retries
+    # https://upstash.com/docs/qstash/api/schedules/create#param-upstash-retries
+    retries = models.IntegerField(
+        default=3,
+        verbose_name="Retries",
+        validators=[MaxValueValidator(5)],
+        help_text="Number of times to retry the task if it fails",
+    )
+    # Configured for Upstash Timeout
+    # https://upstash.com/docs/qstash/api/schedules/create#param-upstash-timeout
+    timeout = models.CharField(
+        max_length=10,
+        default="60s",
+        verbose_name="Timeout",
+        validators=[validate_duration_string],
+        help_text="Duration string for task timeout (e.g., '1s', '5m', '2h'). "
+        "See Max HTTP Connection Timeout on QStash pricing page for allowed values for your Upstash account.",
+    )
+    updated_at = models.DateTimeField(auto_now=True)
+    is_active = models.BooleanField(default=True)
+    active_at = models.DateTimeField(null=True, blank=True, default=timezone.now)
+    is_paused = models.BooleanField(default=False)
+    paused_at = models.DateTimeField(null=True, blank=True)
+    is_resumed = models.BooleanField(default=False)
+    resumed_at = models.DateTimeField(null=True, blank=True)
+
+    def save(self, *args, **kwargs):
+        current_task_name = self.task
+        if not self.pk or self.task_name != current_task_name:
+            self.task_name = current_task_name
+
+        if not self.is_active:
+            self.is_paused = True
+            self.is_resumed = False
+            self.paused_at = timezone.now()
+            self.resumed_at = None
+            self.active_at = None
+            self.is_active = False
+        elif self.is_active:
+            self.is_paused = False
+            self.is_resumed = True
+            self.paused_at = None
+            self.resumed_at = timezone.now()
+            self.active_at = timezone.now()
+        super().save(*args, **kwargs)
+
+    def did_just_resume(self, delta_seconds: int = 60) -> bool:
+        if not self.is_resumed or not self.resumed_at:
+            return False
+        now = timezone.now()
+        delta_window = now - timedelta(seconds=delta_seconds)
+        return self.resumed_at >= delta_window
+
+    def did_just_pause(self, delta_seconds: int = 60) -> bool:
+        if not self.is_paused or not self.paused_at:
+            return False
+        now = timezone.now()
+        delta_window = now - timedelta(seconds=delta_seconds)
+        return self.paused_at >= delta_window

django_qstash/schedules/services.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import logging
+
+from django.db import transaction
+from qstash.schedule import Schedule
+
+from django_qstash.client import qstash_client
+from django_qstash.schedules.formatters import format_task_schedule_for_qstash
+from django_qstash.schedules.models import TaskSchedule
+
+logger = logging.getLogger(__name__)
+
+
+@transaction.atomic
+def sync_task_schedule_instance_to_qstash(instance: TaskSchedule) -> TaskSchedule:
+    """Sync a task schedule to QStash.
+
+    Creates a new schedule if none exists, handles pause/resume state changes,
+    and updates existing schedules when active.
+    """
+    data = format_task_schedule_for_qstash(instance)
+    qstash_client.schedule.create(**data)
+
+    sync_state_changes(instance)
+
+    return instance
+
+
+def sync_state_changes(instance: TaskSchedule) -> None:
+    """Handle pause/resume state changes."""
+    if instance.did_just_resume():
+        try:
+            qstash_client.schedule.resume(instance.schedule_id)
+        except Exception:
+            logger.exception("Failed to resume schedule %s", instance.schedule_id)
+    elif instance.did_just_pause():
+        try:
+            qstash_client.schedule.pause(instance.schedule_id)
+        except Exception:
+            logger.exception("Failed to pause schedule %s", instance.schedule_id)
+
+
+def get_task_schedule_from_qstash(
+    instance: TaskSchedule, as_dict: bool = False
+) -> Schedule | dict | None:
+    """Get a schedule from QStash."""
+    try:
+        response = qstash_client.schedule.get(instance.schedule_id)
+    except Exception:
+        logger.exception("Failed to lookup schedule %s", instance.schedule_id)
+        return None
+    if response:
+        return response.__dict__ if as_dict else response
+    return None
+
+
+def delete_task_schedule_from_qstash(instance: TaskSchedule) -> None:
+    """Delete a schedule from QStash."""
+    try:
+        qstash_client.schedule.delete(instance.schedule_id)
+    except Exception:
+        logger.exception("Failed to delete schedule %s", instance.schedule_id)
+    return

django_qstash/schedules/signals.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from django.db.models.signals import post_save
+from django.db.models.signals import pre_delete
+from django.dispatch import receiver
+
+from django_qstash.schedules import services
+from django_qstash.schedules.models import TaskSchedule
+
+
+@receiver(post_save, sender=TaskSchedule)
+def sync_schedule_to_qstash_receiver(sender, instance, created, **kwargs):
+    """
+    Sync the django-qstash TaskSchedule to QStash on save.
+    """
+    services.sync_task_schedule_instance_to_qstash(instance)
+
+
+@receiver(pre_delete, sender=TaskSchedule)
+def delete_schedule_from_qstash_receiver(sender, instance, **kwargs):
+    services.delete_task_schedule_from_qstash(instance)

django_qstash/schedules/validators.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import re
+
+from django_qstash.schedules.exceptions import InvalidDurationStringValidationError
+
+
+def validate_duration_string(value):
+    if not re.match(r"^\d+[smhd]$", value):
+        raise InvalidDurationStringValidationError(
+            'Invalid duration format. Must be a number followed by s (seconds), m (minutes), h (hours), or d (days). E.g., "60s", "5m", "2h", "7d"'
+        )
+
+    # Extract number and unit
+    number = int(value[:-1])
+    unit = value[-1]
+
+    # Convert to days
+    days = {
+        "s": number / (24 * 60 * 60),  # seconds to days
+        "m": number / (24 * 60),  # minutes to days
+        "h": number / 24,  # hours to days
+        "d": number,  # already in days
+    }[unit]
+
+    if days > 7:
+        raise InvalidDurationStringValidationError(
+            "Duration too long. Maximum allowed: 7 days (equivalent to: 604800s, 10080m, 168h, 7d)"
+        )

django_qstash/settings.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import warnings
+
+from django.conf import settings
+
+QSTASH_TOKEN = getattr(settings, "QSTASH_TOKEN", None)
+DJANGO_QSTASH_DOMAIN = getattr(settings, "DJANGO_QSTASH_DOMAIN", None)
+DJANGO_QSTASH_WEBHOOK_PATH = getattr(
+    settings, "DJANGO_QSTASH_WEBHOOK_PATH", "/qstash/webhook/"
+)
+if not QSTASH_TOKEN or not DJANGO_QSTASH_DOMAIN:
+    warnings.warn(
+        "QSTASH_TOKEN and DJANGO_QSTASH_DOMAIN should be set for QStash functionality",
+        RuntimeWarning,
+        stacklevel=2,
+    )

django_qstash/tasks.py

@@ -1,28 +1,15 @@
 from __future__ import annotations
 
 import functools
-import warnings
 from typing import Any
 from typing import Callable
 
-from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
-from qstash import QStash
 
-QSTASH_TOKEN = getattr(settings, "QSTASH_TOKEN", None)
-DJANGO_QSTASH_DOMAIN = getattr(settings, "DJANGO_QSTASH_DOMAIN", None)
-DJANGO_QSTASH_WEBHOOK_PATH = getattr(
-    settings, "DJANGO_QSTASH_WEBHOOK_PATH", "/qstash/webhook/"
-)
-if not QSTASH_TOKEN or not DJANGO_QSTASH_DOMAIN:
-    warnings.warn(
-        "QSTASH_TOKEN and DJANGO_QSTASH_DOMAIN should be set for QStash functionality",
-        RuntimeWarning,
-        stacklevel=2,
-    )
-
-# Initialize QStash client once
-qstash_client = QStash(QSTASH_TOKEN)
+from django_qstash.callbacks import get_callback_url
+from django_qstash.client import qstash_client
+from django_qstash.settings import DJANGO_QSTASH_DOMAIN
+from django_qstash.settings import QSTASH_TOKEN
 
 
 class QStashTask:
@@ -39,8 +26,6 @@ class QStashTask:
         self.delay_seconds = delay_seconds
         self.deduplicated = deduplicated
         self.options = options
-        self.callback_domain = DJANGO_QSTASH_DOMAIN.rstrip("/")
-        self.webhook_path = DJANGO_QSTASH_WEBHOOK_PATH.strip("/")
 
         if func is not None:
             functools.update_wrapper(self, func)
@@ -84,12 +69,7 @@ class QStashTask:
             "options": self.options,
         }
 
-        # Ensure callback URL is properly formatted
-        callback_domain = self.callback_domain
-        if not callback_domain.startswith(("http://", "https://")):
-            callback_domain = f"https://{callback_domain}"
-
-        url = f"{callback_domain}/{self.webhook_path}/"
+        url = get_callback_url()
         # Send to QStash using the official SDK
         response = qstash_client.message.publish_json(
             url=url,

{django_qstash-0.0.5.dist-info → django_qstash-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-qstash
-Version: 0.0.5
+Version: 0.0.7
 Summary: A drop-in replacement for Celery's shared_task with Upstash QStash.
 Author-email: Justin Mitchel <justin@codingforentrepreneurs.com>
 Project-URL: Changelog, https://github.com/jmitchel3/django-qstash

django_qstash-0.0.7.dist-info/RECORD

@@ -0,0 +1,42 @@
+django_qstash/__init__.py,sha256=y677U8dn62nPF5Er1ROJB-qzlukk7PqiCT2_7iL4osg,117
+django_qstash/callbacks.py,sha256=VG5tGdNzAmUEh7NlpghrxhWvnpRNXZucWmWwxaemw0M,530
+django_qstash/client.py,sha256=cgHf-g6lDAltY_Vt6GUVJNY2JSz1czBOHL-WVkkLs2M,149
+django_qstash/exceptions.py,sha256=pH6kKRJFIVFkDHUJQ9yRWmtGdBBSXpNAwMSFuNzMgPw,392
+django_qstash/handlers.py,sha256=mmm8TJOqV3j1rQXooNOa128gtmALXFNCAaDZ5xwIcuw,4950
+django_qstash/settings.py,sha256=YvpXMo1AdIWvbotISWJmhg0vrW3A3UQ4BieNzMfRC7Y,524
+django_qstash/tasks.py,sha256=VYv7m0Uz1v8kPBegGHam5AH0Hcc-n53BZz3IdQcAqsk,4462
+django_qstash/utils.py,sha256=wrTU30cobO2di18BNEFtKD4ih2euf7eQNpg6p6TkQ1Y,1185
+django_qstash/views.py,sha256=H32f_jGnlwOTO0YG9znNo2b-GRYZ8TM-Wt0T62SGdXM,639
+django_qstash/discovery/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/discovery/fields.py,sha256=qZDKMpl6VMRJL0FkGwXkeN_rcCT32cupDaXJOz-bFzs,1226
+django_qstash/discovery/models.py,sha256=9ml9lTKEqEKx2uqYvejZw_BjdnowgFOPE7rYNt_8E9A,685
+django_qstash/discovery/utils.py,sha256=k-QfOGElehCM7tV5v0FJAfwKqJWjez4xFf2RUyxIgP0,3218
+django_qstash/discovery/validators.py,sha256=NNCf7ltW--sTw0w8FWwTp-4PtiS35U6DITEApx-D7X4,645
+django_qstash/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/management/commands/clear_stale_results.py,sha256=stHCnvC1ER_rZXKUK-YVUgazC2q04eGIHjo_BrPSDEI,2096
+django_qstash/management/commands/task_schedules.py,sha256=b9lJ1vjQKHyGzWAo9csGwE_oaKfgcSC8bPFLt9Ry6WE,4278
+django_qstash/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/results/admin.py,sha256=q9fn3lfn0gviMfiimYij0wBCYww7FxyrOfGPr1NvntA,434
+django_qstash/results/apps.py,sha256=4me4cg5yeoeSJTphkHYzGMJUfGucT47FNIUMYu5gmIo,275
+django_qstash/results/models.py,sha256=aEiAhGJOuLRtjibUw6xdQqUt3eYKLqY2as4I4QSrF5U,1047
+django_qstash/results/services.py,sha256=HvNp5D1tQ__nz4LVUTAGxuyLl_dnlBps4pJ6E9HD2kA,991
+django_qstash/results/migrations/0001_initial.py,sha256=A90SKgWmBf4SIJYG1Jh6-b_81Ia1zIzGj3Bfl1O4-kg,1902
+django_qstash/results/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/schedules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash/schedules/admin.py,sha256=ToFkdGfN3smNctTduLQpwxZ5yW20jW4HKRr7x1UilIk,1673
+django_qstash/schedules/apps.py,sha256=zTyTH6xTZPKsEC2MlJcQBDp2ZiRWdMfq2j2jGbpBLH0,360
+django_qstash/schedules/exceptions.py,sha256=fvXArrK24ZBGITijuJ_I5xixURmFrJpQ6Dbi2bLNqCQ,195
+django_qstash/schedules/formatters.py,sha256=KMt1457z4Mp0Mob2IxgTBHmye_mRfcLn7Rdf7ThvbEg,1157
+django_qstash/schedules/forms.py,sha256=S5Wy2mZha2-th4oAQLjkC9JytfXFNJcL1j18u6rslxI,524
+django_qstash/schedules/models.py,sha256=WS4b5ssh07ekiTe5_y4phLKGl7uTXHJBiF4W47vkGec,4357
+django_qstash/schedules/services.py,sha256=DqwYn2kSEJ7f06WskmWRWIzeadV70aHURgWGvmg9FK0,2055
+django_qstash/schedules/signals.py,sha256=g1aRAbZx-stnvD589mZagR6I27E56064fUyWsxKitR4,696
+django_qstash/schedules/validators.py,sha256=i8IEjnRVk-iysmqvT_kbPYpxTKCQWoX9P1JHcL3zkhI,925
+django_qstash/schedules/migrations/0001_initial.py,sha256=66cA8xnJV3h7QgzCaOiv-Nu3Xl9IdZQPgQKhxyW3bs4,4516
+django_qstash/schedules/migrations/0002_taskschedule_updated_at.py,sha256=6hZO0a9P2ZpOROkk7O5UXBhahghU0QfxZl4E-c3HKGw,459
+django_qstash/schedules/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_qstash-0.0.7.dist-info/METADATA,sha256=VXoUQawPhDe9DL1H6D1RxonOPVzzG-yGS1gmfWLjM0Q,12307
+django_qstash-0.0.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+django_qstash-0.0.7.dist-info/top_level.txt,sha256=AlV3WSK1A0ZvKuCLsINtIJhJW8zo7SEB-D3_RAjZ0hI,14
+django_qstash-0.0.7.dist-info/RECORD,,

django_qstash-0.0.5.dist-info/RECORD

@@ -1,19 +0,0 @@
-django_qstash/__init__.py,sha256=iG3lEbUQGkNq3qifS8onh9F6HGZpf4IQfVwGJNFjJUU,117
-django_qstash/exceptions.py,sha256=pH6kKRJFIVFkDHUJQ9yRWmtGdBBSXpNAwMSFuNzMgPw,392
-django_qstash/handlers.py,sha256=mmm8TJOqV3j1rQXooNOa128gtmALXFNCAaDZ5xwIcuw,4950
-django_qstash/tasks.py,sha256=tiBJz8BIOYRD6MN0k4_1ncKCjLlptP3BvTad9lz7YVo,5220
-django_qstash/utils.py,sha256=wrTU30cobO2di18BNEFtKD4ih2euf7eQNpg6p6TkQ1Y,1185
-django_qstash/views.py,sha256=H32f_jGnlwOTO0YG9znNo2b-GRYZ8TM-Wt0T62SGdXM,639
-django_qstash/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-django_qstash/management/commands/clear_stale_results.py,sha256=stHCnvC1ER_rZXKUK-YVUgazC2q04eGIHjo_BrPSDEI,2096
-django_qstash/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-django_qstash/results/admin.py,sha256=q9fn3lfn0gviMfiimYij0wBCYww7FxyrOfGPr1NvntA,434
-django_qstash/results/apps.py,sha256=4me4cg5yeoeSJTphkHYzGMJUfGucT47FNIUMYu5gmIo,275
-django_qstash/results/models.py,sha256=aEiAhGJOuLRtjibUw6xdQqUt3eYKLqY2as4I4QSrF5U,1047
-django_qstash/results/services.py,sha256=HvNp5D1tQ__nz4LVUTAGxuyLl_dnlBps4pJ6E9HD2kA,991
-django_qstash/results/migrations/0001_initial.py,sha256=A90SKgWmBf4SIJYG1Jh6-b_81Ia1zIzGj3Bfl1O4-kg,1902
-django_qstash/results/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-django_qstash-0.0.5.dist-info/METADATA,sha256=G0tRPosSRgvu7fxwG2BBUkA6WKpFb6xmHNjaoqGRLKQ,12307
-django_qstash-0.0.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-django_qstash-0.0.5.dist-info/top_level.txt,sha256=AlV3WSK1A0ZvKuCLsINtIJhJW8zo7SEB-D3_RAjZ0hI,14
-django_qstash-0.0.5.dist-info/RECORD,,