Remove django-tasks dependency

Author: RealOrangeOne

.github/workflows/ci.yml

@@ -43,6 +43,9 @@ jobs:
           pip install --upgrade pip
           pip install -e . --group dev
           pip install Django~=${{ matrix.django-version }}
+      - name: Install django-tasks
+        run: pip install django-tasks
+        if: matrix.django-version != '6.0'
       - name: Lint
         run: just lint
       - name: Run fast tests

django_tasks_db/backend.py

@@ -9,22 +9,32 @@
 from django.db.models import Expression
 from django.utils.module_loading import import_string
 from django.utils.version import PY311
-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 TaskResultDoesNotExist
-from django_tasks.signals import task_enqueued
-from django_tasks.utils import normalize_json
 from typing_extensions import ParamSpec
 
+try:
+    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 TaskResultDoesNotExist
+    from django.tasks.signals import task_enqueued
+    from django.utils.json import normalize_json
+except ImportError:
+    from django_tasks.backends.base import BaseTaskBackend  # type: ignore[no-redef]
+    from django_tasks.base import Task  # type: ignore[no-redef]
+    from django_tasks.base import TaskResult as BaseTaskResult  # type: ignore[no-redef]
+    from django_tasks.exceptions import TaskResultDoesNotExist  # type: ignore[no-redef]
+    from django_tasks.signals import task_enqueued  # type: ignore[no-redef]
+    from django_tasks.utils import normalize_json  # type: ignore[no-redef]
+
+
 if TYPE_CHECKING:
     from .models import DBTaskResult
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
-@dataclass(frozen=True, slots=PY311, kw_only=True)  # type: ignore[literal-required]
+@dataclass(frozen=True, slots=PY311, kw_only=True)  # type: ignore[literal-required,misc]
 class TaskResult(BaseTaskResult[T]):
     db_result: "DBTaskResult"
 

django_tasks_db/compat.py

@@ -1,10 +1,19 @@
+_task_classes = []
+
 try:
     from django.tasks.base import Task as DjangoTask
+
+    _task_classes.append(DjangoTask)
 except ImportError:
-    DjangoTask = None  # type: ignore[misc,assignment]
+    pass
 
-from django_tasks.base import Task
+try:
+    from django_tasks.base import Task
+
+    _task_classes.append(Task)
+except ImportError:
+    pass
 
 __all__ = ["TASK_CLASSES"]
 
-TASK_CLASSES = (Task, DjangoTask) if DjangoTask is not None else (Task,)
+TASK_CLASSES = tuple(_task_classes)

django_tasks_db/management/commands/db_worker.py

@@ -14,11 +14,20 @@
 from django.db import close_old_connections
 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, task_backends
-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
+from django.utils.crypto import get_random_string
+
+try:
+    from django.tasks import DEFAULT_TASK_BACKEND_ALIAS, task_backends
+    from django.tasks.base import DEFAULT_TASK_QUEUE_NAME, TaskContext
+    from django.tasks.exceptions import InvalidTaskBackend
+    from django.tasks.signals import task_finished, task_started
+    TASKS_LOGGER = "django.tasks"
+except ImportError:
+    from django_tasks import DEFAULT_TASK_BACKEND_ALIAS, task_backends
+    from django_tasks.base import DEFAULT_TASK_QUEUE_NAME, TaskContext
+    from django_tasks.exceptions import InvalidTaskBackendError as InvalidTaskBackend
+    from django_tasks.signals import task_finished, task_started
+    TASKS_LOGGER = "django_tasks"
 
 from django_tasks_db.backend import DatabaseBackend
 from django_tasks_db.models import DBTaskResult
@@ -197,7 +206,7 @@ def run_task(self, db_task_result: DBTaskResult) -> None:
 def valid_backend_name(val: str) -> str:
     try:
         backend = task_backends[val]
-    except InvalidTaskBackendError as e:
+    except InvalidTaskBackend as e:
         raise ArgumentTypeError(e.args[0]) from e
     if not isinstance(backend, DatabaseBackend):
         raise ArgumentTypeError(f"Backend '{val}' is not a database backend")
@@ -283,11 +292,11 @@ def add_arguments(self, parser: ArgumentParser) -> None:
             nargs="?",
             type=validate_worker_id,
             help="Worker id. MUST be unique across worker pool (default: auto-generate)",
-            default=get_random_id(),
+            default=get_random_string(32),
         )
 
     def configure_logging(self, verbosity: int) -> None:
-        tasks_logger = logging.getLogger("django_tasks")
+        tasks_logger = logging.getLogger(TASKS_LOGGER)
 
         if verbosity == 0:
             tasks_logger.setLevel(logging.CRITICAL)

django_tasks_db/management/commands/prune_db_task_results.py

@@ -5,13 +5,23 @@
 from django.core.management.base import BaseCommand
 from django.db.models import Q
 from django.utils import timezone
-from django_tasks import (
-    DEFAULT_TASK_BACKEND_ALIAS,
-    DEFAULT_TASK_QUEUE_NAME,
-    task_backends,
-)
-from django_tasks.base import TaskResultStatus
-from django_tasks.exceptions import InvalidTaskBackendError
+
+try:
+    from django.tasks import (
+        DEFAULT_TASK_BACKEND_ALIAS,
+        DEFAULT_TASK_QUEUE_NAME,
+        task_backends,
+    )
+    from django.tasks.base import TaskResultStatus
+    from django.tasks.exceptions import InvalidTaskBackend
+except ImportError:
+    from django_tasks import (
+        DEFAULT_TASK_BACKEND_ALIAS,
+        DEFAULT_TASK_QUEUE_NAME,
+        task_backends,
+    )
+    from django_tasks.base import TaskResultStatus
+    from django_tasks.exceptions import InvalidTaskBackendError as InvalidTaskBackend
 
 from django_tasks_db.backend import DatabaseBackend
 from django_tasks_db.models import DBTaskResult
@@ -22,7 +32,7 @@
 def valid_backend_name(val: str) -> DatabaseBackend:
     try:
         backend = task_backends[val]
-    except InvalidTaskBackendError as e:
+    except InvalidTaskBackend as e:
         raise ArgumentTypeError(e.args[0]) from e
     if not isinstance(backend, DatabaseBackend):
         raise ArgumentTypeError(f"Backend '{val}' is not a database backend")

django_tasks_db/models.py

@@ -1,6 +1,7 @@
 import datetime
 import logging
 import uuid
+from traceback import format_exception
 from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar
 
 import django
@@ -12,21 +13,30 @@
 from django.utils import timezone
 from django.utils.module_loading import import_string
 from django.utils.translation import gettext_lazy as _
-from django_tasks.base import (
-    DEFAULT_TASK_PRIORITY,
-    DEFAULT_TASK_QUEUE_NAME,
-    TASK_MAX_PRIORITY,
-    TASK_MIN_PRIORITY,
-    Task,
-    TaskError,
-    TaskResultStatus,
-)
-from django_tasks.utils import (
-    get_exception_traceback,
-    get_module_path,
-)
 from typing_extensions import ParamSpec
 
+try:
+    from django.tasks.base import (
+        DEFAULT_TASK_PRIORITY,
+        DEFAULT_TASK_QUEUE_NAME,
+        TASK_MAX_PRIORITY,
+        TASK_MIN_PRIORITY,
+        Task,
+        TaskError,
+        TaskResultStatus,
+    )
+except ImportError:
+    from django_tasks.base import (  # type: ignore[no-redef]
+        DEFAULT_TASK_PRIORITY,
+        DEFAULT_TASK_QUEUE_NAME,
+        TASK_MAX_PRIORITY,
+        TASK_MIN_PRIORITY,
+        Task,
+        TaskError,
+        TaskResultStatus,
+    )
+
+
 from .compat import TASK_CLASSES
 from .utils import normalize_uuid, retry
 
@@ -168,7 +178,7 @@ def task(self) -> Task[P, T]:
             queue_name=self.queue_name,
             run_after=None if self.run_after == get_date_max() else self.run_after,
             backend=self.backend_name,
-        )  # type: ignore[return-value]
+        )
 
     @property
     def task_result(self) -> "TaskResult[T]":
@@ -248,8 +258,8 @@ def set_successful(self, return_value: Any) -> None:
     def set_failed(self, exc: BaseException) -> None:
         self.status = TaskResultStatus.FAILED
         self.finished_at = timezone.now()
-        self.exception_class_path = get_module_path(type(exc))
-        self.traceback = get_exception_traceback(exc)
+        self.exception_class_path = f"{type(exc).__module__}.{type(exc).__qualname__}"
+        self.traceback = "".join(format_exception(exc))
         self.return_value = None
 
         self.save(

pyproject.toml

@@ -42,7 +42,6 @@ dependencies = [
     "Django>=4.2",
     "typing_extensions",
     "django-stubs-ext",
-    "django-tasks>=0.12.0"
 ]
 
 [project.urls]

tests/tasks.py

@@ -1,7 +1,10 @@
 import time
 from typing import Any
 
-from django_tasks import TaskContext, task
+try:
+    from django.tasks import TaskContext, task
+except ImportError:
+    from django_tasks import TaskContext, task  # type:ignore[no-redef]
 
 
 @task()

tests/tests.py

@@ -28,15 +28,34 @@
 from django.test import SimpleTestCase, TestCase, TransactionTestCase, override_settings
 from django.test.testcases import _deferredSkip  # type:ignore[attr-defined]
 from django.utils import timezone
-from django_tasks import (
-    TaskResultStatus,
-    default_task_backend,
-    task_backends,
-)
-from django_tasks.base import Task
-from django_tasks.exceptions import InvalidTaskError, TaskResultDoesNotExist
-from django_tasks.signals import task_enqueued
-from django_tasks.utils import get_random_id
+from django.utils.crypto import get_random_string
+
+try:
+    from django.tasks import (
+        TaskResultStatus,
+        default_task_backend,
+        task_backends,
+    )
+    from django.tasks.base import Task
+    from django.tasks.exceptions import InvalidTask, TaskResultDoesNotExist
+    from django.tasks.signals import task_enqueued
+
+    DUMMY_BACKEND = "django.tasks.backends.dummy.DummyBackend"
+    LOGGER = "django.tasks"
+except ImportError:
+    from django_tasks import (
+        TaskResultStatus,
+        default_task_backend,
+        task_backends,
+    )
+    from django_tasks.base import Task
+    from django_tasks.exceptions import InvalidTaskError as InvalidTask
+    from django_tasks.exceptions import TaskResultDoesNotExist
+    from django_tasks.signals import task_enqueued
+
+    DUMMY_BACKEND = "django_tasks.backends.dummy.DummyBackend"
+    LOGGER = "django_tasks"
+
 
 from django_tasks_db import DatabaseBackend, compat
 from django_tasks_db.admin import DBTaskResultAdmin
@@ -166,7 +185,7 @@ def test_refresh_result(self) -> None:
             started_at=timezone.now(),
             finished_at=timezone.now(),
             return_value=42,
-            worker_ids=[get_random_id()],
+            worker_ids=[get_random_string(32)],
         )
 
         self.assertEqual(result.status, TaskResultStatus.READY)
@@ -197,7 +216,7 @@ async def test_refresh_result_async(self) -> None:
             started_at=timezone.now(),
             finished_at=timezone.now(),
             return_value=42,
-            worker_ids=[get_random_id()],
+            worker_ids=[get_random_string(32)],
         )
 
         self.assertEqual(result.status, TaskResultStatus.READY)
@@ -335,7 +354,7 @@ def test_doesnt_wait_until_transaction_commit(self) -> None:
             self.assertEqual(self.get_task_count_in_new_connection(), 1)
 
     def test_enqueue_logs(self) -> None:
-        with self.assertLogs("django_tasks", level="DEBUG") as captured_logs:
+        with self.assertLogs(LOGGER, level="DEBUG") as captured_logs:
             result = test_tasks.noop_task.enqueue()
 
         self.assertEqual(len(captured_logs.output), 1)
@@ -421,7 +440,7 @@ def test_validate_on_enqueue(self) -> None:
             )
 
         with self.assertRaisesMessage(
-            InvalidTaskError, "Queue 'unknown_queue' is not valid for backend"
+            InvalidTask, "Queue 'unknown_queue' is not valid for backend"
         ):
             task_with_custom_queue_name.enqueue()
 
@@ -439,7 +458,7 @@ async def test_validate_on_aenqueue(self) -> None:
             )
 
         with self.assertRaisesMessage(
-            InvalidTaskError, "Queue 'unknown_queue' is not valid for backend"
+            InvalidTask, "Queue 'unknown_queue' is not valid for backend"
         ):
             await task_with_custom_queue_name.aenqueue()
 
@@ -511,11 +530,11 @@ def test_postgres_id_function_expression(self) -> None:
             "BACKEND": "django_tasks_db.DatabaseBackend",
             "QUEUES": ["default", "queue-1"],
         },
-        "dummy": {"BACKEND": "django_tasks.backends.dummy.DummyBackend"},
+        "dummy": {"BACKEND": DUMMY_BACKEND},
     }
 )
 class DatabaseBackendWorkerTestCase(TransactionTestCase):
-    worker_id = get_random_id()
+    worker_id = get_random_string(32)
 
     run_worker = staticmethod(
         partial(
@@ -531,7 +550,7 @@ class DatabaseBackendWorkerTestCase(TransactionTestCase):
 
     def tearDown(self) -> None:
         logger = logging.getLogger("django_tasks_db")
-        tasks_logger = logging.getLogger("django_tasks")
+        tasks_logger = logging.getLogger(LOGGER)
 
         # Reset the logger after every run, to ensure the correct `stdout` is used
         for handler in logger.handlers:
@@ -1240,7 +1259,7 @@ def test_exclusive_transaction(self) -> None:
             "BACKEND": "django_tasks_db.DatabaseBackend",
             "QUEUES": ["default", "queue-1"],
         },
-        "dummy": {"BACKEND": "django_tasks.backends.dummy.DummyBackend"},
+        "dummy": {"BACKEND": DUMMY_BACKEND},
     }
 )
 class DatabaseBackendPruneTaskResultsTestCase(TransactionTestCase):
@@ -1518,7 +1537,7 @@ def start_worker(
             args = []
 
         if worker_id is None:
-            worker_id = get_random_id()
+            worker_id = get_random_string(32)
 
         p = subprocess.Popen(
             [
@@ -1606,7 +1625,7 @@ def test_repeat_ctrl_c(self) -> None:
         result = test_tasks.hang.enqueue()
         self.assertEqual(DBTaskResult.objects.get(id=result.id).worker_ids, [])
 
-        worker_id = get_random_id()
+        worker_id = get_random_string(32)
 
         process = self.start_worker(worker_id=worker_id)