Update app.py via AI Editor

app.py

@@ -14,6 +14,8 @@ from dash.exceptions import PreventUpdate
 from PIL import Image
 import google.generativeai as genai
 import time
+import uuid
+import threading
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -26,10 +28,54 @@ model = genai.GenerativeModel('gemini-2.5-pro-preview-03-25')
 app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP, 'https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap'])
 app.config.suppress_callback_exceptions = True
 
-log_messages = []
-generated_pptx = None
+# Session store: session_id -> {'log_messages': [], 'generated_pptx': None, 'lock': threading.Lock(), ...}
+SESSION_DATA = {}
+SESSION_DATA_LOCK = threading.Lock()
 
+def get_session_id_from_cookie(cookies):
+    if not cookies:
+        return None
+    items = cookies.split(';')
+    for item in items:
+        k, sep, v = item.strip().partition('=')
+        if k == 'dash-session-id' and sep:
+            return v
+    return None
+
+def get_or_create_session_data(session_id):
+    with SESSION_DATA_LOCK:
+        if session_id not in SESSION_DATA:
+            SESSION_DATA[session_id] = {
+                'log_messages': [],
+                'generated_pptx': None,
+                'lock': threading.Lock()
+            }
+        return SESSION_DATA[session_id]
+
+# Layout with dcc.Store and session id setting
 app.layout = html.Div([
+    dcc.Store(id='session-id', storage_type='local'),
+    # set session id cookie if not present
+    html.Script('''
+    (function() {
+        function uuidv4() {
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+                var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+        if (!document.cookie.split('; ').find(row => row.startsWith('dash-session-id='))) {
+            var sessionid = uuidv4();
+            document.cookie = 'dash-session-id=' + sessionid + '; path=/; SameSite=Lax';
+            window.localStorage.setItem('dash-session-id', sessionid);
+        } else {
+            var sessionid = document.cookie.split('; ').find(row => row.startsWith('dash-session-id=')).split('=')[1];
+            window.localStorage.setItem('dash-session-id', sessionid);
+        }
+        window.dash_clientside = window.dash_clientside || {};
+        window.dash_clientside.sessionid = sessionid;
+    })();
+    '''),
     dbc.Container([
         dbc.Row([
             dbc.Col([
@@ -85,13 +131,14 @@ app.layout = html.Div([
     dcc.Interval(id='interval-component', interval=1*1000, n_intervals=0)
 ])
 
-def add_log(message):
-    global log_messages
-    logger.info(message)
-    log_messages.insert(0, f"{time.strftime('%H:%M:%S')} - {message}")
+def add_log(message, session_id):
+    session = get_or_create_session_data(session_id)
+    with session['lock']:
+        logger.info(message)
+        session['log_messages'].insert(0, f"{time.strftime('%H:%M:%S')} - {message}")
 
-def process_document(text):
-    add_log("Starting document processing...")
+def process_document(text, session_id):
+    add_log("Starting document processing...", session_id)
     prompt = f"""
     Create a PowerPoint presentation based on the following document. 
     Generate slides with titles and content. Format the output as markdown, 
@@ -103,13 +150,13 @@ def process_document(text):
     Document:
     {text}
     """
-    add_log("Sending request to Gemini model...")
+    add_log("Sending request to Gemini model...", session_id)
     response = model.generate_content(prompt)
-    add_log("Received response from Gemini model.")
+    add_log("Received response from Gemini model.", session_id)
     return response.text
 
-def generate_image_prompt(slide_content):
-    add_log(f"Generating image prompt for slide: {slide_content[:30]}...")
+def generate_image_prompt(slide_content, session_id):
+    add_log(f"Generating image prompt for slide: {slide_content[:30]}...", session_id)
     prompt = f"""
     Based on the following slide content, create a detailed prompt for generating 
     an image that represents the main idea of the slide. The image should be 
@@ -119,11 +166,11 @@ def generate_image_prompt(slide_content):
     Image prompt:
     """
     response = model.generate_content(prompt)
-    add_log("Image prompt generated.")
+    add_log("Image prompt generated.", session_id)
     return response.text
 
-def generate_image(prompt):
-    add_log(f"Generating image for prompt: {prompt[:30]}...")
+def generate_image(prompt, session_id):
+    add_log(f"Generating image for prompt: {prompt[:30]}...", session_id)
     url = "https://api.stability.ai/v2beta/stable-image/generate/sd3"
     headers = {
         "Authorization": f"Bearer {STABILITY_API_KEY}",
@@ -137,25 +184,25 @@ def generate_image(prompt):
     try:
         response = requests.post(url, headers=headers, data=data, files=files)
         response.raise_for_status()
-        add_log("Image generated successfully.")
+        add_log("Image generated successfully.", session_id)
         return response.content
     except requests.exceptions.RequestException as e:
-        add_log(f"Error generating image: {str(e)}")
+        add_log(f"Error generating image: {str(e)}", session_id)
         return None
 
-def markdown_to_pptx(md_text):
-    add_log("Starting PowerPoint generation...")
+def markdown_to_pptx(md_text, session_id):
+    add_log("Starting PowerPoint generation...", session_id)
     prs = Presentation()
     slides = re.split(r'# Slide \d+:', md_text)
     slides = [slide.strip() for slide in slides if slide.strip()]
     with ThreadPoolExecutor() as executor:
         futures = []
         for i, slide_content in enumerate(slides):
-            add_log(f"Processing slide {i+1}/{len(slides)}...")
-            image_prompt = generate_image_prompt(slide_content)
-            futures.append(executor.submit(generate_image, image_prompt))
+            add_log(f"Processing slide {i+1}/{len(slides)}...", session_id)
+            image_prompt = generate_image_prompt(slide_content, session_id)
+            futures.append(executor.submit(generate_image, image_prompt, session_id))
         for i, (slide_content, future) in enumerate(zip(slides, futures)):
-            add_log(f"Creating slide {i+1}/{len(slides)}...")
+            add_log(f"Creating slide {i+1}/{len(slides)}...", session_id)
             lines = slide_content.split('\n')
             title = lines[0].strip()
             current_slide = prs.slides.add_slide(prs.slide_layouts[6])
@@ -178,7 +225,7 @@ def markdown_to_pptx(md_text):
                     p.font.size = Pt(18)
                     p.level = 1
                     p.bullet = True
-            add_log(f"Adding image to slide {i+1}...")
+            add_log(f"Adding image to slide {i+1}...", session_id)
             image_data = future.result()
             if image_data:
                 image_stream = io.BytesIO(image_data)
@@ -188,20 +235,35 @@ def markdown_to_pptx(md_text):
                     img_width = Inches(4)
                     img_height = img_width / aspect_ratio
                     current_slide.shapes.add_picture(image_stream, Inches(5.5), Inches(1.5), width=img_width, height=img_height)
-                    add_log(f"Image added successfully to slide {i+1}.")
+                    add_log(f"Image added successfully to slide {i+1}.", session_id)
                 except Exception as e:
-                    add_log(f"Error adding image to slide {i+1}: {str(e)}")
+                    add_log(f"Error adding image to slide {i+1}: {str(e)}", session_id)
                     placeholder = current_slide.shapes.add_textbox(Inches(5.5), Inches(1.5), Inches(4), Inches(6))
                     placeholder.text_frame.text = "Image addition failed"
             else:
-                add_log(f"Failed to generate image for slide {i+1}: {title}")
+                add_log(f"Failed to generate image for slide {i+1}: {title}", session_id)
                 placeholder = current_slide.shapes.add_textbox(Inches(5.5), Inches(1.5), Inches(4), Inches(6))
                 placeholder.text_frame.text = "Image generation failed"
-    add_log("PowerPoint generation completed.")
+    add_log("PowerPoint generation completed.", session_id)
     output = io.BytesIO()
     prs.save(output)
     return output.getvalue()
 
+@app.callback(
+    Output('session-id', 'data'),
+    Input('interval-component', 'n_intervals')
+)
+def store_session_id(n_intervals):
+    # Get from browser localStorage via JS (see layout). This value is available clientside.
+    # Dash will update session-id dcc.Store once on page load.
+    import flask
+    cookies = flask.request.cookies
+    session_id = cookies.get('dash-session-id')
+    if not session_id:
+        # Should not happen, JS sets cookie, but fallback for safety
+        session_id = str(uuid.uuid4())
+    return session_id
+
 @app.callback(
     Output('upload-file-name', 'children'),
     Input('upload-file', 'filename')
@@ -216,11 +278,14 @@ def update_filename(filename):
     Output('download-ppt-button', 'disabled'),
     Input('generate-button', 'n_clicks'),
     State('upload-file', 'contents'),
-    State('document-text', 'value')
+    State('document-text', 'value'),
+    State('session-id', 'data')
 )
-def generate_slides(n_clicks, file_contents, document_text):
+def generate_slides(n_clicks, file_contents, document_text, session_id):
     if n_clicks is None:
         raise PreventUpdate
+    if not session_id:
+        raise PreventUpdate
     decoded_file_text = None
     if file_contents:
         content_type, content_string = file_contents.split(',')
@@ -232,7 +297,6 @@ def generate_slides(n_clicks, file_contents, document_text):
                 decoded_file_text = decoded.decode('latin-1')
             except Exception:
                 return "Could not decode uploaded file as text. Please upload a UTF-8 or Latin-1 encoded text file.", True
-    # Combine both file and text if both are present
     combined_text = ""
     if decoded_file_text and document_text:
         combined_text = decoded_file_text.strip() + "\n\n" + document_text.strip()
@@ -244,12 +308,12 @@ def generate_slides(n_clicks, file_contents, document_text):
         return "Please upload a file or enter text.", True
 
     try:
-        add_log("Starting slide generation...")
-        slides_markdown = process_document(combined_text)
-        add_log("Slide generation completed.")
+        add_log("Starting slide generation...", session_id)
+        slides_markdown = process_document(combined_text, session_id)
+        add_log("Slide generation completed.", session_id)
         return slides_markdown, False
     except Exception as e:
-        add_log(f"An error occurred during slide generation: {str(e)}")
+        add_log(f"An error occurred during slide generation: {str(e)}", session_id)
         return f"An error occurred: {str(e)}", True
 
 @app.callback(
@@ -257,41 +321,54 @@ def generate_slides(n_clicks, file_contents, document_text):
     Output('download-ppt-button', 'disabled', allow_duplicate=True),
     Input('generate-ppt-button', 'n_clicks'),
     State('slides-content', 'value'),
+    State('session-id', 'data'),
     prevent_initial_call=True
 )
-def generate_powerpoint(n_clicks, slides_content):
-    global generated_pptx
-    if n_clicks is None or not slides_content:
+def generate_powerpoint(n_clicks, slides_content, session_id):
+    if n_clicks is None or not slides_content or not session_id:
         raise PreventUpdate
-    try:
-        add_log("Starting PowerPoint generation...")
-        generated_pptx = markdown_to_pptx(slides_content)
-        add_log("PowerPoint generation completed.")
-        return '\n'.join(log_messages[:100]), False
-    except Exception as e:
-        error_message = f"An error occurred during PowerPoint generation: {str(e)}"
-        add_log(error_message)
-        return '\n'.join(log_messages[:100]), True
+    session = get_or_create_session_data(session_id)
+    with session['lock']:
+        try:
+            add_log("Starting PowerPoint generation...", session_id)
+            pptx_bytes = markdown_to_pptx(slides_content, session_id)
+            session['generated_pptx'] = pptx_bytes
+            add_log("PowerPoint generation completed.", session_id)
+            return '\n'.join(session['log_messages'][:100]), False
+        except Exception as e:
+            error_message = f"An error occurred during PowerPoint generation: {str(e)}"
+            add_log(error_message, session_id)
+            return '\n'.join(session['log_messages'][:100]), True
 
 @app.callback(
     Output("download-pptx", "data"),
     Input('download-ppt-button', 'n_clicks'),
+    State('session-id', 'data'),
     prevent_initial_call=True
 )
-def download_powerpoint(n_clicks):
-    if n_clicks is None or generated_pptx is None:
+def download_powerpoint(n_clicks, session_id):
+    if n_clicks is None or not session_id:
         raise PreventUpdate
-    return dcc.send_bytes(generated_pptx, "presentation.pptx")
+    session = get_or_create_session_data(session_id)
+    with session['lock']:
+        if session['generated_pptx'] is None:
+            raise PreventUpdate
+        return dcc.send_bytes(session['generated_pptx'], "presentation.pptx")
 
 @app.callback(
     Output('log-output', 'children', allow_duplicate=True),
     Input('interval-component', 'n_intervals'),
+    State('session-id', 'data'),
     prevent_initial_call=True
 )
-def update_logs(n_intervals):
-    return '\n'.join(log_messages[:100])
+def update_logs(n_intervals, session_id):
+    if not session_id:
+        return ""
+    session = get_or_create_session_data(session_id)
+    with session['lock']:
+        return '\n'.join(session['log_messages'][:100])
 
 if __name__ == '__main__':
     print("Starting the Dash application...")
-    app.run(debug=True, host='0.0.0.0', port=7860)
+    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)
     print("Dash application has finished running.")