Renames and updates from upstream

Update the JSON normalize implementation, rename variables

Author: RealOrangeOne

README.md

@@ -210,16 +210,16 @@ default_task_backend.get_result(result_id)
 If your task returns something, it can be retrieved from the `.return_value` attribute on a `TaskResult`. Accessing this property on an unsuccessful task (ie not `SUCCEEDED`) will raise a `ValueError`.
 
 ```python
-assert result.status == ResultStatus.SUCCEEDED
+assert result.status == TaskResultStatus.SUCCEEDED
 assert result.return_value == 42
 ```
 
 If a result has been updated in the background, you can call `refresh` on it to update its values. Results obtained using `get_result` will always be up-to-date.
 
 ```python
-assert result.status == ResultStatus.READY
+assert result.status == TaskResultStatus.READY
 result.refresh()
-assert result.status == ResultStatus.SUCCEEDED
+assert result.status == TaskResultStatus.SUCCEEDED
 ```
 
 #### Errors

django_tasks/__init__.py

@@ -10,30 +10,30 @@
 
 from .backends.base import BaseTaskBackend
 from .base import (
-    DEFAULT_QUEUE_NAME,
     DEFAULT_TASK_BACKEND_ALIAS,
-    ResultStatus,
+    DEFAULT_TASK_QUEUE_NAME,
     TaskContext,
     TaskResult,
+    TaskResultStatus,
     task,
 )
 from .exceptions import InvalidTaskBackendError
 
 __version__ = importlib.metadata.version(__name__)
 
 __all__ = [
-    "tasks",
+    "task_backends",
     "default_task_backend",
     "DEFAULT_TASK_BACKEND_ALIAS",
-    "DEFAULT_QUEUE_NAME",
-    "ResultStatus",
+    "DEFAULT_TASK_QUEUE_NAME",
+    "TaskResultStatus",
     "TaskResult",
     "TaskContext",
     "task",
 ]
 
 
-class TasksHandler(BaseConnectionHandler[BaseTaskBackend]):
+class TaskBackendHandler(BaseConnectionHandler[BaseTaskBackend]):
     settings_name = "TASKS"
     exception_class = InvalidTaskBackendError
 
@@ -64,8 +64,8 @@ def create_connection(self, alias: str) -> BaseTaskBackend:
         return backend_cls(alias=alias, params=params)  # type:ignore[no-any-return]
 
 
-tasks = TasksHandler()
+task_backends = TaskBackendHandler()
 
 default_task_backend: BaseTaskBackend = ConnectionProxy(  # type:ignore[assignment]
-    tasks, DEFAULT_TASK_BACKEND_ALIAS
+    task_backends, DEFAULT_TASK_BACKEND_ALIAS
 )

django_tasks/backends/base.py

@@ -12,9 +12,9 @@
 from typing_extensions import ParamSpec
 
 from django_tasks.base import (
-    DEFAULT_PRIORITY,
-    MAX_PRIORITY,
-    MIN_PRIORITY,
+    TASK_DEFAULT_PRIORITY,
+    TASK_MAX_PRIORITY,
+    TASK_MIN_PRIORITY,
     Task,
     TaskResult,
 )
@@ -44,10 +44,10 @@ class BaseTaskBackend(metaclass=ABCMeta):
     """Does the backend support tasks being executed in a given priority order?"""
 
     def __init__(self, alias: str, params: dict) -> None:
-        from django_tasks import DEFAULT_QUEUE_NAME
+        from django_tasks import DEFAULT_TASK_QUEUE_NAME
 
         self.alias = alias
-        self.queues = set(params.get("QUEUES", [DEFAULT_QUEUE_NAME]))
+        self.queues = set(params.get("QUEUES", [DEFAULT_TASK_QUEUE_NAME]))
         self.enqueue_on_commit = bool(params.get("ENQUEUE_ON_COMMIT", True))
         self.options = params.get("OPTIONS", {})
 
@@ -82,18 +82,18 @@ def validate_task(self, task: Task) -> None:
                 "Task takes context but does not have a first argument of 'context'."
             )
 
-        if not self.supports_priority and task.priority != DEFAULT_PRIORITY:
+        if not self.supports_priority and task.priority != TASK_DEFAULT_PRIORITY:
             raise InvalidTaskError(
                 "Backend does not support setting priority of tasks."
             )
 
         if (
-            task.priority < MIN_PRIORITY
-            or task.priority > MAX_PRIORITY
+            task.priority < TASK_MIN_PRIORITY
+            or task.priority > TASK_MAX_PRIORITY
             or int(task.priority) != task.priority
         ):
             raise InvalidTaskError(
-                f"priority must be a whole number between {MIN_PRIORITY} and {MAX_PRIORITY}."
+                f"priority must be a whole number between {TASK_MIN_PRIORITY} and {TASK_MAX_PRIORITY}."
             )
 
         if not self.supports_defer and task.run_after is not None:

django_tasks/backends/database/backend.py

@@ -12,8 +12,9 @@
 from django_tasks.backends.base import BaseTaskBackend
 from django_tasks.base import Task
 from django_tasks.base import TaskResult as BaseTaskResult
-from django_tasks.exceptions import ResultDoesNotExist
+from django_tasks.exceptions import TaskResultDoesNotExist
 from django_tasks.signals import task_enqueued
+from django_tasks.utils import normalize_json
 
 if TYPE_CHECKING:
     from .models import DBTaskResult
@@ -42,7 +43,7 @@ def _task_to_db_task(
         from .models import DBTaskResult
 
         return DBTaskResult(
-            args_kwargs={"args": args, "kwargs": kwargs},
+            args_kwargs=normalize_json({"args": args, "kwargs": kwargs}),
             priority=task.priority,
             task_path=task.module_path,
             queue_name=task.queue_name,
@@ -77,15 +78,15 @@ def get_result(self, result_id: str) -> TaskResult:
         try:
             return DBTaskResult.objects.get(id=result_id).task_result
         except (DBTaskResult.DoesNotExist, ValidationError) as e:
-            raise ResultDoesNotExist(result_id) from e
+            raise TaskResultDoesNotExist(result_id) from e
 
     async def aget_result(self, result_id: str) -> TaskResult:
         from .models import DBTaskResult
 
         try:
             return (await DBTaskResult.objects.aget(id=result_id)).task_result
         except (DBTaskResult.DoesNotExist, ValidationError) as e:
-            raise ResultDoesNotExist(result_id) from e
+            raise TaskResultDoesNotExist(result_id) from e
 
     def check(self, **kwargs: Any) -> Iterable[checks.CheckMessage]:
         yield from super().check(**kwargs)

django_tasks/backends/database/management/commands/db_worker.py

@@ -15,11 +15,11 @@
 from django.db.utils import OperationalError
 from django.utils.autoreload import DJANGO_AUTORELOAD_ENV, run_with_reloader
 
-from django_tasks import DEFAULT_TASK_BACKEND_ALIAS, tasks
+from django_tasks import DEFAULT_TASK_BACKEND_ALIAS, task_backends
 from django_tasks.backends.database.backend import DatabaseBackend
 from django_tasks.backends.database.models import DBTaskResult
 from django_tasks.backends.database.utils import exclusive_transaction
-from django_tasks.base import DEFAULT_QUEUE_NAME, TaskContext
+from django_tasks.base import DEFAULT_TASK_QUEUE_NAME, TaskContext
 from django_tasks.exceptions import InvalidTaskBackendError
 from django_tasks.signals import task_finished, task_started
 from django_tasks.utils import get_random_id
@@ -193,7 +193,7 @@ def run_task(self, db_task_result: DBTaskResult) -> None:
 
 def valid_backend_name(val: str) -> str:
     try:
-        backend = tasks[val]
+        backend = task_backends[val]
     except InvalidTaskBackendError as e:
         raise ArgumentTypeError(e.args[0]) from e
     if not isinstance(backend, DatabaseBackend):
@@ -232,7 +232,7 @@ def add_arguments(self, parser: ArgumentParser) -> None:
         parser.add_argument(
             "--queue-name",
             nargs="?",
-            default=DEFAULT_QUEUE_NAME,
+            default=DEFAULT_TASK_QUEUE_NAME,
             type=str,
             help="The queues to process. Separate multiple with a comma. To process all queues, use '*' (default: %(default)r)",
         )

django_tasks/backends/database/management/commands/prune_db_task_results.py

@@ -6,18 +6,22 @@
 from django.db.models import Q
 from django.utils import timezone
 
-from django_tasks import DEFAULT_QUEUE_NAME, DEFAULT_TASK_BACKEND_ALIAS, tasks
+from django_tasks import (
+    DEFAULT_TASK_BACKEND_ALIAS,
+    DEFAULT_TASK_QUEUE_NAME,
+    task_backends,
+)
 from django_tasks.backends.database.backend import DatabaseBackend
 from django_tasks.backends.database.models import DBTaskResult
-from django_tasks.base import ResultStatus
+from django_tasks.base import TaskResultStatus
 from django_tasks.exceptions import InvalidTaskBackendError
 
 logger = logging.getLogger("django_tasks.backends.database.prune_db_task_results")
 
 
 def valid_backend_name(val: str) -> DatabaseBackend:
     try:
-        backend = tasks[val]
+        backend = task_backends[val]
     except InvalidTaskBackendError as e:
         raise ArgumentTypeError(e.args[0]) from e
     if not isinstance(backend, DatabaseBackend):
@@ -47,7 +51,7 @@ def add_arguments(self, parser: ArgumentParser) -> None:
         parser.add_argument(
             "--queue-name",
             nargs="?",
-            default=DEFAULT_QUEUE_NAME,
+            default=DEFAULT_TASK_QUEUE_NAME,
             type=str,
             help="The queues to process. Separate multiple with a comma. To process all queues, use '*' (default: %(default)r)",
         )
@@ -114,8 +118,8 @@ def handle(
             results = results.filter(finished_at__lte=min_age)
         else:
             results = results.filter(
-                Q(status=ResultStatus.SUCCEEDED, finished_at__lte=min_age)
-                | Q(status=ResultStatus.FAILED, finished_at__lte=failed_min_age)
+                Q(status=TaskResultStatus.SUCCEEDED, finished_at__lte=min_age)
+                | Q(status=TaskResultStatus.FAILED, finished_at__lte=failed_min_age)
             )
 
         if dry_run:

django_tasks/backends/database/migrations/0008_separate_results_field.py

@@ -4,7 +4,7 @@
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.migrations.state import StateApps
 
-from django_tasks import ResultStatus
+from django_tasks import TaskResultStatus
 
 
 def separate_results_field(
@@ -14,12 +14,12 @@ def separate_results_field(
 
     # If a task succeeded, the result is its return value
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
-        status=ResultStatus.SUCCEEDED
+        status=TaskResultStatus.SUCCEEDED
     ).update(return_value=models.F("result"))
 
     # If a task failed, the result is the exception data (or nothing)
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
-        status=ResultStatus.FAILED
+        status=TaskResultStatus.FAILED
     ).update(exception_data=models.F("result"))
 
 
@@ -30,12 +30,12 @@ def merge_results_field(
 
     # If a task succeeded, the result is its return value
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
-        status=ResultStatus.SUCCEEDED
+        status=TaskResultStatus.SUCCEEDED
     ).update(result=models.F("return_value"))
 
     # If a task failed, the result is the exception data (or nothing)
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
-        status=ResultStatus.FAILED
+        status=TaskResultStatus.FAILED
     ).update(result=models.F("exception_data"))
 
 

django_tasks/backends/database/migrations/0011_rename_complete_status.py

@@ -4,7 +4,7 @@
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.migrations.state import StateApps
 
-from django_tasks import ResultStatus
+from django_tasks import TaskResultStatus
 
 
 def separate_results_field(
@@ -14,7 +14,7 @@ def separate_results_field(
 
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
         status="COMPLETE"
-    ).update(status=ResultStatus.SUCCEEDED)
+    ).update(status=TaskResultStatus.SUCCEEDED)
 
 
 def merge_results_field(
@@ -23,7 +23,7 @@ def merge_results_field(
     DBTaskResult = apps.get_model("django_tasks_database", "DBTaskResult")
 
     DBTaskResult.objects.using(schema_editor.connection.alias).filter(
-        status=ResultStatus.SUCCEEDED
+        status=TaskResultStatus.SUCCEEDED
     ).update(status="COMPLETE")