edu-rdm-integration 3.22.1__py3-none-any.whl → 3.23.0__py3-none-any.whl

edu_rdm_integration/core/consts.py

@@ -39,3 +39,6 @@ ACADEMIC_YEAR = {
 TASK_QUEUE_NAME = 'RDM'
 FAST_TRANSFER_TASK_QUEUE_NAME = 'RDM_FAST'
 LONG_TRANSFER_TASK_QUEUE_NAME = 'RDM_LONG'
+
+# Лаг по времени между сбором и экспортом при работе с репликам (в секундах)
+PAUSE_TIME = 15

edu_rdm_integration/pipelines/transfer/tasks.py

@@ -1,3 +1,4 @@
+import time
 from datetime import (
     datetime,
 )
@@ -37,6 +38,7 @@ from educommon.utils.date import (
 from edu_rdm_integration.core.consts import (
     FAST_TRANSFER_TASK_QUEUE_NAME,
     LONG_TRANSFER_TASK_QUEUE_NAME,
+    PAUSE_TIME,
     TASK_QUEUE_NAME,
 )
 from edu_rdm_integration.core.enums import (
@@ -206,6 +208,9 @@ class BaseTransferLatestEntitiesDataPeriodicTask(BaseTransferLatestEntitiesDataM
 
                         continue
 
+            # Лаг времени для достаки данных в реплику
+            time.sleep(PAUSE_TIME)
+
             try:
                 if export_enabled:
                     self._run_export_entity_data(entity_enum.key, task_id)

edu_rdm_integration/rdm_entities/models.py

@@ -70,6 +70,11 @@ class RDMEntityEnum(TitledModelEnum):
 
         return model_enums
 
+    @classmethod
+    def get_choices(cls) -> list[tuple[str, str]]:
+        """Возвращает список кортежей из ключей и ключей перечисления сущностей."""
+        return [(key, key) for key in sorted(cls.get_model_enum_keys())]
+
     @classmethod
     def extend(
         cls,

edu_rdm_integration/rdm_models/models.py

@@ -35,15 +35,6 @@ from m3_db_utils.models import (
 class BaseRDMModel(ReprStrPreModelMixin, BaseObjectModel):
     """Базовая модель РВД."""
 
-    collecting_sub_stage = ForeignKey(
-        verbose_name='Подэтап сбора данных',
-        to='edu_rdm_integration_collect_data_stage.RDMCollectingDataSubStage',
-        on_delete=CASCADE,
-    )
-    operation = SmallIntegerField(
-        verbose_name='Действие',
-        choices=EntityLogOperation.get_choices(),
-    )
     created = DateTimeField(
         verbose_name='Дата создания',
         auto_now_add=True,
@@ -68,10 +59,32 @@ class BaseRDMModel(ReprStrPreModelMixin, BaseObjectModel):
         abstract = True
 
 
-class BaseMainRDMModel(BaseRDMModel):
+class BaseAdditionalRDMModel(BaseRDMModel):
+    """Абстрактная вспомогательная модель РВД.
+
+    Является базовым классом для моделей РВД, которые не являются основными для сущностей РВД. Для таких моделей
+    производится сбор данных.
+    """
+
+    collecting_sub_stage = ForeignKey(
+        verbose_name='Подэтап сбора данных',
+        to='edu_rdm_integration_collect_data_stage.RDMCollectingDataSubStage',
+        on_delete=CASCADE,
+    )
+    operation = SmallIntegerField(
+        verbose_name='Действие',
+        choices=EntityLogOperation.get_choices(),
+    )
+
+    class Meta:
+        abstract = True
+
+
+class BaseMainRDMModel(BaseAdditionalRDMModel):
     """Абстрактная основная модель РВД.
 
-    Является базовым классом для моделей РВД, которые являются основными для сущностей РВД.
+    Является базовым классом для моделей РВД, которые являются основными для сущностей РВД. Для таких моделей
+    производится сбор и выгрузка данных.
     """
 
     exporting_sub_stage = ForeignKey(
@@ -103,6 +116,11 @@ class RDMModelEnum(TitledModelEnum):
         verbose_name = 'Модель-перечисление моделей "Региональной витрины данных"'
         verbose_name_plural = 'Модели-перечисления моделей "Региональной витрины данных"'
 
+    @classmethod
+    def get_choices(cls) -> list[tuple[str, str]]:
+        """Возвращает список кортежей из ключей и ключей перечисления моделей."""
+        return [(key, key) for key in sorted(cls.get_model_enum_keys())]
+
     @classmethod
     def _get_model_relations(cls, model: Type['BaseRDMModel']) -> dict[str, str]:
         """Получение списка связей модели РВД."""

edu_rdm_integration/stages/collect_data/functions/base/runners.py

@@ -1,3 +1,7 @@
+from itertools import (
+    islice,
+)
+
 from django.conf import (
     settings,
 )
@@ -27,6 +31,9 @@ class BaseCollectingDataRunner(EduRunner):
             size=settings.RDM_COLLECT_CHUNK_SIZE,
         )
 
+        if settings.DEBUG and settings.RDM_COLLECT_CHUNKS_LIMIT:
+            raw_logs_chunks = islice(raw_logs_chunks, settings.RDM_COLLECT_CHUNKS_LIMIT)
+
         for chunk_index, raw_logs_chunk in enumerate(raw_logs_chunks, start=1):
             raw_logs = list(raw_logs_chunk)
             for runnable_class in self._prepare_runnable_classes():

edu_rdm_integration/stages/collect_data/models.py

@@ -65,6 +65,11 @@ class RDMCollectingDataStageStatus(TitledModelEnum):
         verbose_name = 'Модель-перечисление статусов этапа сбора данных'
         verbose_name_plural = 'Модели-перечисления статусов этапов сбора данных'
 
+    @classmethod
+    def get_choices(cls) -> list[tuple[str, str]]:
+        """Возвращает список кортежей из ключей и ключей перечисления статусов."""
+        return [(key, key) for key in cls.get_model_enum_keys()]
+
 
 class RDMCollectingDataStage(ReprStrPreModelMixin, BaseObjectModel):
     """Этап подготовки данных в рамках Функций. За работу Функции отвечает ранер менеджер."""

edu_rdm_integration/stages/collect_data/registry/actions.py

@@ -83,7 +83,7 @@ class BaseCollectingDataProgressPack(BaseCommandProgressPack):
             'header': 'Модель',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(key, key) for key in RDMModelEnum.get_model_enum_keys()],
+                choices=partial(RDMModelEnum.get_choices),
                 parser=str,
                 lookup=lambda key: Q(model=key) if key else Q(),
             ),
@@ -93,7 +93,7 @@ class BaseCollectingDataProgressPack(BaseCommandProgressPack):
             'header': 'Статус асинхронной задачи',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(value.key, value.title) for value in AsyncTaskStatus.get_model_enum_values()],
+                choices=partial(AsyncTaskStatus.get_choices),
                 parser=str,
                 lookup='task__status_id',
             ),
@@ -118,7 +118,7 @@ class BaseCollectingDataProgressPack(BaseCommandProgressPack):
             'header': 'Статус сбора',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(key, key) for key in RDMCollectingDataStageStatus.get_model_enum_keys()],
+                choices=partial(RDMCollectingDataStageStatus.get_choices),
                 parser=str,
                 lookup=lambda key: Q(stage__status=key) if key else Q(),
             ),

edu_rdm_integration/stages/collect_data/registry/templates/ui-js/collect-command-window.js

@@ -1,7 +1,9 @@
 {% load educommon %}
 {% include "ui-js/validators.js" %}
+{% include "ui-js/collect-and-export-validators.js" %}
 
-var win = Ext.getCmp('{{ component.client_id }}');
+var logsPeriodStartField = Ext.getCmp('logs_period_started_at');
+var logsPeriodEndField = Ext.getCmp('logs_period_ended_at');
 
 Ext.onReady(function() {
     // Инициализация валидаторов
@@ -41,24 +43,11 @@ function initializeValidators() {
         });
     }
 
-    // Устанавливаем текущую дату и время как максимальное значение
-    // и выполняем валидацию каждую секунду
-    var validationInterval = setInterval(function() {
-        var now = new Date();
-
-        logsPeriodStartField.setMaxValue(now);
-        logsPeriodEndField.setMaxValue(now);
-
-        logsPeriodStartField.validate();
-        logsPeriodEndField.validate();
-    }, 1000);
-
-    win.on('destroy', function() {
-        clearInterval(validationInterval);
-    });
-
-    logsPeriodStartField.validator = logsPeriodsValidator;
-    logsPeriodEndField.validator = logsPeriodsValidator;
+    // Устанавливаем время по умолчанию в календаре и доп валидатор
+    setupPeriodFields(
+        logsPeriodStartField,
+        logsPeriodEndField,
+    );
 }
 
 function initializeBatchSizeSplitByLogic() {

edu_rdm_integration/stages/collect_data/registry/templates/ui-js/validators.js

@@ -47,20 +47,5 @@ var instituteCountValidator = function() {
     }
     
     this.clearInvalid();
-    return true;
-};
-
-var logsPeriodStartField = Ext.getCmp('logs_period_started_at');
-var logsPeriodEndField = Ext.getCmp('logs_period_ended_at');
-
-var logsPeriodsValidator = function () {
-    if (
-        logsPeriodStartField.getValue() &&
-        logsPeriodEndField.getValue() &&
-        logsPeriodStartField.getValue() > logsPeriodEndField.getValue()
-    ) {
-        return 'Дата конца периода не может быть меньше даты начала периода'
-    };
-
     return true;
 };

edu_rdm_integration/stages/export_data/functions/base/runners.py

@@ -1,3 +1,11 @@
+from itertools import (
+    islice,
+)
+
+from django.conf import (
+    settings,
+)
+
 from edu_function_tools.runners import (
     EduRunner,
 )
@@ -41,6 +49,9 @@ class BaseExportDataRunner(EduRunner):
         """Возвращает генератор запускаемых объектов."""
         model_ids_chunks = self._prepare_model_ids_chunks(*args, **kwargs)
 
+        if settings.DEBUG and settings.RDM_EXPORT_CHUNKS_LIMIT:
+            model_ids_chunks = islice(model_ids_chunks, settings.RDM_EXPORT_CHUNKS_LIMIT)
+
         for chunk_index, model_ids_chunk in enumerate(model_ids_chunks, start=1):
             for runnable_class in self._prepare_runnable_classes():
                 runnable = runnable_class(

edu_rdm_integration/stages/export_data/migrations/0003_alter_rdmexportingdatasubstageattachment_exporting_data_sub_stage.py

@@ -0,0 +1,22 @@
+# Generated by Django 3.2.24 on 2025-10-17 14:11
+
+import django.db.models.deletion
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('edu_rdm_integration_export_data_stage', '0002_auto_20250704_0810'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='rdmexportingdatasubstageattachment',
+            name='exporting_data_sub_stage',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='edu_rdm_integration_export_data_stage.rdmexportingdatasubstage', verbose_name='Подэтап выгрузки данных'),
+        ),
+    ]

edu_rdm_integration/stages/export_data/migrations/{0003_fix_fk_constraints.py → 0004_fix_fk_constraints.py}

@@ -1,4 +1,4 @@
-# Generated by Django 3.2.24 on 2025-10-08 14:44
+# Generated by Django 3.2.24 on 2025-10-17 14:15
 
 from django.db import (
     migrations,
@@ -28,7 +28,7 @@ def apply_fk_updates(apps, schema_editor):
         table_name=RDMExportingDataSubStageAttachment._meta.db_table,
         field_name='exporting_data_sub_stage_id',
         target_table=RDMExportingDataSubStage._meta.db_table,
-        on_delete='CASCADE',
+        on_delete='SET NULL',
     )
 
     RDMExportingDataSubStageEntity = apps.get_model(
@@ -68,9 +68,9 @@ def apply_fk_updates(apps, schema_editor):
 class Migration(migrations.Migration):
 
     dependencies = [
-        ('edu_rdm_integration_export_data_stage', '0002_auto_20250704_0810'),
+        ('edu_rdm_integration_export_data_stage', '0003_alter_rdmexportingdatasubstageattachment_exporting_data_sub_stage'),
     ]
 
     operations = [
         migrations.RunPython(apply_fk_updates, reverse_code=migrations.RunPython.noop),
-    ]
+    ]

edu_rdm_integration/stages/export_data/models.py

@@ -69,6 +69,11 @@ class RDMExportingDataStageStatus(TitledModelEnum):
         title='Завершено',
     )
 
+    @classmethod
+    def get_choices(cls) -> list[tuple[str, str]]:
+        """Возвращает список кортежей из ключей и ключей перечисления статусов."""
+        return [(key, key) for key in cls.get_model_enum_keys()]
+
     class Meta:
         db_table = 'rdm_exporting_data_stage_status'
         verbose_name = 'Модель-перечисление статусов этапа выгрузки данных'
@@ -163,6 +168,10 @@ class RDMExportingDataSubStageStatus(TitledModelEnum):
     )
     PROCESS_ERROR = ModelEnumValue(title='Ошибка обработки витриной')
 
+    IN_EXPORT =  ModelEnumValue(
+        title='Экспортируется',
+    )
+
     class Meta:
         db_table = 'rdm_exporting_data_sub_stage_status'
         verbose_name = 'Модель-перечисление статусов подэтапа выгрузки данных'
@@ -248,7 +257,9 @@ class RDMExportingDataSubStageAttachment(ReprStrPreModelMixin, BaseObjectModel):
     exporting_data_sub_stage = ForeignKey(
         to=RDMExportingDataSubStage,
         verbose_name='Подэтап выгрузки данных',
-        on_delete=CASCADE,
+        null=True,
+        blank=True,
+        on_delete=SET_NULL,
     )
 
     # TODO PYTD-22 В зависимости от принятого решения по инструменту ограничения доступа к media-файлам, нужно будет

edu_rdm_integration/stages/export_data/registry/actions.py

@@ -86,7 +86,7 @@ class BaseExportingDataProgressPack(BaseCommandProgressPack):
             'header': 'Сущность',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(key, key) for key in RDMEntityEnum.get_model_enum_keys()],
+                choices=partial(RDMEntityEnum.get_choices),
                 parser=str,
                 lookup=lambda key: Q(entity=key) if key else Q(),
             ),
@@ -96,7 +96,7 @@ class BaseExportingDataProgressPack(BaseCommandProgressPack):
             'header': 'Статус асинхронной задачи',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(value.key, value.title) for value in AsyncTaskStatus.get_model_enum_values()],
+                choices=partial(AsyncTaskStatus.get_choices),
                 parser=str,
                 lookup='task__status_id',
             ),
@@ -131,7 +131,7 @@ class BaseExportingDataProgressPack(BaseCommandProgressPack):
             'header': 'Статус экспорта',
             'sortable': True,
             'filter': ChoicesFilter(
-                choices=[(key, key) for key in RDMExportingDataStageStatus.get_model_enum_keys()],
+                choices=partial(RDMExportingDataStageStatus.get_choices),
                 parser=str,
                 lookup=lambda key: Q(stage__status=key) if key else Q(),
             ),
@@ -228,7 +228,8 @@ class BaseExportingDataProgressPack(BaseCommandProgressPack):
             ready_sub_stages=Subquery(
                 RDMExportingDataSubStage.objects.filter(
                     stage_id=OuterRef('stage_id'),
-                    status=RDMExportingDataSubStageStatus.READY_FOR_EXPORT.key,
+                    status__in=(RDMExportingDataSubStageStatus.READY_FOR_EXPORT.key,
+                                RDMExportingDataSubStageStatus.IN_EXPORT.key)
                 )
                 .annotate(
                     ready_count=Func(F('id'), function='Count', output_field=IntegerField()),

edu_rdm_integration/stages/export_data/registry/templates/ui-js/create-export-command-win.js

@@ -1,4 +1,5 @@
-var win = Ext.getCmp('{{ component.client_id }}');
+{% include "ui-js/collect-and-export-validators.js" %}
+
 var periodStartField = Ext.getCmp('period_started_at');
 var periodEndField = Ext.getCmp('period_ended_at');
 
@@ -8,34 +9,17 @@ Ext.onReady(function() {
 });
 
 function initializeValidators() {
-    // Устанавливаем текущую дату и время как максимальное значение
-    // и выполняем валидацию каждую секунду
-    var validationInterval = setInterval(function() {
-        var now = new Date();
-
-        periodStartField.setMaxValue(now);
-        periodEndField.setMaxValue(now);
-
-        periodStartField.validate();
-        periodEndField.validate();
-    }, 1000);
-
-    win.on('destroy', function() {
-        clearInterval(validationInterval);
-    });
-
-    var periodsValidator = function () {
-        if (
-            periodStartField.getValue() &&
-            periodEndField.getValue() &&
-            periodStartField.getValue() > periodEndField.getValue()
-        ) {
-            return 'Дата конца периода не может быть меньше даты начала периода'
-        };
-
-        return true;
-    };
-
-    periodStartField.validator = periodsValidator;
-    periodEndField.validator = periodsValidator;
+    // Установка максимальной даты (завтра 23:59:59)
+    const maxDate = new Date();
+    maxDate.setDate(maxDate.getDate() + 1);
+    maxDate.setHours(23, 59, 59);
+
+    periodStartField.setMaxValue(maxDate);
+    periodEndField.setMaxValue(maxDate);
+
+    // Устанавливаем время по умолчанию в календаре и доп валидатор
+    setupPeriodFields(
+        periodStartField,
+        periodEndField,
+    );
 }

edu_rdm_integration/stages/service/service_outdated_data/cleaners/base.py

@@ -1,8 +1,16 @@
+import asyncio
 from abc import (
     ABCMeta,
     abstractmethod,
 )
+from pathlib import (
+    Path,
+)
+from typing import (
+    TYPE_CHECKING,
+)
 
+import asyncpg
 from django.conf import (
     settings,
 )
@@ -15,6 +23,12 @@ from educommon import (
 )
 
 
+if TYPE_CHECKING:
+    from asyncpg import (
+        Pool,
+    )
+
+
 class BaseServiceOutdatedDataCleaner(metaclass=ABCMeta):
     """Базовый класс уборщика устаревших сервисных данных."""
 
@@ -112,8 +126,15 @@ class BaseServiceOutdatedDataCleaner(metaclass=ABCMeta):
         """Возвращает имя таблицы в базе данных."""
         if cls.model is None:
             raise NotImplementedError('Необходимо задать атрибут "model"')
+
         return cls.model._meta.db_table
 
+    async def file_deletion_process(self, file_paths: list[str]):
+        """Функция для удаления файлов, связанных с удалёнными устаревшими записями.
+
+        Очистка данных производится в таблицах системных моделей РВД.
+        """
+
     def get_orphan_reference_condition(
         self,
         reference_table: str,
@@ -148,67 +169,137 @@ class BaseServiceOutdatedDataCleaner(metaclass=ABCMeta):
             )
         """
 
-    def get_chunk_bounds(self):
+    def get_chunk_bounded(self):
         """Возвращает границы чанков для текущей таблицы."""
-        sql = self.SELECT_RDM_CHUNK_BOUNDED_SQL.format(
+        get_chunk_bounded_sql = self.SELECT_RDM_CHUNK_BOUNDED_SQL.format(
             table_name=self.get_table_name(),
-            chunk_size=settings.CLEANUP_MODELS_OUTDATED_DATA_CHUNK_SIZE,
-        )
-        with connection.cursor() as cursor:
-            cursor.execute(sql)
-            return cursor.fetchall()
-
-    def _log_query(self, sql: str):
-        """Логирует SQL-запрос."""
-        try:
-            import sqlparse
-            sql = sqlparse.format(sql, reindent=True, strip_comments=True)
-        except ImportError:
-            pass
-
-        logger.info(
-            f'Запрос для удаления устаревших данных модели {self.get_table_name()}:\n{sql}\n'
+            chunk_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_CHUNK_SIZE,
         )
 
-    def _execute_delete_sql(self, delete_sql: str) -> int:
-        """Выполняет SQL-запрос на удаление (или только логирует в safe-режиме)."""
-        deleted = 0
         if self._log_sql:
-            self._log_query(delete_sql)
+            # Проверка на доступность sqlparse для форматирования
+            try:
+                import sqlparse
+            except ImportError:
+                sqlparse = None
 
-        if self._safe:
+            if sqlparse:
+                # Форматирование кода
+                get_chunk_bounded_sql = sqlparse.format(
+                    sql=get_chunk_bounded_sql,
+                    reindent=True,
+                    strip_comments=True,
+                )
             logger.info(
-                f'Безопасный режим включен — запрос удаления для {self.get_table_name()} не выполнен.'
+                f'Запрос для получения границ чанков модели {self.get_table_name()}: \n{get_chunk_bounded_sql}\n'
             )
-            return 0
-        else:
-            with connection.cursor() as cursor:
-                cursor.execute(delete_sql)
-                result = cursor.fetchone()
-                deleted = result[0] if result else 0
 
-        return deleted
+        with connection.cursor() as cursor:
+            cursor.execute(get_chunk_bounded_sql)
+            result = cursor.fetchall()
 
-    def run(self):
-        """Запуск очистки данных."""
+        return result
+
+    async def execute_query(self, pool: 'Pool', query: str):
+        """Асинхронное выполнение запроса."""
+        async with pool.acquire() as conn:
+            try:
+                if self._safe:
+                    logger.info(f'Запрос не будет выполнен, включен безопасный режим!\n')
+
+                    if self._log_sql:
+                        logger.info(f'{query}\n')
+                else:
+                    result = await conn.fetch(query)
+                    if not result:
+                        return
+
+                    if self._log_sql:
+                        logger.info(f'При помощи запроса:\n{query}\n')
+
+                    # Проверяем, что вернул запрос
+                    if 'deleted_count' in result[0]:
+                        deleted_count = result[0]['deleted_count']
+                        self._deleted_count += deleted_count
+                        logger.info(f'Было удалено записей: {deleted_count}')
+                    else:
+                        file_paths = [record['file_path'] for record in result if record.get('file_path')]
+                        if file_paths:
+                            await self.file_deletion_process(file_paths)
+                        deleted_count = len(result)
+                        self._deleted_count += deleted_count
+                        logger.info(f'Было удалено записей с файлами: {deleted_count}')
+
+            except Exception as e:
+                logger.error(f'Ошибка при выполнении {query}\n{e}')
+
+    def prepare_queries(self, chunk_bounded: list[tuple[int, int, int]]) -> list[str]:
+        """Формирование списка запросов для удаления устаревших данных."""
+        queries = []
         conditions = self.get_merged_conditions()
 
-        # Разделяем по чанкам
-        chunk_bounded = self.get_chunk_bounds()
         for chunk_number, first_id, last_id in chunk_bounded:
-            while True:
-                delete_sql = self.REMOVE_OUTDATED_DATA_SQL.format(
-                    table_name=self.get_table_name(),
-                    first_id=first_id,
-                    last_id=last_id,
-                    conditions=conditions,
-                )
-                deleted = self._execute_delete_sql(delete_sql)
-                self._deleted_count += deleted
+            remove_outdated_data_sql = self.REMOVE_OUTDATED_DATA_SQL.format(
+                table_name=self.get_table_name(),
+                first_id=first_id,
+                last_id=last_id,
+                conditions=conditions,
+            )
+
+            queries.append(remove_outdated_data_sql)
+
+        return queries
 
-                if deleted < self.chunk_size:
-                    break
+    async def execute_queries(self, queries: list[str]) -> None:
+        """Асинхронное выполнение запросов."""
+        DB_SETTINGS = settings.DATABASES['default']
 
-        logger.info(
-            f'Удалено устаревших записей сервисной модели {self.model.__name__}: {self._deleted_count}'
+        pool = await asyncpg.create_pool(
+            max_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_POOL_SIZE,
+            min_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_POOL_SIZE,
+            host=DB_SETTINGS['HOST'],
+            port=DB_SETTINGS['PORT'],
+            user=DB_SETTINGS['USER'],
+            password=DB_SETTINGS['PASSWORD'],
+            database=DB_SETTINGS['NAME'],
         )
+
+        tasks = [self.execute_query(pool, query) for query in queries]
+
+        await asyncio.gather(*tasks)
+
+    def run(self):
+        """Запуск очистки устаревших данных."""
+        chunk_bounded = self.get_chunk_bounded()
+
+        queries = self.prepare_queries(chunk_bounded=chunk_bounded)
+
+        if queries:
+            even_loop = asyncio.new_event_loop()
+            try:
+                even_loop.run_until_complete(self.execute_queries(queries=queries))
+            finally:
+                even_loop.close()
+
+        logger.info(f'Удалено записей модели {self.model.__name__}: {self._deleted_count}')
+
+
+class ServiceFileCleaner:
+    """Асинхронный сервис для безопасного удаления файлов из MEDIA_ROOT."""
+
+    @staticmethod
+    async def file_deletion_process(file_paths: list[str]) -> None:
+        """Удаляет указанные файлы, считая пути относительными к MEDIA_ROOT."""
+        media_root = Path(settings.MEDIA_ROOT).resolve()
+
+        async def delete_file(path_str: str):
+            path = (media_root / path_str).resolve()
+            try:
+                exists = await asyncio.to_thread(path.exists)
+                if exists and await asyncio.to_thread(path.is_file):
+                    await asyncio.to_thread(path.unlink)
+
+            except Exception as e:
+                logger.warning(f"Не удалось удалить {path}: {e}")
+
+        await asyncio.gather(*(delete_file(path) for path in file_paths))