edu-async-tasks 1.0.0__py3-none-any.whl

edu_async_tasks/__init__.py

@@ -0,0 +1,35 @@
+"""Реестр "Асинхронные задачи"."""
+
+from typing import (
+    Union,
+)
+
+from .config import (
+    Config,
+)
+
+
+__config: Union[Config, None] = None
+
+
+def set_config(config: Config) -> None:
+    assert isinstance(config, Config)
+
+    global __config
+
+    __config = config
+
+
+def get_config() -> Config:
+    global __config
+
+    if __config is None:
+        raise ValueError('Конфигурация не установлена')
+
+    return __config
+
+
+def reset_config() -> None:
+    global __config
+
+    __config = None

edu_async_tasks/config.py

@@ -0,0 +1,57 @@
+from pydantic.class_validators import (
+    validator,
+)
+from pydantic.dataclasses import (
+    dataclass,
+)
+from pydantic.fields import (
+    Field,
+)
+
+
+@dataclass
+class Config:
+    task_start_time_format: str = Field(
+        title='Формат времени',
+        default='%H:%M %d.%m.%Y'
+    )
+    task_default_user_name: str = Field(
+        title='Имя пользователя по-умолчанию',
+        default='Система'
+    )
+    default_lock_expire: int = Field(  # noqa
+        title='Задача считается уникальной в течение',
+        default=30 * 60
+    )
+    filter_days_after_start: int = Field(  # noqa
+        title='Фильтр реестра - количество дней, в течение которых были запущены задачи',
+        default=7
+    )
+
+    @validator('task_start_time_format')
+    @classmethod
+    def validate_task_start_time_format(cls, value):
+        if not isinstance(value, str) or not value:
+            raise ValueError(f'Неверное значение поля "{cls.task_start_time_format.title}"')
+        return value
+
+    @validator('task_default_user_name')
+    @classmethod
+    def validate_task_default_user_name(cls, value):
+        if not isinstance(value, str) or not value:
+            raise ValueError(f'Неверное значение поля "{cls.task_default_user_name.title}"')
+        return value
+
+    @validator('default_lock_expire')
+    @classmethod
+    def validate_default_lock_expire(cls, value):
+        if not isinstance(value, int) or value <= 0:
+            raise ValueError(f'Неверное значение поля "{cls.default_lock_expire.title}"')
+        return value
+
+    @validator('filter_days_after_start')
+    @classmethod
+    def validate_filter_days_after_start(cls, value):
+        if not isinstance(value, int) or value <= 0:
+            raise ValueError(f'Неверное значение поля "{cls.filter_days_after_start.title}"')
+        return value

edu_async_tasks/core/__init__.py

@@ -0,0 +1 @@
+default_app_config = __name__ + '.apps.AppConfig'

edu_async_tasks/core/adapters/db.py

@@ -0,0 +1,35 @@
+from typing import (
+    TYPE_CHECKING,
+)
+
+from django.core.exceptions import (
+    ValidationError,
+)
+
+from ..models import (
+    RunningTask,
+)
+
+
+if TYPE_CHECKING:
+    from django.db.models.query import (
+        QuerySet,
+    )
+
+
+class RunningTasksRepository:
+
+    def get_by_id(self, id_: str) -> RunningTask:
+        return RunningTask.objects.get(pk=id_)
+
+    def get_by_ids(self, *ids: str) -> 'QuerySet[RunningTask]':
+        """Возвращает кверисет асинхронных задач."""
+        try:
+            result = RunningTask.objects.filter(id__in=ids)
+        except ValidationError:
+            result = RunningTask.objects.none()
+
+        return result
+
+
+running_tasks_repository = RunningTasksRepository()

edu_async_tasks/core/apps.py

@@ -0,0 +1,9 @@
+from django.apps import (
+    AppConfig as AppConfigBase,
+)
+
+
+class AppConfig(AppConfigBase):
+
+    name = __package__
+    label = 'edu_async_tasks_core'

edu_async_tasks/core/domain/__init__.py

@@ -0,0 +1,7 @@
+from .model import (
+    PeriodicTaskLocker,
+    TaskLocker,
+    TaskResult,
+    TaskUniqueException,
+    uuid_or_none,
+)

edu_async_tasks/core/domain/model.py

@@ -0,0 +1,163 @@
+from dataclasses import (
+    dataclass,
+)
+from logging import (
+    getLogger,
+)
+from typing import (
+    Optional,
+    Union,
+)
+from uuid import (
+    UUID,
+)
+
+from celery.exceptions import (
+    Ignore,
+)
+from celery.result import (
+    AsyncResult,
+)
+from django.core.cache import (
+    cache,
+)
+from django.utils.functional import (
+    cached_property,
+)
+
+import edu_async_tasks
+
+
+@dataclass
+class TaskResult:
+    """Результат асинхронной задачи."""
+
+    values: dict
+    progress: str = ''
+    error: str = ''
+    state: str = ''
+
+
+def uuid_or_none(value) -> Union[UUID, None]:
+    """Преобразует строку в UUID или возвращает None."""
+    if value is None or isinstance(value, UUID):
+        return value
+
+    try:
+        return UUID(value)
+
+    except (AttributeError, ValueError):
+        return None
+
+
+class EduAsyncTasksException(Exception):
+    """Базовое исключение."""
+
+
+class TasksNotCancellable(EduAsyncTasksException):
+    def __init__(self, msg='Необходимо выбрать только выполняющиеся задачи', *args, **kwargs):
+        super().__init__(msg, *args, **kwargs)
+
+
+class TaskUniqueException(EduAsyncTasksException):
+    def __init__(self, msg='Задача в очереди или выполняется', *args, **kwargs):
+        super().__init__(msg, *args, **kwargs)
+
+
+class TaskLocker:
+    """Класс, отвечающий за блокировку задач."""
+
+    # формат ключа в кэше
+    LOCK_ID_FORMAT = 'async_task:lock:{task_name}_{params}'
+
+    DEFAULT_LOCK_MSG = 'Задача уже выполняется или находится в очереди'
+    DEFAULT_LOCK_VALUE = 'value'
+
+    def __init__(
+        self,
+        task_name: str = '',
+        params: Optional[dict] = None,
+        task_id: Optional[str] = None,
+        expire_on: Optional[int] = None,
+    ):
+        self.task_name = task_name
+        self.task_id = task_id
+        self.params = params if params is not None else {}
+        self.expire_on = expire_on if expire_on is not None else edu_async_tasks.get_config().default_lock_expire
+
+    @cached_property
+    def lock_id(self) -> str:
+        """Ключ в кэше."""
+        return self.LOCK_ID_FORMAT.format(
+            task_name=self.task_name,
+            params='&'.join(f'{k}={v}' for k, v in self.params.items())
+        )
+
+    def acquire_lock(self) -> str:
+        """Установка блокировки."""
+        value = self.task_id or self.DEFAULT_LOCK_VALUE
+        cache.set(self.lock_id, value, self.expire_on)
+        getLogger(__name__).debug(
+            f'Lock acquired for Task {self.task_name} ({self.params}) with value: {value}'
+        )
+
+        return self.lock_id
+
+    def delete_lock(self) -> None:
+        """Удаление блокировки."""
+        self.delete_lock_by_id(self.lock_id)
+
+    @staticmethod
+    def delete_lock_by_id(lock_id: str) -> bool:
+        """Удаление блокировки по ключу.
+
+        :param lock_id: ключ
+        """
+        return cache.delete(lock_id)
+
+    def is_locked(self) -> bool:
+        """Установлена ли блокировка."""
+        is_locked = False
+
+        value = cache.get(self.lock_id)
+
+        if value:
+            is_locked = True
+
+            # Возможна ситуация, когда задача по которой была выставлена блокировка
+            # завершила свою работу, при этом блокировка не была снята. Поэтому проверяем
+            # статус задачи по которой выставлялась блокировка:
+            if value != self.DEFAULT_LOCK_VALUE and uuid_or_none(value):
+                # значит в value должен быть task_id предыдущей задачи и по нему пытаемся определить её статус
+                async_result = AsyncResult(value)
+                if async_result and async_result.ready():
+                    # задача есть, но она уже завершилась - снимаем блокировку
+                    self.delete_lock()
+                    is_locked = False
+
+        return is_locked
+
+    def raise_if_locked(self, message: Optional[str] = None):
+        """Если блокировано, то вызывает исключение.
+
+        :raises: edu_async_tasks.exceptions.TaskUniqueException
+        """
+        if self.is_locked():
+            getLogger(__name__).debug(f'Add failed. Task {self.task_name} currently locked ({self.params})')
+
+            raise TaskUniqueException(message or self.DEFAULT_LOCK_MSG)
+
+
+class PeriodicTaskLocker(TaskLocker):
+    """Класс отвечающий за блокировку задач.
+
+    Переопределён для возможности игнорирования повторного запуска для уже
+    запущенных периодических задач.
+    """
+
+    def raise_if_locked(self, message: Optional[str] = None):
+        """Если блокировано, то вызывает исключение."""
+        if self.is_locked():
+            getLogger(__name__).debug(f'Add failed. Task {self.task_name} currently locked ({self.params})')
+
+            raise Ignore()

edu_async_tasks/core/migrations/0001_initial.py

@@ -0,0 +1,65 @@
+import django.contrib.postgres.fields.jsonb
+import django.db.models.deletion
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AsyncTaskStatus',
+            fields=[
+                ('title', models.TextField(verbose_name='расшифровка значения')),
+                ('key', models.CharField(db_index=True, max_length=512, primary_key=True, serialize=False, verbose_name='ключ')),
+                ('order_number', models.PositiveIntegerField(default=100000, verbose_name='Порядковый номер')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='AsyncTaskType',
+            fields=[
+                ('title', models.TextField(verbose_name='расшифровка значения')),
+                ('key', models.CharField(db_index=True, max_length=512, primary_key=True, serialize=False, verbose_name='ключ')),
+                ('order_number', models.PositiveIntegerField(default=100000, verbose_name='Порядковый номер')),
+            ],
+            options={
+                'verbose_name': 'Тип асинхронных задач',
+                'verbose_name_plural': 'Типы асинхронных задач',
+            },
+        ),
+        migrations.CreateModel(
+            name='RunningTask',
+            fields=[
+                ('id', models.UUIDField(primary_key=True, serialize=False, verbose_name='ID задачи')),
+                ('name', models.CharField(blank=True, max_length=512, verbose_name='Наименование задачи')),
+                ('profile_id', models.PositiveIntegerField(blank=True, null=True)),
+                ('description', models.CharField(blank=True, max_length=512, verbose_name='Описание задачи')),
+                ('options', django.contrib.postgres.fields.jsonb.JSONField(blank=True, null=True, verbose_name='Дополнительные опции задачи')),
+                ('queued_at', models.DateTimeField(blank=True, db_index=True, null=True, verbose_name='Дата и время помещения в очередь')),
+                ('started_at', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время запуска задачи')),
+                ('finished_at', models.DateTimeField(blank=True, null=True, verbose_name='Дата и время завершения задачи')),
+                ('profile_type', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.ContentType')),
+                ('status', models.ForeignKey(default='PENDING', on_delete=django.db.models.deletion.PROTECT, to='edu_async_tasks_core.AsyncTaskStatus', verbose_name='Состояние задачи')),
+                ('task_type', models.ForeignKey(default='UNKNOWN', on_delete=django.db.models.deletion.PROTECT, to='edu_async_tasks_core.AsyncTaskType', verbose_name='Тип задачи')),
+            ],
+            options={
+                'verbose_name': 'Асинхронная задача',
+                'verbose_name_plural': 'Асинхронные задачи',
+            },
+        ),
+        migrations.AddIndex(
+            model_name='runningtask',
+            index=models.Index(fields=['profile_type', 'profile_id'], name='async_task__profile_c97023_idx'),
+        ),
+    ]

edu_async_tasks/core/migrations/0002_task_type_and_status_data.py

@@ -0,0 +1,115 @@
+from django.db import (
+    migrations,
+)
+
+
+def init_task_types(apps, schema_editor):
+    """Заполнение первоначальными данными AsyncTaskType."""
+    AsyncTaskType = apps.get_model('edu_async_tasks_core', 'AsyncTaskType')  # noqa: N806
+
+    AsyncTaskType.objects.bulk_create([
+        AsyncTaskType(
+            key='UNKNOWN',
+            title='Неизвестно',
+        ),
+        AsyncTaskType(
+            key='SYSTEM',
+            title='Системная',
+        ),
+        AsyncTaskType(
+            key='REPORT',
+            title='Отчет',
+        ),
+        AsyncTaskType(
+            key='IMPORT',
+            title='Импорт данных',
+        ),
+        AsyncTaskType(
+            key='SCHEDULE_FORMING',
+            title='Формирование расписания',
+        ),
+        AsyncTaskType(
+            key='SCHEDULE_CLEANER',
+            title='Очищение расписания',
+        ),
+        AsyncTaskType(
+            key='SCHEDULE_PATTERN_COPY',
+            title='Копирование шаблона расписания',
+        ),
+        AsyncTaskType(
+            key='ST_PRINTING',
+            title='Печать учебных планов',
+        ),
+        AsyncTaskType(
+            key='ASYNC_REQUEST',
+            title='Отправка асинхронных запросов',
+        ),
+        AsyncTaskType(
+            key='MASS_EXPULSION',
+            title='Массовый выпуск',
+        ),
+        AsyncTaskType(
+            key='AIO_CLIENT',
+            title='AIO клиент',
+        ),
+    ], ignore_conflicts=True)
+
+
+def init_task_statuses(apps, schema_editor):
+    """Заполнение первоначальными данными AsyncTaskStatus."""
+    AsyncTaskStatus = apps.get_model('edu_async_tasks_core', 'AsyncTaskStatus')  # noqa: N806
+
+    AsyncTaskStatus.objects.bulk_create([
+        AsyncTaskStatus(
+            key='PENDING',
+            title='В ожидании',
+        ),
+        AsyncTaskStatus(
+            key='RECEIVED',
+            title='В очереди',
+        ),
+        AsyncTaskStatus(
+            key='STARTED',
+            title='Выполняется',
+        ),
+        AsyncTaskStatus(
+            key='SUCCESS',
+            title='Успешно выполнена',
+        ),
+        AsyncTaskStatus(
+            key='REVOKED',
+            title='Остановлена',
+        ),
+        AsyncTaskStatus(
+            key='FAILURE',
+            title='Ошибка',
+        ),
+        AsyncTaskStatus(
+            key='RETRY',
+            title='Перезапуск',
+        ),
+        AsyncTaskStatus(
+            key='IGNORED',
+            title='Игнорирована',
+        ),
+        AsyncTaskStatus(
+            key='REJECTED',
+            title='Отменена',
+        ),
+        AsyncTaskStatus(
+            key='UNKNOWN',
+            title='Неизвестно',
+        ),
+    ], ignore_conflicts=True)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('edu_async_tasks_core', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RunPython(init_task_types, reverse_code=migrations.RunPython.noop),
+        migrations.RunPython(init_task_statuses, reverse_code=migrations.RunPython.noop),
+    ]

edu_async_tasks/core/migrations/0003_rename_async_task__profile_c97023_idx_edu_async_t_profile_70c100_idx_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.0.9 on 2024-09-25 10:08
+
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('edu_async_tasks_core', '0002_task_type_and_status_data'),
+    ]
+
+    operations = [
+        migrations.RenameIndex(
+            model_name='runningtask',
+            new_name='edu_async_t_profile_70c100_idx',
+            old_name='async_task__profile_c97023_idx',
+        ),
+        migrations.AlterField(
+            model_name='runningtask',
+            name='options',
+            field=models.JSONField(blank=True, null=True, verbose_name='Дополнительные опции задачи'),
+        ),
+    ]