Update run.py

run.py

@@ -63,13 +63,11 @@ class LegalDashboardRunner:
         ]
         
         missing_required = []
-        missing_optional = []
         
         # Check required modules
         for module, description in required_modules:
             try:
                 __import__(module)
-                self.logger.info(f"✅ {description}")
             except ImportError:
                 missing_required.append((module, description))
                 self.logger.error(f"❌ {description} - Missing: {module}")
@@ -78,10 +76,8 @@ class LegalDashboardRunner:
         for module, description in optional_modules:
             try:
                 __import__(module)
-                self.logger.info(f"✅ {description}")
             except ImportError:
-                missing_optional.append((module, description))
-                self.logger.warning(f"⚠️ {description} - Optional: {module}")
+                self.logger.warning(f"⚠️ Optional module missing: {module} ({description})")
         
         if missing_required:
             self.logger.error("❌ Missing required dependencies:")
@@ -89,42 +85,20 @@ class LegalDashboardRunner:
                 self.logger.error(f"  pip install {module}")
             return False
         
-        if missing_optional and config.is_hf_spaces:
-            # Check if gradio is available for HF Spaces
-            if any(module == "gradio" for module, _ in missing_optional):
-                self.logger.error("❌ Gradio is required for HF Spaces deployment")
-                return False
-        
         return True
     
     def test_database_connection(self) -> bool:
         """Test database connectivity"""
         try:
             import sqlite3
-            import tempfile
-            
-            # Test with temporary database
-            test_db = os.path.join(tempfile.gettempdir(), "test_legal_dashboard.db")
-            
-            conn = sqlite3.connect(test_db)
-            cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY)")
-            cursor.execute("INSERT INTO test (id) VALUES (1)")
-            cursor.execute("SELECT * FROM test")
-            result = cursor.fetchone()
+            db_path = config.database_config["path"]
+            db_dir = os.path.dirname(db_path)
+            os.makedirs(db_dir, exist_ok=True)
+            conn = sqlite3.connect(db_path)
+            conn.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY);")
             conn.close()
-            
-            # Clean up
-            if os.path.exists(test_db):
-                os.remove(test_db)
-            
-            if result:
-                self.logger.info("✅ Database connectivity test passed")
-                return True
-            else:
-                self.logger.error("❌ Database test failed - no data returned")
-                return False
-                
+            self.logger.info("✅ Database connectivity test passed")
+            return True
         except Exception as e:
             self.logger.error(f"❌ Database connectivity test failed: {e}")
             return False
@@ -133,44 +107,35 @@ class LegalDashboardRunner:
         """Run Gradio interface for HF Spaces"""
         try:
             self.logger.info("🤗 Starting Gradio interface for HF Spaces...")
-            
             # Import and run Gradio app
-            if os.path.exists("app.py"):
-                import app  # This will run the Gradio interface
-            else:
-                self.logger.error("❌ app.py not found for Gradio interface")
-                return False
-                
+            import app # Assumes app.py at root is the Gradio entrypoint
+            self.logger.info("✅ Gradio interface started successfully from app.py")
         except Exception as e:
             self.logger.error(f"❌ Failed to start Gradio interface: {e}")
             return False
     
     def run_fastapi_server(self):
-        """Run FastAPI server"""
+        """Run FastAPI server for Docker, Local, or HF Docker Spaces"""
         try:
             self.logger.info("🚀 Starting FastAPI server...")
             
             import uvicorn
             from app.main import app
             
-            # Server configuration
+            # Server configuration from config.py
             server_config = config.server_config
             
             self.logger.info(f"🌐 Server starting on {server_config['host']}:{server_config['port']}")
             self.logger.info(f"👥 Workers: {server_config['workers']}")
-            self.logger.info(f"📊 Log level: {server_config['log_level']}")
             
-            # Run server
             uvicorn.run(
-                app,
+                "app.main:app", # Use string import for reload compatibility
                 host=server_config['host'],
                 port=server_config['port'],
                 workers=server_config['workers'],
-                log_level=server_config['log_level'],
-                access_log=server_config['access_log'],
+                log_level=server_config['log_level'].lower(),
                 reload=server_config['reload']
             )
-            
         except Exception as e:
             self.logger.error(f"❌ Failed to start FastAPI server: {e}")
             return False
@@ -181,58 +146,43 @@ class LegalDashboardRunner:
         print("🏛️ Legal Dashboard - Universal Runner")
         print("=" * 60)
         
-        # Setup environment
         if not setup_environment():
             self.logger.error("❌ Environment setup failed")
             sys.exit(1)
         
-        # Check dependencies
         if not self.check_dependencies():
             self.logger.error("❌ Dependency check failed")
             sys.exit(1)
         
-        # Test database
         if not self.test_database_connection():
             self.logger.error("❌ Database test failed")
             sys.exit(1)
         
-        # Show configuration summary
         self.logger.info("📋 Configuration Summary:")
         self.logger.info(f"  Environment: {config.environment}")
-        self.logger.info(f"  HF Spaces: {config.is_hf_spaces}")
-        self.logger.info(f"  Docker: {config.is_docker}")
-        self.logger.info(f"  Development: {config.is_development}")
         self.logger.info(f"  Data Directory: {config.directories['data']}")
-        self.logger.info(f"  Cache Directory: {config.directories['cache']}")
         
-        # Run appropriate interface
+        # --- ✅ FIX: منطق هوشمند برای تشخیص نوع اسپیس در هاگینگ فیس ---
+        # اگر در محیط هاگینگ فیس هستیم و فایل app.py (مخصوص گرادیو) وجود دارد، رابط گرادیو را اجرا کن
+        # در غیر این صورت (برای داکر، لوکال و داکر اسپیس در هاگینگ فیس) سرور اصلی FastAPI را اجرا کن
+        is_gradio_space = config.is_hf_spaces and os.path.exists("app.py")
+
         try:
-            if config.is_hf_spaces:
-                # HF Spaces - use Gradio interface
+            if is_gradio_space:
                 self.run_gradio_interface()
             else:
-                # Docker/Local - use FastAPI server
                 self.run_fastapi_server()
                 
         except KeyboardInterrupt:
             self.logger.info("🛑 Received keyboard interrupt")
-        except Exception as e:
-            self.logger.error(f"❌ Unexpected error: {e}")
-            sys.exit(1)
         finally:
             self.shutdown()
     
     def shutdown(self):
         """Graceful shutdown"""
         self.logger.info("🔄 Shutting down Legal Dashboard...")
-        
         if self.app_process:
-            try:
-                self.app_process.terminate()
-                self.app_process.wait(timeout=10)
-            except:
-                self.app_process.kill()
-        
+            self.app_process.terminate()
         self.logger.info("✅ Shutdown completed")
 
 def main():