django-qstash 0.0.1__tar.gz → 0.0.3__tar.gz

{django_qstash-0.0.1 → django_qstash-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-qstash
-Version: 0.0.1
+Version: 0.0.3
 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
@@ -27,6 +27,8 @@ Requires-Dist: django>=4.2
 Requires-Dist: qstash>=2
 Requires-Dist: requests>=2.30
 
+> :warning: **BETA Software**: Working on being production-ready soon.
+
 # Django QStash `pip install django-qstash`
 
 A drop-in replacement for Celery's shared_task leveraging Upstash QStash for a truly serverless Django application to run background tasks asynchronously from the request/response cycle.
@@ -49,6 +51,7 @@ Depends on:
 # from celery import shared_task
 from django_qstash import shared_task
 
+
 @shared_task
 def math_add_task(a, b, save_to_file=False):
     logger.info(f"Adding {a} and {b}")
@@ -73,23 +76,24 @@ math_add_task.delay(12, 454, save_to_file=True)
 
 
 ```python
-QSTASH_TOKEN="your_token"
-QSTASH_CURRENT_SIGNING_KEY="your_current_signing_key"
-QSTASH_NEXT_SIGNING_KEY="your_next_signing_key"
+QSTASH_TOKEN = "your_token"
+QSTASH_CURRENT_SIGNING_KEY = "your_current_signing_key"
+QSTASH_NEXT_SIGNING_KEY = "your_next_signing_key"
 
 # required for django-qstash
-DJANGO_QSTASH_DOMAIN="https://example.com"
-DJANGO_QSTASH_WEBHOOK_PATH="/qstash/webhook/"
+DJANGO_QSTASH_DOMAIN = "https://example.com"
+DJANGO_QSTASH_WEBHOOK_PATH = "/qstash/webhook/"
 ```
 
 
+`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.com`
 
-`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.net`
+In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/).
 
-In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/). 
 
+`DJANGO_QSTASH_WEBHOOK_PATH` (default:`/qstash/webhook/`): The path where QStash will send webhooks to your Django application.
 
-`DJANGO_QSTASH_WEBHOOK_PATH`: The path where QStash will send webhooks to your Django application. Defaults to `/qstash/webhook/`
 
+`DJANGO_QSTASH_FORCE_HTTPS` (default:`True`): Whether to force HTTPS for the webhook.
 
-`DJANGO_QSTASH_FORCE_HTTPS`: Whether to force HTTPS for the webhook. Defaults to `True`.
+`DJANGO_QSTASH_RESULT_TTL` (default:`604800`): A number of seconds after which task result data can be safely deleted. Defaults to 604800 seconds (7 days or 7 * 24 * 60 * 60).

{django_qstash-0.0.1 → django_qstash-0.0.3}/README.md

@@ -1,3 +1,5 @@
+> :warning: **BETA Software**: Working on being production-ready soon.
+
 # Django QStash `pip install django-qstash`
 
 A drop-in replacement for Celery's shared_task leveraging Upstash QStash for a truly serverless Django application to run background tasks asynchronously from the request/response cycle.
@@ -20,6 +22,7 @@ Depends on:
 # from celery import shared_task
 from django_qstash import shared_task
 
+
 @shared_task
 def math_add_task(a, b, save_to_file=False):
     logger.info(f"Adding {a} and {b}")
@@ -44,23 +47,24 @@ math_add_task.delay(12, 454, save_to_file=True)
 
 
 ```python
-QSTASH_TOKEN="your_token"
-QSTASH_CURRENT_SIGNING_KEY="your_current_signing_key"
-QSTASH_NEXT_SIGNING_KEY="your_next_signing_key"
+QSTASH_TOKEN = "your_token"
+QSTASH_CURRENT_SIGNING_KEY = "your_current_signing_key"
+QSTASH_NEXT_SIGNING_KEY = "your_next_signing_key"
 
 # required for django-qstash
-DJANGO_QSTASH_DOMAIN="https://example.com"
-DJANGO_QSTASH_WEBHOOK_PATH="/qstash/webhook/"
+DJANGO_QSTASH_DOMAIN = "https://example.com"
+DJANGO_QSTASH_WEBHOOK_PATH = "/qstash/webhook/"
 ```
 
 
+`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.com`
 
-`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.net`
+In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/).
 
-In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/). 
 
+`DJANGO_QSTASH_WEBHOOK_PATH` (default:`/qstash/webhook/`): The path where QStash will send webhooks to your Django application.
 
-`DJANGO_QSTASH_WEBHOOK_PATH`: The path where QStash will send webhooks to your Django application. Defaults to `/qstash/webhook/`
 
+`DJANGO_QSTASH_FORCE_HTTPS` (default:`True`): Whether to force HTTPS for the webhook.
 
-`DJANGO_QSTASH_FORCE_HTTPS`: Whether to force HTTPS for the webhook. Defaults to `True`.
+`DJANGO_QSTASH_RESULT_TTL` (default:`604800`): A number of seconds after which task result data can be safely deleted. Defaults to 604800 seconds (7 days or 7 * 24 * 60 * 60).

{django_qstash-0.0.1 → django_qstash-0.0.3}/pyproject.toml

@@ -6,7 +6,7 @@ requires = [
 
 [project]
 name = "django-qstash"
-version = "0.0.1"
+version = "0.0.3"
 description = "A drop-in replacement for Celery's shared_task with Upstash QStash."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -40,3 +40,69 @@ urls.Changelog = "https://github.com/jmitchel3/django-qstash"
 urls.Documentation = "https://github.com/jmitchel3/django-qstash"
 urls.Funding = "https://github.com/jmitchel3/django-qstash"
 urls.Repository = "https://github.com/jmitchel3/django-qstash"
+
+[tool.isort]
+add_imports = [
+  "from __future__ import annotations",
+]
+force_single_line = true
+profile = "black"
+src_paths = [
+  ".",
+  "example",
+  "src",
+]
+
+[tool.pyproject-fmt]
+max_supported_python = "3.13"
+
+[tool.pytest.ini_options]
+addopts = """\
+    --strict-config
+    --strict-markers
+    --ds=tests.settings
+    """
+django_find_project = false
+xfail_strict = true
+
+[tool.coverage.run]
+branch = true
+parallel = true
+source = [
+  "django_qstash",
+  "tests",
+]
+omit = [
+  "*/migrations/*",
+]
+
+[tool.coverage.paths]
+source = [
+  "src",
+  ".tox/**/site-packages",
+]
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.mypy]
+enable_error_code = [
+  "ignore-without-code",
+  "redundant-expr",
+  "truthy-bool",
+]
+mypy_path = "src/"
+namespace_packages = false
+strict = true
+warn_unreachable = true
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+
+[tool.rstcheck]
+ignore_directives = [
+  "autoclass",
+  "autofunction",
+]
+report_level = "ERROR"

{django_qstash-0.0.1 → django_qstash-0.0.3}/src/django_qstash/__init__.py

@@ -1,4 +1,6 @@
-__version__ = "0.1.0"
+from __future__ import annotations
+
+__version__ = "0.0.3"
 
 from .tasks import shared_task
 

django_qstash-0.0.3/src/django_qstash/exceptions.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+
+class WebhookError(Exception):
+    """Base exception for webhook handling errors."""
+
+    pass
+
+
+class SignatureError(WebhookError):
+    """Invalid or missing signature."""
+
+    pass
+
+
+class PayloadError(WebhookError):
+    """Invalid payload structure or content."""
+
+    pass
+
+
+class TaskError(WebhookError):
+    """Error in task execution."""
+
+    pass

django_qstash-0.0.3/src/django_qstash/handlers.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from django.conf import settings
+from django.http import HttpRequest
+from qstash import Receiver
+
+from . import utils
+from .exceptions import PayloadError
+from .exceptions import SignatureError
+from .exceptions import TaskError
+from .results.services import store_task_result
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TaskPayload:
+    function: str
+    module: str
+    args: list
+    kwargs: dict
+    task_name: str
+    function_path: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TaskPayload:
+        """Create TaskPayload from dictionary."""
+        is_valid, error = utils.validate_task_payload(data)
+        if not is_valid:
+            raise PayloadError(error)
+
+        function_path = f"{data['module']}.{data['function']}"
+        return cls(
+            function=data["function"],
+            module=data["module"],
+            args=data["args"],
+            kwargs=data["kwargs"],
+            task_name=data.get("task_name", function_path),
+            function_path=function_path,
+        )
+
+
+class QStashWebhook:
+    def __init__(self):
+        self.receiver = Receiver(
+            current_signing_key=settings.QSTASH_CURRENT_SIGNING_KEY,
+            next_signing_key=settings.QSTASH_NEXT_SIGNING_KEY,
+        )
+        self.force_https = getattr(settings, "DJANGO_QSTASH_FORCE_HTTPS", True)
+
+    def verify_signature(self, body: str, signature: str, url: str) -> None:
+        """Verify QStash signature."""
+        if not signature:
+            raise SignatureError("Missing Upstash-Signature header")
+
+        if self.force_https and not url.startswith("https://"):
+            url = url.replace("http://", "https://")
+
+        try:
+            self.receiver.verify(body=body, signature=signature, url=url)
+        except Exception as e:
+            raise SignatureError(f"Invalid signature: {e}")
+
+    def parse_payload(self, body: str) -> TaskPayload:
+        """Parse and validate webhook payload."""
+        try:
+            data = json.loads(body)
+            return TaskPayload.from_dict(data)
+        except json.JSONDecodeError as e:
+            raise PayloadError(f"Invalid JSON payload: {e}")
+
+    def execute_task(self, payload: TaskPayload) -> Any:
+        """Import and execute the task function."""
+        try:
+            task_func = utils.import_string(payload.function_path)
+        except ImportError as e:
+            raise TaskError(f"Could not import task function: {e}")
+
+        try:
+            if callable(task_func) and hasattr(task_func, "actual_func"):
+                return task_func.actual_func(*payload.args, **payload.kwargs)
+            return task_func(*payload.args, **payload.kwargs)
+        except Exception as e:
+            raise TaskError(f"Task execution failed: {e}")
+
+    def handle_request(self, request: HttpRequest) -> tuple[dict, int]:
+        """Process webhook request and return response data and status code."""
+        payload = None  # Initialize payload as None
+        try:
+            body = request.body.decode()
+            self.verify_signature(
+                body=body,
+                signature=request.headers.get("Upstash-Signature"),
+                url=request.build_absolute_uri(),
+            )
+
+            payload = self.parse_payload(body)
+            result = self.execute_task(payload)
+
+            store_task_result(
+                task_id=request.headers.get("Upstash-Message-Id"),
+                task_name=payload.task_name,
+                status="SUCCESS",
+                result=result,
+                args=payload.args,
+                kwargs=payload.kwargs,
+            )
+
+            return {
+                "status": "success",
+                "task_name": payload.task_name,
+                "result": result if result is not None else "null",
+            }, 200
+
+        except (SignatureError, PayloadError) as e:
+            logger.exception("Authentication error: %s", str(e))
+            return {
+                "status": "error",
+                "error_type": e.__class__.__name__,
+                "error": str(e),
+                "task_name": getattr(payload, "task_name", None),
+            }, 400
+        except TaskError as e:
+            logger.exception("Task execution error: %s", str(e))
+            return {
+                "status": "error",
+                "error_type": e.__class__.__name__,
+                "error": str(e),
+                "task_name": payload.task_name if payload else None,
+            }, 500
+        except Exception as e:
+            logger.exception("Unexpected error in webhook handler: %s", str(e))
+            return {
+                "status": "error",
+                "error_type": "InternalServerError",
+                "error": "An unexpected error occurred",
+                "task_name": getattr(payload, "task_name", None),
+            }, 500

django_qstash-0.0.3/src/django_qstash/management/commands/clear_stale_results.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from datetime import timedelta
+
+from django.apps import apps
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+DJANGO_QSTASH_RESULT_TTL = getattr(settings, "DJANGO_QSTASH_RESULT_TTL", 604800)
+
+
+class Command(BaseCommand):
+    help = f"""Clears stale task results older than\n
+    {DJANGO_QSTASH_RESULT_TTL} seconds (settings.DJANGO_QSTASH_RESULT_TTL)"""
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--no-input",
+            action="store_true",
+            help="Do not ask for confirmation",
+        )
+        parser.add_argument(
+            "--since",
+            type=int,
+            help="The number of seconds ago to clear results for",
+        )
+
+    def handle(self, *args, **options):
+        no_input = options["no_input"]
+        since = options.get("since") or DJANGO_QSTASH_RESULT_TTL
+        cutoff_date = timezone.now() - timedelta(seconds=since)
+        try:
+            TaskResult = apps.get_model("django_qstash_results", "TaskResult")
+        except LookupError:
+            self.stdout.write(
+                self.style.ERROR(
+                    "Django QStash Results not installed.\nAdd `django_qstash.results` to INSTALLED_APPS and run migrations."
+                )
+            )
+            return
+        to_delete = TaskResult.objects.filter(date_done__lt=cutoff_date)
+
+        if not to_delete.exists():
+            self.stdout.write("No stale Django QStash task results found")
+            return
+
+        # use input to confirm  deletion
+        self.stdout.write(
+            f"Deleting {to_delete.count()} task results older than {cutoff_date} ({DJANGO_QSTASH_RESULT_TTL} seconds)"
+        )
+        if not no_input:
+            if input("Are you sure? (y/n): ") != "y":
+                self.stdout.write("Skipping deletion")
+                return
+
+        deleted_count, _ = to_delete.delete()
+
+        self.stdout.write(
+            self.style.SUCCESS(f"Successfully deleted {deleted_count} stale results.")
+        )

django_qstash-0.0.3/src/django_qstash/results/admin.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from django.contrib import admin
+
+from .models import TaskResult
+
+
+@admin.register(TaskResult)
+class TaskResultAdmin(admin.ModelAdmin):
+    readonly_fields = [
+        "task_name",
+        "status",
+        "date_done",
+        "result",
+        "traceback",
+        "args",
+        "kwargs",
+        "task_id",
+        "date_created",
+    ]
+    list_display = ["task_name", "status", "date_done"]

django_qstash-0.0.3/src/django_qstash/results/apps.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+
+class ResultsConfig(AppConfig):
+    name = "django_qstash.results"
+    label = "django_qstash_results"
+    verbose_name = "django_qstash_results"
+    default_auto_field = "django.db.models.BigAutoField"

django_qstash-0.0.3/src/django_qstash/results/migrations/0001_initial.py

@@ -0,0 +1,62 @@
+# Generated by Django 5.1.4 on 2024-12-30 23:31
+
+from __future__ import annotations
+
+import uuid
+
+import django.utils.timezone
+from django.db import migrations
+from django.db import models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="TaskResult",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid1,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "task_id",
+                    models.CharField(db_index=True, max_length=255, unique=True),
+                ),
+                ("task_name", models.CharField(max_length=255)),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("PENDING", "Pending"),
+                            ("SUCCESS", "Success"),
+                            ("FAILURE", "Failure"),
+                        ],
+                        default="PENDING",
+                        max_length=50,
+                    ),
+                ),
+                (
+                    "date_created",
+                    models.DateTimeField(default=django.utils.timezone.now),
+                ),
+                ("date_done", models.DateTimeField(null=True)),
+                ("result", models.JSONField(null=True)),
+                ("traceback", models.TextField(null=True)),
+                ("args", models.JSONField(null=True)),
+                ("kwargs", models.JSONField(null=True)),
+            ],
+            options={
+                "ordering": ["-date_done"],
+            },
+        ),
+    ]

django_qstash-0.0.3/src/django_qstash/results/models.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import uuid
+
+from django.db import models
+from django.utils import timezone
+
+
+class TaskResult(models.Model):
+    id = models.UUIDField(
+        primary_key=True, default=uuid.uuid1, editable=False, unique=True
+    )
+    task_id = models.CharField(max_length=255, unique=True, db_index=True)
+    task_name = models.CharField(max_length=255)
+    status = models.CharField(
+        max_length=50,
+        choices=[
+            ("PENDING", "Pending"),
+            ("SUCCESS", "Success"),
+            ("FAILURE", "Failure"),
+        ],
+        default="PENDING",
+    )
+    date_created = models.DateTimeField(default=timezone.now)
+    date_done = models.DateTimeField(null=True)
+    result = models.JSONField(null=True)
+    traceback = models.TextField(null=True)
+    args = models.JSONField(null=True)
+    kwargs = models.JSONField(null=True)
+
+    class Meta:
+        app_label = "django_qstash_results"
+        ordering = ["-date_done"]
+
+    def __str__(self):
+        return f"{self.task_name} ({self.task_id})"

django_qstash-0.0.3/src/django_qstash/results/services.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+
+from django.apps import apps
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+
+def store_task_result(
+    task_id, task_name, status, result=None, traceback=None, args=None, kwargs=None
+):
+    """Helper function to store task results if the results app is installed"""
+    try:
+        TaskResult = apps.get_model("django_qstash_results", "TaskResult")
+        task_result = TaskResult.objects.create(
+            task_id=task_id,
+            task_name=task_name,
+            status=status,
+            date_done=timezone.now(),
+            result=result,
+            traceback=traceback,
+            args=args,
+            kwargs=kwargs,
+        )
+        return task_result
+    except LookupError:
+        # Model isn't installed, skip storage
+        logger.debug(
+            "Django QStash Results not installed. Add `django_qstash.results` to INSTALLED_APPS and run migrations."
+        )
+        return None

django_qstash-0.0.3/src/django_qstash/views.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import json
+
+from django.http import HttpRequest
+from django.http import HttpResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_http_methods
+
+from .handlers import QStashWebhook
+
+
+@csrf_exempt
+@require_http_methods(["POST"])
+def qstash_webhook_view(request: HttpRequest) -> HttpResponse:
+    """Handle QStash webhook requests."""
+    webhook = QStashWebhook()
+    response_data, status_code = webhook.handle_request(request)
+    return HttpResponse(
+        json.dumps(response_data), status=status_code, content_type="application/json"
+    )

{django_qstash-0.0.1 → django_qstash-0.0.3}/src/django_qstash.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-qstash
-Version: 0.0.1
+Version: 0.0.3
 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
@@ -27,6 +27,8 @@ Requires-Dist: django>=4.2
 Requires-Dist: qstash>=2
 Requires-Dist: requests>=2.30
 
+> :warning: **BETA Software**: Working on being production-ready soon.
+
 # Django QStash `pip install django-qstash`
 
 A drop-in replacement for Celery's shared_task leveraging Upstash QStash for a truly serverless Django application to run background tasks asynchronously from the request/response cycle.
@@ -49,6 +51,7 @@ Depends on:
 # from celery import shared_task
 from django_qstash import shared_task
 
+
 @shared_task
 def math_add_task(a, b, save_to_file=False):
     logger.info(f"Adding {a} and {b}")
@@ -73,23 +76,24 @@ math_add_task.delay(12, 454, save_to_file=True)
 
 
 ```python
-QSTASH_TOKEN="your_token"
-QSTASH_CURRENT_SIGNING_KEY="your_current_signing_key"
-QSTASH_NEXT_SIGNING_KEY="your_next_signing_key"
+QSTASH_TOKEN = "your_token"
+QSTASH_CURRENT_SIGNING_KEY = "your_current_signing_key"
+QSTASH_NEXT_SIGNING_KEY = "your_next_signing_key"
 
 # required for django-qstash
-DJANGO_QSTASH_DOMAIN="https://example.com"
-DJANGO_QSTASH_WEBHOOK_PATH="/qstash/webhook/"
+DJANGO_QSTASH_DOMAIN = "https://example.com"
+DJANGO_QSTASH_WEBHOOK_PATH = "/qstash/webhook/"
 ```
 
 
+`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.com`
 
-`DJANGO_QSTASH_DOMAIN`: Must be a valid and publicly accessible domain. For example `https://djangoqstash.net`
+In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/).
 
-In development mode, we recommend using a tunnel like [Cloudflare Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with a domain name you control. You can also consider [ngrok](https://ngrok.com/). 
 
+`DJANGO_QSTASH_WEBHOOK_PATH` (default:`/qstash/webhook/`): The path where QStash will send webhooks to your Django application.
 
-`DJANGO_QSTASH_WEBHOOK_PATH`: The path where QStash will send webhooks to your Django application. Defaults to `/qstash/webhook/`
 
+`DJANGO_QSTASH_FORCE_HTTPS` (default:`True`): Whether to force HTTPS for the webhook.
 
-`DJANGO_QSTASH_FORCE_HTTPS`: Whether to force HTTPS for the webhook. Defaults to `True`.
+`DJANGO_QSTASH_RESULT_TTL` (default:`604800`): A number of seconds after which task result data can be safely deleted. Defaults to 604800 seconds (7 days or 7 * 24 * 60 * 60).

django_qstash-0.0.3/src/django_qstash.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+README.md
+pyproject.toml
+src/django_qstash/__init__.py
+src/django_qstash/exceptions.py
+src/django_qstash/handlers.py
+src/django_qstash/tasks.py
+src/django_qstash/utils.py
+src/django_qstash/views.py
+src/django_qstash.egg-info/PKG-INFO
+src/django_qstash.egg-info/SOURCES.txt
+src/django_qstash.egg-info/dependency_links.txt
+src/django_qstash.egg-info/requires.txt
+src/django_qstash.egg-info/top_level.txt
+src/django_qstash/management/commands/__init__.py
+src/django_qstash/management/commands/clear_stale_results.py
+src/django_qstash/results/__init__.py
+src/django_qstash/results/admin.py
+src/django_qstash/results/apps.py
+src/django_qstash/results/models.py
+src/django_qstash/results/services.py
+src/django_qstash/results/migrations/0001_initial.py
+src/django_qstash/results/migrations/__init__.py
+tests/test_exceptions.py
+tests/test_handlers.py
+tests/test_results_models.py
+tests/test_tasks.py
+tests/test_utils.py
+tests/test_views.py

django_qstash-0.0.3/tests/test_exceptions.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+
+from django_qstash.exceptions import PayloadError
+from django_qstash.exceptions import SignatureError
+from django_qstash.exceptions import TaskError
+from django_qstash.exceptions import WebhookError
+
+
+def test_webhook_error():
+    """Test that WebhookError can be raised and is an Exception"""
+    with pytest.raises(WebhookError):
+        raise WebhookError("Test webhook error")
+
+
+def test_signature_error():
+    """Test that SignatureError can be raised and is a WebhookError"""
+    with pytest.raises(SignatureError):
+        raise SignatureError("Invalid signature")
+
+    # Verify inheritance
+    assert issubclass(SignatureError, WebhookError)
+
+
+def test_payload_error():
+    """Test that PayloadError can be raised and is a WebhookError"""
+    with pytest.raises(PayloadError):
+        raise PayloadError("Invalid payload")
+
+    # Verify inheritance
+    assert issubclass(PayloadError, WebhookError)
+
+
+def test_task_error():
+    """Test that TaskError can be raised and is a WebhookError"""
+    with pytest.raises(TaskError):
+        raise TaskError("Task execution failed")
+
+    # Verify inheritance
+    assert issubclass(TaskError, WebhookError)
+
+
+def test_error_messages():
+    """Test that error messages are properly stored"""
+    message = "Custom error message"
+
+    try:
+        raise WebhookError(message)
+    except WebhookError as e:
+        assert str(e) == message
+
+    try:
+        raise SignatureError(message)
+    except SignatureError as e:
+        assert str(e) == message

django_qstash-0.0.3/tests/test_handlers.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import json
+from unittest.mock import Mock
+from unittest.mock import patch
+
+import pytest
+from django.http import HttpRequest
+
+from django_qstash.exceptions import PayloadError
+from django_qstash.exceptions import SignatureError
+from django_qstash.exceptions import TaskError
+from django_qstash.handlers import QStashWebhook
+from django_qstash.handlers import TaskPayload
+
+# Add pytest mark for database access
+pytestmark = pytest.mark.django_db
+
+
+class TestTaskPayload:
+    def test_from_dict_valid(self):
+        data = {
+            "function": "test_func",
+            "module": "test_module",
+            "args": [1, 2],
+            "kwargs": {"key": "value"},
+        }
+        payload = TaskPayload.from_dict(data)
+
+        assert payload.function == "test_func"
+        assert payload.module == "test_module"
+        assert payload.args == [1, 2]
+        assert payload.kwargs == {"key": "value"}
+        assert payload.task_name == "test_module.test_func"
+        assert payload.function_path == "test_module.test_func"
+
+    def test_from_dict_invalid(self):
+        data = {"invalid": "data"}
+        with pytest.raises(PayloadError):
+            TaskPayload.from_dict(data)
+
+
+class TestQStashWebhook:
+    @pytest.fixture
+    def webhook(self):
+        return QStashWebhook()
+
+    def test_verify_signature_missing(self, webhook):
+        with pytest.raises(SignatureError, match="Missing Upstash-Signature"):
+            webhook.verify_signature("body", "", "http://example.com")
+
+    def test_verify_signature_invalid(self, webhook):
+        with pytest.raises(SignatureError, match="Invalid signature"):
+            webhook.verify_signature("body", "invalid", "http://example.com")
+
+    def test_parse_payload_invalid_json(self, webhook):
+        with pytest.raises(PayloadError, match="Invalid JSON payload"):
+            webhook.parse_payload("invalid json")
+
+    def test_execute_task_import_error(self, webhook):
+        payload = Mock(function_path="nonexistent.module")
+        with pytest.raises(TaskError, match="Could not import task function"):
+            webhook.execute_task(payload)
+
+    def test_handle_request_success(self, webhook):
+        request = Mock(spec=HttpRequest)
+        request.body = json.dumps(
+            {"function": "test_func", "module": "test_module", "args": [], "kwargs": {}}
+        ).encode()
+        request.headers = {"Upstash-Signature": "valid", "Upstash-Message-Id": "123"}
+        request.build_absolute_uri.return_value = "https://example.com"
+
+        with (
+            patch.object(webhook, "verify_signature"),
+            patch.object(webhook, "execute_task") as mock_execute,
+        ):
+            mock_execute.return_value = "result"
+            response, status = webhook.handle_request(request)
+
+        assert status == 200
+        assert response["status"] == "success"
+        assert response["result"] == "result"
+
+    def test_handle_request_signature_error(self, webhook):
+        request = Mock(spec=HttpRequest)
+        request.body = json.dumps(
+            {"function": "test_func", "module": "test_module", "args": [], "kwargs": {}}
+        ).encode()
+        request.headers = {}
+        request.build_absolute_uri.return_value = "https://example.com"
+
+        response, status = webhook.handle_request(request)
+
+        assert status == 400
+        assert response["status"] == "error"
+        assert response["error_type"] == "SignatureError"
+
+    def test_handle_request_task_error(self, webhook):
+        request = Mock(spec=HttpRequest)
+        request.body = json.dumps(
+            {"function": "test_func", "module": "test_module", "args": [], "kwargs": {}}
+        ).encode()
+        request.headers = {"Upstash-Signature": "valid", "Upstash-Message-Id": "123"}
+        request.build_absolute_uri.return_value = "https://example.com"
+
+        with (
+            patch.object(webhook, "verify_signature"),
+            patch.object(webhook, "execute_task") as mock_execute,
+        ):
+            mock_execute.side_effect = TaskError("Task failed")
+            response, status = webhook.handle_request(request)
+
+        assert status == 500
+        assert response["status"] == "error"
+        assert response["error_type"] == "TaskError"
+        assert response["error"] == "Task failed"
+        assert response["task_name"] is not None
+
+    def test_handle_request_unexpected_error(self, webhook):
+        request = Mock(spec=HttpRequest)
+        request.body = json.dumps(
+            {"function": "test_func", "module": "test_module", "args": [], "kwargs": {}}
+        ).encode()
+        request.headers = {"Upstash-Signature": "valid"}
+        request.build_absolute_uri.return_value = "https://example.com"
+
+        with patch.object(webhook, "verify_signature") as mock_verify:
+            mock_verify.side_effect = Exception("Unexpected error")
+            response, status = webhook.handle_request(request)
+
+        assert status == 500
+        assert response["status"] == "error"
+        assert response["error_type"] == "InternalServerError"
+        assert response["error"] == "An unexpected error occurred"
+        assert response["task_name"] is None
+
+    def test_execute_task_with_actual_func(self, webhook):
+        def actual_function(*args, **kwargs):
+            return "actual result"
+
+        mock_func = Mock()
+        mock_func.actual_func = actual_function
+
+        payload = Mock(function_path="test.path", args=[1, 2], kwargs={"key": "value"})
+
+        with patch(
+            "django_qstash.handlers.utils.import_string", return_value=mock_func
+        ):
+            result = webhook.execute_task(payload)
+
+        assert result == "actual result"

django_qstash-0.0.3/tests/test_results_models.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+
+import pytest
+from django.utils import timezone
+
+from django_qstash.results.models import TaskResult
+
+
+@pytest.mark.django_db(transaction=True)
+class TestTaskResult:
+    def test_create_task_result(self):
+        task_result = TaskResult.objects.create(
+            task_id="test-task-123",
+            task_name="test_module.test_function",
+        )
+
+        assert isinstance(task_result.id, uuid.UUID)
+        assert task_result.task_id == "test-task-123"
+        assert task_result.task_name == "test_module.test_function"
+        assert task_result.status == "PENDING"
+        assert isinstance(task_result.date_created, datetime)
+        assert task_result.date_done is None
+        assert task_result.result is None
+        assert task_result.traceback is None
+        assert task_result.args is None
+        assert task_result.kwargs is None
+
+    def test_str_representation(self):
+        task_result = TaskResult.objects.create(
+            task_id="test-task-123",
+            task_name="test_module.test_function",
+        )
+
+        assert str(task_result) == "test_module.test_function (test-task-123)"
+
+    def test_task_result_with_all_fields(self):
+        task_result = TaskResult.objects.create(
+            task_id="test-task-456",
+            task_name="test_module.other_function",
+            status="SUCCESS",
+            date_done=timezone.now(),
+            result={"success": True},
+            traceback="No errors",
+            args=[1, 2, 3],
+            kwargs={"key": "value"},
+        )
+
+        assert task_result.status == "SUCCESS"
+        assert isinstance(task_result.date_done, datetime)
+        assert task_result.result == {"success": True}
+        assert task_result.traceback == "No errors"
+        assert task_result.args == [1, 2, 3]
+        assert task_result.kwargs == {"key": "value"}
+
+    def test_ordering(self):
+        # Create tasks with different completion dates
+        older_task = TaskResult.objects.create(
+            task_id="older-task",
+            task_name="test.older",
+            status="SUCCESS",
+            date_done=timezone.now(),
+        )
+        newer_task = TaskResult.objects.create(
+            task_id="newer-task",
+            task_name="test.newer",
+            status="SUCCESS",
+            date_done=timezone.now(),
+        )
+
+        # Get all tasks and verify ordering
+        tasks = TaskResult.objects.all()
+        assert tasks[0].task_id == newer_task.task_id
+        assert tasks[1].task_id == older_task.task_id

django_qstash-0.0.3/tests/test_views.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import pytest
+from django.test import Client
+
+
+@pytest.mark.django_db
+class TestQStashWebhook:
+    def setup_method(self):
+        self.client = Client()
+        self.url = "/qstash/webhook/"
+
+    @patch("django_qstash.views.QStashWebhook")
+    def test_valid_webhook_request(self, mock_webhook_class):
+        """Test webhook with valid signature and payload"""
+        # Setup mock webhook instance
+        mock_webhook = mock_webhook_class.return_value
+        mock_webhook.handle_request.return_value = ({"status": "success"}, 200)
+
+        payload = {
+            "function": "sample_task",
+            "module": "tests.test_tasks",
+            "args": [2, 3],
+            "kwargs": {},
+            "task_name": "test_task",
+        }
+
+        response = self.client.post(
+            self.url,
+            data=json.dumps(payload),
+            content_type="application/json",
+            headers={"upstash-signature": "mock-signature"},
+        )
+
+        # Verify response
+        assert response.status_code == 200
+        response_data = json.loads(response.content)
+        assert response_data["status"] == "success"
+
+        # Verify webhook was called correctly
+        mock_webhook.handle_request.assert_called_once()
+
+    @patch("django_qstash.views.QStashWebhook")
+    def test_invalid_request(self, mock_webhook_class):
+        """Test webhook with invalid request"""
+        # Setup mock webhook instance
+        mock_webhook = mock_webhook_class.return_value
+        mock_webhook.handle_request.return_value = ({"error": "Invalid request"}, 400)
+
+        response = self.client.post(
+            self.url,
+            data="invalid json",
+            content_type="application/json",
+            headers={"upstash-signature": "mock-signature"},
+        )
+
+        assert response.status_code == 400
+        response_data = json.loads(response.content)
+        assert "error" in response_data

django_qstash-0.0.1/src/django_qstash/views.py

@@ -1,124 +0,0 @@
-import json
-import logging
-
-from django.conf import settings
-from django.http import (
-    HttpRequest,
-    HttpResponse,
-    HttpResponseBadRequest,
-    HttpResponseForbidden,
-)
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_http_methods
-from qstash import Receiver
-
-from . import utils
-
-DJANGO_QSTASH_FORCE_HTTPS = getattr(settings, "DJANGO_QSTASH_FORCE_HTTPS", True)
-
-logger = logging.getLogger(__name__)
-
-
-# Initialize the QStash receiver
-receiver = Receiver(
-    current_signing_key=settings.QSTASH_CURRENT_SIGNING_KEY,
-    next_signing_key=settings.QSTASH_NEXT_SIGNING_KEY,
-)
-
-
-@csrf_exempt
-@require_http_methods(["POST"])
-def qstash_webhook_view(request: HttpRequest) -> HttpResponse:
-    """
-    Webhook handler for QStash callbacks.
-
-    Expects a POST request with:
-    - Upstash-Signature header for verification
-    - JSON body containing task information:
-        {
-            "function": "full.path.to.function",
-            "module": "module.path",
-            "args": [...],
-            "kwargs": {...},
-            "task_name": "optional_task_name",
-            "options": {...}
-        }
-    """
-    try:
-        # Get the signature from headers
-        signature = request.headers.get("Upstash-Signature")
-        if not signature:
-            return HttpResponseForbidden("Missing Upstash-Signature header")
-
-        # Verify the signature using the QStash SDK
-        url = request.build_absolute_uri()
-        if DJANGO_QSTASH_FORCE_HTTPS and not url.startswith("https://"):
-            url = url.replace("http://", "https://")
-        try:
-            receiver.verify(
-                body=request.body.decode(),
-                signature=signature,
-                url=url,
-            )
-        except Exception as e:
-            logger.error(f"Signature verification failed: {e}")
-            return HttpResponseForbidden("Invalid signature")
-
-        # Parse the payload
-        try:
-            payload = json.loads(request.body.decode())
-        except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse JSON payload: {e}")
-            return HttpResponseBadRequest("Invalid JSON payload")
-
-        # Validate payload structure
-        is_valid, error_message = utils.validate_task_payload(payload)
-        if not is_valid:
-            logger.error(f"Invalid payload structure: {error_message}")
-            return HttpResponseBadRequest(error_message)
-
-        # Import the function
-        try:
-            function_path = f"{payload['module']}.{payload['function']}"
-            task_func = utils.import_string(function_path)
-        except ImportError as e:
-            logger.error(f"Failed to import task function: {e}")
-            return HttpResponseBadRequest(f"Could not import task function: {e}")
-
-        # Execute the task
-        try:
-            if hasattr(task_func, "__call__") and hasattr(task_func, "actual_func"):
-                # If it's a wrapped function, call the actual function directly
-                result = task_func.actual_func(*payload["args"], **payload["kwargs"])
-            else:
-                result = task_func(*payload["args"], **payload["kwargs"])
-
-            # Prepare the response
-            response_data = {
-                "status": "success",
-                "task_name": payload.get("task_name", function_path),
-                "result": result if result is not None else "null",
-            }
-
-            return HttpResponse(
-                json.dumps(response_data), content_type="application/json"
-            )
-
-        except Exception as e:
-            logger.exception(f"Task execution failed: {e}")
-            error_response = {
-                "status": "error",
-                "task_name": payload.get("task_name", function_path),
-                "error": str(e),
-            }
-            return HttpResponse(
-                json.dumps(error_response), status=500, content_type="application/json"
-            )
-
-    except Exception as e:
-        logger.exception(f"Unexpected error in webhook handler: {e}")
-        return HttpResponse(
-            json.dumps({"status": "error", "error": "Internal server error"}),
-            status=500,
-            content_type="application/json",
-        )

django_qstash-0.0.1/src/django_qstash.egg-info/SOURCES.txt

@@ -1,14 +0,0 @@
-README.md
-pyproject.toml
-src/django_qstash/__init__.py
-src/django_qstash/tasks.py
-src/django_qstash/utils.py
-src/django_qstash/views.py
-src/django_qstash.egg-info/PKG-INFO
-src/django_qstash.egg-info/SOURCES.txt
-src/django_qstash.egg-info/dependency_links.txt
-src/django_qstash.egg-info/requires.txt
-src/django_qstash.egg-info/top_level.txt
-tests/test_tasks.py
-tests/test_utils.py
-tests/test_views.py

django_qstash-0.0.1/tests/test_views.py

@@ -1,75 +0,0 @@
-import json
-from unittest.mock import patch
-
-import pytest
-from django.test import Client
-
-
-@pytest.mark.django_db
-class TestQStashWebhook:
-    def setup_method(self):
-        self.client = Client()
-        self.url = "/qstash/webhook/"  # Adjust if your URL is different
-
-    @patch("django_qstash.views.receiver")
-    def test_valid_webhook_request(self, mock_receiver):
-        """Test webhook with valid signature and payload"""
-        payload = {
-            "function": "sample_task",
-            "module": "tests.test_tasks",
-            "args": [2, 3],
-            "kwargs": {},
-            "task_name": "test_task",
-        }
-
-        # Mock signature verification
-        mock_receiver.verify.return_value = True
-
-        response = self.client.post(
-            self.url,
-            data=json.dumps(payload),
-            content_type="application/json",
-            headers={"upstash-signature": "mock-signature"},
-        )
-
-        assert response.status_code == 200
-        response_data = json.loads(response.content)
-        assert response_data["status"] == "success"
-
-    def test_missing_signature(self):
-        """Test webhook request without signature header"""
-        response = self.client.post(
-            self.url, data=json.dumps({}), content_type="application/json"
-        )
-        assert response.status_code == 403
-
-    @patch("django_qstash.views.receiver")
-    def test_invalid_json_payload(self, mock_receiver):
-        """Test webhook with invalid JSON payload"""
-        mock_receiver.verify.return_value = True
-
-        response = self.client.post(
-            self.url,
-            data="invalid json",
-            content_type="application/json",
-            headers={"upstash-signature": "mock-signature"},
-        )
-        assert response.status_code == 400
-
-    @patch("django_qstash.views.receiver")
-    def test_invalid_payload_structure(self, mock_receiver):
-        """Test webhook with missing required fields"""
-        mock_receiver.verify.return_value = True
-
-        payload = {
-            "function": "sample_task",
-            # missing required fields
-        }
-
-        response = self.client.post(
-            self.url,
-            data=json.dumps(payload),
-            content_type="application/json",
-            headers={"upstash-signature": "mock-signature"},
-        )
-        assert response.status_code == 400