Опер справку починил

python_parser/adapters/parsers/monitoring_fuel.py

@@ -44,6 +44,21 @@ class MonitoringFuelParser(ParserPort):
             description="Получение временного ряда по ID и колонкам"
         )
 
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для мониторинга топлива"""
+        # Для monitoring_fuel определяем геттер из параметра mode
+        getter_name = get_params.pop("mode", None)
+        if not getter_name:
+            # Если режим не указан, берем первый доступный
+            available_getters = list(self.getters.keys())
+            if available_getters:
+                getter_name = available_getters[0]
+                logger.warning(f"⚠️ Режим не указан, используем первый доступный: {getter_name}")
+            else:
+                raise ValueError("Парсер не имеет доступных геттеров")
+        
+        return getter_name
+
     def _get_total_by_columns(self, params: dict):
         """Агрегация данных по колонкам"""
         # Валидируем параметры с помощью схемы Pydantic

python_parser/adapters/parsers/monitoring_tar.py

@@ -24,6 +24,16 @@ class MonitoringTarParser(ParserPort):
         # Регистрируем геттеры
         self.register_getter('get_tar_data', self._get_tar_data_wrapper, required_params=['mode'])
         self.register_getter('get_tar_full_data', self._get_tar_full_data_wrapper, required_params=[])
+
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для мониторинга ТАР"""
+        # Для monitoring_tar определяем геттер по параметрам
+        if 'mode' in get_params:
+            # Если есть параметр mode, используем get_tar_data
+            return 'get_tar_data'
+        else:
+            # Если нет параметра mode, используем get_tar_full_data
+            return 'get_tar_full_data'
     
     def parse(self, file_path: str, params: Dict[str, Any] = None) -> pd.DataFrame:
         """Парсит ZIP архив с файлами мониторинга ТЭР"""

python_parser/adapters/parsers/oper_spravka_tech_pos.py

@@ -24,6 +24,11 @@ class OperSpravkaTechPosParser(ParserPort):
         
         # Регистрируем геттер
         self.register_getter('get_tech_pos', self._get_tech_pos_wrapper, required_params=['id'])
+
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для операционных справок технологических позиций"""
+        # Для oper_spravka_tech_pos всегда используем геттер get_tech_pos
+        return 'get_tech_pos'
     
     def parse(self, file_path: str, params: Dict[str, Any] = None) -> pd.DataFrame:
         """Парсит ZIP архив с файлами операционных справок технологических позиций"""

python_parser/adapters/parsers/statuses_repair_ca.py

@@ -28,6 +28,11 @@ class StatusesRepairCAParser(ParserPort):
             description="Получение статусов ремонта по ОГ и ключам"
         )
 
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для статусов ремонта СА"""
+        # Для statuses_repair_ca всегда используем геттер get_repair_statuses
+        return 'get_repair_statuses'
+
     def parse(self, file_path: str, params: dict) -> Dict[str, Any]:
         """Парсинг файла статусов ремонта СА"""
         logger.debug(f"🔍  StatusesRepairCAParser.parse вызван с файлом: {file_path}")

python_parser/adapters/parsers/svodka_ca.py

@@ -27,6 +27,23 @@ class SvodkaCAParser(ParserPort):
             description="Получение данных по режимам и таблицам"
         )
 
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для сводки СА"""
+        # Для svodka_ca определяем режим из данных или используем 'fact' по умолчанию
+        if hasattr(self, 'df') and self.df is not None and not self.df.empty:
+            modes_in_df = self.df['mode'].unique() if 'mode' in self.df.columns else ['fact']
+            # Используем первый найденный режим или 'fact' по умолчанию
+            default_mode = modes_in_df[0] if len(modes_in_df) > 0 else 'fact'
+        else:
+            default_mode = 'fact'
+        
+        # Устанавливаем режим в параметры, если он не указан
+        if 'mode' not in get_params:
+            get_params['mode'] = default_mode
+        
+        # Для svodka_ca всегда используем геттер get_ca_data
+        return 'get_ca_data'
+
     def _get_data_wrapper(self, params: dict):
         """Получение данных по режимам и таблицам"""
         logger.debug(f"🔍  _get_data_wrapper вызван с параметрами: {params}")

python_parser/adapters/parsers/svodka_pm.py

@@ -42,6 +42,21 @@ class SvodkaPMParser(ParserPort):
             description="Получение данных по всем ОГ из сводки ПМ"
         )
 
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для сводки ПМ"""
+        # Для svodka_pm определяем геттер из параметра mode
+        getter_name = get_params.pop("mode", None)
+        if not getter_name:
+            # Если режим не указан, берем первый доступный
+            available_getters = list(self.getters.keys())
+            if available_getters:
+                getter_name = available_getters[0]
+                logger.warning(f"⚠️ Режим не указан, используем первый доступный: {getter_name}")
+            else:
+                raise ValueError("Парсер не имеет доступных геттеров")
+        
+        return getter_name
+
     def parse(self, file_path: str, params: dict) -> Dict[str, pd.DataFrame]:
         """Парсинг ZIP архива со сводками ПМ и возврат словаря с DataFrame"""
         # Проверяем расширение файла

python_parser/adapters/parsers/svodka_repair_ca.py

@@ -31,6 +31,11 @@ class SvodkaRepairCAParser(ParserPort):
             description="Получение данных о ремонтных работах"
         )
 
+    def determine_getter(self, get_params: dict) -> str:
+        """Определение геттера для сводки ремонта СА"""
+        # Для svodka_repair_ca всегда используем геттер get_repair_data
+        return 'get_repair_data'
+
     def _get_repair_data_wrapper(self, params: dict):
         """Получение данных о ремонтных работах"""
         logger.debug(f"🔍  _get_repair_data_wrapper вызван с параметрами: {params}")

python_parser/app/endpoints/common.py

@@ -164,10 +164,25 @@ async def get_server_info():
     """Получение подробной информации о сервере"""
     import platform
     import sys
+    import os
+    import psutil
+    
+    # Получаем информацию о процессе
+    process = psutil.Process()
+    parent_process = process.parent()
+    
+    # Получаем информацию о системе
+    cpu_cores = psutil.cpu_count()
+    memory_info = psutil.virtual_memory()
+    memory_mb = memory_info.total / (1024 * 1024)  # Конвертируем в MB
     
     return {
         "message": "Svodka Parser API",
         "version": "1.0.0",
+        "process_id": process.pid,
+        "parent_id": parent_process.pid if parent_process else None,
+        "cpu_cores": cpu_cores,
+        "memory_mb": memory_mb,
         "python_version": sys.version,
         "platform": platform.platform(),
         "available_parsers": list(PARSERS.keys())

python_parser/app/endpoints/oper_spravka_tech_pos.py

@@ -41,20 +41,20 @@ def get_async_report_service() -> AsyncReportService:
               500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
           },)
 async def upload_oper_spravka_tech_pos(
-    file: UploadFile = File(..., description="Excel файл оперативной справки техпос (.xlsx, .xlsm, .xls)")
+    file: UploadFile = File(..., description="ZIP архив с файлами оперативной справки техпос (.zip)")
 ):
     """Загрузка и обработка отчета оперативной справки техпос"""
     report_service = get_report_service()
 
     try:
-        if not file.filename.endswith(('.xlsx', '.xlsm', '.xls')):
+        if not file.filename.endswith('.zip'):
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 content=UploadErrorResponse(
-                    message="Поддерживаются только Excel файлы (.xlsx, .xlsm, .xls)",
+                    message="Поддерживаются только ZIP архивы (.zip)",
                     error_code="INVALID_FILE_TYPE",
                     details={
-                        "expected_formats": [".xlsx", ".xlsm", ".xls"],
+                        "expected_formats": [".zip"],
                         "received_format": file.filename.split('.')[-1] if '.' in file.filename else "unknown"
                     }
                 ).model_dump()
@@ -115,9 +115,11 @@ async def get_oper_spravka_tech_pos_data(
         result = report_service.get_data(request)
 
         if result.success:
+            # Извлекаем данные из result.data["value"]
+            data = result.data.get("value", []) if isinstance(result.data, dict) else result.data
             return OperSpravkaTechPosResponse(
                 success=True,
-                data=result.data
+                data=data
             )
         else:
             raise HTTPException(status_code=404, detail=result.message)
@@ -136,20 +138,20 @@ async def get_oper_spravka_tech_pos_data(
               500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
           },)
 async def async_upload_oper_spravka_tech_pos(
-    file: UploadFile = File(..., description="Excel файл оперативной справки техпос (.xlsx, .xlsm, .xls)")
+    file: UploadFile = File(..., description="ZIP архив с файлами оперативной справки техпос (.zip)")
 ):
     """Асинхронная загрузка и обработка отчета оперативной справки техпос"""
     async_service = get_async_report_service()
 
     try:
-        if not file.filename.endswith(('.xlsx', '.xlsm', '.xls')):
+        if not file.filename.endswith('.zip'):
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 content=UploadErrorResponse(
-                    message="Поддерживаются только Excel файлы (.xlsx, .xlsm, .xls)",
+                    message="Поддерживаются только ZIP архивы (.zip)",
                     error_code="INVALID_FILE_TYPE",
                     details={
-                        "expected_formats": [".xlsx", ".xlsm", ".xls"],
+                        "expected_formats": [".zip"],
                         "received_format": file.filename.split('.')[-1] if '.' in file.filename else "unknown"
                     }
                 ).model_dump()

python_parser/core/ports.py

@@ -84,6 +84,35 @@ class ParserPort(ABC):
         except Exception as e:
             raise ValueError(f"Ошибка выполнения геттера '{getter_name}': {str(e)}")
 
+    def determine_getter(self, get_params: Dict[str, Any]) -> str:
+        """
+        Определение имени геттера на основе параметров запроса
+        
+        Args:
+            get_params: Параметры запроса
+            
+        Returns:
+            Имя геттера для выполнения
+            
+        Raises:
+            ValueError: Если не удается определить геттер
+        """
+        # По умолчанию используем первый доступный геттер
+        available_getters = list(self.getters.keys())
+        if not available_getters:
+            raise ValueError("Парсер не имеет доступных геттеров")
+        
+        # Если указан режим, используем его
+        if 'mode' in get_params:
+            mode = get_params['mode']
+            if mode in self.getters:
+                return mode
+            else:
+                raise ValueError(f"Режим '{mode}' не найден. Доступные: {available_getters}")
+        
+        # Иначе используем первый доступный
+        return available_getters[0]
+
     @abstractmethod
     def parse(self, file_path: str, params: dict) -> pd.DataFrame:
         """Парсинг файла и возврат DataFrame"""

python_parser/core/services.py

@@ -122,83 +122,14 @@ class ReportService:
             # Получаем параметры запроса
             get_params = request.get_params or {}
             
-            # Для svodka_ca определяем режим из данных или используем 'fact' по умолчанию
-            if request.report_type == 'svodka_ca':
-                # Извлекаем режим из DataFrame или используем 'fact' по умолчанию
-                if hasattr(parser, 'df') and parser.df is not None and not parser.df.empty:
-                    modes_in_df = parser.df['mode'].unique() if 'mode' in parser.df.columns else ['fact']
-                    # Используем первый найденный режим или 'fact' по умолчанию
-                    default_mode = modes_in_df[0] if len(modes_in_df) > 0 else 'fact'
-                else:
-                    default_mode = 'fact'
-                
-                # Устанавливаем режим в параметры, если он не указан
-                if 'mode' not in get_params:
-                    get_params['mode'] = default_mode
-            
-            # Определяем имя геттера
-            if request.report_type == 'svodka_ca':
-                # Для svodka_ca используем геттер get_ca_data
-                getter_name = 'get_ca_data'
-            elif request.report_type == 'svodka_repair_ca':
-                # Для svodka_repair_ca используем геттер get_repair_data
-                getter_name = 'get_repair_data'
-            elif request.report_type == 'statuses_repair_ca':
-                # Для statuses_repair_ca используем геттер get_repair_statuses
-                getter_name = 'get_repair_statuses'
-            elif request.report_type == 'monitoring_tar':
-                # Для monitoring_tar определяем геттер по параметрам
-                if 'mode' in get_params:
-                    # Если есть параметр mode, используем get_tar_data
-                    getter_name = 'get_tar_data'
-                else:
-                    # Если нет параметра mode, используем get_tar_full_data
-                    getter_name = 'get_tar_full_data'
-            elif request.report_type == 'monitoring_fuel':
-                # Для monitoring_fuel определяем геттер из параметра mode
-                getter_name = get_params.pop("mode", None)
-                if not getter_name:
-                    # Если режим не указан, берем первый доступный
-                    available_getters = list(parser.getters.keys())
-                    if available_getters:
-                        getter_name = available_getters[0]
-                        logger.warning(f"⚠️ Режим не указан, используем первый доступный: {getter_name}")
-                    else:
-                        return DataResult(
-                            success=False,
-                            message="Парсер не имеет доступных геттеров"
-                        )
-            elif request.report_type == 'svodka_pm':
-                # Для svodka_pm определяем геттер из параметра mode
-                getter_name = get_params.pop("mode", None)
-                if not getter_name:
-                    # Если режим не указан, берем первый доступный
-                    available_getters = list(parser.getters.keys())
-                    if available_getters:
-                        getter_name = available_getters[0]
-                        logger.warning(f"⚠️ Режим не указан, используем первый доступный: {getter_name}")
-                    else:
-                        return DataResult(
-                            success=False,
-                            message="Парсер не имеет доступных геттеров"
-                        )
-            elif request.report_type == 'oper_spravka_tech_pos':
-                # Для oper_spravka_tech_pos используем геттер get_tech_pos
-                getter_name = 'get_tech_pos'
-            else:
-                # Для других парсеров определяем из параметра mode
-                getter_name = get_params.pop("mode", None)
-                if not getter_name:
-                    # Если режим не указан, берем первый доступный
-                    available_getters = list(parser.getters.keys())
-                    if available_getters:
-                        getter_name = available_getters[0]
-                        logger.warning(f"⚠️ Режим не указан, используем первый доступный: {getter_name}")
-                    else:
-                        return DataResult(
-                            success=False,
-                            message="Парсер не имеет доступных геттеров"
-                        )
+            # Определяем имя геттера через парсер (делегируем логику в адаптер)
+            try:
+                getter_name = parser.determine_getter(get_params)
+            except ValueError as e:
+                return DataResult(
+                    success=False,
+                    message=str(e)
+                )
 
             # Получаем значение через указанный геттер
             try:

python_parser/requirements.txt

@@ -11,4 +11,5 @@ requests>=2.31.0
 # pytest-cov>=4.0.0
 # pytest-mock>=3.10.0
 httpx>=0.24.0 
-numpy
+numpy
+psutil>=5.9.0