Update app.py via AI Editor

app.py

@@ -452,92 +452,141 @@ def update_right_col(selected_type, shred_doc, pink_doc, pink_review_doc, red_do
 @app.callback(
     Output('file-list', 'children'),
     Output('store-shred', 'data'),
+    Output({'type': f'uploaded-doc-name-shred', 'index': ALL}, 'children'),
+    Output({'type': f'uploaded-doc-name-pink', 'index': ALL}, 'children'),
+    Output({'type': f'uploaded-doc-name-pink_review', 'index': ALL}, 'children'),
+    Output({'type': f'uploaded-doc-name-red', 'index': ALL}, 'children'),
+    Output({'type': f'uploaded-doc-name-red_review', 'index': ALL}, 'children'),
+    Output({'type': f'uploaded-doc-name-gold', 'index': ALL}, 'children'),
+    Output({'type': f'upload-doc-type-shred', 'index': ALL}, 'contents'),
+    Output({'type': f'upload-doc-type-pink', 'index': ALL}, 'contents'),
+    Output({'type': f'upload-doc-type-pink_review', 'index': ALL}, 'contents'),
+    Output({'type': f'upload-doc-type-red', 'index': ALL}, 'contents'),
+    Output({'type': f'upload-doc-type-red_review', 'index': ALL}, 'contents'),
+    Output({'type': f'upload-doc-type-gold', 'index': ALL}, 'contents'),
+    Output({'type': f'radio-doc-source-shred', 'index': ALL}, 'value'),
+    Output({'type': f'radio-doc-source-pink', 'index': ALL}, 'value'),
+    Output({'type': f'radio-doc-source-pink_review', 'index': ALL}, 'value'),
+    Output({'type': f'radio-doc-source-red', 'index': ALL}, 'value'),
+    Output({'type': f'radio-doc-source-red_review', 'index': ALL}, 'value'),
+    Output({'type': f'radio-doc-source-gold', 'index': ALL}, 'value'),
     Input('upload-document', 'contents'),
     State('upload-document', 'filename'),
     State('file-list', 'children'),
-    State('store-shred', 'data')
-)
-def update_output(list_of_contents, list_of_names, existing_files, current_shred):
-    global uploaded_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 = process_document(content, name)
-            uploaded_files[name] = file_content
-            new_files.append(
-                dbc.Row([
-                    dbc.Col(
-                        html.Button('×', id={'type': 'remove-file', 'index': name}, style={'marginRight': '5px', 'fontSize': '10px'}),
-                        width=1
-                    ),
-                    dbc.Col(
-                        html.Span(name, style={'wordBreak': 'break-all'}),
-                        width=11
-                    )
-                ], id={'type': 'file-row', 'index': name}, align="center", className="mb-1")
-            )
-        if existing_files is None:
-            existing_files = []
-        elif not isinstance(existing_files, list):
-            existing_files = [existing_files]
-        logging.info("Documents uploaded and file list updated.")
-        return existing_files + new_files, current_shred
-    return existing_files, current_shred
-
-@app.callback(
-    Output('file-list', 'children'),
-    Output('store-shred', 'data'),
+    State('store-shred', 'data'),
     Input({'type': 'remove-file', 'index': ALL}, 'n_clicks'),
     State('file-list', 'children'),
     State('store-shred', 'data'),
+    Input({'type': f'upload-doc-type-shred', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-shred', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-shred', 'index': ALL}, 'id'),
+    Input({'type': f'upload-doc-type-pink', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-pink', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-pink', 'index': ALL}, 'id'),
+    Input({'type': f'upload-doc-type-pink_review', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-pink_review', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-pink_review', 'index': ALL}, 'id'),
+    Input({'type': f'upload-doc-type-red', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-red', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-red', 'index': ALL}, 'id'),
+    Input({'type': f'upload-doc-type-red_review', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-red_review', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-red_review', 'index': ALL}, 'id'),
+    Input({'type': f'upload-doc-type-gold', 'index': ALL}, 'contents'),
+    State({'type': f'upload-doc-type-gold', 'index': ALL}, 'filename'),
+    State({'type': f'upload-doc-type-gold', 'index': ALL}, 'id'),
     prevent_initial_call=True
 )
-def remove_file(n_clicks, existing_files, current_shred):
-    global uploaded_files
-    ctx = dash.callback_context
-    if not ctx.triggered:
-        raise dash.exceptions.PreventUpdate
-    triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
-    if not triggered_id.startswith("{\"type\":\"remove-file\""):
-        raise dash.exceptions.PreventUpdate
-    try:
-        import json
-        triggered_dict = json.loads(triggered_id)
-        removed_file = triggered_dict['index']
-    except Exception as e:
-        logging.error(f"Could not parse removed file from callback context: {e}")
-        raise dash.exceptions.PreventUpdate
-    uploaded_files.pop(removed_file, None)
-    logging.info(f"Removed file: {removed_file}")
-    filtered_files = []
-    if existing_files:
-        for file in existing_files:
-            try:
-                file_id = file['props']['id']
-                if file_id['index'] != removed_file:
+def combined_upload_remove_update(
+    upload_contents, upload_filenames, existing_files, current_shred,
+    remove_n_clicks, remove_existing_files, remove_current_shred,
+    upload_shred_contents, upload_shred_filenames, upload_shred_ids,
+    upload_pink_contents, upload_pink_filenames, upload_pink_ids,
+    upload_pink_review_contents, upload_pink_review_filenames, upload_pink_review_ids,
+    upload_red_contents, upload_red_filenames, upload_red_ids,
+    upload_red_review_contents, upload_red_review_filenames, upload_red_review_ids,
+    upload_gold_contents, upload_gold_filenames, upload_gold_ids
+):
+    global uploaded_files, uploaded_doc_contents
+    ctx = callback_context
+    outputs = [dash.no_update]*21
+
+    # Handle Shred upload
+    if ctx.triggered and ctx.triggered[0]['prop_id'].startswith('upload-document'):
+        new_files = []
+        if upload_contents is not None:
+            for i, (content, name) in enumerate(zip(upload_contents, upload_filenames)):
+                file_content = process_document(content, name)
+                uploaded_files[name] = file_content
+                new_files.append(
+                    dbc.Row([
+                        dbc.Col(
+                            html.Button('×', id={'type': 'remove-file', 'index': name}, style={'marginRight': '5px', 'fontSize': '10px'}),
+                            width=1
+                        ),
+                        dbc.Col(
+                            html.Span(name, style={'wordBreak': 'break-all'}),
+                            width=11
+                        )
+                    ], id={'type': 'file-row', 'index': name}, align="center", className="mb-1")
+                )
+            if existing_files is None:
+                existing_files = []
+            elif not isinstance(existing_files, list):
+                existing_files = [existing_files]
+            logging.info("Documents uploaded and file list updated.")
+            outputs[0] = existing_files + new_files
+            outputs[1] = current_shred
+        return outputs
+
+    # Handle file removal
+    if ctx.triggered and ctx.triggered[0]['prop_id'].startswith("{\"type\":\"remove-file\""):
+        try:
+            import json
+            triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
+            triggered_dict = json.loads(triggered_id)
+            removed_file = triggered_dict['index']
+        except Exception as e:
+            logging.error(f"Could not parse removed file from callback context: {e}")
+            outputs[0] = remove_existing_files
+            outputs[1] = remove_current_shred
+            return outputs
+        uploaded_files.pop(removed_file, None)
+        logging.info(f"Removed file: {removed_file}")
+        filtered_files = []
+        if remove_existing_files:
+            for file in remove_existing_files:
+                try:
+                    file_id = file['props']['id']
+                    if file_id['index'] != removed_file:
+                        filtered_files.append(file)
+                except Exception as e:
                     filtered_files.append(file)
-            except Exception as e:
-                filtered_files.append(file)
-    return filtered_files, current_shred
-
-def make_upload_callback(src):
-    @app.callback(
-        Output({'type': f'uploaded-doc-name-{src}', 'index': MATCH}, 'children'),
-        Output({'type': f'upload-doc-type-{src}', 'index': MATCH}, 'contents'),
-        Output({'type': f'radio-doc-source-{src}', 'index': MATCH}, 'value'),
-        Input({'type': f'upload-doc-type-{src}', 'index': MATCH}, 'contents'),
-        State({'type': f'upload-doc-type-{src}', 'index': MATCH}, 'filename'),
-        State({'type': f'upload-doc-type-{src}', 'index': MATCH}, 'id')
-    )
-    def update_uploaded_doc_name(contents, filename, id_dict):
-        global uploaded_doc_contents
-        if contents is not None:
-            uploaded_doc_contents[(src, id_dict['index'])] = (contents, filename)
-            logging.info(f"{id_dict['index']} {src} file uploaded: {filename}")
-            return filename, contents, "uploaded"
-        return "", None, "loaded"
-for src in ["shred", "pink", "pink_review", "red", "red_review", "gold"]:
-    make_upload_callback(src)
+        outputs[0] = filtered_files
+        outputs[1] = remove_current_shred
+        return outputs
+
+    # Handle all doc-type uploads
+    doc_upload_types = [
+        ("shred", upload_shred_contents, upload_shred_filenames, upload_shred_ids, 2, 8, 14),
+        ("pink", upload_pink_contents, upload_pink_filenames, upload_pink_ids, 3, 9, 15),
+        ("pink_review", upload_pink_review_contents, upload_pink_review_filenames, upload_pink_review_ids, 4, 10, 16),
+        ("red", upload_red_contents, upload_red_filenames, upload_red_ids, 5, 11, 17),
+        ("red_review", upload_red_review_contents, upload_red_review_filenames, upload_red_review_ids, 6, 12, 18),
+        ("gold", upload_gold_contents, upload_gold_filenames, upload_gold_ids, 7, 13, 19)
+    ]
+    for src, contents, filenames, ids, name_idx, content_idx, radio_idx in doc_upload_types:
+        if contents and any(c is not None for c in contents):
+            for i, content in enumerate(contents):
+                if content is not None:
+                    uploaded_doc_contents[(src, ids[i]['index'])] = (content, filenames[i])
+                    logging.info(f"{ids[i]['index']} {src} file uploaded: {filenames[i]}")
+                    outputs[name_idx] = [filenames[i] if j==i else "" for j in range(len(contents))]
+                    outputs[content_idx] = [content if j==i else None for j in range(len(contents))]
+                    outputs[radio_idx] = ["uploaded" if j==i else "loaded" for j in range(len(contents))]
+                    return outputs
+
+    return outputs
 
 def gemini_generate(prompt, max_tokens=4096, temperature=0.25):
     result_holder = {}
@@ -605,6 +654,8 @@ Now, generate the {document_type}:
     Output('store-gold-review', 'data'),
     Output('store-loe', 'data'),
     Output('store-virtual-board', 'data'),
+    Output('chat-output', 'children'),
+    Output("download-document", "data"),
     Input({'type': 'btn-generate-doc', 'index': ALL}, 'n_clicks'),
     State({'type': 'btn-generate-doc', 'index': ALL}, 'id'),
     State({'type': 'radio-doc-source-shred', 'index': ALL}, 'value'),
@@ -634,9 +685,25 @@ Now, generate the {document_type}:
     State('store-gold-review', 'data'),
     State('store-loe', 'data'),
     State('store-virtual-board', 'data'),
+    Input('btn-send-chat', 'n_clicks'),
+    Input('btn-clear-chat', 'n_clicks'),
+    State('chat-input', 'value'),
+    State('selected-doc-type', 'data'),
+    State('document-preview', 'children'),
+    Input("btn-download", "n_clicks"),
+    State('selected-doc-type', 'data'),
+    State('store-shred', 'data'),
+    State('store-pink', 'data'),
+    State('store-pink-review', 'data'),
+    State('store-red', 'data'),
+    State('store-red-review', 'data'),
+    State('store-gold', 'data'),
+    State('store-gold-review', 'data'),
+    State('store-loe', 'data'),
+    State('store-virtual-board', 'data'),
     prevent_initial_call=True
 )
-def generate_any_doc(
+def combined_doc_chat_download(
     n_clicks_list, btn_ids,
     radio_shred, upload_shred_contents, upload_shred_filenames,
     radio_pink, upload_pink_contents, upload_pink_filenames,
@@ -644,322 +711,258 @@ def generate_any_doc(
     radio_red, upload_red_contents, upload_red_filenames,
     radio_red_review, upload_red_review_contents, upload_red_review_filenames,
     radio_gold, upload_gold_contents, upload_gold_filenames,
-    store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
+    store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board,
+    btn_send, btn_clear, chat_input, chat_doc_type, doc_preview,
+    btn_download, dl_doc_type, dl_store_shred, dl_store_pink, dl_store_pink_review, dl_store_red, dl_store_red_review, dl_store_gold, dl_store_gold_review, dl_store_loe, dl_store_virtual_board
 ):
     ctx = callback_context
-    logging.info(f"generate_any_doc triggered: n_clicks_list={n_clicks_list}, btn_ids={btn_ids}")
-    if not ctx.triggered:
-        raise dash.exceptions.PreventUpdate
-    idx = [i for i, x in enumerate(n_clicks_list) if x]
-    if not idx:
-        raise dash.exceptions.PreventUpdate
-    idx = idx[-1]
-    doc_type = btn_ids[idx]['index']
-
-    shred_doc = store_shred
-    pink_doc = store_pink
-    pink_review_doc = store_pink_review
-    red_doc = store_red
-    red_review_doc = store_red_review
-    gold_doc = store_gold
-    gold_review_doc = store_gold_review
-    loe_doc = store_loe
-    virtual_board_doc = store_virtual_board
-
-    def get_doc_from_radio(radio, upload_contents, upload_filenames, loaded_var):
-        if radio and radio[0] == 'uploaded':
-            if upload_contents and upload_contents[0] and upload_filenames and upload_filenames[0]:
-                return process_document(upload_contents[0], upload_filenames[0])
+    # Default outputs
+    outputs = [dash.no_update]*12 + [None]
+
+    # Document generation triggers
+    if ctx.triggered and ctx.triggered[0]['prop_id'].startswith("{\"type\":\"btn-generate-doc\""):
+        # Use the same logic as before for document generation
+        idx = [i for i, x in enumerate(n_clicks_list) if x]
+        if not idx:
+            return outputs
+        idx = idx[-1]
+        doc_type = btn_ids[idx]['index']
+
+        shred_doc = store_shred
+        pink_doc = store_pink
+        pink_review_doc = store_pink_review
+        red_doc = store_red
+        red_review_doc = store_red_review
+        gold_doc = store_gold
+        gold_review_doc = store_gold_review
+        loe_doc = store_loe
+        virtual_board_doc = store_virtual_board
+
+        def get_doc_from_radio(radio, upload_contents, upload_filenames, loaded_var):
+            if radio and radio[0] == 'uploaded':
+                if upload_contents and upload_contents[0] and upload_filenames and upload_filenames[0]:
+                    return process_document(upload_contents[0], upload_filenames[0])
+                else:
+                    return None
             else:
-                return None
-        else:
-            return loaded_var
+                return loaded_var
 
-    if doc_type == "Shred":
-        if not uploaded_files:
-            logging.info("No uploaded files for Shred. Aborting.")
-            return html.Div("Please upload a document before shredding."), "", None, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        file_contents = list(uploaded_files.values())
-        try:
-            generated = generate_document(doc_type, file_contents)
-            shred_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Shred document generated.")
-            return preview, "Shred generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating document: {str(e)}")
-            return html.Div(f"Error generating document: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Shred":
+            if not uploaded_files:
+                return [html.Div("Please upload a document before shredding."), "", None, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            file_contents = list(uploaded_files.values())
+            try:
+                generated = generate_document(doc_type, file_contents)
+                shred_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "Shred generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating document: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if doc_type == "Pink":
-        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
-        if not shred:
-            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [shred])
-            pink_doc = generated
-            preview = markdown_narrative_preview(generated)
-            logging.info("Pink document generated.")
-            return preview, "Pink generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Pink: {str(e)}")
-            return html.Div(f"Error generating Pink: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-
-    if doc_type == "Pink Review":
-        pink = get_doc_from_radio(radio_pink, upload_pink_contents, upload_pink_filenames, pink_doc)
-        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
-        if not pink or not shred:
-            return html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [pink, shred])
-            pink_review_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Pink Review document generated.")
-            return preview, "Pink Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Pink Review: {str(e)}")
-            return html.Div(f"Error generating Pink Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Pink":
+            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            if not shred:
+                return [html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [shred])
+                pink_doc = generated
+                preview = markdown_narrative_preview(generated)
+                return [preview, "Pink generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Pink: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if doc_type == "Red":
-        pink_review = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_doc)
-        if not pink_review:
-            return html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [pink_review])
-            red_doc = generated
-            preview = markdown_narrative_preview(generated)
-            logging.info("Red document generated.")
-            return preview, "Red generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Red: {str(e)}")
-            return html.Div(f"Error generating Red: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-
-    if doc_type == "Red Review":
-        red = get_doc_from_radio(radio_red, upload_red_contents, upload_red_filenames, red_doc)
-        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
-        if not red or not shred:
-            return html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [red, shred])
-            red_review_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Red Review document generated.")
-            return preview, "Red Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Red Review: {str(e)}")
-            return html.Div(f"Error generating Red Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Pink Review":
+            pink = get_doc_from_radio(radio_pink, upload_pink_contents, upload_pink_filenames, pink_doc)
+            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            if not pink or not shred:
+                return [html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [pink, shred])
+                pink_review_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "Pink Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Pink Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if doc_type == "Gold":
-        red_review = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_doc)
-        if not red_review:
-            return html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [red_review])
-            gold_doc = generated
-            preview = markdown_narrative_preview(generated)
-            logging.info("Gold document generated.")
-            return preview, "Gold generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Gold: {str(e)}")
-            return html.Div(f"Error generating Gold: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-
-    if doc_type == "Gold Review":
-        gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
-        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
-        if not gold or not shred:
-            return html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [gold, shred])
-            gold_review_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Gold Review document generated.")
-            return preview, "Gold Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Gold Review: {str(e)}")
-            return html.Div(f"Error generating Gold Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Red":
+            pink_review = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_doc)
+            if not pink_review:
+                return [html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [pink_review])
+                red_doc = generated
+                preview = markdown_narrative_preview(generated)
+                return [preview, "Red generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Red: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if doc_type == "LOE":
-        gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
-        if not gold:
-            return html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            generated = generate_document(doc_type, [gold])
-            loe_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("LOE document generated.")
-            return preview, "LOE generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating LOE: {str(e)}")
-            return html.Div(f"Error generating LOE: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Red Review":
+            red = get_doc_from_radio(radio_red, upload_red_contents, upload_red_filenames, red_doc)
+            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            if not red or not shred:
+                return [html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [red, shred])
+                red_review_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "Red Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Red Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if doc_type == "Virtual Board":
-        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
-        if not shred:
-            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        try:
-            lm_text = ""
-            lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred, re.IGNORECASE)
-            if lm_match:
-                lm_text = lm_match.group(1)
-            else:
-                lm_text = shred
-            generated = generate_document(doc_type, [lm_text])
-            virtual_board_doc = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Virtual Board document generated.")
-            return preview, "Virtual Board generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
-        except Exception as e:
-            logging.error(f"Error generating Virtual Board: {str(e)}")
-            return html.Div(f"Error generating Virtual Board: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Gold":
+            red_review = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_doc)
+            if not red_review:
+                return [html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [red_review])
+                gold_doc = generated
+                preview = markdown_narrative_preview(generated)
+                return [preview, "Gold generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Gold: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    return html.Div("Unsupported document type or missing required sources."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
+        if doc_type == "Gold Review":
+            gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
+            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            if not gold or not shred:
+                return [html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [gold, shred])
+                gold_review_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "Gold Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Gold Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-@app.callback(
-    Output('chat-output', 'children'),
-    Output('document-preview', 'children'),
-    Output('store-shred', 'data'),
-    Output('store-pink', 'data'),
-    Output('store-pink-review', 'data'),
-    Output('store-red', 'data'),
-    Output('store-red-review', 'data'),
-    Output('store-gold', 'data'),
-    Output('store-gold-review', 'data'),
-    Output('store-loe', 'data'),
-    Output('store-virtual-board', 'data'),
-    Input('btn-send-chat', 'n_clicks'),
-    Input('btn-clear-chat', 'n_clicks'),
-    State('chat-input', 'value'),
-    State('selected-doc-type', 'data'),
-    State('document-preview', 'children'),
-    State('store-shred', 'data'),
-    State('store-pink', 'data'),
-    State('store-pink-review', 'data'),
-    State('store-red', 'data'),
-    State('store-red-review', 'data'),
-    State('store-gold', 'data'),
-    State('store-gold-review', 'data'),
-    State('store-loe', 'data'),
-    State('store-virtual-board', 'data'),
-    prevent_initial_call=True
-)
-def update_document_via_chat(btn_send, btn_clear, chat_input, selected_doc_type, doc_preview,
-                             store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board):
-    ctx = callback_context
-    if not ctx.triggered:
-        raise dash.exceptions.PreventUpdate
-    trigger_id = ctx.triggered[0]['prop_id'].split('.')[0]
-    if trigger_id == 'btn-clear-chat':
-        return "", dash.no_update, store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
-
-    doc_map = {
-        "Shred": store_shred,
-        "Pink": store_pink,
-        "Pink Review": store_pink_review,
-        "Red": store_red,
-        "Red Review": store_red_review,
-        "Gold": store_gold,
-        "Gold Review": store_gold_review,
-        "LOE": store_loe,
-        "Virtual Board": store_virtual_board
-    }
-    current_document = doc_map.get(selected_doc_type)
-
-    if not chat_input or current_document is None:
-        raise dash.exceptions.PreventUpdate
+        if doc_type == "LOE":
+            gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
+            if not gold:
+                return [html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                generated = generate_document(doc_type, [gold])
+                loe_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "LOE generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating LOE: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
 
-    if selected_doc_type in spreadsheet_types:
-        prompt = f"""Update the following {selected_doc_type} spreadsheet based on this instruction: {chat_input}
+        if doc_type == "Virtual Board":
+            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            if not shred:
+                return [html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            try:
+                lm_text = ""
+                lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred, re.IGNORECASE)
+                if lm_match:
+                    lm_text = lm_match.group(1)
+                else:
+                    lm_text = shred
+                generated = generate_document(doc_type, [lm_text])
+                virtual_board_doc = generated
+                preview = markdown_table_preview(generated)
+                return [preview, "Virtual Board generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+            except Exception as e:
+                return [html.Div(f"Error generating Virtual Board: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+
+        return [html.Div("Unsupported document type or missing required sources."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc, "", None]
+
+    # Chat triggers
+    if ctx.triggered and (ctx.triggered[0]['prop_id'] == 'btn-send-chat.n_clicks' or ctx.triggered[0]['prop_id'] == 'btn-clear-chat.n_clicks'):
+        if ctx.triggered[0]['prop_id'] == 'btn-clear-chat.n_clicks':
+            return [dash.no_update]*11 + ["", None]
+
+        doc_map = {
+            "Shred": store_shred,
+            "Pink": store_pink,
+            "Pink Review": store_pink_review,
+            "Red": store_red,
+            "Red Review": store_red_review,
+            "Gold": store_gold,
+            "Gold Review": store_gold_review,
+            "LOE": store_loe,
+            "Virtual Board": store_virtual_board
+        }
+        current_document = doc_map.get(chat_doc_type)
+
+        if not chat_input or current_document is None:
+            return [dash.no_update]*11 + ["", None]
+
+        if chat_doc_type in spreadsheet_types:
+            prompt = f"""Update the following {chat_doc_type} spreadsheet based on this instruction: {chat_input}
 Current spreadsheet (markdown table format):
 {current_document}
 Instructions:
 1. Provide the updated spreadsheet as a markdown table only.
 2. Do not include any narrative, only the markdown table.
-Now, provide the updated {selected_doc_type} spreadsheet:
+Now, provide the updated {chat_doc_type} spreadsheet:
 """
-    else:
-        prompt = f"""Update the following {selected_doc_type} document based on this instruction: {chat_input}
+        else:
+            prompt = f"""Update the following {chat_doc_type} document based on this instruction: {chat_input}
 Current document:
 {current_document}
 Instructions:
 1. Provide the updated document content.
 2. Maintain proper formatting and structure.
 3. Incorporate the requested changes seamlessly.
-4. If the {selected_doc_type} is Pink, Red, or Gold then your goal is to write a FULL proposal response, not just a strategy and be compliant and compelling by addressing all the requirements from the document provided.  Focus on describing the approach and highly detailed how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes and improve on innovations of the approach.  Do not just say things like we will, or MicroHealth will, use active voice and verbs that are definitive in nature, not maybe, could be, should be, can be and things like that.  This is a proposal response so logical flow is important so the reader can follow.
-Now, provide the updated {selected_doc_type}:
+4. If the {chat_doc_type} is Pink, Red, or Gold then your goal is to write a FULL proposal response, not just a strategy and be compliant and compelling by addressing all the requirements from the document provided.  Focus on describing the approach and highly detailed how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes and improve on innovations of the approach.  Do not just say things like we will, or MicroHealth will, use active voice and verbs that are definitive in nature, not maybe, could be, should be, can be and things like that.  This is a proposal response so logical flow is important so the reader can follow.
+Now, provide the updated {chat_doc_type}:
 """
-    logging.info(f"Updating document via chat for {selected_doc_type} instruction: {chat_input}")
-    try:
-        new_document = gemini_generate(prompt, max_tokens=4096, temperature=0.5)
-        if selected_doc_type in spreadsheet_types:
-            preview = markdown_table_preview(new_document)
-        else:
-            preview = markdown_narrative_preview(new_document)
-        # Only update the relevant store
-        stores = [store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board]
-        doc_types = ["Shred", "Pink", "Pink Review", "Red", "Red Review", "Gold", "Gold Review", "LOE", "Virtual Board"]
-        new_stores = []
-        for dt, s in zip(doc_types, stores):
-            if dt == selected_doc_type:
-                new_stores.append(new_document)
-            else:
-                new_stores.append(s)
-        return f"Document updated based on: {chat_input}", preview, *new_stores
-    except Exception as e:
-        logging.error(f"Error updating document via chat: {str(e)}")
-        return f"Error updating document: {str(e)}", html.Div(f"Error updating document: {str(e)}"), store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
-
-@app.callback(
-    Output("download-document", "data"),
-    Input("btn-download", "n_clicks"),
-    State('selected-doc-type', 'data'),
-    State('store-shred', 'data'),
-    State('store-pink', 'data'),
-    State('store-pink-review', 'data'),
-    State('store-red', 'data'),
-    State('store-red-review', 'data'),
-    State('store-gold', 'data'),
-    State('store-gold-review', 'data'),
-    State('store-loe', 'data'),
-    State('store-virtual-board', 'data'),
-    prevent_initial_call=True
-)
-def download_document(n_clicks, selected_doc_type, store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board):
-    doc_map = {
-        "Shred": store_shred,
-        "Pink": store_pink,
-        "Pink Review": store_pink_review,
-        "Red": store_red,
-        "Red Review": store_red_review,
-        "Gold": store_gold,
-        "Gold Review": store_gold_review,
-        "LOE": store_loe,
-        "Virtual Board": store_virtual_board
-    }
-    current_document = doc_map.get(selected_doc_type)
-    if current_document is None:
-        raise dash.exceptions.PreventUpdate
-
-    if selected_doc_type in spreadsheet_types:
+        logging.info(f"Updating document via chat for {chat_doc_type} instruction: {chat_input}")
         try:
-            xlsx_bytes = markdown_tables_to_xlsx(current_document)
-            logging.info(f"{selected_doc_type} document downloaded as Excel.")
-            return dcc.send_bytes(xlsx_bytes.read(), f"{selected_doc_type}.xlsx")
-        except Exception as e:
-            logging.error(f"Error downloading {selected_doc_type} document: {str(e)}")
-            return dcc.send_string(f"Error downloading {selected_doc_type}: {str(e)}", f"{selected_doc_type}_error.txt")
-    else:
-        try:
-            plain = strip_markdown(current_document)
-            doc = Document()
-            for para in plain.split('\n'):
-                doc.add_paragraph(para)
-            output = BytesIO()
-            doc.save(output)
-            logging.info(f"{selected_doc_type} document downloaded as Word.")
-            output.seek(0)
-            return dcc.send_bytes(output.read(), f"{selected_doc_type}.docx")
+            new_document = gemini_generate(prompt, max_tokens=4096, temperature=0.5)
+            if chat_doc_type in spreadsheet_types:
+                preview = markdown_table_preview(new_document)
+            else:
+                preview = markdown_narrative_preview(new_document)
+            stores = [store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board]
+            doc_types = ["Shred", "Pink", "Pink Review", "Red", "Red Review", "Gold", "Gold Review", "LOE", "Virtual Board"]
+            new_stores = []
+            for dt, s in zip(doc_types, stores):
+                if dt == chat_doc_type:
+                    new_stores.append(new_document)
+                else:
+                    new_stores.append(s)
+            return [preview, dash.no_update] + new_stores + ["Document updated based on: {}".format(chat_input), None]
         except Exception as e:
-            logging.error(f"Error downloading document: {str(e)}")
-            return dcc.send_string(f"Error downloading document: {str(e)}", f"{selected_doc_type}_error.txt")
+            return [html.Div(f"Error updating document: {str(e)}"), dash.no_update, store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board, f"Error updating document: {str(e)}", None]
+
+    # Download trigger
+    if ctx.triggered and ctx.triggered[0]['prop_id'] == "btn-download.n_clicks":
+        doc_map = {
+            "Shred": dl_store_shred,
+            "Pink": dl_store_pink,
+            "Pink Review": dl_store_pink_review,
+            "Red": dl_store_red,
+            "Red Review": dl_store_red_review,
+            "Gold": dl_store_gold,
+            "Gold Review": dl_store_gold_review,
+            "LOE": dl_store_loe,
+            "Virtual Board": dl_store_virtual_board
+        }
+        current_document = doc_map.get(dl_doc_type)
+        if current_document is None:
+            return outputs
+        if dl_doc_type in spreadsheet_types:
+            try:
+                xlsx_bytes = markdown_tables_to_xlsx(current_document)
+                logging.info(f"{dl_doc_type} document downloaded as Excel.")
+                return [dash.no_update]*11 + ["", dcc.send_bytes(xlsx_bytes.read(), f"{dl_doc_type}.xlsx")]
+            except Exception as e:
+                return [dash.no_update]*11 + ["", dcc.send_string(f"Error downloading {dl_doc_type}: {str(e)}", f"{dl_doc_type}_error.txt")]
+        else:
+            try:
+                plain = strip_markdown(current_document)
+                doc = Document()
+                for para in plain.split('\n'):
+                    doc.add_paragraph(para)
+                output = BytesIO()
+                doc.save(output)
+                logging.info(f"{dl_doc_type} document downloaded as Word.")
+                output.seek(0)
+                return [dash.no_update]*11 + ["", dcc.send_bytes(output.read(), f"{dl_doc_type}.docx")]
+            except Exception as e:
+                return [dash.no_update]*11 + ["", dcc.send_string(f"Error downloading document: {str(e)}", f"{dl_doc_type}_error.txt")]
+    return outputs
 
 @app.callback(
     Output("chat-input", "rows"),