Update app.py

app.py

@@ -721,17 +721,29 @@ class NutrientCalculator:
     def __init__(self, volume_liters: float = 1.0):
         self.volume = volume_liters
         self.results: Dict[str, Dict[str, Any]] = {}
-        self.target_profile = DEFAULT_VALUES['BASE_PROFILE'].copy()
-        self.actual_profile = {k: 0.0 for k in DEFAULT_VALUES['BASE_PROFILE']}
+        self.target_profile = BASE_PROFILE.copy()
+        self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
+        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
         self.total_ec = 0.0
+
+        # Расчет азота
+        total_parts = NO3_RATIO + NH4_RATIO
+        self.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / total_parts)
+        self.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / total_parts)
+        self.initial_n_profile = {
+            "NO3-": self.target_profile['N (NO3-)'],
+            "NH4+": self.target_profile['N (NH4+)']
+        }
+
+        # Настройки компенсации по умолчанию
         self.compensation_weights = {
-            'KNO3': 0.5,
-            'CaNO3': 0.3,
-            'K2SO4': 0.2
+            'KNO3': 0.5,  # Вес калийной селитры (0-1)
+            'CaNO3': 0.3, # Вес кальциевой селитры (0-1)
+            'K2SO4': 0.2  # Вес сульфата калия (0-1)
         }
-        self.fertilizers: Dict[str, Dict[str, float]] = {}
 
     def _label(self, element: str) -> str:
+        """Форматирование названий элементов для вывода"""
         labels = {
             'N (NO3-)': 'NO3',
             'N (NH4+)': 'NH4'
@@ -739,6 +751,7 @@ class NutrientCalculator:
         return labels.get(element, element)
 
     def set_compensation_weights(self, kno3_weight: float, cano3_weight: float, k2so4_weight: float):
+        """Установка весов для компенсации элементов"""
         total = kno3_weight + cano3_weight + k2so4_weight
         self.compensation_weights = {
             'KNO3': kno3_weight / total,
@@ -746,84 +759,13 @@ class NutrientCalculator:
             'K2SO4': k2so4_weight / total
         }
 
-    def _apply(self, fert_name: str, main_element: str, required_ppm: float):
-        if required_ppm <= 0:
-            return
-
-        try:
-            content = self.fertilizers[fert_name][main_element]
-            grams = (required_ppm * self.volume) / (content * 1000)
-            
-            if fert_name not in self.results:
-                self.results[fert_name] = {
-                    'граммы': 0.0,
-                    'миллиграммы': 0,
-                    'вклад в EC': 0.0
-                }
-                for element in self.fertilizers[fert_name]:
-                    self.results[fert_name][f'внесет {self._label(element)}'] = 0.0
-            
-            self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] = int(self.results[fert_name]['граммы'] * 1000)
-            
-            fert_ec = 0.0
-            for element, percent in self.fertilizers[fert_name].items():
-                added_ppm = (grams * percent * 1000) / self.volume
-                self.results[fert_name][f'внесет {self._label(element)}'] += added_ppm
-                self.actual_profile[element] += added_ppm
-                fert_ec += added_ppm * DEFAULT_VALUES['EC_COEFFICIENTS'].get(element, 0.0015)
-            
-            self.results[fert_name]['вклад в EC'] += fert_ec
-            self.total_ec += fert_ec
-            
-        except KeyError as e:
-            logger.error(f"Key error in _apply: {str(e)}")
-            raise
-
-    def _balance_nitrogen_with_compensation(self):
-        try:
-            # Вносим NH4+
-            nh4_needed = self.target_profile['N (NH4+)'] - self.actual_profile['N (NH4+)']
-            if nh4_needed > 0.1:
-                self._apply("Аммоний азотнокислый", "N (NH4+)", nh4_needed)
-            
-            # Вносим NO3- с компенсацией
-            no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
-            if no3_needed > 0.1:
-                # Через CaNO3 (если нужен Ca)
-                ca_part = self.compensation_weights['CaNO3'] * no3_needed
-                ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
-                if ca_needed > 0.1:
-                    max_ca_no3 = (ca_needed / self.fertilizers["Кальциевая селитра"]["Ca"]) * \
-                                self.fertilizers["Кальциевая селитра"]["N (NO3-)"]
-                    ca_no3_part = min(ca_part, max_ca_no3)
-                    self._apply("Кальциевая селитра", "N (NO3-)", ca_no3_part)
-                    no3_needed -= ca_no3_part
-                
-                # Через KNO3 (если нужен K)
-                kno3_part = self.compensation_weights['KNO3'] * no3_needed
-                k_remaining = self.target_profile['K'] - self.actual_profile['K']
-                if k_remaining > 0.1:
-                    max_k_no3 = (k_remaining / self.fertilizers["Калий азотнокислый"]["K"]) * \
-                               self.fertilizers["Калий азотнокислый"]["N (NO3-)"]
-                    k_no3_part = min(kno3_part, max_k_no3)
-                    self._apply("Калий азотнокислый", "N (NO3-)", k_no3_part)
-                    no3_needed -= k_no3_part
-                
-                # Остаток через K2SO4 (если разрешено весами)
-                if no3_needed > 0.1 and self.compensation_weights['K2SO4'] > 0:
-                    pass  # Логика компенсации через K2SO4
-
-        except Exception as e:
-            logger.error(f"Error in _balance_nitrogen_with_compensation: {str(e)}")
-            raise
-
     def calculate(self) -> Dict[str, Any]:
+        """Основной метод расчета с новой логикой"""
         try:
             # 1. Вносим Mg и S
             self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
             
-            # 2. Балансируем азот
+            # 2. Балансируем азот с учетом компенсации
             self._balance_nitrogen_with_compensation()
             
             # 3. Вносим Ca (остаток)
@@ -836,7 +778,7 @@ class NutrientCalculator:
             if p_needed > 0.1:
                 self._apply("Монофосфат калия", "P", p_needed)
             
-            # 5. Корректируем K
+            # 5. Корректируем K через сульфат калия (если остался дефицит)
             k_needed = self.target_profile['K'] - self.actual_profile['K']
             if k_needed > 0.1:
                 self._apply("Калий сернокислый", "K", k_needed)
@@ -844,19 +786,18 @@ class NutrientCalculator:
             return self.results
             
         except Exception as e:
-            logger.error(f"Calculation error: {str(e)}")
+            print(f"Ошибка при расчёте: {str(e)}")
             raise
 
-    def calculate_ec(self) -> float:
-        return round(self.total_ec, 2)
+    # ... остальные методы класса NutrientCalculator ...
 
 def round_floats(obj: Union[float, Dict, List], ndigits: int = 3) -> Union[float, Dict, List]:
-    """Рекурсивно округляет float значения"""
+    """Рекурсивно округляет все float значения в структуре данных"""
     if isinstance(obj, float):
         return round(obj, ndigits)
     elif isinstance(obj, dict):
         return {k: round_floats(v, ndigits) for k, v in obj.items()}
-    elif isinstance(obj, list):
+    elif isinstance(obj, (list, tuple)):
         return [round_floats(x, ndigits) for x in obj]
     return obj
 
@@ -864,113 +805,101 @@ def round_floats(obj: Union[float, Dict, List], ndigits: int = 3) -> Union[float
 def handle_calculation():
     try:
         data = request.get_json()
-        logger.info(f"Received request data: {data}")
         
-        # Валидация базовой структуры
-        if not data or not isinstance(data, dict):
-            logger.error("Invalid JSON format")
-            return jsonify({'error': 'Invalid JSON format'}), 400
+        # Получаем параметр точности округления (по умолчанию 3)
+        rounding_precision = int(data['profileSettings'].get('rounding_precision', 3))
         
-        # Проверка обязательных разделов
-        required_sections = ['fertilizerConstants', 'profileSettings']
-        for section in required_sections:
-            if section not in data or not isinstance(data[section], dict):
-                logger.error(f"Missing or invalid section: {section}")
-                return jsonify({'error': f'Missing or invalid {section}'}), 400
-
-        # Извлечение данных
-        try:
-            rounding_precision = int(data['profileSettings'].get('rounding_precision', 3))
-            volume_liters = float(data['profileSettings'].get('liters', DEFAULT_VALUES['VOLUME_LITERS']))
-            total_nitrogen = float(data['profileSettings'].get('TOTAL_NITROG', DEFAULT_VALUES['TOTAL_NITROGEN']))
-            no3_ratio = float(data['profileSettings'].get('NO3_RAT', DEFAULT_VALUES['NO3_RATIO']))
-            nh4_ratio = DEFAULT_VALUES['NH4_RATIO']
-        except (ValueError, TypeError) as e:
-            logger.error(f"Invalid numeric value: {str(e)}")
-            return jsonify({'error': f'Invalid numeric value: {str(e)}'}), 400
-
-        # Проверка удобрений
-        required_fertilizers = {
-            "Кальциевая селитра": ["N (NO3-)", "Ca"],
-            "Калий азотнокислый": ["N (NO3-)", "K"],
-            "��ммоний азотнокислый": ["N (NO3-)", "N (NH4+)"],
-            "Сульфат магния": ["Mg", "S"],
-            "Монофосфат калия": ["P", "K"],
-            "Калий сернокислый": ["K", "S"]
-        }
+        # Проверка обязательных полей
+        if not data or 'fertilizerConstants' not in data or 'profileSettings' not in data:
+            return jsonify({'error': 'Неверный формат данных'}), 400
+        
+        # Извлекаем данные из запроса
+        fertilizer_data = data['fertilizerConstants']
+        profile_data = data['profileSettings']
         
-        for fert, elements in required_fertilizers.items():
-            if fert not in data['fertilizerConstants']:
-                logger.error(f"Missing fertilizer: {fert}")
-                return jsonify({'error': f'Missing fertilizer: {fert}'}), 400
-            for element in elements:
-                if element not in data['fertilizerConstants'][fert]:
-                    logger.error(f"Missing element {element} in {fert}")
-                    return jsonify({'error': f'Missing element {element} in {fert}'}), 400
-
-        # Создание калькулятора
-        calculator = NutrientCalculator(volume_liters=volume_liters)
-        calculator.fertilizers = data['fertilizerConstants']
+        # Устанавливаем константы из запроса
+        TOTAL_NITROGEN = float(profile_data.get('TOTAL_NITROG', 125.0))
+        NO3_RATIO = float(profile_data.get('NO3_RAT', 8.25))
+        VOLUME_LITERS = float(profile_data.get('liters', 100))
+        NH4_RATIO = 1.00  # Фиксированное значение
         
-        # Установка целевого профиля
+        # Формируем целевой профиль
         target_profile = {
-            'P': float(data['profileSettings'].get('P', DEFAULT_VALUES['BASE_PROFILE']['P'])),
-            'K': float(data['profileSettings'].get('K', DEFAULT_VALUES['BASE_PROFILE']['K'])),
-            'Mg': float(data['profileSettings'].get('Mg', DEFAULT_VALUES['BASE_PROFILE']['Mg'])),
-            'Ca': float(data['profileSettings'].get('Ca', DEFAULT_VALUES['BASE_PROFILE']['Ca'])),
-            'S': float(data['profileSettings'].get('S', DEFAULT_VALUES['BASE_PROFILE']['S'])),
-            'N (NO3-)': total_nitrogen * (no3_ratio / (no3_ratio + nh4_ratio)),
-            'N (NH4+)': total_nitrogen * (nh4_ratio / (no3_ratio + nh4_ratio))
+            'P': float(profile_data.get('P', 31.0)),
+            'K': float(profile_data.get('K', 210.0)),
+            'Mg': float(profile_data.get('Mg', 24.0)),
+            'Ca': float(profile_data.get('Ca', 84.0)),
+            'S': float(profile_data.get('S', 56.439)),
+            'N (NO3-)': 0,  # Будет рассчитано в калькуляторе
+            'N (NH4+)': 0   # Будет рассчитано в калькуляторе
         }
+        
+        # Обновляем константы удобрений
+        NUTRIENT_CONTENT_IN_FERTILIZERS = {
+            "Кальциевая селитра": {
+                "N (NO3-)": float(fertilizer_data["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
+                "Ca": float(fertilizer_data["Кальциевая селитра"].get("Ca", 0.16972))
+            },
+            "Калий азотнокислый": {
+                "N (NO3-)": float(fertilizer_data["Калий азотнокислый"].get("N (NO3-)", 0.13854)),
+                "K": float(fertilizer_data["Калий азотнокислый"].get("K", 0.36672))
+            },
+            "Аммоний азотнокислый": {
+                "N (NO3-)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
+                "N (NH4+)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
+            },
+            "Сульфат магния": {
+                "Mg": float(fertilizer_data["Сульфат магния"].get("Mg", 0.1022)),
+                "S": float(fertilizer_data["Сульфат магния"].get("S", 0.13483))
+            },
+            "Монофосфат калия": {
+                "P": float(fertilizer_data["Монофосфат калия"].get("P", 0.22761)),
+                "K": float(fertilizer_data["Монофосфат калия"].get("K", 0.28731))
+            },
+            "Калий сернокислый": {
+                "K": float(fertilizer_data["Калий сернокислый"].get("K", 0.44874)),
+                "S": float(fertilizer_data["Калий сернокислый"].get("S", 0.18401))
+            }
+        }
+        
+        # Создаем и настраиваем калькулятор
+        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
         calculator.target_profile = target_profile
-
-        # Установка весов компенсации (��сли есть)
-        if 'compensationWeights' in data['profileSettings']:
-            try:
-                weights = data['profileSettings']['compensationWeights']
-                calculator.set_compensation_weights(
-                    float(weights.get('KNO3', 0.5)),
-                    float(weights.get('CaNO3', 0.3)),
-                    float(weights.get('K2SO4', 0.2))
-                )
-            except Exception as e:
-                logger.warning(f"Invalid compensation weights: {str(e)}")
-
-        # Выполнение расчета
-        try:
-            results = calculator.calculate()
-        except Exception as e:
-            logger.error(f"Calculation failed: {str(e)}\n{traceback.format_exc()}")
-            return jsonify({'error': 'Calculation failed'}), 500
-
-        # Формирование ответа
+        calculator.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
+        
+        # Устанавливаем параметры азота
+        calculator.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / (NO3_RATIO + NH4_RATIO))
+        calculator.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / (NO3_RATIO + NH4_RATIO))
+        
+        # Выполняем расчет
+        results = calculator.calculate()
+        
+        # Формируем ответ
         response = {
             'actual_profile': calculator.actual_profile,
             'fertilizers': results,
             'total_ec': calculator.calculate_ec(),
             'total_ppm': sum(calculator.actual_profile.values()),
             'nitrogen_ratios': {
-                'NO3_RATIO': no3_ratio,
-                'NH4_RATIO': nh4_ratio,
-                'TOTAL_NITROGEN': total_nitrogen
+                'NO3_RATIO': NO3_RATIO,
+                'NH4_RATIO': NH4_RATIO,
+                'TOTAL_NITROGEN': TOTAL_NITROGEN
             }
         }
-
-        # Округление значений
+        
+        # Округляем все числовые значения
         rounded_response = round_floats(response, rounding_precision)
         
-        # Коррекция миллиграммов
+        # Для миллиграммов применяем целочисленное округление
         if 'fertilizers' in rounded_response:
             for fert in rounded_response['fertilizers'].values():
                 if 'миллиграммы' in fert:
                     fert['миллиграммы'] = int(round(fert['граммы'] * 1000))
-
-        logger.info("Calculation completed successfully")
+        
         return jsonify(rounded_response)
         
     except Exception as e:
-        logger.error(f"Server error: {str(e)}\n{traceback.format_exc()}")
-        return jsonify({'error': 'Internal server error'}), 500
+        return jsonify({'error': str(e)}), 500
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))