Enhance error handling and logging in initialization process

- Add detailed logging and error tracking in ClassifierApp initialization
- Improve error reporting in main() function
- Add sync_system_info() method to update system information
- Refactor model creation and initialization with more robust error handling
- Update model_info.json with latest signature and cache statistics

Ніби робочий варіант, але потрібно розібратися із створенням і оновленням сигнатур різними моделями!

app.py

@@ -2,9 +2,13 @@ import gradio as gr
 import torch
 import os
 from classifier_app import ClassifierApp, config
+from typing import Dict
 
 def create_interface(app: ClassifierApp) -> gr.Blocks:
     """Створення веб-інтерфейсу"""
+    # Синхронізуємо інформацію перед створенням інтерфейсу
+    initial_info = app.sync_system_info()
+    
     with gr.Blocks() as demo:
         gr.Markdown("# SDC Classifier")
 
@@ -113,19 +117,6 @@ def create_interface(app: ClassifierApp) -> gr.Blocks:
                 save_btn = gr.Button("Зберегти розмічені дані")
                 save_out = gr.Label()
 
-        gr.Markdown("""
-        ### Інструкція:
-        1. У вкладці "Налаштування моделі" можна:
-           - Вибрати тип моделі (OpenAI або Local)
-           - Налаштувати параметри вибраної моделі
-           - Завантажити новий JSON файл з класами
-           - Примусово перебудувати signatures
-        2. Після зміни налаштувань натисніть "Оновити signatures"
-        3. Використовуйте повзунок "Поріг впевненості" для фільтрації результатів
-        4. На вкладці "Пакетна обробка" можна аналізувати багато повідомлень
-        5. Результати можна зберегти в CSV файл
-        """)
-
         # Підключення обробників подій
         model_type.change(
             fn=app.update_model_inputs,
@@ -185,20 +176,37 @@ def create_interface(app: ClassifierApp) -> gr.Blocks:
 
     return demo
 
+
 def main():
-    app = ClassifierApp()
-    init_result, classifier = app.initialize_environment()
-    
-    if classifier is None or init_result["status"] != "success":
-        print("Не вдалося ініціалізувати середовище")
-        return
+    try:
+        print("\nЗапуск програми...")
+        app = ClassifierApp()
+        
+        print("\nПочаток ініціалізації середовища...")
+        init_result, classifier = app.initialize_environment()
+        
+        print("\nРезультат ініціалізації:")
+        print(f"Статус: {init_result['status']}")
+        
+        if init_result.get('errors'):
+            print("Помилки:", init_result['errors'])
+            
+        if classifier is None or init_result["status"] != "success":
+            print("\nНе вдалося ініціалізувати середовище")
+            return
 
-    print(f"Статус ініціалізації: {init_result['status']}")
-    print(f"Кількість завантажених класів: {len(init_result['classes_info']['classes_list'])}")
-    print(f"Сигнатури: {'Завантажено' if os.path.exists(config.DEFAULT_SIGNATURES_FILE) else 'Створюються'}")
+        print(f"\nІнформація про систему:")
+        print(f"Кількість завантажених класів: {len(init_result['classes_info']['classes_list'])}")
+        print(f"Сигнатури: {'Завантажено' if os.path.exists(config.DEFAULT_SIGNATURES_FILE) else 'Створюються'}")
 
-    demo = create_interface(app)
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+        demo = create_interface(app)
+        demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+        
+    except Exception as e:
+        print(f"\nКритична помилка в main(): {str(e)}")
+        import traceback
+        print("\nДетальний traceback:")
+        print(traceback.format_exc())
 
 if __name__ == "__main__":
     main()

classifier_app.py

@@ -32,53 +32,98 @@ class ClassifierApp:
 
     def initialize_environment(self) -> Tuple[Dict, Optional[SDCClassifier]]:
         """Ініціалізація середовища при першому запуску"""
-        
-        if not os.path.exists(config.DEFAULT_CLASSES_FILE):
-            self.initial_info["errors"].append(
-                f"ПОМИЛКА: Файл {config.DEFAULT_CLASSES_FILE} не знайдено!"
-            )
-            self.initial_info["status"] = "error"
-            return self.initial_info, None
-            
         try:
-            self.classifier = SDCClassifier()
-            classes = self.classifier.load_classes(config.DEFAULT_CLASSES_FILE)
+            # Перевіряємо наявність необхідних файлів
+            if not os.path.exists(config.DEFAULT_CLASSES_FILE):
+                self.initial_info["errors"].append(
+                    f"ПОМИЛКА: Файл {config.DEFAULT_CLASSES_FILE} не знайдено!"
+                )
+                self.initial_info["status"] = "error"
+                print(f"\nПомилка: Файл {config.DEFAULT_CLASSES_FILE} не знайдено!")
+                return self.initial_info, None
+                
+            print("\nСтворення класифікатора...")
+            try:
+                # Визначаємо яка модель використовувалась для сигнатур
+                signatures_model = None
+                if os.path.exists(config.MODEL_INFO_FILE):
+                    with open(config.MODEL_INFO_FILE, 'r') as f:
+                        model_info = json.load(f)
+                        if not model_info.get('using_local', True):
+                            signatures_model = "text-embedding-3-small"  # Модель, яка використовувалась
+                
+                # Створюємо класифікатор з тією ж моделлю
+                self.classifier = SDCClassifier(openai_api_key=os.getenv("OPENAI_API_KEY"))
+                print(f"Використовується модель: {signatures_model or 'local'}")
+                
+            except Exception as e:
+                print(f"\nПомилка при створенні класифікатора: {str(e)}")
+                self.initial_info["errors"].append(f"Помилка при створенні класифікатора: {str(e)}")
+                self.initial_info["status"] = "error"
+                return self.initial_info, None
             
-            self.initial_info["classes_info"] = {
-                "total_classes": len(classes),
-                "classes_list": list(classes.keys()),
-                "hints_per_class": {cls: len(hints) for cls, hints in classes.items()}
-            }
+            print("\nЗавантаження класів...")
+            try:
+                classes = self.classifier.load_classes(config.DEFAULT_CLASSES_FILE)
+                self.initial_info["classes_info"] = {
+                    "total_classes": len(classes),
+                    "classes_list": list(classes.keys()),
+                    "hints_per_class": {cls: len(hints) for cls, hints in classes.items()}
+                }
+            except Exception as e:
+                print(f"\nПомилка при завантаженні класів: {str(e)}")
+                self.initial_info["errors"].append(f"Помилка при завантаженні класів: {str(e)}")
+                self.initial_info["status"] = "error"
+                return self.initial_info, None
             
+            print("\nПеревірка та завантаження сигнатур...")
             if os.path.exists(config.DEFAULT_SIGNATURES_FILE):
-                self.classifier.load_signatures(config.DEFAULT_SIGNATURES_FILE)
-                self.initial_info["status"] = "success"
+                try:
+                    self.classifier.load_signatures(config.DEFAULT_SIGNATURES_FILE)
+                    self.initial_info["status"] = "success"
+                    print("Сигнатури завантажено успішно")
+                except Exception as e:
+                    print(f"\nПомилка при завантаженні сигнатур: {str(e)}")
+                    self.initial_info["errors"].append(f"Помилка при завантаженні сигнатур: {str(e)}")
+                    self.initial_info["status"] = "error"
+                    return self.initial_info, None
             else:
+                print("\nСтворення нових сигнатур...")
                 self.initial_info["status"] = "creating_signatures"
-                result = self.classifier.initialize_signatures(
-                    force_rebuild=True,
-                    signatures_file=config.DEFAULT_SIGNATURES_FILE
-                )
-                
-                if isinstance(result, str) and "error" in result.lower():
-                    self.initial_info["errors"].append(result)
+                try:
+                    result = self.classifier.initialize_signatures(
+                        force_rebuild=True,
+                        signatures_file=config.DEFAULT_SIGNATURES_FILE
+                    )
+                    if isinstance(result, str) and "error" in result.lower():
+                        print(f"\nПомилка при створенні сигнатур: {result}")
+                        self.initial_info["errors"].append(result)
+                        self.initial_info["status"] = "error"
+                        return self.initial_info, None
+                except Exception as e:
+                    print(f"\nПомилка при створенні сигнатур: {str(e)}")
+                    self.initial_info["errors"].append(f"Помилка при створенні сигнатур: {str(e)}")
                     self.initial_info["status"] = "error"
                     return self.initial_info, None
             
+            print("\nЗбереження інформації про модель...")
             try:
                 self.classifier.save_model_info(config.MODEL_INFO_FILE)
                 with open(config.MODEL_INFO_FILE, "r") as f:
                     self.initial_info["model_info"] = json.load(f)
                     
                 self.initial_info["status"] = "success"
+                print("\nІніціалізація завершена успішно")
                 return self.initial_info, self.classifier
-                
-            except (FileNotFoundError, json.JSONDecodeError) as e:
+                    
+            except Exception as e:
+                print(f"\nПомилка при збереженні інформації про модель: {str(e)}")
                 self.initial_info["errors"].append(f"Помилка при читанні model_info: {str(e)}")
                 self.initial_info["status"] = "error"
                 return self.initial_info, None
-                
+                    
         except Exception as e:
+            print(f"\nЗагальна помилка при ініціалізації: {str(e)}")
             self.initial_info["errors"].append(f"ПОМИЛКА при ініціалізації: {str(e)}")
             self.initial_info["status"] = "error"
             return self.initial_info, None
@@ -91,10 +136,16 @@ class ClassifierApp:
         device: Optional[str] = None
     ) -> SDCClassifier:
         """Створення класифікатора з відповідними параметрами"""
+        classifier = SDCClassifier()
+        
         if model_type == "OpenAI":
-            return SDCClassifier(openai_model=openai_model)
+            if hasattr(classifier, 'set_openai_model'):
+                classifier.set_openai_model(openai_model)
         else:
-            return SDCClassifier(local_model=local_model, device=device)
+            if hasattr(classifier, 'set_local_model'):
+                classifier.set_local_model(local_model, device)
+        
+        return classifier
 
     def update_model_inputs(
         self,
@@ -261,6 +312,39 @@ class ClassifierApp:
         except Exception as e:
             return f"Помилка: {str(e)}"
 
+    def sync_system_info(self) -> Dict:
+        """Синхронізація системної інформації"""
+        try:
+            if self.classifier is None:
+                raise ValueError("Класифікатор не ініціалізовано")
+                
+            self.classifier.save_model_info(config.MODEL_INFO_FILE)
+            with open(config.MODEL_INFO_FILE, "r") as f:
+                model_info = json.load(f)
+            
+            self.initial_info = {
+                "status": "success",
+                "model_info": model_info,
+                "classes_info": {
+                    "total_classes": len(self.classifier.classes_json),
+                    "classes_list": list(self.classifier.classes_json.keys()),
+                    "hints_per_class": {
+                        cls: len(hints) 
+                        for cls, hints in self.classifier.classes_json.items()
+                    }
+                },
+                "errors": []
+            }
+            return self.initial_info
+        except Exception as e:
+            self.initial_info = {
+                "status": "error",
+                "model_info": {},
+                "classes_info": {},
+                "errors": [str(e)]
+            }
+            return self.initial_info
+
     @staticmethod
     def update_system_markdown(info: Dict) -> str:
         """Оновлення Markdown з системною інформацією"""

model_info.json

@@ -1,13 +1,13 @@
 {
   "using_local": true,
   "classes_count": 131,
-  "signatures_count": 15,
+  "signatures_count": 131,
   "cache_stats": {
-    "total_entries": 6765,
-    "cache_size_mb": 44.05,
-    "hits": 0,
-    "misses": 0,
-    "hit_rate_percent": 0
+    "total_entries": 8746,
+    "cache_size_mb": 51.91,
+    "hits": 122,
+    "misses": 1450,
+    "hit_rate_percent": 7.76
   },
   "local_model": {
     "model_name": "cambridgeltl/SapBERT-from-PubMedBERT-fulltext",