Update TrendAnalysis.py

TrendAnalysis.py

@@ -279,7 +279,8 @@ def perform_trend_analysis(df):
     return df, topic_labels
 
 
-def build_dashboard(df, titleNm, topic_year):
+def build_dashboard(df, titleNm, topic_year,existing_app=None):
+    global dash_app
     TitleName = titleNm + "_" + topic_year
     color_palette = px.colors.qualitative.Vivid
     unique_topics = sorted(df["topic"].unique())
@@ -291,7 +292,8 @@ def build_dashboard(df, titleNm, topic_year):
     # Calculate the number of papers in each cluster
     cluster_sizes = df.groupby("topic").size().reset_index(name="paper_count")
     df = df.merge(cluster_sizes, on="topic", how="left")
-
+    app = existing_app if existing_app else dash.Dash(__name__, external_stylesheets=[dbc.themes.DARKLY])
+    
     # Improved marker scaling with a better range
     min_size = 50
     max_size = 140
@@ -338,8 +340,7 @@ def build_dashboard(df, titleNm, topic_year):
 
     df["theme"] = df.apply(classify_theme, axis=1)
 
-    # Initialize the Dash app with an improved Bootstrap theme
-    app = dash.Dash(__name__, external_stylesheets=[dbc.themes.DARKLY])  # DARKLY for a sleek dark theme
+    
 
     # Create a more visually appealing figure
     fig = go.Figure()
@@ -903,92 +904,11 @@ def build_dashboard(df, titleNm, topic_year):
     return app
 
 
-# Global variables to track Dash app state
-dash_thread = None
-dash_app = None
-DASH_PORT = 7860
-
-
-# Simplified shutdown function that doesn't rely on request or psutil connections
-def shutdown_dash_app():
-    global dash_thread, dash_app
-
-    if dash_app is not None:
-        try:
-            print("Shutting down previous Dash app...")
-
-            # If we have a Dash app with a server
-            if hasattr(dash_app, 'server'):
-                # Set a shutdown flag
-                dash_app._shutdown = True
-
-            # Force the thread to terminate
-            if dash_thread and dash_thread.is_alive():
-                import ctypes
-                ctypes.pythonapi.PyThreadState_SetAsyncExc(
-                    ctypes.c_long(dash_thread.ident),
-                    ctypes.py_object(SystemExit)
-                )
-                dash_thread.join(timeout=2)
-
-            # Try to find and kill the process using the port
-            try:
-                import psutil
-                import os
-                import signal
-
-                for proc in psutil.process_iter(['pid']):
-                    try:
-                        for conn in proc.connections(kind='inet'):
-                            if conn.laddr.port == DASH_PORT:
-                                print(f"Killing process {proc.pid} using port {DASH_PORT}")
-                                os.kill(proc.pid, signal.SIGTERM)
-                    except:
-                        pass
-            except:
-                print("Could not find process using port")
-
-            # Clear references
-            dash_app = None
-            print("Previous Dash app successfully shut down")
-            return True
-
-        except Exception as e:
-            print(f"Error shutting down Dash app: {e}")
-            # Even if there were errors, reset the state
-            dash_app = None
-            return True
-
-    return True  # No app to shut down
-
-
-# Updated function to run Dash with error handling
-def run_dash(df, titleNm, Topic_year):
-    global dash_app
-
-    try:
-        # Build the dashboard
-        dash_app = build_dashboard(df, titleNm, Topic_year)
-
-        # Run the server
-        dash_app.run_server(debug=False, port=DASH_PORT, use_reloader=False)
-    except Exception as e:
-        print(f"Error running Dash app: {e}")
-        dash_app = None
-
-
-# Update your endpoint - removed request parameter from shutdown_dash_app
 @router.post("/analyze-trends/")
 async def analyze_trends(request: Request, data_request: TrendAnalysisRequest):
     global dash_thread
     TitleName = data_request.topic
     Topic_year = data_request.year
-    # First, ensure any existing dashboard is properly shut down
-    shutdown_dash_app()
-
-    # Short delay to ensure port is freed
-    import time
-    time.sleep(1)
 
     # Fetch and process data
     df, current_page, total_pages, papers_count, total_papers = await fetch_papers_with_pagination(
@@ -1015,17 +935,36 @@ async def analyze_trends(request: Request, data_request: TrendAnalysisRequest):
 
     # Create cluster statistics
     cluster_sizes = df.groupby("topic").size().to_dict()
-
-    # Create and start a new thread for the dashboard
-    dash_thread = threading.Thread(target=run_dash, args=(df, TitleName, Topic_year))
-    dash_thread.daemon = True
-    dash_thread.start()
-
-    # Open browser automatically
-    browser_thread = threading.Thread(target=open_browser)
+    
+    # Build the dashboard
+    from app import get_or_create_dash_app
+    dash_app = get_or_create_dash_app()
+    
+    # Build the dashboard using existing dash_app
+    updated_dash_app = build_dashboard(df, TitleName, Topic_year if Topic_year else "", existing_app=dash_app)
+    
+    # Update the global dash_app in the main app
+    from app import dash_app as main_dash_app
+    main_dash_app.layout = updated_dash_app.layout
+    
+    # Add dashboard_path to the response
+    dashboard_path = f"/dash"
+    
+    # Get base URL from request and build complete URL
+    base_url = str(request.base_url)
+    dashboard_url = f"{base_url}dash"
+    
+    # Open browser in a new thread
+    def open_browser():
+        import webbrowser
+        webbrowser.open(dashboard_url,new=2)
+    
+    # Start a thread to open the browser after a short delay
+    import threading
+    browser_thread = threading.Timer(1.5, open_browser)
     browser_thread.daemon = True
     browser_thread.start()
-
+    
     return {
         "message": f"Trend analysis completed for papers (page {current_page + 1} of {total_pages})",
         "current_page": current_page,
@@ -1034,11 +973,46 @@ async def analyze_trends(request: Request, data_request: TrendAnalysisRequest):
         "total_papers": total_papers,
         "cluster_sizes": cluster_sizes,
         "cluster_titles": topic_labels,
-        "dashboard_url": f"http://localhost:{DASH_PORT}"
+        "dashboard_url": dashboard_url,
+        "redirect": True  # Add a flag to indicate redirect is needed
     }
 
 
-# Function to open browser after a short delay
-def open_browser():
-    time.sleep(2)  # Wait for servers to start
-    webbrowser.open_new(f"http://0.0.0.0:{DASH_PORT}")
+# Additional function to add at the bottom of TrendAnalysis.py to ensure browser opening works
+# on direct dashboard access as well
+
+@router.get("/dashboard/{userId}/{topic}/{year}")
+@router.get("/dashboard/{userId}/{topic}")
+async def get_dashboard(request: Request, userId: str, topic: str, year: str = None):
+    # Fetch and process data
+    from pydantic import BaseModel
+    import webbrowser
+    import threading
+    
+    class TempRequest(BaseModel):
+        userId: str
+        topic: str
+        year: str = None
+        page: int = 0
+    
+    data_request = TempRequest(userId=userId, topic=topic, year=year)
+    
+    # Get base URL from request and build complete URL
+    base_url = str(request.base_url)
+    dashboard_url = f"{base_url}dash"
+    
+    # Open browser in a new thread
+    def open_browser():
+        webbrowser.open(dashboard_url,new=2)
+    
+    # Start a thread to open the browser after a short delay
+    browser_thread = threading.Timer(1.5, open_browser)
+    browser_thread.daemon = True
+    browser_thread.start()
+    
+    # Reuse the analyze_trends logic to create the dashboard
+    result = await analyze_trends(request, data_request)
+    
+    # Redirect to the dash app
+    from fastapi.responses import RedirectResponse
+    return RedirectResponse(url="/dash")