edu-rdm-integration 3.9.2__py3-none-any.whl → 3.10.1__py3-none-any.whl

edu_rdm_integration/{export_data → stages/export_data}/strategies.py

@@ -5,37 +5,37 @@ from typing import (
 from edu_rdm_integration.adapters.strategies import (
     WebEduSyncBaseRunnerLazySavingPredefinedQueueFunctionImplementationStrategy,
 )
-from edu_rdm_integration.consts import (
+from edu_rdm_integration.core.consts import (
     REGIONAL_DATA_MART_INTEGRATION_EXPORTING_DATA,
 )
-from edu_rdm_integration.export_data.base.caches import (
+from edu_rdm_integration.stages.export_data.functions.base.caches import (
     BaseExportDataFunctionCacheStorage,
     BaseExportDataRunnerCacheStorage,
 )
-from edu_rdm_integration.export_data.base.errors import (
+from edu_rdm_integration.stages.export_data.functions.base.errors import (
     BaseExportDataError,
 )
-from edu_rdm_integration.export_data.base.functions import (
+from edu_rdm_integration.stages.export_data.functions.base.functions import (
     BaseExportDataFunction,
 )
-from edu_rdm_integration.export_data.base.helpers import (
+from edu_rdm_integration.stages.export_data.functions.base.helpers import (
     BaseExportDataFunctionHelper,
     BaseExportDataRunnerHelper,
 )
-from edu_rdm_integration.export_data.base.managers import (
+from edu_rdm_integration.stages.export_data.functions.base.managers import (
     BaseExportDataRunnerManager,
 )
-from edu_rdm_integration.export_data.base.presenters import (
+from edu_rdm_integration.stages.export_data.functions.base.presenters import (
     BaseExportDataResultPresenter,
 )
-from edu_rdm_integration.export_data.base.results import (
+from edu_rdm_integration.stages.export_data.functions.base.results import (
     BaseExportDataFunctionResult,
     BaseExportDataRunnerResult,
 )
-from edu_rdm_integration.export_data.base.runners import (
+from edu_rdm_integration.stages.export_data.functions.base.runners import (
     BaseExportDataRunner,
 )
-from edu_rdm_integration.export_data.base.validators import (
+from edu_rdm_integration.stages.export_data.functions.base.validators import (
     BaseExportDataFunctionValidator,
     BaseExportDataRunnerValidator,
 )
@@ -44,8 +44,7 @@ from edu_rdm_integration.export_data.base.validators import (
 class ExportDataFunctionImplementationStrategy(
     WebEduSyncBaseRunnerLazySavingPredefinedQueueFunctionImplementationStrategy,
 ):
-    """
-    Стратегия создания функций выгрузки данных.
+    """Стратегия создания функций выгрузки данных.
 
     Стратегия создания функции с отложенным сохранением и предустановленной очередью объектов на сохранение функций
     выгрузки данных для выгрузки в "Региональная витрина данных".
@@ -53,8 +52,7 @@ class ExportDataFunctionImplementationStrategy(
 
     @classmethod
     def _prepare_uuid(cls):
-        """
-        Получение UUID класса. Используется при регистрации сущности в базе данных.
+        """Получение UUID класса. Используется при регистрации сущности в базе данных.
 
         Если ничего не возвращает, то регистрация в БД не будет произведена.
         """
@@ -62,30 +60,22 @@ class ExportDataFunctionImplementationStrategy(
 
     @classmethod
     def _prepare_verbose_name(cls) -> str:
-        """
-        Полное наименование для дальнейшей регистрации и отображения пользователю.
-        """
+        """Полное наименование для дальнейшей регистрации и отображения пользователю."""
         return 'Стратегия создания функций выгрузки данных'
 
     @classmethod
     def _prepare_tags(cls) -> list[str]:
-        """
-        Список тегов, по которым сущность можно будет осуществлять поиск.
-        """
+        """Список тегов, по которым сущность можно будет осуществлять поиск."""
         return [REGIONAL_DATA_MART_INTEGRATION_EXPORTING_DATA]
 
     @classmethod
     def _prepare_key(cls) -> str:
-        """
-        Возвращает уникальный идентификатор стратегии создания функции.
-        """
+        """Возвращает уникальный идентификатор стратегии создания функции."""
         return 'REGIONAL_DATA_MART_INTEGRATION_EXPORTING_DATA'
 
     @classmethod
     def _prepare_title(cls) -> str:
-        """
-        Возвращает название стратегии создания функции.
-        """
+        """Возвращает название стратегии создания функции."""
         return (
             'Стратегия создания функции с отложенным сохранением и предустановленной очередью объектов на сохранение '
             'функций выгрузки данных в "Региональная витрина данных". Сохранение производится после удачной работы '
@@ -94,85 +84,57 @@ class ExportDataFunctionImplementationStrategy(
 
     @classmethod
     def _prepare_function_template_name(cls) -> Optional[str]:
-        """
-        Формирование названия шаблона создания функции.
-        """
+        """Формирование названия шаблона создания функции."""
         return 'function_export_data_template'
 
     def _prepare_manager_class(self):
-        """
-        Устанавливает класс менеджера.
-        """
+        """Устанавливает класс менеджера."""
         self._manager_class = BaseExportDataRunnerManager
 
     def _prepare_runner_class(self):
-        """
-        Устанавливает класс ранера.
-        """
+        """Устанавливает класс ранера."""
         self._runner_class = BaseExportDataRunner
 
     def _prepare_function_class(self):
-        """
-        Устанавливает класс Функции.
-        """
+        """Устанавливает класс Функции."""
         self._function_class = BaseExportDataFunction
 
     def _prepare_runner_helper_class(self):
-        """
-        Устанавливает класс помощника ранера.
-        """
+        """Устанавливает класс помощника ранера."""
         self._runner_helper_class = BaseExportDataRunnerHelper
 
     def _prepare_function_helper_class(self):
-        """
-        Устанавливает класс помощника функции.
-        """
+        """Устанавливает класс помощника функции."""
         self._function_helper_class = BaseExportDataFunctionHelper
 
     def _prepare_runner_validator_class(self):
-        """
-        Устанавливает класс валидатора ранера.
-        """
+        """Устанавливает класс валидатора ранера."""
         self._runner_validator_class = BaseExportDataRunnerValidator
 
     def _prepare_function_validator_class(self):
-        """
-        Устанавливает класс валидатора Функции.
-        """
+        """Устанавливает класс валидатора Функции."""
         self._function_validator_class = BaseExportDataFunctionValidator
 
     def _prepare_runner_cache_storage_class(self):
-        """
-        Устанавливает класс хранилища кешей ранера.
-        """
+        """Устанавливает класс хранилища кешей ранера."""
         self._runner_cache_storage_class = BaseExportDataRunnerCacheStorage
 
     def _prepare_function_cache_storage_class(self):
-        """
-        Устанавливает класс хранилища кешей Функции.
-        """
+        """Устанавливает класс хранилища кешей Функции."""
         self._function_cache_storage_class = BaseExportDataFunctionCacheStorage
 
     def _prepare_error_class(self):
-        """
-        Устанавливает класс ошибки.
-        """
+        """Устанавливает класс ошибки."""
         self._error_class = BaseExportDataError
 
     def _prepare_runner_result_class(self):
-        """
-        Устанавливает класс результата.
-        """
+        """Устанавливает класс результата."""
         self._runner_result_class = BaseExportDataRunnerResult
 
     def _prepare_function_result_class(self):
-        """
-        Устанавливает класс результата.
-        """
+        """Устанавливает класс результата."""
         self._function_result_class = BaseExportDataFunctionResult
 
     def _prepare_result_presenter_class(self):
-        """
-        Устанавливает класс презентера результата.
-        """
+        """Устанавливает класс презентера результата."""
         self._result_presenter_class = BaseExportDataResultPresenter

edu_rdm_integration/stages/service/apps.py

@@ -0,0 +1,19 @@
+from django.apps import (
+    AppConfig,
+)
+
+
+class RDMServiceStageAppConfig(AppConfig):
+    """Приложение для организации этапа сервисного обслуживания интеграции с РВД."""
+
+    name = 'edu_rdm_integration.stages.service'
+    label = 'edu_rdm_integration_service_stage'
+    verbose_name = 'Этап сервисного обслуживания'
+
+    def ready(self):
+        """Готовность приложения."""
+        if self.name == 'edu_rdm_integration.stages.service':
+            # ruff: noqa: F401
+            from . import (
+                tasks,
+            )

edu_rdm_integration/stages/service/tasks.py

@@ -0,0 +1,63 @@
+import celery
+from celery.schedules import (
+    crontab,
+)
+from django.conf import (
+    settings,
+)
+
+from educommon.async_task.models import (
+    AsyncTaskType,
+)
+from educommon.async_task.tasks import (
+    UniquePeriodicAsyncTask,
+)
+
+from edu_rdm_integration.core.consts import (
+    TASK_QUEUE_NAME,
+)
+from edu_rdm_integration.stages.collect_data.helpers import (
+    set_failed_status_suspended_collecting_data_stages,
+)
+from edu_rdm_integration.stages.export_data.helpers import (
+    set_failed_status_suspended_exporting_data_stages,
+)
+
+
+class CheckSuspendedExportedStagePeriodicTask(UniquePeriodicAsyncTask):
+    """Периодическая задача поиска зависших этапов/подэтапов экспорта."""
+
+    queue = TASK_QUEUE_NAME
+    routing_key = TASK_QUEUE_NAME
+    description = 'Поиск зависших этапов/подэтапов экспорта в "Региональная витрина данных"'
+    lock_expire_seconds = settings.RDM_CHECK_SUSPEND_TASK_LOCK_EXPIRE_SECONDS
+    task_type = AsyncTaskType.SYSTEM
+    run_every = crontab(
+        minute=settings.RDM_CHECK_SUSPEND_TASK_MINUTE,
+        hour=settings.RDM_CHECK_SUSPEND_TASK_HOUR,
+        day_of_week=settings.RDM_CHECK_SUSPEND_TASK_DAY_OF_WEEK,
+    )
+
+    def process(self, *args, **kwargs):
+        """Выполнение задачи."""
+        super().process(*args, **kwargs)
+
+        change_status_collecting_result = set_failed_status_suspended_collecting_data_stages()
+        change_status_exporting_result = set_failed_status_suspended_exporting_data_stages()
+
+        task_result = {
+            'Прервано сборок': (
+                f'Этапов {change_status_collecting_result["change_stage_count"]}'
+                f' и подэтапов {change_status_collecting_result["change_sub_stage_count"]}'
+            ),
+            'Прервано выгрузок': (
+                f'Этапов {change_status_exporting_result["change_stage_count"]}'
+                f' и подэтапов {change_status_exporting_result["change_sub_stage_count"]}'
+            ),
+        }
+
+        self.set_progress(values=task_result)
+
+
+celery_app = celery.app.app_or_default()
+celery_app.register_task(CheckSuspendedExportedStagePeriodicTask)

edu_rdm_integration/stages/upload_data/apps.py

@@ -0,0 +1,19 @@
+from django.apps import (
+    AppConfig,
+)
+
+
+class RDMUploadDataStageAppConfig(AppConfig):
+    """Приложение для организации этапа выгрузки файлов в РВД."""
+
+    name = 'edu_rdm_integration.stages.upload_data'
+    label = 'edu_rdm_integration_upload_data_stage'
+    verbose_name = 'Этап выгрузки файлов в РВД'
+
+    def ready(self):
+        """Готовность приложения."""
+        if self.name == 'edu_rdm_integration.stages.upload_data':
+            # ruff: noqa: F401
+            from . import (
+                tasks,
+            )

edu_rdm_integration/stages/upload_data/consts.py

@@ -0,0 +1,10 @@
+from edu_rdm_integration.stages.upload_data.models import (
+    DataMartRequestStatus,
+)
+
+
+FAILED_STATUSES = {
+    DataMartRequestStatus.FAILED_PROCESSING,
+    DataMartRequestStatus.REQUEST_ID_NOT_FOUND,
+    DataMartRequestStatus.FLC_ERROR,
+}

edu_rdm_integration/{export_data → stages/upload_data}/dataclasses.py

@@ -5,6 +5,7 @@ from typing import (
 
 class UploadFile(NamedTuple):
     """Структура файла подэтапа для очереди отправки."""
+
     attachment_id: int
     attachment_name: str
     attachment_size: int

edu_rdm_integration/stages/upload_data/enums.py

@@ -0,0 +1,17 @@
+from m3.db import (
+    BaseEnumerate,
+)
+
+
+class FileUploadStatusEnum(BaseEnumerate):
+    """Действие по отслеживаемым данным."""
+
+    IN_PROGRESS = 1
+    FINISHED = 2
+    ERROR = 3
+
+    values = {
+        IN_PROGRESS: 'В процессе загрузки в витрину',
+        FINISHED: 'Загрузка в витрину закончена',
+        ERROR: 'Ошибка загрузки в витрину',
+    }

edu_rdm_integration/{export_data/export_manager.py → stages/upload_data/export_managers.py}

@@ -3,8 +3,6 @@ from pathlib import (
 )
 from typing import (
     TYPE_CHECKING,
-    Any,
-    Iterable,
     Optional,
 )
 
@@ -22,51 +20,63 @@ from django.db.transaction import (
 from uploader_client.adapters import (
     adapter,
 )
+from web_edu.plugins.gis_ruo.enums import (
+    OPERATIONS_METHODS_MAP,
+)
 
 from educommon import (
     logger,
 )
 
-from edu_rdm_integration.consts import (
+from edu_rdm_integration.core.consts import (
     LOGS_DELIMITER,
 )
-from edu_rdm_integration.enums import (
-    FileUploadStatusEnum,
+from edu_rdm_integration.core.redis_cache import (
+    AbstractCache,
 )
-from edu_rdm_integration.export_data.base.consts import (
-    OPERATIONS_METHODS_MAP,
+from edu_rdm_integration.stages.export_data.consts import (
+    ATTACHMENTS_LIMIT,
+    TOTAL_ATTACHMENTS_SIZE_KEY,
+)
+from edu_rdm_integration.stages.export_data.functions.base.consts import (
     OPERATIONS_URLS_MAP,
 )
-from edu_rdm_integration.export_data.base.requests import (
+from edu_rdm_integration.stages.export_data.functions.base.requests import (
     RegionalDataMartEntityRequest,
 )
-from edu_rdm_integration.export_data.consts import (
-    ATTACHMENTS_LIMIT,
-    TOTAL_ATTACHMENTS_SIZE_KEY,
+from edu_rdm_integration.stages.export_data.models import (
+    ExportingDataSubStage,
+    ExportingDataSubStageAttachment,
+    ExportingDataSubStageStatus,
 )
-from edu_rdm_integration.export_data.dataclasses import (
+from edu_rdm_integration.stages.upload_data.consts import (
+    FAILED_STATUSES,
+)
+from edu_rdm_integration.stages.upload_data.dataclasses import (
     UploadFile,
 )
-from edu_rdm_integration.export_data.queue import (
-    Queue,
+from edu_rdm_integration.stages.upload_data.enums import (
+    FileUploadStatusEnum,
 )
-from edu_rdm_integration.helpers import (
-    FAILED_STATUSES,
+from edu_rdm_integration.stages.upload_data.helpers import (
     UploadStatusHelper,
 )
-from edu_rdm_integration.models import (
+from edu_rdm_integration.stages.upload_data.models import (
     DataMartRequestStatus,
-    ExportingDataSubStage,
-    ExportingDataSubStageAttachment,
-    ExportingDataSubStageStatus,
     ExportingDataSubStageUploaderClientLog,
     UploadStatusRequestLog,
 )
-from edu_rdm_integration.redis_cache import (
-    AbstractCache,
+from edu_rdm_integration.stages.upload_data.queues import (
+    Queue,
 )
 
 
+if TYPE_CHECKING:
+    from uploader_client.models import (
+        Entry,
+    )
+
+
 class ExportQueueSender:
     """Класс отправки данных в очередь РВД."""
 
@@ -86,9 +96,9 @@ class ExportQueueSender:
         sended_attachment_ids = ExportingDataSubStageUploaderClientLog.objects.filter(
             file_upload_status=FileUploadStatusEnum.IN_PROGRESS
         ).values_list('attachment_id', flat=True)
-        file_size = ExportingDataSubStageAttachment.objects.filter(
-            id__in=sended_attachment_ids
-        ).aggregate(Sum('attachment_size'))['attachment_size__sum']
+        file_size = ExportingDataSubStageAttachment.objects.filter(id__in=sended_attachment_ids).aggregate(
+            Sum('attachment_size')
+        )['attachment_size__sum']
 
         return file_size or 0
 
@@ -98,25 +108,30 @@ class ExportQueueSender:
 
     def get_sub_stages_attachments_to_export(self):
         """Выборка готовых к экспорту подэтапов."""
-        sub_stage_ids = ExportingDataSubStage.objects.filter(
-            self._make_stage_filter()
-        ).order_by('started_at').values_list('id', flat=True)[:self.limit]
-
-        return ExportingDataSubStage.objects.filter(
-            id__in=sub_stage_ids
-        ).annotate(
-            attachment_id=F('exportingdatasubstageattachment__id'),
-            attachment_name=F('exportingdatasubstageattachment__attachment'),
-            attachment_size=F('exportingdatasubstageattachment__attachment_size'),
-            operation=F('exportingdatasubstageattachment__operation'),
-            entity=F('exportingdatasubstageentity__entity_id')
-        ).order_by('id', 'operation').values(
-            'id',
-            'attachment_id',
-            'attachment_name',
-            'attachment_size',
-            'operation',
-            'entity',
+        sub_stage_ids = (
+            ExportingDataSubStage.objects.filter(self._make_stage_filter())
+            .order_by('started_at')
+            .values_list('id', flat=True)[: self.limit]
+        )
+
+        return (
+            ExportingDataSubStage.objects.filter(id__in=sub_stage_ids)
+            .annotate(
+                attachment_id=F('exportingdatasubstageattachment__id'),
+                attachment_name=F('exportingdatasubstageattachment__attachment'),
+                attachment_size=F('exportingdatasubstageattachment__attachment_size'),
+                operation=F('exportingdatasubstageattachment__operation'),
+                entity=F('exportingdatasubstageentity__entity_id'),
+            )
+            .order_by('id', 'operation')
+            .values(
+                'id',
+                'attachment_id',
+                'attachment_name',
+                'attachment_size',
+                'operation',
+                'entity',
+            )
         )
 
     def set_sub_stage_to_cache(self, sub_stage_id: int, entity_name: str, attachments: list[UploadFile]) -> bool:
@@ -129,14 +144,10 @@ class ExportQueueSender:
         self.queue_total_file_size += sub_stage_total_size
         # Обновим размер файлов в кеш
         self.cache.set(
-            TOTAL_ATTACHMENTS_SIZE_KEY,
-            self.queue_total_file_size,
-            timeout=settings.RDM_REDIS_CACHE_TIMEOUT_SECONDS
+            TOTAL_ATTACHMENTS_SIZE_KEY, self.queue_total_file_size, timeout=settings.RDM_REDIS_CACHE_TIMEOUT_SECONDS
         )
 
-        logger.info(
-             f'{LOGS_DELIMITER * 2}ExportedDataSubStage {sub_stage_id} {entity_name} added to the queue'
-        )
+        logger.info(f'{LOGS_DELIMITER * 2}ExportedDataSubStage {sub_stage_id} {entity_name} added to the queue')
 
         return True
 
@@ -162,12 +173,14 @@ class ExportQueueSender:
                     prev_sub_stage = stage_attachment['id']
 
                 if stage_attachment['attachment_size']:
-                    stage_files.append(UploadFile(
-                        stage_attachment['attachment_id'],
-                        stage_attachment['attachment_name'],
-                        stage_attachment['attachment_size'],
-                        stage_attachment['operation']
-                    ))
+                    stage_files.append(
+                        UploadFile(
+                            stage_attachment['attachment_id'],
+                            stage_attachment['attachment_name'],
+                            stage_attachment['attachment_size'],
+                            stage_attachment['operation'],
+                        )
+                    )
                     entity = stage_attachment['entity']
 
             # Обновляем общий объем очереди и закидываем последний элемент
@@ -176,14 +189,10 @@ class ExportQueueSender:
         else:
             # Сохраняем объем отправленных файлов в кеш
             self.cache.set(
-                TOTAL_ATTACHMENTS_SIZE_KEY,
-                self.queue_total_file_size,
-                timeout=settings.RDM_REDIS_CACHE_TIMEOUT_SECONDS
+                TOTAL_ATTACHMENTS_SIZE_KEY, self.queue_total_file_size, timeout=settings.RDM_REDIS_CACHE_TIMEOUT_SECONDS
             )
             self.queue_is_full = True
-            logger.warning(
-                f'Total exported file size:  {self.queue_total_file_size} - queue is full!!!'
-            )
+            logger.warning(f'Total exported file size:  {self.queue_total_file_size} - queue is full!!!')
 
 
 class WorkerSender:
@@ -303,9 +312,7 @@ class WorkerSender:
                     errors.append(result.error)
                     status = ExportingDataSubStageStatus.FAILED.key
                 else:
-                    logger.info(
-                        f'Response with {result.response.status_code} code and content {result.response.text}'
-                    )
+                    logger.info(f'Response with {result.response.status_code} code and content {result.response.text}')
                     self.entities.add(entity_key)
 
             # Сохраняем информацию об отправке файлов и убираем подэтап с файлами из очереди
@@ -316,9 +323,7 @@ class WorkerSender:
                 sub_stage.save()
 
             self.queue.delete_from_queue(sub_stage_id=sub_stage_id, entity_name=entity_key)
-            logger.info(
-                f'{LOGS_DELIMITER * 3}ExportedDataSubStage {sub_stage_id} {entity_key} sended from the queue'
-            )
+            logger.info(f'{LOGS_DELIMITER * 3}ExportedDataSubStage {sub_stage_id} {entity_key} sent from the queue')
 
     def run(self):
         """Запуск воркера отправки."""