Update app.py via AI Editor

app.py

@@ -1,5 +1,5 @@
 import dash
-from dash import dcc, html, Input, Output, State, callback
+from dash import dcc, html, Input, Output, State, callback, ALL
 import dash_bootstrap_components as dbc
 import base64
 import io
@@ -7,18 +7,59 @@ import pandas as pd
 import openai
 import os
 import time
+import uuid
+import threading
+import tempfile
+import shutil
+import logging
+from flask import request
 from dash.exceptions import PreventUpdate
 import PyPDF2
 import docx
 import chardet
 
+# --- Logging Setup ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("maiko_matrix_app")
+
+# --- App and Session Setup ---
 app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
 
 openai.api_key = os.environ.get('OPENAI_API_KEY')
 
-uploaded_files = {}
-current_matrix = None
-matrix_type = None
+# Session management globals
+SESSION_DATA = {}
+SESSION_LOCKS = {}
+
+def get_session_id():
+    if 'session-id' in request.cookies:
+        return request.cookies['session-id']
+    # Generate new session id (uuid4) if not present
+    session_id = str(uuid.uuid4())
+    logger.info(f"Generated new session id: {session_id}")
+    return session_id
+
+def get_session_data():
+    session_id = get_session_id()
+    if session_id not in SESSION_DATA:
+        SESSION_DATA[session_id] = {
+            'uploaded_files': {},  # filename -> temp file path
+            'file_texts': {},      # filename -> extracted text
+            'current_matrix': None,
+            'matrix_type': None,
+            'temp_dir': tempfile.mkdtemp(prefix=f"maiko_{session_id}_"),
+        }
+        SESSION_LOCKS[session_id] = threading.Lock()
+    return SESSION_DATA[session_id], SESSION_LOCKS[session_id]
+
+def cleanup_session_tempdirs():
+    # Called optionally on server shutdown for cleanup
+    for sess in SESSION_DATA.values():
+        try:
+            shutil.rmtree(sess['temp_dir'])
+        except Exception as e:
+            logger.warning(f"Failed to cleanup tempdir: {e}")
 
 matrix_types = {
     "Project Deliverables Matrix": "Generate a project deliverables matrix all presumed and actual deliverables based on tasks, requirements and scope.",
@@ -40,73 +81,101 @@ matrix_types = {
     "SWOT Matrix": "Create a matrix analyzing Strengths, Weaknesses, Opportunities, and Threats."
 }
 
+# --- UI Layout ---
 app.layout = dbc.Container([
     dbc.Row([
         dbc.Col([
-            html.H4("Project Artifacts", className="mt-3 mb-4"),
-            dcc.Upload(
-                id='upload-files',
-                children=html.Div([
-                    'Drag and Drop or ',
-                    html.A('Select Files')
-                ]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px 0'
-                },
-                multiple=True
-            ),
-            html.Div(id='file-list'),
-            html.Hr(),
-            html.Div([
-                dbc.Button(
-                    matrix_type,
-                    id=f'btn-{matrix_type.lower().replace(" ", "-")}',
-                    color="link",
-                    className="mb-2 w-100 text-left custom-button",
-                    style={'overflow': 'hidden', 'text-overflow': 'ellipsis', 'white-space': 'nowrap'}
-                ) for matrix_type in matrix_types.keys()
-            ])
-        ], width=3),
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("Project Artifacts", className="mb-3 mt-1"),
+                    dcc.Upload(
+                        id='upload-files',
+                        children=html.Div([
+                            'Drag and Drop or ',
+                            html.A('Select Files')
+                        ]),
+                        style={
+                            'width': '100%',
+                            'height': '60px',
+                            'lineHeight': '60px',
+                            'borderWidth': '1px',
+                            'borderStyle': 'dashed',
+                            'borderRadius': '5px',
+                            'textAlign': 'center',
+                            'margin': '10px 0'
+                        },
+                        multiple=True
+                    ),
+                    html.Div(id='file-list'),
+                    html.Hr(),
+                    html.Div([
+                        dbc.Button(
+                            matrix_label,
+                            id={'type': 'matrix-btn', 'index': matrix_label},
+                            color="link",
+                            className="mb-2 w-100 text-left custom-button",
+                            style={'overflow': 'hidden', 'text-overflow': 'ellipsis', 'white-space': 'nowrap'}
+                        ) for matrix_label in matrix_types.keys()
+                    ])
+                ])
+            ], className="mb-2")
+        ], width=3, style={'minWidth': '260px', 'background': '#f8f9fa', 'height': '100vh', 'position': 'fixed', 'overflowY': 'auto'}),
         dbc.Col([
-            html.Div(style={"height": "20px"}),
-            dcc.Loading(
-                id="loading-indicator",
-                type="dot",
-                children=[html.Div(id="loading-output")]
-            ),
-            html.Div(id='matrix-preview', className="border p-3 mb-3"),
-            dbc.Button("Download Matrix", id="btn-download", color="success", className="mt-3"),
-            dcc.Download(id="download-matrix"),
+            dbc.Row([
+                dbc.Col([
+                    html.H2("Maiko Project Matrix Generator", className="mb-3 mt-2")
+                ])
+            ]),
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            dcc.Loading(
+                                id="loading",
+                                type="default",
+                                children=[
+                                    html.Div(id="loading-output"),
+                                    html.Div(id='matrix-preview', className="border p-3 mb-3"),
+                                    dbc.Button("Download Matrix", id="btn-download", color="success", className="mt-3"),
+                                    dcc.Download(id="download-matrix"),
+                                ]
+                            )
+                        ])
+                    ])
+                ])
+            ]),
             html.Hr(),
-            html.Div(style={"height": "20px"}),
-            dcc.Loading(
-                id="chat-loading",
-                type="dot",
-                children=[
-                    dbc.Input(id="chat-input", type="text", placeholder="Chat with Maiko to update matrix...", className="mb-2"),
-                    dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3"),
-                    html.Div(id="chat-output")
-                ]
-            )
-        ], width=9)
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            dcc.Loading(
+                                id="chat-loading",
+                                type="default",
+                                children=[
+                                    dbc.Textarea(id="chat-input", placeholder="Chat with Maiko to update matrix...", className="mb-2", style={'width': '100%', 'wordWrap': 'break-word'}),
+                                    dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3"),
+                                    html.Div(id="chat-output")
+                                ]
+                            )
+                        ])
+                    ])
+                ])
+            ])
+        ], width=9, style={'marginLeft': '30%'})
     ])
-], fluid=True)
+], fluid=True, style={'padding': '0'})
 
-def parse_file_content(contents, filename):
-    content_type, content_string = contents.split(',')
-    decoded = base64.b64decode(content_string)
+
+# --- File Parsing ---
+def parse_file_content(file_path, filename):
     try:
+        with open(file_path, "rb") as f:
+            decoded = f.read()
         if filename.endswith('.pdf'):
             with io.BytesIO(decoded) as pdf_file:
                 reader = PyPDF2.PdfReader(pdf_file)
-                return ' '.join([page.extract_text() for page in reader.pages])
+                return ' '.join([page.extract_text() or "" for page in reader.pages])
         elif filename.endswith('.docx'):
             with io.BytesIO(decoded) as docx_file:
                 doc = docx.Document(docx_file)
@@ -117,7 +186,7 @@ def parse_file_content(contents, filename):
         else:
             return "Unsupported file format"
     except Exception as e:
-        print(f"Error processing file {filename}: {str(e)}")
+        logger.exception(f"Error processing file {filename}: {str(e)}")
         return "Error processing file"
 
 def truncate_filename(filename, max_length=24):
@@ -126,102 +195,137 @@ def truncate_filename(filename, max_length=24):
     else:
         return filename[:max_length - 3] + '...'
 
+def get_file_cards(file_dict):
+    cards = []
+    for name in file_dict:
+        cards.append(
+            dbc.Card(
+                dbc.CardBody(
+                    dbc.Row([
+                        dbc.Col(
+                            html.Span(
+                                truncate_filename(name),
+                                title=name,
+                                style={
+                                    'display': 'inline-block',
+                                    'overflow': 'hidden',
+                                    'textOverflow': 'ellipsis',
+                                    'whiteSpace': 'nowrap',
+                                    'maxWidth': '90%',
+                                    'verticalAlign': 'middle',
+                                }
+                            ),
+                            width='auto',
+                            style={'display': 'flex', 'alignItems': 'center', 'padding': '0'}
+                        ),
+                        dbc.Col(
+                            dbc.Button(
+                                "Delete",
+                                id={'type': 'remove-file', 'index': name},
+                                color="danger",
+                                size="sm",
+                                style={'marginLeft': 'auto', 'float': 'right'}
+                            ),
+                            width='auto',
+                            style={'display': 'flex', 'alignItems': 'center', 'justifyContent': 'flex-end', 'padding': '0'}
+                        ),
+                    ],
+                    justify="between",
+                    align="center",
+                    style={"margin": "0", "padding": "0"}
+                    ),
+                    style={'padding': '6px 8px', 'margin': '0', 'display': 'flex', 'alignItems': 'center', 'background': 'none', 'boxShadow': 'none'}
+                ),
+                style={'border': 'none', 'boxShadow': 'none', 'background': 'none', 'marginBottom': '2px'}
+            )
+        )
+    return cards
+
+# --- Callbacks ---
+
 @app.callback(
     Output('file-list', 'children'),
     Input('upload-files', 'contents'),
     State('upload-files', 'filename'),
-    State('file-list', 'children')
+    prevent_initial_call=True
 )
-def update_output(list_of_contents, list_of_names, existing_files):
-    global uploaded_files
+def update_output(list_of_contents, list_of_names):
+    session_data, lock = get_session_data()
+    logger.info("Uploading files...")
     if list_of_contents is not None:
-        new_files = []
-        for i, (content, name) in enumerate(zip(list_of_contents, list_of_names)):
-            file_content = parse_file_content(content, name)
-            uploaded_files[name] = file_content
-            new_files.append(
-                dbc.Card(
-                    dbc.CardBody(
-                        dbc.Row([
-                            dbc.Col(
-                                html.Span(
-                                    truncate_filename(name),
-                                    title=name,
-                                    style={
-                                        'display': 'inline-block',
-                                        'overflow': 'hidden',
-                                        'textOverflow': 'ellipsis',
-                                        'whiteSpace': 'nowrap',
-                                        'maxWidth': '90%',
-                                        'verticalAlign': 'middle',
-                                    }
-                                ),
-                                width='auto',
-                                style={'display': 'flex', 'alignItems': 'center', 'padding': '0'}
-                            ),
-                            dbc.Col(
-                                dbc.Button(
-                                    "Delete",
-                                    id={'type': 'remove-file', 'index': name},
-                                    color="danger",
-                                    size="sm",
-                                    style={'marginLeft': 'auto', 'float': 'right'}
-                                ),
-                                width='auto',
-                                style={'display': 'flex', 'alignItems': 'center', 'justifyContent': 'flex-end', 'padding': '0'}
-                            ),
-                        ],
-                        justify="between",
-                        align="center",
-                        style={"margin": "0", "padding": "0"}
-                        ),
-                        style={'padding': '6px 8px', 'margin': '0', 'display': 'flex', 'alignItems': 'center', 'background': 'none', 'boxShadow': 'none'}
-                    ),
-                    style={'border': 'none', 'boxShadow': 'none', 'background': 'none', 'marginBottom': '2px'}
-                )
-            )
-        if existing_files is None:
-            existing_files = []
-        return existing_files + new_files
-    return existing_files
+        with lock:
+            for content, name in zip(list_of_contents, list_of_names):
+                content_type, content_string = content.split(',')
+                decoded = base64.b64decode(content_string)
+                temp_path = os.path.join(session_data['temp_dir'], name)
+                with open(temp_path, 'wb') as f:
+                    f.write(decoded)
+                session_data['uploaded_files'][name] = temp_path
+                session_data['file_texts'][name] = parse_file_content(temp_path, name)
+            logger.info(f"Files after upload: {list(session_data['uploaded_files'].keys())}")
+        return get_file_cards(session_data['uploaded_files'])
+    raise PreventUpdate
 
 @app.callback(
     Output('file-list', 'children', allow_duplicate=True),
-    Input({'type': 'remove-file', 'index': dash.ALL}, 'n_clicks'),
+    Input({'type': 'remove-file', 'index': ALL}, 'n_clicks'),
     State('file-list', 'children'),
     prevent_initial_call=True
 )
-def remove_file(n_clicks, existing_files):
-    global uploaded_files
+def remove_file(n_clicks, existing_cards):
+    session_data, lock = get_session_data()
     ctx = dash.callback_context
     if not ctx.triggered:
         raise PreventUpdate
-    # Find which button was pressed
     triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
-    # triggered_id is a dict-like string, e.g. "{'type':'remove-file','index':'filename'}"
-    # Safely eval to dict (since dash handles this)
     import ast
     try:
         triggered_id_dict = ast.literal_eval(triggered_id)
         removed_file = triggered_id_dict['index']
     except Exception:
         raise PreventUpdate
-    uploaded_files.pop(removed_file, None)
-    # Filter out the file that was removed
-    filtered_files = []
-    for file_card in existing_files:
-        # file_card is a dict representing a dbc.Card
-        # Traverse to get filename from card body
+    with lock:
+        if removed_file in session_data['uploaded_files']:
+            try:
+                os.remove(session_data['uploaded_files'][removed_file])
+            except Exception as e:
+                logger.warning(f"Failed to delete temp file {removed_file}: {e}")
+            session_data['uploaded_files'].pop(removed_file, None)
+            session_data['file_texts'].pop(removed_file, None)
+        logger.info(f"Files after deletion: {list(session_data['uploaded_files'].keys())}")
+    return get_file_cards(session_data['uploaded_files'])
+
+@app.callback(
+    Output('matrix-preview', 'children'),
+    Output('loading-output', 'children'),
+    [Input({'type': 'matrix-btn', 'index': matrix_label}, 'n_clicks') for matrix_label in matrix_types.keys()],
+    prevent_initial_call=True
+)
+def generate_matrix(*args):
+    session_data, lock = get_session_data()
+    ctx = dash.callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
+    import ast
+    try:
+        triggered = ast.literal_eval(button_id)
+        matrix_type = triggered['index']
+    except Exception:
+        raise PreventUpdate
+
+    if not session_data['uploaded_files']:
+        return html.Div("Please upload project artifacts before generating a matrix."), ""
+    file_contents = list(session_data['file_texts'].values())
+    with lock:
         try:
-            # Card > CardBody > Row > [Col, Col] > Col[0] > Span
-            filename_span = file_card['props']['children']['props']['children'][0]['props']['children'][0]['props']['children']
-            # The span text is truncated; check its title for the full name
-            span_title = file_card['props']['children']['props']['children'][0]['props']['children'][0]['props']['title']
-            if span_title != removed_file:
-                filtered_files.append(file_card)
-        except Exception:
-            filtered_files.append(file_card)
-    return filtered_files
+            session_data['matrix_type'] = matrix_type
+            session_data['current_matrix'] = generate_matrix_with_gpt(matrix_type, file_contents)
+            logger.info(f"{matrix_type} generated for session.")
+            return dbc.Table.from_dataframe(session_data['current_matrix'], striped=True, bordered=True, hover=True), f"{matrix_type} generated"
+        except Exception as e:
+            logger.exception(f"Error generating matrix: {str(e)}")
+            return html.Div(f"Error generating matrix: {str(e)}"), "Error"
 
 def generate_matrix_with_gpt(matrix_type, file_contents):
     prompt = f"""Generate a {matrix_type} based on the following project artifacts:
@@ -240,53 +344,22 @@ Item1A|Item1B|Item1C
 Item2A|Item2B|Item2C
 Now, generate the {matrix_type}:
 """
-
     response = openai.ChatCompletion.create(
         model="gpt-4-turbo",
         messages=[
-            {"role": "system", "content": "You are a precise matrix generator that outputs only the requested matrix without any additional text. Based on the files uploaded, as the project manager you perform the analysis and make appropriate assumptions to populate the matrix like roles, tasks, timelines, logically squencing the matrix etc."},
+            {"role": "system", "content": "You are a precise matrix generator that outputs only the requested matrix without any additional text. Based on the files uploaded, as the project manager you perform the analysis and make appropriate assumptions to populate the matrix like roles, tasks, timelines, logically sequencing the matrix etc."},
             {"role": "user", "content": prompt}
         ]
     )
-
     matrix_text = response.choices[0].message.content.strip()
-    print("Raw matrix text from GPT:", matrix_text)
-
+    logger.info(f"Raw matrix text from GPT: {matrix_text[:200]}...")  # log only first 200 chars
     lines = [line.strip() for line in matrix_text.split('\n') if '|' in line]
     data = [line.split('|') for line in lines]
     data = [[cell.strip() for cell in row] for row in data]
-
     headers = data[0]
     data = data[1:]
-
     return pd.DataFrame(data, columns=headers)
 
-@app.callback(
-    Output('matrix-preview', 'children'),
-    Output('loading-output', 'children'),
-    [Input(f'btn-{matrix_type.lower().replace(" ", "-")}', 'n_clicks') for matrix_type in matrix_types.keys()],
-    prevent_initial_call=True
-)
-def generate_matrix(*args):
-    global current_matrix, matrix_type
-    ctx = dash.callback_context
-    if not ctx.triggered:
-        raise PreventUpdate
-    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
-    matrix_type = button_id.replace('btn-', '').replace('-', ' ').title()
-    
-    if not uploaded_files:
-        return html.Div("Please upload project artifacts before generating a matrix."), ""
-
-    file_contents = list(uploaded_files.values())
-    
-    try:
-        current_matrix = generate_matrix_with_gpt(matrix_type, file_contents)
-        return dbc.Table.from_dataframe(current_matrix, striped=True, bordered=True, hover=True), f"{matrix_type} generated"
-    except Exception as e:
-        print(f"Error generating matrix: {str(e)}")
-        return html.Div(f"Error generating matrix: {str(e)}"), "Error"
-
 @app.callback(
     Output('chat-output', 'children'),
     Output('matrix-preview', 'children', allow_duplicate=True),
@@ -295,13 +368,14 @@ def generate_matrix(*args):
     prevent_initial_call=True
 )
 def update_matrix_via_chat(n_clicks, chat_input):
-    global current_matrix, matrix_type
-    if not chat_input or current_matrix is None:
+    session_data, lock = get_session_data()
+    if not chat_input or session_data['current_matrix'] is None or session_data['matrix_type'] is None:
         raise PreventUpdate
-    
-    prompt = f"""Update the following {matrix_type} based on this instruction: {chat_input}
+    matrix_type = session_data['matrix_type']
+    with lock:
+        prompt = f"""Update the following {matrix_type} based on this instruction: {chat_input}
 Current matrix:
-{current_matrix.to_string(index=False)}
+{session_data['current_matrix'].to_string(index=False)}
 Instructions:
 1. Provide ONLY the updated matrix as a table.
 2. Use ONLY pipe symbols (|) to separate columns.
@@ -312,46 +386,39 @@ Instructions:
 7. Each subsequent row should represent a single item in the matrix.
 Now, provide the updated {matrix_type}:
 """
-    
-    response = openai.ChatCompletion.create(
-        model="gpt-4-turbo",
-        messages=[
-            {"role": "system", "content": "You are a precise matrix updater that outputs only the requested matrix without any additional text. You will make assumptions as a project manager to produce the matrix based on the limited informaton provided"},
-            {"role": "user", "content": prompt}
-        ]
-    )
-
-    updated_matrix_text = response.choices[0].message.content.strip()
-    print("Raw updated matrix text from GPT:", updated_matrix_text)
-
-    lines = [line.strip() for line in updated_matrix_text.split('\n') if '|' in line]
-    data = [line.split('|') for line in lines]
-    data = [[cell.strip() for cell in row] for row in data]
-
-    headers = data[0]
-    data = data[1:]
+        response = openai.ChatCompletion.create(
+            model="gpt-4-turbo",
+            messages=[
+                {"role": "system", "content": "You are a precise matrix updater that outputs only the requested matrix without any additional text. You will make assumptions as a project manager to produce the matrix based on the limited information provided"},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        updated_matrix_text = response.choices[0].message.content.strip()
+        logger.info(f"Raw updated matrix text from GPT: {updated_matrix_text[:200]}...")
+        lines = [line.strip() for line in updated_matrix_text.split('\n') if '|' in line]
+        data = [line.split('|') for line in lines]
+        data = [[cell.strip() for cell in row] for row in data]
+        headers = data[0]
+        data = data[1:]
+        session_data['current_matrix'] = pd.DataFrame(data, columns=headers)
+        return f"Matrix updated based on: {chat_input}", dbc.Table.from_dataframe(session_data['current_matrix'], striped=True, bordered=True, hover=True)
 
-    current_matrix = pd.DataFrame(data, columns=headers)
-    
-    return f"Matrix updated based on: {chat_input}", dbc.Table.from_dataframe(current_matrix, striped=True, bordered=True, hover=True)
-    
 @app.callback(
     Output("download-matrix", "data"),
     Input("btn-download", "n_clicks"),
     prevent_initial_call=True
 )
 def download_matrix(n_clicks):
-    global current_matrix, matrix_type
-    if current_matrix is None:
+    session_data, lock = get_session_data()
+    if session_data['current_matrix'] is None or session_data['matrix_type'] is None:
         raise PreventUpdate
-    
     output = io.BytesIO()
     with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
-        current_matrix.to_excel(writer, sheet_name='Sheet1', index=False)
-    
-    return dcc.send_bytes(output.getvalue(), f"{matrix_type}.xlsx")
+        session_data['current_matrix'].to_excel(writer, sheet_name='Sheet1', index=False)
+    logger.info(f"Matrix downloaded: {session_data['matrix_type']}")
+    return dcc.send_bytes(output.getvalue(), f"{session_data['matrix_type']}.xlsx")
 
 if __name__ == '__main__':
     print("Starting the Dash application...")
-    app.run(debug=False, 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.")