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

edu_rdm_integration/stages/upload_data/helpers.py

@@ -0,0 +1,164 @@
+from concurrent.futures import (
+    ThreadPoolExecutor,
+)
+from json import (
+    JSONDecodeError,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Optional,
+)
+
+from django.conf import (
+    settings,
+)
+from django.db import (
+    transaction,
+)
+from django.db.models import (
+    QuerySet,
+)
+from uploader_client.adapters import (
+    adapter,
+)
+
+from educommon import (
+    logger,
+)
+
+from edu_rdm_integration.core.redis_cache import (
+    AbstractCache,
+)
+from edu_rdm_integration.stages.export_data.consts import (
+    TOTAL_ATTACHMENTS_SIZE_KEY,
+)
+from edu_rdm_integration.stages.export_data.functions.base.requests import (
+    RegionalDataMartStatusRequest,
+)
+from edu_rdm_integration.stages.export_data.models import (
+    ExportingDataSubStageStatus,
+)
+from edu_rdm_integration.stages.upload_data.consts import (
+    FAILED_STATUSES,
+)
+from edu_rdm_integration.stages.upload_data.enums import (
+    FileUploadStatusEnum,
+)
+from edu_rdm_integration.stages.upload_data.models import (
+    DataMartRequestStatus,
+    ExportingDataSubStageUploaderClientLog,
+    UploadStatusRequestLog,
+)
+
+
+if TYPE_CHECKING:
+    from uploader_client.logging.base import (
+        Entry,
+    )
+
+
+class UploadStatusHelper:
+    """Хелпер проверки статуса загрузки данных в витрину."""
+
+    def __init__(self, in_progress_uploads: QuerySet, cache: AbstractCache) -> None:
+        self._in_progress_uploads = in_progress_uploads
+        self.cache = cache
+
+    def run(self, thread_count: int = 1) -> None:
+        """Запускает проверки статусов."""
+        if thread_count > 1:
+            with ThreadPoolExecutor(max_workers=thread_count) as pool:
+                pool.map(self._process_upload, self._in_progress_uploads)
+        else:
+            for upload in self._in_progress_uploads:
+                self._process_upload(upload)
+
+    @classmethod
+    def send_upload_status_request(cls, request_id: str) -> tuple[Optional[dict[str, Any]], 'Entry']:
+        """Формирует и отправляет запрос для получения статуса загрузки данных в витрину."""
+        request = RegionalDataMartStatusRequest(
+            request_id=request_id,
+            method='GET',
+            parameters={},
+            headers={
+                'Content-Type': 'application/json',
+            },
+        )
+
+        result = adapter.send(request)
+
+        response = None
+
+        if result.error:
+            logger.warning(
+                f'Ошибка при получении статуса загрузки данных в витрину. Идентификатор загрузки: {request_id}. '
+                f'Ошибка: {result.error}, запрос: {result.log.request}, ответ: {result.log.response}',
+            )
+        else:
+            logger.info(
+                f'Получен ответ со статусом {result.response.status_code} и содержимым {result.response.text}. '
+                f'Идентификатор загрузки: {request_id}',
+            )
+            try:
+                response = result.response.json()
+            except JSONDecodeError:
+                logger.error(
+                    f'Не удалось получить данные из ответа запроса статуса загрузки данных в витрину. '
+                    f'Идентификатор загрузки: {request_id}, ответ: {result.response.text}',
+                )
+
+        return response, result.log
+
+    @classmethod
+    def update_upload_status(
+        cls,
+        upload: ExportingDataSubStageUploaderClientLog,
+        response: Optional[dict[str, Any]],
+        log_entry: 'Entry',
+    ) -> None:
+        """Обновляет статус загрузки данных в витрину."""
+        request_status = None
+
+        if isinstance(response, dict):
+            request_status = DataMartRequestStatus.get_values_to_enum_data().get(response.get('code'))
+
+            if not request_status:
+                logger.error(
+                    'Не удалось определить статус загрузки данных в витрину. Идентификатор загрузки: '
+                    f'{upload.request_id}, данные ответа: {response}',
+                )
+
+        with transaction.atomic():
+            UploadStatusRequestLog.objects.create(
+                upload=upload,
+                entry=log_entry,
+                request_status_id=getattr(request_status, 'key', None),
+            )
+
+            if request_status in FAILED_STATUSES:
+                upload.file_upload_status = FileUploadStatusEnum.ERROR
+                upload.sub_stage.status_id = ExportingDataSubStageStatus.PROCESS_ERROR.key
+                upload.sub_stage.save()
+
+            elif request_status == DataMartRequestStatus.SUCCESSFULLY_PROCESSED:
+                upload.file_upload_status = FileUploadStatusEnum.FINISHED
+
+            if upload.file_upload_status != FileUploadStatusEnum.IN_PROGRESS:
+                upload.save()
+
+    def _process_upload(self, upload: ExportingDataSubStageUploaderClientLog) -> None:
+        """Обрабатывает запись загрузки данных в витрину."""
+        response, log_entry = self.send_upload_status_request(upload.request_id)
+        self.update_upload_status(upload, response, log_entry)
+        # Обновим размер файлов в кеш (с блокировкой на время обновления)
+        with self.cache.lock(f'{TOTAL_ATTACHMENTS_SIZE_KEY}:lock', timeout=300):
+            queue_total_file_size = self.cache.get(TOTAL_ATTACHMENTS_SIZE_KEY) or 0
+            if queue_total_file_size:
+                queue_total_file_size -= upload.attachment.attachment_size
+                if queue_total_file_size > 0:
+                    self.cache.set(
+                        TOTAL_ATTACHMENTS_SIZE_KEY,
+                        queue_total_file_size,
+                        timeout=settings.RDM_REDIS_CACHE_TIMEOUT_SECONDS,
+                    )

edu_rdm_integration/stages/upload_data/management/base.py

@@ -0,0 +1,134 @@
+from typing import (
+    TYPE_CHECKING,
+)
+
+import uploader_client
+from django.core.cache import (
+    DEFAULT_CACHE_ALIAS,
+    caches,
+)
+from django.core.management import (
+    BaseCommand,
+)
+from uploader_client.adapters import (
+    UploaderAdapter,
+)
+from uploader_client.contrib.rdm.interfaces.configurations import (
+    RegionalDataMartUploaderConfig,
+)
+
+
+if TYPE_CHECKING:
+    from uploader_client.interfaces import (
+        OpenAPIRequest,
+    )
+
+
+class BaseDatamartClientCommand(BaseCommand):
+    """Базовая команда для загрузки данных/получение статуса в РВД с использованием uploader_client."""
+
+    TIMEOUT = 300
+    REQUEST_RETRIES = 1
+
+    def add_arguments(self, parser):
+        """Добавление параметров."""
+        parser.add_argument(
+            '--url',
+            type=str,
+            required=True,
+            help='url хоста Datamart Studio',
+        )
+        parser.add_argument(
+            '--datamart_mnemonic',
+            type=str,
+            required=True,
+            help='мнемоника Витрины',
+        )
+        parser.add_argument(
+            '--organization_ogrn',
+            type=str,
+            required=True,
+            help='ОГРН организации, в рамках которой развёрнута Витрина',
+        )
+        parser.add_argument(
+            '--installation_name',
+            type=str,
+            required=True,
+            help='имя инсталляции в целевой Витрине',
+        )
+        parser.add_argument(
+            '--installation_id',
+            type=int,
+            required=True,
+            help='идентификатор инсталляции (присутствует в её названии)',
+        )
+        parser.add_argument(
+            '--username',
+            type=str,
+            required=True,
+            help='имя пользователя IAM',
+        )
+        parser.add_argument(
+            '--password',
+            type=str,
+            required=True,
+            help='пароль пользователя IAM',
+        )
+
+    def _configure_agent_client(
+        self,
+        url,
+        datamart_mnemonic,
+        organization_ogrn,
+        installation_name,
+        installation_id,
+        username,
+        password,
+    ):
+        """Конфигурирование клиента загрузчика данных в Витрину."""
+        uploader_client.set_config(
+            RegionalDataMartUploaderConfig(
+                interface='uploader_client.contrib.rdm.interfaces.rest.ProxyAPIInterface',
+                cache=caches[DEFAULT_CACHE_ALIAS],
+                url=url,
+                datamart_name=datamart_mnemonic,
+                organization_ogrn=organization_ogrn,
+                installation_name=installation_name,
+                installation_id=installation_id,
+                username=username,
+                password=password,
+                timeout=self.TIMEOUT,
+                request_retries=self.REQUEST_RETRIES,
+            )
+        )
+
+    def _get_request(self, **options) -> 'OpenAPIRequest':
+        """Возвращает запрос для отправки в РВД."""
+        raise NotImplementedError
+
+    def handle(self, *args, **options):
+        """Выполнение действий команды."""
+        self._configure_agent_client(
+            url=options['url'],
+            datamart_mnemonic=options['datamart_mnemonic'],
+            organization_ogrn=options['organization_ogrn'],
+            installation_name=options['installation_name'],
+            installation_id=options['installation_id'],
+            username=options['username'],
+            password=options['password'],
+        )
+
+        request = self._get_request(**options)
+
+        result = UploaderAdapter().send(request)
+
+        if result.error:
+            self.stdout.write(self.style.ERROR('ERROR:\n'))
+            self.stdout.write(
+                f'{result.error}\nREQUEST:\n"{result.log.request}"\n\nRESPONSE:\n"{result.log.response}"\n'
+            )
+        else:
+            self.stdout.write(self.style.SUCCESS('SUCCESS:\n'))
+            self.stdout.write(
+                f'Response with {result.response.status_code} code and content:\n{result.response.text}\n'
+            )

edu_rdm_integration/{management → stages/upload_data/management}/commands/async_fix_attachment_size.py

@@ -1,5 +1,4 @@
-"""
-Команда для проставления расчетов файла . По умолчанию собирается за месяц. Обновление работает асинхронно.
+"""Команда для проставления расчетов файла . По умолчанию собирается за месяц. Обновление работает асинхронно.
 
 Выполнение:
 django-admin async_fix_attachment_size --chunk_size=50 --count_store_size --connection_pool_size=5
@@ -15,7 +14,6 @@ django-admin async_fix_attachment_size --chunk_size=50 --count_store_size --conn
 --async_workers_count количество одновременных асинхронных воркеров-исполнителей по умолчанию 20
 """
 
-
 import asyncio
 from datetime import (
     date,
@@ -39,12 +37,12 @@ from educommon.utils.seqtools import (
     make_chunks,
 )
 
-from edu_rdm_integration.enums import (
-    FileUploadStatusEnum,
-)
-from edu_rdm_integration.models import (
+from edu_rdm_integration.stages.export_data.models import (
     ExportingDataSubStageAttachment,
 )
+from edu_rdm_integration.stages.upload_data.enums import (
+    FileUploadStatusEnum,
+)
 
 
 DEFAULT_QUERYSET_CHUNK_SIZE = 500
@@ -61,7 +59,7 @@ class Command(BaseCommand):
         'Команда для проставления размера по умолчанию (в байтах) для отправленных файлов.'
     )
 
-    def __init__(self,  *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         self.result = {
@@ -76,25 +74,21 @@ class Command(BaseCommand):
             '--chunk_size',
             type=int,
             default=DEFAULT_QUERYSET_CHUNK_SIZE,
-            help='Кол-во единовременно изменяемых элементов в запросе'
+            help='Кол-во единовременно изменяемых элементов в запросе',
+        )
+        (
+            parser.add_argument(
+                '--count_store_size', action='store_true', default=False, help='Рассчитать размер файлов'
+            ),
         )
         parser.add_argument(
-            '--count_store_size',
-            action='store_true',
-            default=False,
-            help='Рассчитать размер файлов'
-        ),
-        parser.add_argument(
-            '--connection_pool_size',
-            type=int,
-            default=DEFAULT_POOL_SIZE,
-            help='Кол-во одновременных коннектов к базе'
+            '--connection_pool_size', type=int, default=DEFAULT_POOL_SIZE, help='Кол-во одновременных коннектов к базе'
         )
         parser.add_argument(
             '--async_workers_count',
             type=int,
             default=DEFAULT_ASYNC_WORKERS_COUNT,
-            help='Кол-во одновременных асинхронных воркеров-исполнителей'
+            help='Кол-во одновременных асинхронных воркеров-исполнителей',
         )
         parser.add_argument(
             '--date_begin',
@@ -108,11 +102,7 @@ class Command(BaseCommand):
         )
 
     def get_attachments_fix_query(
-        self,
-        chunk_size: int,
-        date_begin: date,
-        date_end: date,
-        count_store_size: bool
+        self, chunk_size: int, date_begin: date, date_end: date, count_store_size: bool
     ) -> list[tuple[int, int]]:
         """Формирование id файлов, которым надо обновить размер."""
         logger.info('Определение файлов, которым надо обновить размер.')
@@ -128,25 +118,22 @@ class Command(BaseCommand):
         for chunk in make_chunks(attachment_query.iterator(), chunk_size):
             if count_store_size:
                 update_attachments.append(
-                   [
-                       (
-                           attachment.id, attachment.attachment.size
-                           if attachment.attachment.field.storage.exists(attachment.attachment.name)
-                           else DEFAULT_FILE_SIZE
-                       )
-                       for attachment in chunk
-                   ]
+                    [
+                        (
+                            attachment.id,
+                            attachment.attachment.size
+                            if attachment.attachment.field.storage.exists(attachment.attachment.name)
+                            else DEFAULT_FILE_SIZE,
+                        )
+                        for attachment in chunk
+                    ]
                 )
             else:
                 update_attachments.append([(attachment.id, DEFAULT_FILE_SIZE) for attachment in chunk])
 
         return update_attachments
 
-    async def execute_update_sql(
-        self,
-        pool: asyncpg.Pool,
-        data: list[tuple[int, int]]
-    ) -> None:
+    async def execute_update_sql(self, pool: asyncpg.Pool, data: list[tuple[int, int]]) -> None:
         """Метод для исполнения сгенерированного UPDATE sql запроса."""
         self.result['initial_count_rows_to_fix'] += len(data)
         logger.info('Обновление размера файлов')
@@ -157,18 +144,14 @@ class Command(BaseCommand):
                     UPDATE rdm_exporting_data_sub_stage_attachment
                     set attachment_size = $2
                     where id = $1;
-                    """, data,
+                    """,
+                    data,
                 )
                 self.result['fixed_rows_count'] += len(data)
             except Exception as ex:
                 self.result['errors'].append(str(ex))
 
-    async def fix_attachment_size(
-        self,
-        fix_queries: list,
-        pool_size: int = None,
-        workers_count: int = None
-    ) -> None:
+    async def fix_attachment_size(self, fix_queries: list, pool_size: int = None, workers_count: int = None) -> None:
         """Асинхронное обновление размера файлов."""
         pool = await asyncpg.create_pool(
             max_size=pool_size,
@@ -177,7 +160,7 @@ class Command(BaseCommand):
             port=DB_SETTINGS['PORT'],
             user=DB_SETTINGS['USER'],
             password=DB_SETTINGS['PASSWORD'],
-            database=DB_SETTINGS['NAME']
+            database=DB_SETTINGS['NAME'],
         )
         if len(fix_queries) > workers_count:
             for chunk in make_chunks(fix_queries, workers_count):
@@ -192,9 +175,9 @@ class Command(BaseCommand):
         connection_pool_size: int,
         chunk_size: int,
         date_begin: date,
-        date_end:date,
+        date_end: date,
         async_workers_count: int,
-        count_store_size: bool
+        count_store_size: bool,
     ):
         """Обновление размеров файла."""
         fix_queries = self.get_attachments_fix_query(chunk_size, date_begin, date_end, count_store_size)
@@ -228,12 +211,7 @@ class Command(BaseCommand):
         logger.info('Обновление размеров файла\n')
 
         self.update_attachment_size(
-            connection_pool_size,
-            chunk_size,
-            date_begin,
-            date_end,
-            async_workers_count,
-            count_store_size
+            connection_pool_size, chunk_size, date_begin, date_end, async_workers_count, count_store_size
         )
 
         delta = datetime.now() - time_start

edu_rdm_integration/{management → stages/upload_data/management}/commands/check_upload_status.py

@@ -1,5 +1,4 @@
-"""
-Команда для проверки состояния отправленных в витрину данных.
+"""Команда для проверки состояния отправленных в витрину данных.
 
 Необязательные параметры:
 --period_started_at - дата и время начала периода загрузки данных в витрину
@@ -9,6 +8,7 @@
 Пример использования:
 python manage.py check_upload_status --period_started_at="01.11.2023 10:00:00" --thread_count=4
 """
+
 from datetime import (
     date,
     datetime,
@@ -18,6 +18,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
 )
+
 from django.core.cache import (
     cache,
 )
@@ -25,16 +26,16 @@ from django.core.management.base import (
     BaseCommand,
 )
 
-from edu_rdm_integration.consts import (
+from edu_rdm_integration.core.consts import (
     DATETIME_FORMAT,
 )
-from edu_rdm_integration.enums import (
+from edu_rdm_integration.stages.upload_data.enums import (
     FileUploadStatusEnum,
 )
-from edu_rdm_integration.helpers import (
+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 (
     ExportingDataSubStageUploaderClientLog,
 )
 

edu_rdm_integration/{management → stages/upload_data/management}/commands/datamart_status.py

@@ -1,13 +1,13 @@
-from edu_rdm_integration.export_data.base.requests import (
+from edu_rdm_integration.stages.export_data.functions.base.requests import (
     RegionalDataMartStatusRequest,
 )
-from edu_rdm_integration.management.general import (
+from edu_rdm_integration.stages.upload_data.management.base import (
     BaseDatamartClientCommand,
 )
 
 
+# ruff: noqa: D101
 class Command(BaseDatamartClientCommand):
-
     help = 'Команда для получения статуса загрузки файла в РВД с использованием uploader-client.'  # noqa A003
 
     def add_arguments(self, parser):

edu_rdm_integration/{management → stages/upload_data/management}/commands/datamart_upload.py

@@ -2,17 +2,17 @@ from pathlib import (
     Path,
 )
 
-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.management.general import (
+from edu_rdm_integration.stages.upload_data.management.base import (
     BaseDatamartClientCommand,
 )
 
 
+# ruff: noqa: D101
 class Command(BaseDatamartClientCommand):
-
-    help = 'Команда для загрузки csv-файла в РВД с использованием uploader-client.'  # noqa A003
+    help = 'Команда для загрузки csv-файла в РВД с использованием uploader-client.'
 
     def add_arguments(self, parser):
         """Добавление параметров."""