Update app.py

app.py

@@ -1,515 +1,74 @@
 """
-Jajabor – SEBA Assamese Class 10 Tutor
-Simplified version for Hugging Face Spaces
+Jajabor – Minimal Working Version for Hugging Face Spaces
 """
 
+import gradio as gr
 import os
-import sqlite3
-from datetime import datetime
 
-# Import with error handling
-try:
-    from PyPDF2 import PdfReader
-    PDF_AVAILABLE = True
-except ImportError:
-    PDF_AVAILABLE = False
-    print("PyPDF2 not available")
-
-try:
-    from sentence_transformers import SentenceTransformer
-    EMBEDDING_AVAILABLE = True
-except ImportError:
-    EMBEDDING_AVAILABLE = False
-    print("sentence-transformers not available")
-
-try:
-    import faiss
-    FAISS_AVAILABLE = True
-except ImportError:
-    FAISS_AVAILABLE = False
-    print("faiss not available")
-
-try:
-    from transformers import pipeline
-    TRANSFORMERS_AVAILABLE = True
-except ImportError:
-    TRANSFORMERS_AVAILABLE = False
-    print("transformers not available")
-
-try:
-    import gradio as gr
-    GRADIO_AVAILABLE = True
-except ImportError:
-    GRADIO_AVAILABLE = False
-    print("gradio not available")
-
-try:
-    import pytesseract
-    from PIL import Image
-    OCR_AVAILABLE = True
-except ImportError:
-    OCR_AVAILABLE = False
-    print("OCR dependencies not available")
-
-try:
-    import sympy as sp
-    SYMPY_AVAILABLE = True
-except ImportError:
-    SYMPY_AVAILABLE = False
-    print("sympy not available")
-
-# -------------------- CONFIG --------------------
-APP_NAME = "Jajabor – SEBA Class 10 Tutor"
-
-BASE_DIR = os.path.abspath(os.path.dirname(__file__))
-PDF_DIR = os.path.join(BASE_DIR, "pdfs", "class10")
-DB_PATH = os.path.join(BASE_DIR, "jajabor_users.db")
-
-# -------------------- DATABASE --------------------
-def init_db():
-    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
-    conn = sqlite3.connect(DB_PATH)
-    cur = conn.cursor()
-    cur.execute(
-        """
-        CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            username TEXT UNIQUE,
-            created_at TEXT
-        )
-        """
-    )
-    cur.execute(
-        """
-        CREATE TABLE IF NOT EXISTS interactions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER,
-            timestamp TEXT,
-            query TEXT,
-            answer TEXT,
-            is_math INTEGER,
-            FOREIGN KEY(user_id) REFERENCES users(id)
-        )
-        """
-    )
-    conn.commit()
-    conn.close()
-
-def get_or_create_user(username: str):
-    username = username.strip()
-    if not username:
-        return None
-    conn = sqlite3.connect(DB_PATH)
-    cur = conn.cursor()
-    cur.execute("SELECT id FROM users WHERE username=?", (username,))
-    row = cur.fetchone()
-    if row:
-        user_id = row[0]
-    else:
-        cur.execute(
-            "INSERT INTO users (username, created_at) VALUES (?, ?)",
-            (username, datetime.now().isoformat()),
-        )
-        conn.commit()
-        user_id = cur.lastrowid
-    conn.close()
-    return user_id
-
-def log_interaction(user_id, query, answer, is_math=False):
-    conn = sqlite3.connect(DB_PATH)
-    cur = conn.cursor()
-    cur.execute(
-        """
-        INSERT INTO interactions (user_id, timestamp, query, answer, is_math)
-        VALUES (?, ?, ?, ?, ?)
-        """,
-        (user_id, datetime.now().isoformat(), query, answer, 1 if is_math else 0),
-    )
-    conn.commit()
-    conn.close()
-
-# -------------------- SIMPLE TUTOR --------------------
-class SimpleTutor:
-    def __init__(self):
-        self.llm = None
-        self.embedding_model = None
-        self.index = None
-        self.corpus_chunks = []
-        
-        print("🔄 Loading models...")
-        self._load_models()
-        self.load_pdfs()
-        print("✅ Tutor initialized")
-    
-    def _load_models(self):
-        """Load models with error handling"""
-        if EMBEDDING_AVAILABLE:
-            try:
-                self.embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
-                print("✅ Embedding model loaded")
-            except Exception as e:
-                print(f"❌ Could not load embedding model: {e}")
-        
-        if TRANSFORMERS_AVAILABLE:
-            try:
-                self.llm = pipeline(
-                    "text2text-generation",
-                    model="google/flan-t5-small",
-                    device=-1
-                )
-                print("✅ LLM loaded")
-            except Exception as e:
-                print(f"❌ Could not load LLM: {e}")
-    
-    def load_pdfs(self):
-        """Simple PDF loading"""
-        if not PDF_AVAILABLE:
-            print("📚 PDF reading not available")
-            return
-            
-        if not os.path.exists(PDF_DIR):
-            print(f"📁 PDF directory not found: {PDF_DIR}")
-            return
-        
-        all_texts = []
-        pdf_files = [f for f in os.listdir(PDF_DIR) if f.lower().endswith('.pdf')]
-        
-        if not pdf_files:
-            print("📭 No PDF files found in directory")
-            return
+def simple_chat(message, history):
+    """Simple echo function for testing"""
+    if not message.strip():
+        return history, "অনুগ্ৰহ কৰি প্ৰশ্ন লিখক।"
+    
+    responses = [
+        "আপোনাৰ প্ৰশ্নটো বুজিলোঁ। অধ্যয়নৰ বাবে শুভেচ্ছা!",
+        "এই বিষয়টো মনোযোগেৰে পঢ়িবলৈ চেষ্টা কৰক।",
+        "আপোনাৰ পাঠ্যপুথিৰ সংশ্লিষ্ট অধ্যায়টো চাওক।",
+        "জাজাবৰ আপোনাক সহায় কৰিবলৈ সদায় সাজু আছে!",
+        "এই প্ৰশ্নটোৰ বাবে আপোনাৰ শিক্ষকৰ সহায় ল'ব পাৰে।"
+    ]
+    
+    import random
+    response = random.choice(responses)
+    
+    if history is None:
+        history = []
+    
+    history.append([message, response])
+    return history, ""
+
+# Create minimal interface
+with gr.Blocks(title="Jajabor – SEBA Tutor") as demo:
+    gr.Markdown("# 🧭 জাজাবৰ – SEBA Class 10 Tutor")
+    gr.Markdown("অসমীয়া মাধ্যমৰ দশম শ্ৰেণীৰ ছাত্ৰ-ছাত্ৰীৰ বাবে AI টিউটাৰ")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 👤 লগিন")
+            username = gr.Textbox(label="আপোনাৰ নাম", placeholder="নাম লিখক...")
+            gr.Markdown("""
+            ### 💡 টিপছ
+            - নাম লিখি প্ৰশ্ন সোধক
+            - পাঠ্যপুথিৰ PDF ফাইলসমূহ `pdfs/class10` ত ৰাখক
+            - জাজাবৰ আপোনাক সহায় কৰিব!
+            """)
+        
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(label="কথোপকথন", height=400)
+            message = gr.Textbox(label="প্ৰশ্ন", placeholder="প্ৰশ্ন লিখক...", lines=2)
             
-        for fname in pdf_files:
-            path = os.path.join(PDF_DIR, fname)
-            try:
-                reader = PdfReader(path)
-                text = ""
-                for page in reader.pages:
-                    text += page.extract_text() or ""
-                if text.strip():
-                    all_texts.append(text)
-                    print(f"📖 Loaded {fname}")
-            except Exception as e:
-                print(f"❌ Error reading {fname}: {e}")
-        
-        # Simple text splitting
-        self.corpus_chunks = []
-        for text in all_texts:
-            chunks = self._split_text(text)
-            self.corpus_chunks.extend(chunks)
-        
-        print(f"📚 Total text chunks: {len(self.corpus_chunks)}")
-        
-        # Build FAISS index if we have chunks and embedding model
-        if self.corpus_chunks and self.embedding_model and FAISS_AVAILABLE:
-            try:
-                print("🔨 Building FAISS index...")
-                embs = self.embedding_model.encode(self.corpus_chunks, show_progress_bar=False).astype("float32")
-                dim = embs.shape[1]
-                self.index = faiss.IndexFlatL2(dim)
-                self.index.add(embs)
-                print(f"✅ FAISS index ready; dim: {dim}")
-            except Exception as e:
-                print(f"❌ FAISS index creation failed: {e}")
-    
-    def _split_text(self, text, chunk_size=400):
-        """Simple text splitting"""
-        if not text:
-            return []
-        chunks = []
-        for i in range(0, len(text), chunk_size):
-            chunk = text[i:i+chunk_size]
-            if chunk.strip():
-                chunks.append(chunk)
-        return chunks
-    
-    def answer_question(self, question):
-        """Simple question answering"""
-        if not question.strip():
-            return "অনুগ্ৰহ কৰি এটা প্ৰশ্ন সোধক।"
-        
-        # Simple math detection
-        if self._is_math_question(question):
-            return self._solve_math(question)
-        
-        # Simple RAG if available
-        context = ""
-        if self.index is not None and self.corpus_chunks:
-            relevant_chunks = self._find_relevant_chunks(question)
-            if relevant_chunks:
-                context = "\n".join(relevant_chunks[:2])
-        
-        # Generate answer
-        if self.llm:
-            try:
-                if context:
-                    prompt = f"প্ৰশ্ন: {question}\n\nসংদৰ্ভ: {context}\n\nসহায়ক উত্তৰ:"
-                else:
-                    prompt = f"প্ৰশ্ন: {question}\n\nউত্তৰ:"
-                
-                response = self.llm(
-                    prompt,
-                    max_new_tokens=150,
-                    temperature=0.3,
-                    do_sample=False
-                )
-                
-                if isinstance(response, list) and len(response) > 0:
-                    answer = response[0].get('generated_text', 'উত্তৰ তৈয়াৰ কৰিব পৰা নগল।')
-                else:
-                    answer = str(response)
-                    
-            except Exception as e:
-                answer = f"উত্তৰ তৈয়াৰ কৰোঁতে সমস্যা: {str(e)}"
-        else:
-            # Fallback responses
-            fallback_responses = [
-                "মই আপোনাৰ প্ৰশ্নটো বুজিলোঁ। অধ্যয়নৰ বাবে শুভেচ্ছা!",
-                "এই বিষয়টো মনোযোগেৰে পঢ়িবলৈ চেষ্টা কৰক।",
-                "আপোনাৰ পাঠ্যপুথিৰ সংশ্লিষ্ট অধ্যায়টো চাওক।",
-                "এই প্ৰশ্নটোৰ বাবে আপোনাৰ শিক্ষকৰ সহায় ল'ব পাৰে।"
-            ]
-            import random
-            answer = random.choice(fallback_responses)
-        
-        return answer
-    
-    def _is_math_question(self, text):
-        """Simple math detection"""
-        math_indicators = ['+', '-', '*', '/', '=', 'x', 'y', 'গণিত', 'সমীকৰণ', 'solve', 'calculate']
-        return any(indicator in text.lower() for indicator in math_indicators)
-    
-    def _solve_math(self, expr):
-        """Simple math solving"""
-        if not SYMPY_AVAILABLE:
-            return "গণিত সমাধানৰ বাবে sympy পেকেজ প্ৰয়োজন।"
-        
-        try:
-            # Clean the expression
-            expr = expr.strip()
-            expr = expr.replace('^', '**')
-            
-            if '=' in expr:
-                parts = expr.split('=')
-                if len(parts) == 2:
-                    left = sp.sympify(parts[0].strip())
-                    right = sp.sympify(parts[1].strip())
-                    equation = sp.Eq(left, right)
-                    solutions = sp.solve(equation)
-                    
-                    if solutions:
-                        solution_str = f"সমীকৰণ: {equation}\n\nসমাধান: x = {solutions[0]}"
-                        if len(solutions) > 1:
-                            solution_str += f"\nবা x = {solutions[1]}"
-                        return solution_str
-                    else:
-                        return "কোনো সমাধান পোৱা নগ'ল।"
-            else:
-                # Just simplify the expression
-                expr_sym = sp.sympify(expr)
-                simplified = sp.simplify(expr_sym)
-                return f"প্ৰকাশ: {expr}\n\nসৰলীকৃত: {simplified}"
-                
-        except Exception as e:
-            return f"গণিত সমাধানত সমস্যা: {str(e)}\nদয়া কৰি স্পষ্টকৈ লিখক, যেনে: 2*x + 3 = 7"
-    
-    def _find_relevant_chunks(self, question, k=3):
-        """Find relevant chunks using FAISS or keyword matching"""
-        if not self.corpus_chunks:
-            return []
-        
-        # Try FAISS first
-        if self.index is not None and self.embedding_model:
-            try:
-                q_vec = self.embedding_model.encode([question]).astype("float32")
-                D, I = self.index.search(q_vec, k)
-                results = []
-                for idx in I[0]:
-                    if 0 <= idx < len(self.corpus_chunks):
-                        results.append(self.corpus_chunks[idx])
-                return results
-            except Exception:
-                pass  # Fall back to keyword matching
-        
-        # Keyword matching fallback
-        question_words = set(question.lower().split())
-        scored_chunks = []
-        
-        for chunk in self.corpus_chunks:
-            chunk_words = set(chunk.lower().split())
-            common_words = question_words.intersection(chunk_words)
-            score = len(common_words)
-            if score > 0:
-                scored_chunks.append((score, chunk))
-        
-        # Return top k chunks
-        scored_chunks.sort(reverse=True)
-        return [chunk for _, chunk in scored_chunks[:k]]
-
-# -------------------- OCR FUNCTION --------------------
-def extract_text_from_image(image_path):
-    """Extract text from image using OCR"""
-    if not OCR_AVAILABLE or not image_path:
-        return ""
-    
-    try:
-        image = Image.open(image_path)
-        text = pytesseract.image_to_string(image)
-        return text.strip()
-    except Exception as e:
-        print(f"OCR error: {e}")
-        return ""
-
-# -------------------- SIMPLE GRADIO APP --------------------
-def create_app():
-    """Create and return the Gradio app"""
-    
-    # Initialize components
-    print("🚀 Starting application...")
-    init_db()
-    tutor = SimpleTutor()
-    
-    # Store user state in memory (simple approach)
-    user_states = {}
-    
-    def get_user_state(username):
-        """Simple user state management"""
-        username = (username or "").strip()
-        if not username:
-            return None
-            
-        if username not in user_states:
-            user_id = get_or_create_user(username)
-            if user_id:
-                user_states[username] = {"username": username, "user_id": user_id}
-            else:
-                return None
-        return user_states[username]
-    
-    def chat_function(message, image, chat_history, username):
-        """Main chat function"""
-        # Initialize chat history if None
-        if chat_history is None:
-            chat_history = []
-        
-        # Check if user is logged in
-        user_state = get_user_state(username)
-        if not user_state:
-            new_history = chat_history + [[message or "", "⚠️ প্ৰথমে নাম লিখি লগিন কৰক।"]]
-            return new_history, ""
-        
-        # Combine text and image input
-        full_question = (message or "").strip()
-        if image is not None:
-            ocr_text = extract_text_from_image(image)
-            if ocr_text:
-                full_question += f"\n[ছবিৰ পাঠ: {ocr_text}]"
-        
-        if not full_question:
-            new_history = chat_history + [["", "⚠️ প্ৰশ্ন লিখক বা ছবি আপলোড কৰক।"]]
-            return new_history, ""
-        
-        # Get answer from tutor
-        answer = tutor.answer_question(full_question)
-        
-        # Log interaction
-        log_interaction(user_state["user_id"], full_question, answer)
-        
-        # Update chat
-        display_question = message if message and message.strip() else "[ছবিৰ প্ৰশ্ন]"
-        new_history = chat_history + [[display_question, answer]]
-        return new_history, ""
-    
-    def clear_chat():
-        """Clear chat history"""
-        return [], None
+            with gr.Row():
+                submit_btn = gr.Button("📤 প্ৰশ্ন পঠিয়াওক", variant="primary")
+                clear_btn = gr.Button("🧹 পৰিষ্কাৰ কৰক", variant="secondary")
+    
+    # Simple event handlers
+    def process_message(msg, hist, user):
+        return simple_chat(msg, hist)
+    
+    submit_btn.click(
+        fn=process_message,
+        inputs=[message, chatbot, username],
+        outputs=[chatbot, message]
+    )
     
-    # Create Gradio interface - SIMPLIFIED without problematic components
-    with gr.Blocks(
-        title=APP_NAME,
-        theme=gr.themes.Soft()
-    ) as demo:
-        
-        gr.Markdown(f"# 🧭 {APP_NAME}")
-        gr.Markdown("SEBA Class 10 AI Tutor - Ask questions in Assamese or English")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 👤 লগিন")
-                username = gr.Textbox(
-                    label="আপোনাৰ নাম",
-                    placeholder="আপোনাৰ নাম লিখক...",
-                    max_lines=1
-                )
-                gr.Markdown("""
-                ### 💡 টিপছ
-                - নাম লিখি প্ৰশ্ন সোধক
-                - পাঠ্যপুথিৰ PDF ফাইলসমূহ `pdfs/class10` ফ'ল্ডাৰত ৰাখক
-                - ছবি আপলোড কৰিলে OCR ৰ সহায়ত পাঠ পঢ়িব
-                """)
-            
-            with gr.Column(scale=2):
-                chatbot = gr.Chatbot(
-                    label="জাজাবৰ সৈতে কথোপকথন",
-                    height=500
-                )
-                
-                with gr.Row():
-                    message = gr.Textbox(
-                        label="প্ৰশ্ন",
-                        placeholder="আপোনাৰ প্ৰশ্ন ইয়াত লিখক...",
-                        lines=2
-                    )
-                
-                with gr.Row():
-                    image = gr.Image(
-                        label="ছবি আপলোড কৰক (ঐচ্ছিক)",
-                        type="filepath"
-                    )
-                
-                with gr.Row():
-                    submit_btn = gr.Button("📤 প্ৰশ্ন পঠিয়াওক", variant="primary")
-                    clear_btn = gr.Button("🧹 পৰিষ্কাৰ কৰক", variant="secondary")
-        
-        # Event handlers
-        submit_btn.click(
-            fn=chat_function,
-            inputs=[message, image, chatbot, username],
-            outputs=[chatbot, message]
-        )
-        
-        message.submit(
-            fn=chat_function,
-            inputs=[message, image, chatbot, username],
-            outputs=[chatbot, message]
-        )
-        
-        clear_btn.click(
-            fn=clear_chat,
-            outputs=[chatbot, image]
-        )
+    message.submit(
+        fn=process_message,
+        inputs=[message, chatbot, username],
+        outputs=[chatbot, message]
+    )
     
-    return demo
+    clear_btn.click(lambda: ([], ""), outputs=[chatbot, message])
 
-# -------------------- MAIN --------------------
+# Launch with minimal settings
 if __name__ == "__main__":
-    if not GRADIO_AVAILABLE:
-        print("❌ Gradio not available. Please install gradio.")
-        exit(1)
-    
-    try:
-        demo = create_app()
-        print("✅ App created successfully")
-        
-        # Simple launch for Hugging Face Spaces
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False  # Critical: must be False for Spaces
-        )
-    except Exception as e:
-        print(f"❌ Error launching app: {e}")
-        # Final fallback
-        try:
-            demo.launch(share=False)
-        except:
-            print("💥 Failed to launch application")
+    demo.launch(share=False)