Update app.py

app.py

@@ -689,52 +689,49 @@ def nutri_call():
 class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
-        self.results = {}
-        self.target_profile = {
+        self.results = defaultdict(lambda: {'grams': 0.0, 'adds': defaultdict(float)})
+        self.target = {
             'P': 0, 'K': 0, 'Mg': 0, 'Ca': 0, 'S': 0,
-            'NO3': 0, 'NH4': 0  # Изменил ключи на NO3/NH4 без скобок
-        }
-        self.actual_profile = {
-            'P': 0.0, 'K': 0.0, 'Mg': 0.0, 'Ca': 0.0, 'S': 0.0,
-            'NO3': 0.0, 'NH4': 0.0
+            'NO3': 0, 'NH4': 0  # Упрощенные ключи
         }
+        self.actual = defaultdict(float)
         self.fertilizers = {}
         self.total_ec = 0.0
 
     def set_target_profile(self, profile_data):
         """Устанавливаем целевые значения с преобразованием ключей"""
-        self.target_profile.update({
+        self.target.update({
             'P': float(profile_data.get('P', 0)),
             'K': float(profile_data.get('K', 0)),
             'Mg': float(profile_data.get('Mg', 0)),
             'Ca': float(profile_data.get('Ca', 0)),
             'S': float(profile_data.get('S', 0)),
-            'NO3': float(profile_data.get('N (NO3-)', 0)),  # Преобразуем ключ
-            'NH4': float(profile_data.get('N (NH4+)', 0))   # Преобразуем ключ
+            'NO3': float(profile_data.get('N (NO3-)', 0)),
+            'NH4': float(profile_data.get('N (NH4+)', 0))
         })
 
     def set_fertilizers(self, fertilizers_data):
-        """Устанавливаем состав удобрений с преобразованием ключей"""
+        """Преобразуем входные данные в единый формат"""
         self.fertilizers = {
+            "Сульфат магния": {
+                "Mg": float(fertilizers_data["Сульфат магния"]["Mg"]),
+                "S": float(fertilizers_data["Сульфат магния"]["S"])
+            },
             "Кальциевая селитра": {
                 "NO3": float(fertilizers_data["Кальциевая селитра"]["N (NO3-)"]),
                 "Ca": float(fertilizers_data["Кальциевая селитра"]["Ca"])
             },
-            "Калий азотнокислый": {
-                "NO3": float(fertilizers_data["Калий азотнокислый"]["N (NO3-)"]),
-                "K": float(fertilizers_data["Калий азотнокислый"]["K"])
+            "Монофосфат калия": {
+                "P": float(fertilizers_data["Монофосфат калия"]["P"]),
+                "K": float(fertilizers_data["Монофосфат калия"]["K"])
             },
             "Аммоний азотнокислый": {
                 "NO3": float(fertilizers_data["Аммоний азотнокислый"]["N (NO3-)"]),
                 "NH4": float(fertilizers_data["Аммоний азотнокислый"]["N (NH4+)"])
             },
-            "Сульфат магния": {
-                "Mg": float(fertilizers_data["Сульфат магния"]["Mg"]),
-                "S": float(fertilizers_data["Сульфат магния"]["S"])
-            },
-            "Монофосфат калия": {
-                "P": float(fertilizers_data["Монофосфат калия"]["P"]),
-                "K": float(fertilizers_data["Монофосфат калия"]["K"])
+            "Калий азотнокислый": {
+                "NO3": float(fertilizers_data["Калий азотнокислый"]["N (NO3-)"]),
+                "K": float(fertilizers_data["Калий азотнокислый"]["K"])
             },
             "Калий сернокислый": {
                 "K": float(fertilizers_data["Калий сернокислый"]["K"]),
@@ -743,86 +740,84 @@ class NutrientCalculator:
         }
 
     def calculate(self):
-        """Логика расчёта с приоритетом по нитратам"""
+        """Новая логика расчёта с приоритетом по азоту"""
         try:
-            # 1. Вносим сульфат магния (Mg + S)
+            # 1. Вносим обязательные компоненты
             self._apply_fertilizer("Сульфат магния", "Mg")
-            
-            # 2. Вносим монофосфат калия (P + K)
             self._apply_fertilizer("Монофосфат калия", "P")
             
-            # 3. Вносим аммоний азотнокислый (NH4 + NO3)
+            # 2. Контроль азота
             self._apply_fertilizer("Аммоний азотнокислый", "NH4")
             
-            # 4. Жёстко контролируем NO3:
-            #    - Если нужно меньше, чем уже внесено, пропускаем кальциевую селитру
-            if self.target_profile['NO3'] > self.actual_profile['NO3']:
+            # 3. Кальций с контролем NO3
+            remaining_no3 = max(self.target['NO3'] - self.actual['NO3'], 0)
+            if remaining_no3 > 0.1:
                 self._apply_fertilizer("Кальциевая селитра", "Ca")
             
-            # 5. Довносим K через калийную селитру или сульфат калия
-            k_deficit = self.target_profile['K'] - self.actual_profile['K']
+            # 4. Калий с минимальным NO3
+            k_deficit = self.target['K'] - self.actual['K']
             if k_deficit > 0.1:
-                # Выбираем удобрение с минимальным NO3
-                if self.actual_profile['NO3'] < self.target_profile['NO3']:
-                    self._apply_fertilizer("Калий азотнокислый", "K", k_deficit)
+                if self.actual['NO3'] < self.target['NO3']:
+                    self._apply_fertilizer("Калий азотнокислый", "K")
                 else:
-                    self._apply_fertilizer("Калий сернокислый", "K", k_deficit)
+                    self._apply_fertilizer("Калий сернокислый", "K")
             
-            # 6. Довносим серу при необходимости
-            s_deficit = self.target_profile['S'] - self.actual_profile['S']
+            # 5. Сера
+            s_deficit = self.target['S'] - self.actual['S']
             if s_deficit > 0.1:
-                self._apply_fertilizer("Калий сернокислый", "S", s_deficit)
+                self._apply_fertilizer("Калий сернокислый", "S")
             
             return True
         except Exception as e:
-            print(f"Ошибка расчёта: {str(e)}")
+            print(f"Calculation error: {str(e)}")
             return False
 
     def _apply_fertilizer(self, name, main_element, required_ppm=None):
-        """Метод внесения удобрений с контролем NO3"""
+        """Умное внесение удобрений с контролем NO3"""
+        if name not in self.fertilizers:
+            return
+
         if required_ppm is None:
-            required_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
+            required_ppm = self.target[main_element] - self.actual[main_element]
         
-        if required_ppm <= 0 or name not in self.fertilizers:
+        if required_ppm <= 0:
             return
 
         content = self.fertilizers[name].get(main_element, 0)
         if content <= 0:
             return
 
-        # Корректируем граммы, если NO3 превышает целевое значение
+        # Корректировка для NO3
         if 'NO3' in self.fertilizers[name]:
-            no3_added = (required_ppm / content) * self.fertilizers[name]['NO3']
-            if self.actual_profile['NO3'] + no3_added > self.target_profile['NO3']:
-                required_ppm = max(0, (self.target_profile['NO3'] - self.actual_profile['NO3']) * content / self.fertilizers[name]['NO3'])
+            no3_limit = max(self.target['NO3'] - self.actual['NO3'], 0)
+            if no3_limit <= 0:
+                return  # Превышение NO3
+            max_grams = (no3_limit * self.volume) / (self.fertilizers[name]['NO3'] * 1000)
+            required_grams = (required_ppm * self.volume) / (content * 1000)
+            grams = min(required_grams, max_grams)
+        else:
+            grams = (required_ppm * self.volume) / (content * 1000)
 
-        grams = (required_ppm * self.volume) / (content * 1000)
-        
-        # Запись результатов
-        if name not in self.results:
-            self.results[name] = {'grams': 0.0, 'adds': {}}
-        
+        # Обновляем профиль
         self.results[name]['grams'] += grams
-        
-        # Обновление профиля
         for element, percent in self.fertilizers[name].items():
             added_ppm = (grams * percent * 1000) / self.volume
-            self.actual_profile[element] += added_ppm
-            self.results[name]['adds'][element] = self.results[name]['adds'].get(element, 0) + added_ppm
-        
+            self.actual[element] += added_ppm
+            self.results[name]['adds'][element] += added_ppm
+
         # Расчёт EC
-        ec_coefficients = {
+        ec_coeff = {
             'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015,
             'Ca': 0.0016, 'S': 0.0014,
             'NO3': 0.0017, 'NH4': 0.0019
         }
         self.total_ec += sum(
-            added_ppm * ec_coefficients.get(element, 0.0015)
-            for element, added_ppm in self.results[name]['adds'].items()
+            added_ppm * ec_coeff.get(elem, 0.0015)
+            for elem, added_ppm in self.results[name]['adds'].items()
         )
 
     def get_results(self):
-        """Форматирование результатов с обратным преобразованием ключей"""
+        """Форматируем выходные данные"""
         return {
             'fertilizers': [
                 {
@@ -832,42 +827,40 @@ class NutrientCalculator:
                 } for name, data in self.results.items()
             ],
             'profile': [
-                {
-                    'element': 'N-NO3' if k == 'NO3' else 'N-NH4' if k == 'NH4' else k,
-                    'ppm': round(v, 3)
-                } for k, v in self.actual_profile.items()
+                {'element': 'P', 'ppm': round(self.actual['P'], 3)},
+                {'element': 'K', 'ppm': round(self.actual['K'], 3)},
+                {'element': 'Mg', 'ppm': round(self.actual['Mg'], 3)},
+                {'element': 'Ca', 'ppm': round(self.actual['Ca'], 3)},
+                {'element': 'S', 'ppm': round(self.actual['S'], 3)},
+                {'element': 'N-NO3', 'ppm': round(self.actual['NO3'], 3)},
+                {'element': 'N-NH4', 'ppm': round(self.actual['NH4'], 3)}
             ],
             'ec': round(self.total_ec, 2),
             'deficits': {
-                'N (NO3-)' if k == 'NO3' else 'N (NH4+)' if k == 'NH4' else k: 
-                max(self.target_profile[k] - self.actual_profile.get(k, 0), 0)
-                for k in self.target_profile
+                'Ca': max(self.target['Ca'] - self.actual['Ca'], 0),
+                'K': max(self.target['K'] - self.actual['K'], 0),
+                'Mg': max(self.target['Mg'] - self.actual['Mg'], 0),
+                'N (NH4+)': max(self.target['NH4'] - self.actual['NH4'], 0),
+                'N (NO3-)': max(self.target['NO3'] - self.actual['NO3'], 0),
+                'P': max(self.target['P'] - self.actual['P'], 0),
+                'S': max(self.target['S'] - self.actual['S'], 0)
             }
         }
 
-@app.route('/calculation', methods=['POST'])
+@app.route('/calculate', methods=['POST'])
 def handle_calculation():
     try:
         data = request.json
         
-        # Валидация входных данных
-        required_fields = ['P', 'K', 'Mg', 'Ca', 'S', 'N (NO3-)', 'N (NH4+)', 'liters']
-        if not all(field in data['profileSettings'] for field in required_fields):
-            return jsonify({'status': 'error', 'message': 'Missing required profile fields'}), 400
-        
-        required_fertilizers = [
-            "Кальциевая селитра", "Калий азотнокислый", "Аммоний азотнокислый",
-            "Сульфат магния", "Монофосфат калия", "Калий сернокислый"
-        ]
-        if not all(fert in data['fertilizerConstants'] for fert in required_fertilizers):
-            return jsonify({'status': 'error', 'message': 'Missing required fertilizers'}), 400
-        
-        # Инициализация калькулятора
+        # Валидация
+        required = ['P', 'K', 'Mg', 'Ca', 'S', 'N (NO3-)', 'N (NH4+)', 'liters']
+        if not all(k in data['profileSettings'] for k in required):
+            return jsonify({'status': 'error', 'message': 'Missing required fields'}), 400
+
         calculator = NutrientCalculator(volume_liters=data['profileSettings']['liters'])
         calculator.set_target_profile(data['profileSettings'])
         calculator.set_fertilizers(data['fertilizerConstants'])
         
-        # Расчёт
         if calculator.calculate():
             return jsonify({
                 'status': 'success',