Update app.py

app.py

@@ -718,40 +718,26 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
 }
 
 class NutrientCalculator:
-    def __init__(self, volume_liters=1.0):
+    def __init__(self, volume_liters: float = 1.0):
         self.volume = volume_liters
         self.results = {}
-        self.target_profile = BASE_PROFILE.copy()
-        self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
-        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
+        self.target_profile = DEFAULT_VALUES['BASE_PROFILE'].copy()
+        self.actual_profile = {k: 0.0 for k in DEFAULT_VALUES['BASE_PROFILE']}
         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,  # Вес калийной селитры (0-1)
-            'CaNO3': 0.3, # Вес кальциевой селитры (0-1)
-            'K2SO4': 0.2  # Вес сульфата калия (0-1)
+            'KNO3': 0.5,
+            'CaNO3': 0.3,
+            'K2SO4': 0.2
         }
 
-    def _label(self, element):
-        """Форматирование названий элементов для вывода"""
+    def _label(self, element: str) -> str:
         labels = {
             'N (NO3-)': 'NO3',
             'N (NH4+)': 'NH4'
         }
         return labels.get(element, element)
 
-    def set_compensation_weights(self, kno3_weight, cano3_weight, k2so4_weight):
-        """Установка весов для компенсации элементов"""
+    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,
@@ -759,174 +745,117 @@ class NutrientCalculator:
             'K2SO4': k2so4_weight / total
         }
 
-    def calculate(self):
-        """Основной метод расчета (исправленная версия)"""
-        try:
-            # 1. Вносим Mg и S
-            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
-            
-            # 2. Балансируем азот с учетом компенсации
-            self._balance_nitrogen_with_compensation()
-            
-            # 3. Вносим Ca (остаток)
-            ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
-            if ca_needed > 0.1:
-                self._apply("Кальциевая селитра", "Ca", ca_needed)
-            
-            # 4. Вносим P
-            p_needed = self.target_profile['P'] - self.actual_profile['P']
-            if p_needed > 0.1:
-                self._apply("Монофосфат калия", "P", p_needed)
-            
-            # 5. Корректируем K
-            k_needed = self.target_profile['K'] - self.actual_profile['K']
-            if k_needed > 0.1:
-                self._apply("Калий сернокислый", "K", k_needed)
-            
-            return self.results
-        except Exception as e:
-            logging.error(f"Calculation error: {str(e)}")
-            raise
-
-
-
-    def _apply(self, fert_name, main_element, required_ppm):
+    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:
-                result = {
+                self.results[fert_name] = {
                     'граммы': 0.0,
                     'миллиграммы': 0,
                     'вклад в EC': 0.0
                 }
                 for element in self.fertilizers[fert_name]:
-                    result[f'внесет {self._label(element)}'] = 0.0
-                self.results[fert_name] = result
-                
+                    self.results[fert_name][f'внесет {self._label(element)}'] = 0.0
+            
             self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
+            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 * EC_COEFFICIENTS.get(element, 0.0015)
-                
+                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:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
+            logger.error(f"Key error in _apply: {str(e)}")
             raise
 
-    def _apply_k_sulfate(self):
-        fert = "Калий сернокислый"
-        k_def = self.target_profile['K'] - self.actual_profile['K']
-        s_def = self.target_profile['S'] - self.actual_profile['S']
-        
-        if k_def <= 0 and s_def <= 0:
-            return
-            
+    def _balance_nitrogen_with_compensation(self):
         try:
-            if s_def > 0.1:
-                s_content = self.fertilizers[fert]["S"]
-                grams_s = (s_def * self.volume) / (s_content * 1000)
+            # Вносим 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
                 
-                k_content = self.fertilizers[fert]["K"]
-                k_from_s = (grams_s * k_content * 1000) / self.volume
+                # Через 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
                 
-                if k_from_s > k_def and k_def > 0.1:
-                    grams = (k_def * self.volume) / (k_content * 1000)
-                else:
-                    grams = grams_s
-                    
-                self._apply(fert, "S", s_def)
+                # Остаток через K2SO4 (если разрешено весами)
+                if no3_needed > 0.1 and self.compensation_weights['K2SO4'] > 0:
+                    pass  # Логика компенсации через K2SO4
+
         except Exception as e:
-            print(f"Ошибка при расчёте сульфата калия: {str(e)}")
+            logger.error(f"Error in _balance_nitrogen_with_compensation: {str(e)}")
             raise
 
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
-
-    def print_report(self):
+    def calculate(self) -> Dict[str, Any]:
         try:
-            print("\n" + "="*60)
-            print("ПРОФИЛЬ ПИТАТЕЛЬНОГО РАСТВОРА (ИТОГО):")
-            print("="*60)
-            table = [[el, round(self.actual_profile[el], 1)] for el in self.actual_profile]
-            print(tabulate(table, headers=["Элемент", "ppm"]))
-
-            print("\nИсходный расчёт азота:")
-            for form, val in self.initial_n_profile.items():
-                print(f"  {form}: {round(val, 1)} ppm")
-
-            print("\n" + "="*60)
-            print(f"РАСЧЕТ ДЛЯ {self.volume} ЛИТРОВ РАСТВОРА")
-            print("="*60)
-            print(f"Общая концентрация: {round(sum(self.actual_profile.values()), 1)} ppm")
-            print(f"EC: {self.calculate_ec()} mS/cm")
-
-            print("\nРЕКОМЕНДУЕМЫЕ УДОБРЕНИЯ:")
-            fert_table = []
-            for fert, data in self.results.items():
-                adds = [f"+{k}: {v:.1f} ppm" for k, v in data.items() if k.startswith('внесет')]
-                fert_table.append([
-                    fert,
-                    round(data['граммы'], 3),
-                    data['миллиграммы'],
-                    round(data['вклад в EC'], 3),
-                    "\n".join(adds)
-                ])
-            print(tabulate(fert_table, 
-                         headers=["Удобрение", "Граммы", "Миллиграммы", "EC (мСм/см)", "Добавит"]))
-
-            print("\nОСТАТОЧНЫЙ ДЕФИЦИТ:")
-            deficit = {
-                k: round(self.target_profile[k] - self.actual_profile[k], 1)
-                for k in self.target_profile
-                if abs(self.target_profile[k] - self.actual_profile[k]) > 0.1
-            }
-            if deficit:
-                for el, val in deficit.items():
-                    print(f"  {el}: {val} ppm")
-            else:
-                print("  Все элементы покрыты полностью")
+            # 1. Вносим Mg и S
+            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
+            
+            # 2. Балансируем азот
+            self._balance_nitrogen_with_compensation()
+            
+            # 3. Вносим Ca (остаток)
+            ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
+            if ca_needed > 0.1:
+                self._apply("Кальциевая селитра", "Ca", ca_needed)
+            
+            # 4. Вносим P
+            p_needed = self.target_profile['P'] - self.actual_profile['P']
+            if p_needed > 0.1:
+                self._apply("Монофосфат калия", "P", p_needed)
+            
+            # 5. Корректируем K
+            k_needed = self.target_profile['K'] - self.actual_profile['K']
+            if k_needed > 0.1:
+                self._apply("Калий сернокислый", "K", k_needed)
+            
+            return self.results
+            
         except Exception as e:
-            print(f"Ошибка при выводе отчёта: {str(e)}")
+            logger.error(f"Calculation error: {str(e)}")
             raise
 
-if __name__ == "__main__":
-    try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.calculate()
-        calculator.print_report()  # Правильный вызов метода класса
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
-
-
-
-
-
-
-
-
-
-
-from flask import request, jsonify
+    def calculate_ec(self) -> float:
+        return round(self.total_ec, 2)
 
-def round_floats(obj, ndigits=3):
-    """Рекурсивно округляет все float значения в структуре данных"""
+def round_floats(obj: Union[float, Dict, List], ndigits: int = 3) -> Union[float, Dict, List]:
+    """Рекурсивно округляет 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, tuple)):
+    elif isinstance(obj, list):
         return [round_floats(x, ndigits) for x in obj]
     return obj
 
@@ -934,104 +863,113 @@ def round_floats(obj, ndigits=3):
 def handle_calculation():
     try:
         data = request.get_json()
+        logger.info(f"Received request data: {data}")
         
-        # Получаем параметр точности округления (по умолчанию 3)
-        rounding_precision = int(data['profileSettings'].get('rounding_precision', 3))
+        # Валидация базовой структуры
+        if not data or not isinstance(data, dict):
+            logger.error("Invalid JSON format")
+            return jsonify({'error': 'Invalid JSON format'}), 400
         
-        # Проверка обязательных полей
-        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']
+        # Проверка обязательных разделов
+        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"]
+        }
         
-        # Устанавливаем константы из запроса
-        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  # Фиксированное значение
+        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']
         
-        # Формируем целевой профиль
+        # Установка целевого профиля
         target_profile = {
-            '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   # Будет рассчитано в калькуляторе
+            '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))
         }
-        
-        # Обновляем константы удобрений
-        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
-        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()
-        
-        # Формируем ответ
+
+        # Установка весов компенсации (если есть)
+        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
+
+        # Формирование ответа
         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['миллиграммы']))
-        
+                    fert['миллиграммы'] = int(round(fert['граммы'] * 1000))
+
+        logger.info("Calculation completed successfully")
         return jsonify(rounded_response)
         
     except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-
-
+        logger.error(f"Server error: {str(e)}\n{traceback.format_exc()}")
+        return jsonify({'error': 'Internal server error'}), 500
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))