Refactor app.py to use ClassifierApp and improve application structure

app.py

@@ -1,128 +1,15 @@
 import gradio as gr
-from sdc_classifier import SDCClassifier
-from dotenv import load_dotenv
 import torch
-import json
 import os
+from classifier_app import ClassifierApp, config
 
-# Load environment variables
-load_dotenv()
-
-def initialize_environment():
-    """Ініціалізація середовища при першому запуску"""
-    DEFAULT_CLASSES_FILE = "classes.json"
-    DEFAULT_SIGNATURES_FILE = "signatures.npz"
-    CACHE_FILE = "embeddings_cache.db"
-    
-    initial_info = {
-        "status": "initializing",
-        "model_info": {},
-        "classes_info": {},
-        "errors": []
-    }
-    
-    # Перевіряємо наявність необхідних файлів
-    if not os.path.exists(DEFAULT_CLASSES_FILE):
-        initial_info["errors"].append(f"ПОМИЛКА: Файл {DEFAULT_CLASSES_FILE} не знайдено!")
-        initial_info["status"] = "error"
-        return initial_info
-        
-    # Створюємо класифікатор та завантажуємо класи
-    try:
-        classifier = SDCClassifier()
-        classes = classifier.load_classes(DEFAULT_CLASSES_FILE)
-        
-        # Збираємо інформацію про класи
-        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()}
-        }
-        
-        # Якщо signatures не існують, створюємо нові
-        if not os.path.exists(DEFAULT_SIGNATURES_FILE):
-            initial_info["status"] = "creating_signatures"
-            result = classifier.initialize_signatures(
-                force_rebuild=True,
-                signatures_file=DEFAULT_SIGNATURES_FILE
-            )
-            
-            if isinstance(result, str) and "error" in result.lower():
-                initial_info["errors"].append(result)
-                initial_info["status"] = "error"
-                return initial_info
-        
-        # Завантажуємо інформацію про модель
-        classifier.save_model_info("model_info.json")
-        with open("model_info.json", "r") as f:
-            initial_info["model_info"] = json.load(f)
-            
-        initial_info["status"] = "success"
-        return initial_info, classifier
-        
-    except Exception as e:
-        initial_info["errors"].append(f"ПОМИЛКА при ініціалізації: {str(e)}")
-        initial_info["status"] = "error"
-        return initial_info, None
-
-def create_classifier(model_type, openai_model=None, local_model=None, device=None):
-    """
-    Створення класифікатора з відповідними параметрами
-    
-    Args:
-        model_type: тип моделі ("OpenAI" або "Local")
-        openai_model: назва моделі OpenAI
-        local_model: шлях до локальної моделі
-        device: пристрій для локальної моделі
-    
-    Returns:
-        SDCClassifier: налаштований класифікатор
-    """
-    if model_type == "OpenAI":
-        return SDCClassifier()
-    else:
-        return SDCClassifier(local_model=local_model, device=device)
-
-def main():
-    # Константи файлів
-    DEFAULT_CLASSES_FILE = "classes.json"
-    DEFAULT_SIGNATURES_FILE = "signatures.npz"
-    CACHE_FILE = "embeddings_cache.db"
-    
-    # Перевіряємо та ініціалізуємо середовище
-    init_result = initialize_environment()
-    if isinstance(init_result, tuple):
-        initial_info, classifier = init_result
-    else:
-        initial_info = init_result
-        print("Не вдалося ініціалізувати середовище")
-        return
-
+def create_interface(app: ClassifierApp) -> gr.Blocks:
+    """Створення веб-інтерфейсу"""
     with gr.Blocks() as demo:
         gr.Markdown("# SDC Classifier")
-        
-        # Додаємо інформаційний блок про модель та класи
-        with gr.Accordion("Інформація про систему", open=True):
-            system_info = gr.JSON(
-                value=initial_info,
-                label="Статус системи"
-            )
-            
-            if initial_info["status"] == "success":
-                gr.Markdown(f"""
-                ### Поточна конфігурація:
-                - Модель: {initial_info['model_info'].get('using_local', 'OpenAI')}
-                - Кількість класів: {initial_info['classes_info']['total_classes']}
-                - Класи: {', '.join(initial_info['classes_info']['classes_list'])}
-                """)
-            else:
-                gr.Markdown(f"""
-                ### Помилки ініціалізації:
-                {chr(10).join('- ' + err for err in initial_info['errors'])}
-                """)
-        
+
         with gr.Tabs():
-            # Вкладка 1: Single Text Testing
+            # Вкладка 1: Тестування одного тексту
             with gr.TabItem("Тестування одного тексту"):
                 with gr.Row():
                     with gr.Column():
@@ -143,7 +30,6 @@ def main():
                     with gr.Column():
                         result_text = gr.JSON(label="Результати аналізу")
                 
-                # Налаштування моделі
                 with gr.Accordion("Налаштування моделі", open=False):
                     with gr.Row():
                         model_type = gr.Radio(
@@ -152,16 +38,13 @@ def main():
                             label="Тип моделі"
                         )
                         model_choice = gr.Dropdown(
-                            choices=[
-                                "text-embedding-3-large",
-                                "text-embedding-3-small"
-                            ],
-                            value="text-embedding-3-large",
+                            choices=config.DEFAULT_OPENAI_MODELS,
+                            value=config.DEFAULT_OPENAI_MODELS[0],
                             label="OpenAI model",
                             visible=True
                         )
                         local_model_path = gr.Textbox(
-                            value="cambridgeltl/SapBERT-from-PubMedBERT-fulltext",
+                            value=config.DEFAULT_LOCAL_MODEL,
                             label="Шлях до локальної моделі",
                             visible=False
                         )
@@ -186,8 +69,17 @@ def main():
                         build_btn = gr.Button("Оновити signatures")
                         build_out = gr.Label(label="Статус signatures")
                         cache_stats = gr.JSON(label="Статистика кешу", value={})
+
+            # Вкладка 2: Інформація про систему
+            with gr.TabItem("Інформація про систему"):
+                system_info = gr.JSON(
+                    value=app.initial_info,
+                    label="Статус системи"
+                )
+                system_md = gr.Markdown()
+                system_md.value = app.update_system_markdown(app.initial_info)
             
-            # Вкладка 2: Batch Processing
+            # Вкладка 3: Пакетна обробка
             with gr.TabItem("Пакетна обробка"):
                 gr.Markdown("## 1) Завантаження даних")
                 with gr.Row():
@@ -233,101 +125,29 @@ def main():
         4. На вкладці "Пакетна обробка" можна аналізувати багато повідомлень
         5. Результати можна зберегти в CSV файл
         """)
-        
+
         # Підключення обробників подій
-        def update_model_inputs(model_type):
-            """Оновлення видимості полів в залежності від типу моделі"""
-            return {
-                model_choice: gr.update(visible=model_type == "OpenAI"),
-                local_model_path: gr.update(visible=model_type == "Local"),
-                device_choice: gr.update(visible=model_type == "Local")
-            }
-        
-        def update_classifier_settings(json_file, model_type, openai_model, 
-                                    local_model, device, force_rebuild):
-            """Оновлення налаштувань класифікатора"""
-            try:
-                # Створюємо новий класифікатор з вибраними параметрами
-                nonlocal classifier
-                classifier = create_classifier(
-                    model_type=model_type,
-                    openai_model=openai_model if model_type == "OpenAI" else None,
-                    local_model=local_model if model_type == "Local" else None,
-                    device=device if model_type == "Local" else None
-                )
-                
-                # Завантажуємо класи
-                if json_file is not None:
-                    with open(json_file.name, 'r', encoding='utf-8') as f:
-                        new_classes = json.load(f)
-                    classifier.load_classes(new_classes)
-                else:
-                    classifier.restore_base_state()
-                
-                # Ініціалізуємо signatures
-                result = classifier.initialize_signatures(
-                    force_rebuild=force_rebuild,
-                    signatures_file=DEFAULT_SIGNATURES_FILE if not force_rebuild else None
-                )
-                
-                # Оновлюємо інформацію про систем��
-                classifier.save_model_info("model_info.json")
-                with open("model_info.json", "r") as f:
-                    model_info = json.load(f)
-                
-                system_info.update(value={
-                    "status": "success",
-                    "model_info": model_info,
-                    "classes_info": {
-                        "total_classes": len(classifier.classes_json),
-                        "classes_list": list(classifier.classes_json.keys()),
-                        "hints_per_class": {cls: len(hints) 
-                                          for cls, hints in classifier.classes_json.items()}
-                    },
-                    "errors": []
-                })
-                
-                return result, classifier.get_cache_stats()
-            except Exception as e:
-                return f"Помилка: {str(e)}", classifier.get_cache_stats()
-        
-        def process_single_text(text, threshold):
-            """Обробка одного тексту"""
-            try:
-                return classifier.process_single_text(text, threshold)
-            except Exception as e:
-                return {"error": str(e)}
-        
-        def load_data(csv_path, emb_path):
-            """Завантаження даних для пакетної обробки"""
-            try:
-                return classifier.load_data(csv_path, emb_path)
-            except Exception as e:
-                return f"Помилка: {str(e)}"
-        
-        def classify_batch(filter_str, threshold):
-            """Пакетна класифікація"""
-            try:
-                return classifier.classify_rows(filter_str, threshold)
-            except Exception as e:
-                return None
-        
-        def save_results():
-            """Збереження результатів"""
-            try:
-                return classifier.save_results()
-            except Exception as e:
-                return f"Помилка: {str(e)}"
-        
-        # Підключення подій
         model_type.change(
-            fn=update_model_inputs,
-            inputs=[model_type],
-            outputs=[model_choice, local_model_path, device_choice]
+            fn=app.update_model_inputs,
+            inputs=[
+                model_type,
+                model_choice,
+                local_model_path,
+                device_choice
+            ],
+            outputs=[
+                model_choice,
+                local_model_path, 
+                device_choice,
+                system_info,
+                system_md,
+                build_out,
+                cache_stats
+            ]
         )
         
         build_btn.click(
-            fn=update_classifier_settings,
+            fn=app.update_classifier_settings,
             inputs=[
                 json_file,
                 model_type,
@@ -336,34 +156,48 @@ def main():
                 device_choice,
                 force_rebuild
             ],
-            outputs=[build_out, cache_stats]
+            outputs=[build_out, cache_stats, system_info, system_md]
         )
         
         single_process_btn.click(
-            fn=process_single_text,
+            fn=app.process_single_text,
             inputs=[text_input, threshold_slider],
             outputs=result_text
         )
         
         load_btn.click(
-            fn=load_data,
+            fn=app.load_data,
             inputs=[csv_input, emb_input],
             outputs=load_output
         )
         
         classify_btn.click(
-            fn=classify_batch,
+            fn=app.classify_batch,
             inputs=[filter_in, batch_threshold],
             outputs=classify_out
         )
         
         save_btn.click(
-            fn=save_results,
+            fn=app.save_results,
             inputs=[],
             outputs=save_out
         )
 
-    # Запуск веб-інтерфейсу
+    return demo
+
+def main():
+    app = ClassifierApp()
+    init_result, classifier = app.initialize_environment()
+    
+    if classifier is None or init_result["status"] != "success":
+        print("Не вдалося ініціалізувати середовище")
+        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 'Створюються'}")
+
+    demo = create_interface(app)
     demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
 
 if __name__ == "__main__":

classifier_app.py

@@ -0,0 +1,278 @@
+from sdc_classifier import SDCClassifier
+from dotenv import load_dotenv
+import torch
+import json
+import os
+from typing import Dict, Tuple, Optional, Any, List
+from dataclasses import dataclass, field
+
+# Load environment variables
+load_dotenv()
+
+@dataclass
+class Config:
+    DEFAULT_CLASSES_FILE: str = "classes.json"
+    DEFAULT_SIGNATURES_FILE: str = "signatures.npz"
+    CACHE_FILE: str = "embeddings_cache.db"
+    MODEL_INFO_FILE: str = "model_info.json"
+    DEFAULT_OPENAI_MODELS: List[str] = field(default_factory=lambda: ["text-embedding-3-large", "text-embedding-3-small"])
+    DEFAULT_LOCAL_MODEL: str = "cambridgeltl/SapBERT-from-PubMedBERT-fulltext"
+
+config = Config()
+
+class ClassifierApp:
+    def __init__(self):
+        self.classifier = None
+        self.initial_info = {
+            "status": "initializing",
+            "model_info": {},
+            "classes_info": {},
+            "errors": []
+        }
+
+    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)
+            
+            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()}
+            }
+            
+            if os.path.exists(config.DEFAULT_SIGNATURES_FILE):
+                self.classifier.load_signatures(config.DEFAULT_SIGNATURES_FILE)
+                self.initial_info["status"] = "success"
+            else:
+                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)
+                    self.initial_info["status"] = "error"
+                    return self.initial_info, None
+            
+            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"
+                return self.initial_info, self.classifier
+                
+            except (FileNotFoundError, json.JSONDecodeError) as 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:
+            self.initial_info["errors"].append(f"ПОМИЛКА при ініціалізації: {str(e)}")
+            self.initial_info["status"] = "error"
+            return self.initial_info, None
+
+    def create_classifier(
+        self,
+        model_type: str,
+        openai_model: Optional[str] = None,
+        local_model: Optional[str] = None,
+        device: Optional[str] = None
+    ) -> SDCClassifier:
+        """Створення класифікатора з відповідними параметрами"""
+        if model_type == "OpenAI":
+            return SDCClassifier(openai_model=openai_model)
+        else:
+            return SDCClassifier(local_model=local_model, device=device)
+
+    def update_model_inputs(
+        self,
+        model_type: str,
+        openai_model: str,
+        local_model: str,
+        device: str
+    ) -> Dict[str, Any]:
+        """Оновлення моделі та інтерфейсу при зміні типу моделі"""
+        try:
+            self.classifier = self.create_classifier(
+                model_type=model_type,
+                openai_model=openai_model if model_type == "OpenAI" else None,
+                local_model=local_model if model_type == "Local" else None,
+                device=device if model_type == "Local" else None
+            )
+            
+            self.classifier.restore_base_state()
+            result = self.classifier.initialize_signatures()
+            
+            self.classifier.save_model_info(config.MODEL_INFO_FILE)
+            with open(config.MODEL_INFO_FILE, "r") as f:
+                model_info = json.load(f)
+            
+            new_system_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 {
+                "model_choice": gr.update(visible=model_type == "OpenAI"),
+                "local_model_path": gr.update(visible=model_type == "Local"),
+                "device_choice": gr.update(visible=model_type == "Local"),
+                "system_info": new_system_info,
+                "system_md": self.update_system_markdown(new_system_info),
+                "build_out": f"Модель змінено на {model_type}",
+                "cache_stats": self.classifier.get_cache_stats()
+            }
+            
+        except Exception as e:
+            error_info = {
+                "status": "error",
+                "errors": [str(e)],
+                "model_info": {},
+                "classes_info": {}
+            }
+            return {
+                "model_choice": gr.update(visible=model_type == "OpenAI"),
+                "local_model_path": gr.update(visible=model_type == "Local"),
+                "device_choice": gr.update(visible=model_type == "Local"),
+                "system_info": error_info,
+                "system_md": self.update_system_markdown(error_info),
+                "build_out": f"Помилка: {str(e)}",
+                "cache_stats": {}
+            }
+
+    def update_classifier_settings(
+        self,
+        json_file: Optional[str],
+        model_type: str,
+        openai_model: str,
+        local_model: str,
+        device: str,
+        force_rebuild: bool
+    ) -> Tuple[str, Dict, Dict, str]:
+        """Оновлення налаштувань класифікатора"""
+        try:
+            self.classifier = self.create_classifier(
+                model_type=model_type,
+                openai_model=openai_model if model_type == "OpenAI" else None,
+                local_model=local_model if model_type == "Local" else None,
+                device=device if model_type == "Local" else None
+            )
+            
+            if json_file is not None:
+                with open(json_file.name, 'r', encoding='utf-8') as f:
+                    new_classes = json.load(f)
+                self.classifier.load_classes(new_classes)
+            else:
+                self.classifier.restore_base_state()
+            
+            result = self.classifier.initialize_signatures(
+                force_rebuild=force_rebuild,
+                signatures_file=config.DEFAULT_SIGNATURES_FILE if not force_rebuild else None
+            )
+            
+            self.classifier.save_model_info(config.MODEL_INFO_FILE)
+            with open(config.MODEL_INFO_FILE, "r") as f:
+                model_info = json.load(f)
+            
+            new_system_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 (
+                result,
+                self.classifier.get_cache_stats(),
+                new_system_info,
+                self.update_system_markdown(new_system_info)
+            )
+        except Exception as e:
+            error_info = {
+                "status": "error",
+                "errors": [str(e)],
+                "model_info": {},
+                "classes_info": {}
+            }
+            return (
+                f"Помилка: {str(e)}",
+                self.classifier.get_cache_stats(),
+                error_info,
+                self.update_system_markdown(error_info)
+            )
+
+    def process_single_text(self, text: str, threshold: float) -> Dict:
+        """Обробка одного тексту"""
+        try:
+            if self.classifier is None:
+                raise ValueError("Класифікатор не ініціалізовано")
+            return self.classifier.process_single_text(text, threshold)
+        except Exception as e:
+            return {"error": str(e)}
+
+    def load_data(self, csv_path: str, emb_path: str) -> str:
+        """Завантаження даних для пакетної обробки"""
+        try:
+            if self.classifier is None:
+                raise ValueError("Класифікатор не ініціалізовано")
+            return self.classifier.load_data(csv_path, emb_path)
+        except Exception as e:
+            return f"Помилка: {str(e)}"
+
+    def classify_batch(self, filter_str: str, threshold: float):
+        """Пакетна класифікація"""
+        try:
+            if self.classifier is None:
+                raise ValueError("Класифікатор не ініціалізовано")
+            return self.classifier.classify_rows(filter_str, threshold)
+        except Exception as e:
+            return None
+
+    def save_results(self) -> str:
+        """Збереження результатів"""
+        try:
+            if self.classifier is None:
+                raise ValueError("Класифікатор не ініціалізовано")
+            return self.classifier.save_results()
+        except Exception as e:
+            return f"Помилка: {str(e)}"
+
+    @staticmethod
+    def update_system_markdown(info: Dict) -> str:
+        """Оновлення Markdown з системною інформацією"""
+        if info["status"] == "success":
+            return f"""
+            ### Поточна конфігурація:
+            - Модель: {info['model_info'].get('using_local', 'OpenAI')}
+            - Кількість класів: {info['classes_info']['total_classes']}
+            - Класи: {', '.join(info['classes_info']['classes_list'])}
+            """
+        else:
+            return f"""
+            ### Помилки ініціалізації:
+            {chr(10).join('- ' + err for err in info['errors'])}
+            """

model_info.json

@@ -1,13 +1,13 @@
 {
   "using_local": true,
-  "classes_count": 15,
+  "classes_count": 131,
   "signatures_count": 15,
   "cache_stats": {
-    "total_entries": 3647,
-    "cache_size_mb": 31.64,
-    "hits": 545,
+    "total_entries": 6765,
+    "cache_size_mb": 44.05,
+    "hits": 0,
     "misses": 0,
-    "hit_rate_percent": 100.0
+    "hit_rate_percent": 0
   },
   "local_model": {
     "model_name": "cambridgeltl/SapBERT-from-PubMedBERT-fulltext",