Update huggingface_space/app.py

huggingface_space/app.py

@@ -1,321 +1,338 @@
-"""
-Gradio Interface for Legal Dashboard - Hugging Face Spaces
-==========================================================
-This provides a web interface for the Legal Dashboard using Gradio,
-optimized for deployment on Hugging Face Spaces.
-"""
-
 import os
-import sys
-import asyncio
-import threading
-import time
-import gradio as gr
-import requests
-from typing import Optional, Dict, Any
+import tempfile
+import logging
+from pathlib import Path
+from typing import Optional, Tuple
 
-# Add app directory to Python path
-sys.path.insert(0, '/app')
-sys.path.insert(0, '.')
+try:
+    import gradio as gr
+    GRADIO_AVAILABLE = True
+except ImportError:
+    GRADIO_AVAILABLE = False
+    logging.warning("Gradio not available")
 
-# Set environment variables for the app
-os.environ.setdefault('DATABASE_DIR', '/tmp/legal_dashboard')
-os.environ.setdefault('PYTHONPATH', '/app')
-os.environ.setdefault('LOG_LEVEL', 'INFO')
+# Import our services
+try:
+    from app.services.ocr_service import ocr_service
+    from app.services.database_service import DatabaseService
+    OCR_AVAILABLE = True
+except ImportError:
+    OCR_AVAILABLE = False
+    logging.warning("OCR service not available")
 
-# Global variables
-fastapi_server = None
-server_port = 7860
+logger = logging.getLogger(__name__)
 
-def start_fastapi_server():
-    """Start FastAPI server in a separate thread"""
-    global fastapi_server, server_port
+class LegalDashboardGradio:
+    """
+    Gradio interface for Legal Dashboard
+    """
     
-    try:
-        import uvicorn
-        from app.main import app
+    def __init__(self):
+        self.ocr_service = ocr_service if OCR_AVAILABLE else None
+        self.db_service = None
         
-        print(f"🚀 Starting FastAPI server on port {server_port}...")
-        
-        # Run FastAPI server
-        uvicorn.run(
-            app,
-            host="127.0.0.1",
-            port=server_port,
-            log_level="info",
-            access_log=False
-        )
-    except Exception as e:
-        print(f"❌ Failed to start FastAPI server: {e}")
-        return None
-
-def wait_for_server(timeout=30):
-    """Wait for FastAPI server to be ready"""
-    start_time = time.time()
-    
-    while time.time() - start_time < timeout:
+        # Initialize database if available
         try:
-            response = requests.get(f"http://127.0.0.1:{server_port}/health", timeout=2)
-            if response.status_code == 200:
-                print("✅ FastAPI server is ready!")
-                return True
-        except:
-            pass
-        time.sleep(1)
-    
-    print("❌ FastAPI server failed to start within timeout")
-    return False
-
-def make_api_request(endpoint: str, method: str = "GET", data: Dict = None, token: str = None) -> Dict:
-    """Make request to FastAPI backend"""
-    url = f"http://127.0.0.1:{server_port}{endpoint}"
-    headers = {}
-    
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
+            self.db_service = DatabaseService()
+        except Exception as e:
+            logger.warning(f"Database service not available: {e}")
     
-    if method == "POST" and data:
-        headers["Content-Type"] = "application/json"
-    
-    try:
-        if method == "GET":
-            response = requests.get(url, headers=headers, timeout=10)
-        elif method == "POST":
-            response = requests.post(url, json=data, headers=headers, timeout=10)
-        else:
-            return {"error": f"Unsupported method: {method}"}
+    async def process_document(self, file) -> Tuple[str, str, str]:
+        """
+        Process uploaded document and extract text
+        """
+        if not file:
+            return "❌ No file uploaded", "", ""
         
-        if response.status_code == 200:
-            return response.json()
-        else:
-            return {"error": f"HTTP {response.status_code}: {response.text}"}
-    
-    except requests.exceptions.RequestException as e:
-        return {"error": f"Request failed: {str(e)}"}
-
-# Authentication state
-auth_state = {"token": None, "user": None}
-
-def login_user(username: str, password: str) -> tuple:
-    """Login user and return status"""
-    if not username or not password:
-        return False, "نام کاربری و رمز عبور الزامی است", "", ""
-    
-    data = {"username": username, "password": password}
-    result = make_api_request("/api/auth/login", "POST", data)
-    
-    if "error" in result:
-        return False, f"خطا در ورود: {result['error']}", "", ""
-    
-    if "access_token" in result:
-        auth_state["token"] = result["access_token"]
+        if not self.ocr_service:
+            return "❌ OCR service not available", "", ""
         
-        # Get user info
-        user_info = make_api_request("/api/auth/me", "GET", token=auth_state["token"])
-        if "error" not in user_info:
-            auth_state["user"] = user_info
-            return True, f"خوش آمدید {user_info.get('username', 'کاربر')}!", "", ""
-    
-    return False, "ورود ناموفق", "", ""
-
-def register_user(username: str, email: str, password: str) -> tuple:
-    """Register new user"""
-    if not all([username, email, password]):
-        return False, "تمام فیلدها الزامی است", "", "", ""
-    
-    data = {
-        "username": username,
-        "email": email,
-        "password": password,
-        "role": "user"
-    }
-    
-    result = make_api_request("/api/auth/register", "POST", data)
-    
-    if "error" in result:
-        return False, f"خطا در ثبت نام: {result['error']}", "", "", ""
-    
-    return True, "ثبت نام موفقیت آمیز بود. اکنون می‌توانید وارد شوید.", "", "", ""
-
-def logout_user():
-    """Logout current user"""
-    if auth_state["token"]:
-        make_api_request("/api/auth/logout", "POST", token=auth_state["token"])
-    
-    auth_state["token"] = None
-    auth_state["user"] = None
-    return False, "خروج موفقیت آمیز", "", ""
-
-def get_server_status():
-    """Get server status"""
-    try:
-        response = make_api_request("/health")
-        if "error" not in response:
-            return f"✅ Server Status: {response.get('status', 'Unknown')}"
-        else:
-            return f"❌ Server Error: {response['error']}"
-    except:
-        return "❌ Server not responding"
-
-def process_document(file, document_type: str = "قرارداد"):
-    """Process uploaded document"""
-    if not file:
-        return "لطفاً فایلی را انتخاب کنید"
-    
-    if not auth_state["token"]:
-        return "لطفاً ابتدا وارد شوید"
+        try:
+            # Get file path
+            file_path = file.name
+            file_extension = Path(file_path).suffix.lower()
+            
+            # Process based on file type
+            if file_extension == '.pdf':
+                result = await self.ocr_service.extract_text_from_pdf(file_path)
+            elif file_extension in ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']:
+                result = await self.ocr_service.extract_text_from_image(file_path)
+            else:
+                return f"❌ Unsupported file type: {file_extension}", "", ""
+            
+            if result["success"]:
+                # Process text with NLP if available
+                processed = await self.ocr_service.process_text(result["text"])
+                
+                # Create status message
+                status = f"✅ Successfully processed using {result['method']}"
+                
+                # Create metadata info
+                metadata = f"""
+**Processing Details:**
+- Method: {result['method']}
+- Character Count: {len(result['text'])}
+- Pages: {len(result.get('pages', []))}
+"""
+                
+                if processed.get('entities'):
+                    entities_info = "\n**Named Entities Found:**\n"
+                    for ent in processed['entities'][:10]:  # Show first 10 entities
+                        entities_info += f"- {ent['text']} ({ent['label']})\n"
+                    metadata += entities_info
+                
+                return status, result["text"], metadata
+            else:
+                error_msg = result.get("metadata", {}).get("error", "Unknown error")
+                return f"❌ Processing failed: {error_msg}", "", ""
+                
+        except Exception as e:
+            logger.error(f"Document processing error: {e}")
+            return f"❌ Error: {str(e)}", "", ""
     
-    # This would integrate with your document processing API
-    return f"فایل '{file.name}' از نوع '{document_type}' در حال پردازش است..."
-
-# Start FastAPI server in background
-def start_background_server():
-    """Start FastAPI server in background thread"""
-    server_thread = threading.Thread(target=start_fastapi_server, daemon=True)
-    server_thread.start()
+    def search_documents(self, query: str) -> str:
+        """
+        Search in processed documents
+        """
+        if not query.strip():
+            return "Please enter a search query"
+        
+        if not self.db_service:
+            return "Database service not available"
+        
+        try:
+            # This would search in the database
+            # For now, return a placeholder
+            return f"Search results for '{query}' would appear here.\n\nDatabase integration coming soon..."
+        except Exception as e:
+            return f"Search error: {str(e)}"
     
-    # Wait for server to be ready
-    if wait_for_server():
-        print("🎉 System ready!")
-    else:
-        print("⚠️ System may not be fully functional")
-
-# Start the background server
-start_background_server()
+    def get_system_status(self) -> str:
+        """
+        Get system status information
+        """
+        try:
+            status = []
+            
+            # OCR Service Status
+            if self.ocr_service:
+                ocr_status = self.ocr_service.get_service_status()
+                status.append("🔍 **OCR Service:**")
+                status.append(f"  - Status: {'✅ Ready' if ocr_status['fallback_ready'] else '❌ Not Ready'}")
+                status.append(f"  - Transformers: {'✅ Available' if ocr_status['transformers_ready'] else '❌ Not Available'}")
+                status.append(f"  - spaCy: {'✅ Available' if ocr_status['spacy_ready'] else '❌ Not Available'}")
+                status.append(f"  - Models: {', '.join(ocr_status['models_loaded']) if ocr_status['models_loaded'] else 'None'}")
+            else:
+                status.append("🔍 **OCR Service:** ❌ Not Available")
+            
+            # Database Service Status
+            if self.db_service:
+                status.append("\n💾 **Database Service:** ✅ Available")
+            else:
+                status.append("\n💾 **Database Service:** ❌ Not Available")
+            
+            # System Info
+            status.append(f"\n🖥️ **System Info:**")
+            status.append(f"  - Python: Available")
+            status.append(f"  - Gradio: {'✅ Available' if GRADIO_AVAILABLE else '❌ Not Available'}")
+            
+            return "\n".join(status)
+            
+        except Exception as e:
+            return f"Error getting system status: {str(e)}"
 
-# Create Gradio interface
-with gr.Blocks(
-    title="Legal Dashboard - داشبورد حقوقی",
-    theme=gr.themes.Soft(),
-    css="""
-    .container { max-width: 1200px; margin: auto; }
-    .login-box { background: #f8f9fa; padding: 20px; border-radius: 10px; }
-    .status-box { background: #e7f3ff; padding: 10px; border-radius: 5px; margin: 10px 0; }
-    """,
-    rtl=True
-) as app:
+def create_gradio_interface():
+    """
+    Create and return the Gradio interface
+    """
+    if not GRADIO_AVAILABLE:
+        return None
     
-    gr.Markdown("""
-    # 📊 داشبورد حقوقی
-    ### سیستم مدیریت و تحلیل اسناد حقوقی
+    dashboard = LegalDashboardGradio()
     
-    این سیستم امکان آپلود، تحلیل و مدیریت اسناد حقوقی را فراهم می‌کند.
-    """)
+    # Custom CSS
+    css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .main-header {
+        text-align: center;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .status-box {
+        background: #f8f9fa;
+        border-left: 4px solid #28a745;
+        padding: 15px;
+        border-radius: 5px;
+    }
+    """
     
-    # Authentication section
-    with gr.Tab("🔐 احراز هویت"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### ورود به سیستم")
-                login_username = gr.Textbox(label="نام کاربری", placeholder="admin")
-                login_password = gr.Textbox(label="رمز عبور", type="password", placeholder="admin123")
-                login_btn = gr.Button("ورود", variant="primary")
-                login_status = gr.Textbox(label="وضعیت", interactive=False)
-            
-            with gr.Column():
-                gr.Markdown("### ثبت نام")
-                reg_username = gr.Textbox(label="نام کاربری")
-                reg_email = gr.Textbox(label="ایمیل")
-                reg_password = gr.Textbox(label="رمز عبور", type="password")
-                register_btn = gr.Button("ثبت نام", variant="secondary")
-                reg_status = gr.Textbox(label="وضعیت", interactive=False)
+    with gr.Blocks(css=css, title="Legal Dashboard", theme=gr.themes.Soft()) as iface:
         
-        with gr.Row():
-            logout_btn = gr.Button("خروج", variant="stop")
-            server_status = gr.Textbox(label="وضعیت سرور", value=get_server_status, every=30)
-    
-    # Document processing section
-    with gr.Tab("📄 پردازش اسناد"):
-        gr.Markdown("### آپلود و تحلیل اسناد")
+        # Header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🏛️ Legal Dashboard</h1>
+            <p>Advanced Legal Document Management System with AI-Powered OCR</p>
+        </div>
+        """)
         
-        with gr.Row():
-            with gr.Column():
-                file_input = gr.File(
-                    label="انتخاب فایل",
-                    file_types=[".pdf", ".docx", ".doc", ".txt"],
-                    type="filepath"
-                )
-                doc_type = gr.Dropdown(
-                    label="نوع سند",
-                    choices=["قرارداد", "دادخواست", "رأی دادگاه", "سند اداری", "سایر"],
-                    value="قرارداد"
-                )
-                process_btn = gr.Button("پردازش سند", variant="primary")
+        with gr.Tab("📄 Document Processing"):
+            gr.Markdown("## Upload and Process Documents")
+            gr.Markdown("Upload PDF files or images to extract text using advanced OCR technology.")
             
-            with gr.Column():
-                process_result = gr.Textbox(
-                    label="نتیجه پردازش",
-                    lines=10,
-                    interactive=False
-                )
-    
-    # System information
-    with gr.Tab("ℹ️ اطلاعات سیستم"):
-        gr.Markdown("""
-        ### راهنمای استفاده
-        
-        **احراز هویت:**
-        - کاربر پیش‌فرض: `admin` / `admin123`
-        - برای دسترسی کامل ابتدا وارد شوید
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_input = gr.File(
+                        label="Upload Document",
+                        file_types=[".pdf", ".jpg", ".jpeg", ".png", ".bmp", ".tiff"],
+                        type="file"
+                    )
+                    process_btn = gr.Button("🔍 Process Document", variant="primary", size="lg")
+                
+                with gr.Column(scale=2):
+                    status_output = gr.Textbox(
+                        label="Processing Status",
+                        placeholder="Upload a document and click 'Process Document' to begin...",
+                        interactive=False
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    extracted_text = gr.Textbox(
+                        label="Extracted Text",
+                        placeholder="Processed text will appear here...",
+                        lines=15,
+                        max_lines=30,
+                        interactive=False
+                    )
+                
+                with gr.Column():
+                    metadata_output = gr.Textbox(
+                        label="Processing Details",
+                        placeholder="Processing metadata and analysis will appear here...",
+                        lines=15,
+                        max_lines=30,
+                        interactive=False
+                    )
+            
+            # Connect the processing function
+            process_btn.click(
+                fn=dashboard.process_document,
+                inputs=[file_input],
+                outputs=[status_output, extracted_text, metadata_output]
+            )
         
-        **پردازش اسناد:**
-        - فرمت‌های پشتیبانی شده: PDF, DOCX, DOC, TXT
-        - حداکثر حجم فایل: 50MB
+        with gr.Tab("🔍 Search Documents"):
+            gr.Markdown("## Search Processed Documents")
+            gr.Markdown("Search through previously processed documents using keywords and phrases.")
+            
+            with gr.Row():
+                search_input = gr.Textbox(
+                    label="Search Query",
+                    placeholder="Enter keywords to search...",
+                    scale=3
+                )
+                search_btn = gr.Button("🔍 Search", variant="primary", scale=1)
+            
+            search_results = gr.Textbox(
+                label="Search Results",
+                placeholder="Search results will appear here...",
+                lines=10,
+                interactive=False
+            )
+            
+            # Connect search function
+            search_btn.click(
+                fn=dashboard.search_documents,
+                inputs=[search_input],
+                outputs=[search_results]
+            )
         
-        **ویژگی‌ها:**
-        - تحلیل متن با هوش مصنوعی
-        - استخراج اطلاعات کلیدی
-        - تشخیص نوع سند
-        - آرشیو و مدیریت اسناد
-        """)
+        with gr.Tab("⚙️ System Status"):
+            gr.Markdown("## System Status and Information")
+            
+            status_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+            system_status = gr.Textbox(
+                label="System Status",
+                placeholder="Click 'Refresh Status' to check system health...",
+                lines=15,
+                interactive=False
+            )
+            
+            # Connect status function
+            status_btn.click(
+                fn=dashboard.get_system_status,
+                outputs=[system_status]
+            )
+            
+            # Auto-load status on interface start
+            iface.load(
+                fn=dashboard.get_system_status,
+                outputs=[system_status]
+            )
         
-        api_status = gr.JSON(
-            label="وضعیت API",
-            value=lambda: make_api_request("/health")
-        )
-
-    # Event handlers
-    login_btn.click(
-        fn=login_user,
-        inputs=[login_username, login_password],
-        outputs=[gr.State(), login_status, login_username, login_password]
-    )
-    
-    register_btn.click(
-        fn=register_user,
-        inputs=[reg_username, reg_email, reg_password],
-        outputs=[gr.State(), reg_status, reg_username, reg_email, reg_password]
-    )
-    
-    logout_btn.click(
-        fn=logout_user,
-        outputs=[gr.State(), login_status, login_username, login_password]
-    )
+        with gr.Tab("📚 About"):
+            gr.Markdown("""
+            ## Legal Dashboard
+            
+            **Advanced Legal Document Management System**
+            
+            ### Features:
+            - 📄 **PDF Processing**: Extract text from PDF documents with high accuracy
+            - 🖼️ **Image OCR**: Process scanned documents and images
+            - 🧠 **AI-Powered**: Uses advanced transformer models for text recognition
+            - 🔍 **Smart Search**: Intelligent search capabilities across documents
+            - 📊 **Analytics**: Document analysis and metadata extraction
+            - 🔒 **Secure**: Privacy-focused document processing
+            
+            ### Supported Formats:
+            - **Documents**: PDF
+            - **Images**: JPG, JPEG, PNG, BMP, TIFF
+            
+            ### Technology Stack:
+            - **OCR**: PyMuPDF, OpenCV, Transformers (TrOCR)
+            - **NLP**: spaCy for named entity recognition
+            - **ML**: PyTorch, Hugging Face Transformers
+            - **Interface**: Gradio for web interface
+            
+            ### Usage:
+            1. Upload your document using the **Document Processing** tab
+            2. Click **Process Document** to extract text
+            3. Use the **Search** tab to find specific content
+            4. Check **System Status** for service health
+            
+            ---
+            
+            *This system is designed for legal professionals to efficiently process and manage legal documents with the power of AI.*
+            """)
     
-    process_btn.click(
-        fn=process_document,
-        inputs=[file_input, doc_type],
-        outputs=[process_result]
-    )
+    return iface
 
-# Launch configuration for Hugging Face Spaces
-if __name__ == "__main__":
-    # Check if running in HF Spaces
-    if os.getenv("SPACE_ID"):
-        print("🤗 Running in Hugging Face Spaces")
-        app.launch(
+def launch_gradio_app():
+    """
+    Launch the Gradio application
+    """
+    if not GRADIO_AVAILABLE:
+        print("❌ Gradio not available. Please install gradio: pip install gradio")
+        return None
+    
+    iface = create_gradio_interface()
+    if iface:
+        print("🚀 Starting Legal Dashboard Gradio Interface...")
+        iface.launch(
             server_name="0.0.0.0",
             server_port=7860,
             share=False,
             show_error=True,
-            debug=False
+            show_tips=True,
+            enable_queue=True
         )
-    else:
-        print("🖥️ Running locally")
-        app.launch(
-            server_name="127.0.0.1",
-            server_port=7860,
-            share=True,
-            show_error=True,
-            debug=True
-        )
+    return iface
+
+if __name__ == "__main__":
+    launch_gradio_app()