Update app.py

app.py

@@ -1,297 +1,68 @@
-# config.py
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-class Config:
-    DEBUG = os.getenv('DEBUG', 'False').lower() == 'true'
-    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
-    MODELS_CACHE_DIR = os.getenv('MODELS_CACHE_DIR', './models')
-    HISTORY_FILE = os.getenv('HISTORY_FILE', 'learning_path_history.json')
-    MAX_AUDIO_LENGTH = int(os.getenv('MAX_AUDIO_LENGTH', '600'))  # seconds
-    MAX_TEXT_LENGTH = int(os.getenv('MAX_TEXT_LENGTH', '1000'))
-    SUPPORTED_AUDIO_FORMATS = ['.wav', '.mp3', '.ogg', '.flac']
-    
-    # Visualization settings
-    MAX_TOPICS = int(os.getenv('MAX_TOPICS', '10'))
-    MAX_SUBTOPICS = int(os.getenv('MAX_SUBTOPICS', '5'))
-    FIGURE_DPI = int(os.getenv('FIGURE_DPI', '300'))
-    
-    # Model settings
-    MODEL_TRANSCRIBER = os.getenv('MODEL_TRANSCRIBER', 'openai/whisper-base')
-    MODEL_GENERATOR = os.getenv('MODEL_GENERATOR', 'gpt2')
-    
-    # Retry settings
-    MAX_RETRIES = int(os.getenv('MAX_RETRIES', '3'))
-    RETRY_DELAY = int(os.getenv('RETRY_DELAY', '1'))
-
-# utils.py
-import logging
-import json
-from typing import Dict, Any, Optional, List, Tuple
-import os
-from datetime import datetime
-from config import Config
-
-class Utils:
-    @staticmethod
-    def setup_logging() -> logging.Logger:
-        logger = logging.getLogger("LearningPathGenerator")
-        level = getattr(logging, Config.LOG_LEVEL)
-        logger.setLevel(level)
-        
-        handler = logging.FileHandler("app.log")
-        formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        
-        return logger
-    
-    @staticmethod
-    def save_json(data: Dict[str, Any], filename: str) -> bool:
-        try:
-            with open(filename, 'w', encoding='utf-8') as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-            return True
-        except Exception as e:
-            logging.error(f"Error saving JSON: {str(e)}")
-            return False
-    
-    @staticmethod
-    def load_json(filename: str) -> Optional[Dict[str, Any]]:
-        try:
-            with open(filename, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception as e:
-            logging.error(f"Error loading JSON: {str(e)}")
-            return None
-
-    @staticmethod
-    def extract_topics(analysis: str) -> Tuple[List[str], Dict[str, List[str]]]:
-        # Simple topic extraction logic - could be enhanced
-        topics = ["Main Topic", "Subtopic 1", "Subtopic 2"]
-        subtopics = {
-            "Main Topic": ["Detail 1", "Detail 2"],
-            "Subtopic 1": ["Point 1", "Point 2"],
-            "Subtopic 2": ["Item 1", "Item 2"]
-        }
-        return topics, subtopics
-
-# models.py
-from transformers import pipeline
-import torch
-from typing import Dict, Any
-import logging
-from config import Config
-
-class ModelManager:
-    def __init__(self):
-        self.logger = logging.getLogger("ModelManager")
-        self.models: Dict[str, Any] = {}
-        self._initialize_models()
-    
-    def _initialize_models(self):
-        try:
-            device = 0 if torch.cuda.is_available() else -1
-            
-            self.models["transcriber"] = pipeline(
-                "automatic-speech-recognition",
-                model=Config.MODEL_TRANSCRIBER,
-                device=device
-            )
-            
-            self.models["generator"] = pipeline(
-                "text-generation",
-                model=Config.MODEL_GENERATOR,
-                device=device
-            )
-            
-        except Exception as e:
-            self.logger.error(f"Error initializing models: {str(e)}")
-            raise
-    
-    def get_model(self, name: str) -> Any:
-        return self.models.get(name)
-
-# main.py
 import gradio as gr
-from typing import Dict, Any
-import logging
-from config import Config
-from utils import Utils
-from models import ModelManager
-from visualization import Visualizer
-from datetime import datetime
+import torch
+from transformers import pipeline
 
 class LearningPathGenerator:
     def __init__(self):
-        self.logger = Utils.setup_logging()
-        self.model_manager = ModelManager()
-        self.history_file = Config.HISTORY_FILE
-        
-        if not os.path.exists(self.history_file):
-            Utils.save_json([], self.history_file)
-    
+        self.device = 0 if torch.cuda.is_available() else -1
+        # Initialize models
+        self.transcriber = pipeline("automatic-speech-recognition", 
+                                  model="openai/whisper-base",
+                                  device=self.device)
+        self.generator = pipeline("text-generation", 
+                                model="gpt2",
+                                device=self.device)
+
     def process_audio(self, 
                      audio_path: str, 
-                     path_name: str = "", 
-                     difficulty: str = "intermediate", 
-                     include_resources: bool = True) -> Dict[str, Any]:
+                     difficulty: str = "intermediate") -> dict:
         try:
-            transcriber = self.model_manager.get_model("transcriber")
-            transcription = transcriber(audio_path)["text"]
+            # Transcribe audio
+            transcription = self.transcriber(audio_path)["text"]
             
-            generator = self.model_manager.get_model("generator")
-            analysis = self._generate_analysis(generator, transcription, difficulty, include_resources)
+            # Generate learning path
+            prompt = f"""
+            Based on the following text, create a detailed learning path 
+            for {difficulty} level:
+            {transcription}
             
-            topics, subtopics = Utils.extract_topics(analysis)
-            mind_map = Visualizer.create_mind_map(topics, subtopics)
+            Learning path:
+            """
             
-            if path_name:
-                self._save_to_history(transcription, analysis, path_name)
+            analysis = self.generator(prompt, 
+                                   max_length=300, 
+                                   num_return_sequences=1)[0]["generated_text"]
             
             return {
                 "transcription": transcription,
-                "analysis": analysis,
-                "mind_map": mind_map
+                "analysis": analysis
             }
-            
         except Exception as e:
-            self.logger.error(f"Processing error: {str(e)}")
-            return self._error_response(str(e))
-
-    def _generate_analysis(self, 
-                         generator: Any, 
-                         text: str, 
-                         difficulty: str,
-                         include_resources: bool) -> str:
-        prompt = f"""
-        Based on the following text, create a detailed learning path 
-        for {difficulty} level:
-        {text[:Config.MAX_TEXT_LENGTH]}
-        
-        Learning path:
-        """
-        
-        response = generator(
-            prompt,
-            max_length=300,
-            num_return_sequences=1
-        )[0]["generated_text"]
-        
-        if include_resources:
-            response += self._generate_resources()
-        
-        return response
-    
-    def _generate_resources(self) -> str:
-        return """
-        Recommended Resources:
-        
-        1. Books:
-           - "Essential Guide"
-           - "Advanced Techniques"
-           
-        2. Online Courses:
-           - Coursera: "Topic Specialization"
-           - edX: "Advanced Course"
-           
-        3. Practical Resources:
-           - Interactive tutorials
-           - Practice exercises
-           - Real-world projects
-        """
-    
-    def _save_to_history(self, transcription: str, analysis: str, path_name: str):
-        history = Utils.load_json(self.history_file) or []
-        history.append({
-            "date": datetime.now().isoformat(),
-            "name": path_name,
-            "transcription": transcription,
-            "analysis": analysis
-        })
-        Utils.save_json(history, self.history_file)
-    
-    def _error_response(self, error_msg: str) -> Dict[str, Any]:
-        return {
-            "transcription": f"Error: {error_msg}",
-            "analysis": "Could not generate analysis due to an error.",
-            "mind_map": None
-        }
+            return {
+                "transcription": f"Error: {str(e)}",
+                "analysis": "Could not generate analysis."
+            }
 
-    def create_interface(self):
-        with gr.Blocks(theme=gr.themes.Soft()) as app:
-            gr.Markdown("""
-            # 🎓 Learning Path Generator
-            
-            Upload an audio file describing your learning goals 
-            and receive a personalized learning path with resources!
-            """)
-            
-            with gr.Tab("Generate Path"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        audio_input = gr.Audio(
-                            type="filepath",
-                            label="Audio Upload",
-                            description="Record or upload an audio describing your goals"
-                        )
-                        
-                        with gr.Row():
-                            path_name = gr.Textbox(
-                                label="Path Name",
-                                placeholder="Give your learning path a name (optional)"
-                            )
-                            difficulty = gr.Dropdown(
-                                choices=["beginner", "intermediate", "advanced"],
-                                value="intermediate",
-                                label="Difficulty Level"
-                            )
-                        
-                        include_resources = gr.Checkbox(
-                            label="Include Recommended Resources",
-                            value=True
-                        )
-                        
-                        process_btn = gr.Button(
-                            "Generate Learning Path",
-                            variant="primary"
-                        )
-                
-                text_output = gr.Textbox(
-                    label="Audio Transcription",
-                    lines=4
-                )
-                
-                analysis_output = gr.Textbox(
-                    label="Analysis and Learning Path",
-                    lines=10
-                )
-                
-                mind_map_output = gr.Image(
-                    label="Learning Path Mind Map"
-                )
-            
-            process_btn.click(
-                fn=self.process_audio,
-                inputs=[audio_input, path_name, difficulty, include_resources],
-                outputs={
-                    "transcription": text_output,
-                    "analysis": analysis_output,
-                    "mind_map": mind_map_output
-                }
+def create_interface():
+    app = gr.Interface(
+        fn=LearningPathGenerator().process_audio,
+        inputs=[
+            gr.Audio(type="filepath", label="Upload Audio"),
+            gr.Dropdown(
+                choices=["beginner", "intermediate", "advanced"],
+                value="intermediate",
+                label="Difficulty Level"
             )
-        
-        return app
+        ],
+        outputs=[
+            gr.Textbox(label="Audio Transcription"),
+            gr.Textbox(label="Learning Path")
+        ],
+        title="🎓 Learning Path Generator",
+        description="Upload an audio file describing your learning goals and receive a personalized learning path!"
+    )
+    return app
 
 if __name__ == "__main__":
-    try:
-        generator = LearningPathGenerator()
-        app = generator.create_interface()
-        app.launch(debug=Config.DEBUG)
-    except Exception as e:
-        logging.error(f"Application error: {str(e)}")
-        raise
+    app = create_interface()
+    app.launch()