Update app.py

app.py

@@ -2,113 +2,112 @@ import os
 import sys
 import traceback
 import gradio as gr
+import spaces
 
-def import_with_error_tracking(module_name):
-    """Try to import a module and return detailed error info if it fails"""
+@spaces.GPU
+def test_all_imports():
+    results = []
+    
+    # Test basic imports
+    for lib_name in [
+        "torch", 
+        "numpy", 
+        "pandas", 
+        "PyPDF2", 
+        "transformers", 
+        "sentence_transformers"
+    ]:
+        try:
+            __import__(lib_name)
+            results.append(f"✅ {lib_name}: Successfully imported")
+        except Exception as e:
+            results.append(f"❌ {lib_name}: Error - {str(e)}")
+    
+    # Test langchain imports specifically
     try:
-        module = __import__(module_name)
-        return True, f"Successfully imported {module_name}"
-    except ImportError as e:
-        return False, f"Failed to import {module_name}: {str(e)}"
+        import langchain
+        results.append(f"✅ langchain: Successfully imported (version {langchain.__version__})")
     except Exception as e:
-        return False, f"Error importing {module_name}: {str(e)}"
-
-def test_imports():
-    # Create a report of all import attempts
-    results = []
+        results.append(f"❌ langchain: Error - {str(e)}")
     
-    # Core libraries
-    for lib in ["torch", "numpy", "pandas", "tqdm", "PyPDF2", "transformers", 
-                "sentence_transformers", "langchain", "langchain_community",
-                "arabic_reshaper", "bidi", "rouge_score", "sacrebleu", "spaces"]:
-        success, message = import_with_error_tracking(lib)
-        results.append(f"{'✓' if success else '✗'} {message}")
+    # Test langchain_community imports
+    try:
+        import langchain_community
+        results.append(f"✅ langchain_community: Successfully imported")
+    except Exception as e:
+        results.append(f"❌ langchain_community: Error - {str(e)}")
+        
+        # Try alternative import format
+        try:
+            import langchain.community
+            results.append(f"✅ langchain.community: Successfully imported")
+        except Exception as e2:
+            results.append(f"❌ langchain.community: Error - {str(e2)}")
     
-    # Check if specific model is available
+    # Test specific langchain imports that might be failing
     try:
-        from transformers import AutoTokenizer
-        tokenizer = AutoTokenizer.from_pretrained("ALLaM-AI/ALLaM-7B-Instruct-preview", trust_remote_code=True)
-        results.append("✓ Model tokenizer accessible")
+        from langchain.text_splitter import RecursiveCharacterTextSplitter
+        results.append(f"✅ langchain.text_splitter: Successfully imported")
     except Exception as e:
-        results.append(f"✗ Model access error: {str(e)}")
+        results.append(f"❌ langchain.text_splitter: Error - {str(e)}")
     
-    # Test vector store
     try:
-        from langchain.embeddings import HuggingFaceEmbeddings
-        from langchain_community.vectorstores import FAISS
-        results.append("✓ Vector store components accessible")
+        from langchain.schema import Document
+        results.append(f"✅ langchain.schema: Successfully imported")
     except Exception as e:
-        results.append(f"✗ Vector store error: {str(e)}")
+        results.append(f"❌ langchain.schema: Error - {str(e)}")
     
-    return "\n".join(results)
-
-def check_pdfs():
-    """Check if PDF files are readable"""
-    results = []
+    try:
+        from langchain.embeddings import HuggingFaceEmbeddings
+        results.append(f"✅ langchain.embeddings: Successfully imported")
+    except Exception as e:
+        results.append(f"❌ langchain.embeddings: Error - {str(e)}")
     
-    for pdf_file in ["saudi_vision203.pdf", "saudi_vision2030_ar.pdf"]:
-        if not os.path.exists(pdf_file):
-            results.append(f"{pdf_file}: Not found")
-            continue
-            
-        size = os.path.getsize(pdf_file) / (1024 * 1024)  # Size in MB
-        results.append(f"{pdf_file}: Found ({size:.2f} MB)")
+    try:
+        from langchain_community.vectorstores import FAISS
+        results.append(f"✅ langchain_community.vectorstores: Successfully imported")
+    except Exception as e:
+        results.append(f"❌ langchain_community.vectorstores: Error - {str(e)}")
         
-        # Try to open and read the file
+        # Try alternative import
         try:
-            import PyPDF2
-            with open(pdf_file, 'rb') as f:
-                reader = PyPDF2.PdfReader(f)
-                num_pages = len(reader.pages)
-                text_sample = reader.pages[0].extract_text()[:100] + "..."
-                results.append(f"- Pages: {num_pages}")
-                results.append(f"- Sample text: {text_sample}")
-        except Exception as e:
-            results.append(f"- Error reading file: {str(e)}")
+            from langchain.vectorstores import FAISS
+            results.append(f"✅ langchain.vectorstores: Successfully imported")
+        except Exception as e2:
+            results.append(f"❌ langchain.vectorstores: Error - {str(e2)}")
     
-    return "\n".join(results)
-
-def check_environment():
-    """Get information about the Python environment"""
-    results = []
-    
-    results.append(f"Python version: {sys.version}")
-    results.append(f"Python executable: {sys.executable}")
-    results.append(f"Working directory: {os.getcwd()}")
-    
-    # List all installed packages
+    # Check installed package versions
     try:
         import pkg_resources
-        installed_packages = [f"{pkg.key}=={pkg.version}" for pkg in pkg_resources.working_set]
-        results.append(f"Installed packages ({len(installed_packages)}):")
-        results.append("\n".join(installed_packages))
+        results.append("\n📦 Installed Packages:")
+        for package in ["langchain", "langchain-community", "transformers", "sentence-transformers"]:
+            try:
+                version = pkg_resources.get_distribution(package).version
+                results.append(f"  - {package}: {version}")
+            except:
+                results.append(f"  - {package}: Not installed")
     except:
-        results.append("Could not list installed packages")
+        results.append("❌ Could not check installed packages")
+    
+    # Check PDF files
+    results.append("\n📄 PDF Files:")
+    for pdf_file in ["saudi_vision203.pdf", "saudi_vision2030_ar.pdf"]:
+        if os.path.exists(pdf_file):
+            size = os.path.getsize(pdf_file) / (1024 * 1024)  # MB
+            results.append(f"  - {pdf_file}: Found ({size:.2f} MB)")
+        else:
+            results.append(f"  - {pdf_file}: Not found")
     
     return "\n".join(results)
 
 def main():
-    with gr.Blocks(title="Vision 2030 Assistant - Debug Mode") as interface:
-        gr.Markdown("# Vision 2030 Assistant - Debug Mode")
-        gr.Markdown("This interface helps identify import and initialization issues.")
-        
-        with gr.Tab("Import Testing"):
-            test_btn = gr.Button("Test Imports")
-            import_results = gr.Textbox(label="Import Test Results", lines=20)
-            
-            test_btn.click(test_imports, inputs=[], outputs=[import_results])
+    with gr.Blocks(title="Import Diagnosis") as interface:
+        gr.Markdown("# Vision 2030 Assistant - Import Error Diagnosis")
         
-        with gr.Tab("PDF Testing"):
-            pdf_btn = gr.Button("Test PDFs")
-            pdf_results = gr.Textbox(label="PDF Test Results", lines=20)
-            
-            pdf_btn.click(check_pdfs, inputs=[], outputs=[pdf_results])
+        test_button = gr.Button("Test All Imports")
+        results_box = gr.Textbox(label="Results", lines=30)
         
-        with gr.Tab("Environment"):
-            env_btn = gr.Button("Check Environment")
-            env_results = gr.Textbox(label="Environment Information", lines=30)
-            
-            env_btn.click(check_environment, inputs=[], outputs=[env_results])
+        test_button.click(test_all_imports, inputs=[], outputs=[results_box])
     
     interface.launch()