Done

python_parser/adapters/parsers/monitoring_fuel.py

@@ -3,6 +3,8 @@ import re
 import zipfile
 from typing import Dict, Tuple
 from core.ports import ParserPort
+from core.schema_utils import register_getter_from_schema, validate_params_with_schema
+from app.schemas.monitoring_fuel import MonitoringFuelTotalRequest, MonitoringFuelMonthRequest
 from adapters.pconfig import data_to_json
 
 
@@ -13,37 +15,40 @@ class MonitoringFuelParser(ParserPort):
 
     def _register_default_getters(self):
         """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="total_by_columns",
+        # Используем схемы Pydantic как единый источник правды
+        register_getter_from_schema(
+            parser_instance=self,
+            getter_name="total_by_columns",
             method=self._get_total_by_columns,
-            required_params=["columns"],
-            optional_params=[],
+            schema_class=MonitoringFuelTotalRequest,
             description="Агрегация данных по колонкам"
         )
         
-        self.register_getter(
-            name="month_by_code",
+        register_getter_from_schema(
+            parser_instance=self,
+            getter_name="month_by_code",
             method=self._get_month_by_code,
-            required_params=["month"],
-            optional_params=[],
+            schema_class=MonitoringFuelMonthRequest,
             description="Получение данных за конкретный месяц"
         )
 
     def _get_total_by_columns(self, params: dict):
-        """Агрегация по колонкам (обертка для совместимости)"""
-        columns = params["columns"]
-        if not columns:
-            raise ValueError("Отсутствуют идентификаторы столбцов")
+        """Агрегация данных по колонкам"""
+        # Валидируем параметры с помощью схемы Pydantic
+        validated_params = validate_params_with_schema(params, MonitoringFuelTotalRequest)
+        
+        columns = validated_params["columns"]
         
         # TODO: Переделать под новую архитектуру
         df_means, _ = self.aggregate_by_columns(self.df, columns)
         return df_means.to_dict(orient='index')
 
     def _get_month_by_code(self, params: dict):
-        """Получение данных за месяц (обертка для совместимости)"""
-        month = params["month"]
-        if not month:
-            raise ValueError("Отсутствует идентификатор месяца")
+        """Получение данных за конкретный месяц"""
+        # Валидируем параметры с помощью схемы Pydantic
+        validated_params = validate_params_with_schema(params, MonitoringFuelMonthRequest)
+        
+        month = validated_params["month"]
         
         # TODO: Переделать под новую архитектуру
         df_month = self.get_month(self.df, month)

python_parser/adapters/parsers/svodka_ca.py

@@ -2,6 +2,8 @@ import pandas as pd
 import numpy as np
 
 from core.ports import ParserPort
+from core.schema_utils import register_getter_from_schema, validate_params_with_schema
+from app.schemas.svodka_ca import SvodkaCARequest
 from adapters.pconfig import get_og_by_name
 
 
@@ -12,23 +14,22 @@ class SvodkaCAParser(ParserPort):
 
     def _register_default_getters(self):
         """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="get_data",
+        # Используем схемы Pydantic как единый источник правды
+        register_getter_from_schema(
+            parser_instance=self,
+            getter_name="get_data",
             method=self._get_data_wrapper,
-            required_params=["modes", "tables"],
-            optional_params=[],
+            schema_class=SvodkaCARequest,
             description="Получение данных по режимам и таблицам"
         )
 
     def _get_data_wrapper(self, params: dict):
-        """Обертка для получения данных (для совместимости)"""
-        modes = params["modes"]
-        tables = params["tables"]
+        """Получение данных по режимам и таблицам"""
+        # Валидируем параметры с помощью схемы Pydantic
+        validated_params = validate_params_with_schema(params, SvodkaCARequest)
         
-        if not isinstance(modes, list):
-            raise ValueError("Поле 'modes' должно быть списком")
-        if not isinstance(tables, list):
-            raise ValueError("Поле 'tables' должно быть списком")
+        modes = validated_params["modes"]
+        tables = validated_params["tables"]
         
         # TODO: Переделать под новую архитектуру
         data_dict = {}

python_parser/adapters/parsers/svodka_pm.py

@@ -1,6 +1,8 @@
 import pandas as pd
 
 from core.ports import ParserPort
+from core.schema_utils import register_getter_from_schema, validate_params_with_schema
+from app.schemas.svodka_pm import SvodkaPMSingleOGRequest, SvodkaPMTotalOGsRequest
 from adapters.pconfig import OG_IDS, replace_id_in_path, data_to_json
 
 
@@ -11,48 +13,45 @@ class SvodkaPMParser(ParserPort):
 
     def _register_default_getters(self):
         """Регистрация геттеров по умолчанию"""
-        self.register_getter(
-            name="single_og",
+        # Используем схемы Pydantic как единый источник правды
+        register_getter_from_schema(
+            parser_instance=self,
+            getter_name="single_og",
             method=self._get_single_og,
-            required_params=["id", "codes", "columns"],
-            optional_params=["search"],
+            schema_class=SvodkaPMSingleOGRequest,
             description="Получение данных по одному ОГ"
         )
         
-        self.register_getter(
-            name="total_ogs",
+        register_getter_from_schema(
+            parser_instance=self,
+            getter_name="total_ogs",
             method=self._get_total_ogs,
-            required_params=["codes", "columns"],
-            optional_params=["search"],
+            schema_class=SvodkaPMTotalOGsRequest,
             description="Получение данных по всем ОГ"
         )
 
     def _get_single_og(self, params: dict):
-        """Получение данных по одному ОГ (обертка для совместимости)"""
-        og_id = params["id"]
-        codes = params["codes"]
-        columns = params["columns"]
-        search = params.get("search")
+        """Получение данных по одному ОГ"""
+        # Валидируем параметры с помощью схемы Pydantic
+        validated_params = validate_params_with_schema(params, SvodkaPMSingleOGRequest)
         
-        if not isinstance(codes, list):
-            raise ValueError("Поле 'codes' должно быть списком")
-        if not isinstance(columns, list):
-            raise ValueError("Поле 'columns' должно быть списком")
+        og_id = validated_params["id"]
+        codes = validated_params["codes"]
+        columns = validated_params["columns"]
+        search = validated_params.get("search")
         
         # Здесь нужно получить DataFrame из self.df, но пока используем старую логику
         # TODO: Переделать под новую архитектуру
         return self.get_svodka_og(self.df, og_id, codes, columns, search)
 
     def _get_total_ogs(self, params: dict):
-        """Получение данных по всем ОГ (обертка для совместимости)"""
-        codes = params["codes"]
-        columns = params["columns"]
-        search = params.get("search")
+        """Получение данных по всем ОГ"""
+        # Валидируем параметры с помощью схемы Pydantic
+        validated_params = validate_params_with_schema(params, SvodkaPMTotalOGsRequest)
         
-        if not isinstance(codes, list):
-            raise ValueError("Поле 'codes' должно быть списком")
-        if not isinstance(columns, list):
-            raise ValueError("Поле 'columns' должно быть списком")
+        codes = validated_params["codes"]
+        columns = validated_params["columns"]
+        search = validated_params.get("search")
         
         # TODO: Переделать под новую архитектуру
         return self.get_svodka_total(self.df, codes, columns, search)