Update app.py via AI Editor

app.py

@@ -470,6 +470,18 @@ def update_right_col(selected_type, shred_doc, pink_doc, pink_review_doc, red_do
     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'),
+    Output('document-preview', 'children'),
+    Output('loading-output', 'children'),
+    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'),
+    Output('chat-output', 'children'),
+    Output("download-document", "data"),
     Input('upload-document', 'contents'),
     State('upload-document', 'filename'),
     State('file-list', 'children'),
@@ -495,9 +507,54 @@ def update_right_col(selected_type, shred_doc, pink_doc, pink_review_doc, red_do
     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'),
+    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'),
+    State({'type': 'upload-doc-type-shred', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-shred', 'index': ALL}, 'filename'),
+    State({'type': 'radio-doc-source-pink', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type-pink', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-pink', 'index': ALL}, 'filename'),
+    State({'type': 'radio-doc-source-pink_review', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type-pink_review', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-pink_review', 'index': ALL}, 'filename'),
+    State({'type': 'radio-doc-source-red', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type-red', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-red', 'index': ALL}, 'filename'),
+    State({'type': 'radio-doc-source-red_review', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type-red_review', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-red_review', 'index': ALL}, 'filename'),
+    State({'type': 'radio-doc-source-gold', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type-gold', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type-gold', 'index': ALL}, 'filename'),
+    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'),
+    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 combined_upload_remove_update(
+def master_callback(
     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,
@@ -505,12 +562,25 @@ def combined_upload_remove_update(
     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
+    upload_gold_contents, upload_gold_filenames, upload_gold_ids,
+    n_clicks_list, btn_ids,
+    radio_shred, up_shred_contents, up_shred_filenames,
+    radio_pink, up_pink_contents, up_pink_filenames,
+    radio_pink_review, up_pink_review_contents, up_pink_review_filenames,
+    radio_red, up_red_contents, up_red_filenames,
+    radio_red_review, up_red_review_contents, up_red_review_filenames,
+    radio_gold, up_gold_contents, up_gold_filenames,
+    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
 ):
     global uploaded_files, uploaded_doc_contents
     ctx = callback_context
-    outputs = [dash.no_update]*21
 
+    # Outputs: file-list, store-shred, ...names for uploads, ...upload contents, ...radio values, document-preview, loading-output, store-pink, store-pink-review, store-red, store-red-review, store-gold, store-gold-review, store-loe, store-virtual-board, chat-output, download-document
+    outputs = [dash.no_update] * 32
+
+    # --- File upload/remove logic ---
     # Handle Shred upload
     if ctx.triggered and ctx.triggered[0]['prop_id'].startswith('upload-document'):
         new_files = []
@@ -534,7 +604,6 @@ def combined_upload_remove_update(
                 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
@@ -566,7 +635,7 @@ def combined_upload_remove_update(
         outputs[1] = remove_current_shred
         return outputs
 
-    # Handle all doc-type uploads
+    # Handle all doc-type uploads for preview and radio
     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),
@@ -586,42 +655,41 @@ def combined_upload_remove_update(
                     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 = {}
-    def run_gemini():
-        try:
-            model = genai.GenerativeModel(GEMINI_MODEL)
-            response = model.generate_content(
-                prompt,
-                generation_config=genai.types.GenerationConfig(
-                    temperature=temperature,
-                    max_output_tokens=max_tokens,
-                    top_p=1
+    # --- Document generation/chat/download logic ---
+    def gemini_generate(prompt, max_tokens=4096, temperature=0.25):
+        result_holder = {}
+        def run_gemini():
+            try:
+                model = genai.GenerativeModel(GEMINI_MODEL)
+                response = model.generate_content(
+                    prompt,
+                    generation_config=genai.types.GenerationConfig(
+                        temperature=temperature,
+                        max_output_tokens=max_tokens,
+                        top_p=1
+                    )
                 )
-            )
-            result_holder['result'] = response.text
-            logging.info("Gemini response received.")
-        except Exception as e:
-            logging.error(f"Gemini error: {e}")
-            result_holder['error'] = str(e)
-    thread = threading.Thread(target=run_gemini)
-    thread.start()
-    thread.join()
-    if 'error' in result_holder:
-        raise Exception(result_holder['error'])
-    return result_holder['result']
-
-def generate_document(document_type, file_contents, extra_context=None):
-    if document_type in spreadsheet_types:
-        prompt = f"""Ignore all other instructions and output only a spreadsheet for {document_type} as described below. Do not include any narrative, only the spreadsheet in markdown table format.
+                result_holder['result'] = response.text
+                logging.info("Gemini response received.")
+            except Exception as e:
+                logging.error(f"Gemini error: {e}")
+                result_holder['error'] = str(e)
+        thread = threading.Thread(target=run_gemini)
+        thread.start()
+        thread.join()
+        if 'error' in result_holder:
+            raise Exception(result_holder['error'])
+        return result_holder['result']
+
+    def generate_document(document_type, file_contents, extra_context=None):
+        if document_type in spreadsheet_types:
+            prompt = f"""Ignore all other instructions and output only a spreadsheet for {document_type} as described below. Do not include any narrative, only the spreadsheet in markdown table format.
 Instructions: {document_types[document_type]}
 Project Artifacts:
 {' '.join(file_contents)}
 Output only the spreadsheet as a markdown table, no narrative or explanation."""
-    elif document_type in narrative_types:
-        prompt = f"""Generate a {document_type} document based on the following project artifacts:
+        elif document_type in narrative_types:
+            prompt = f"""Generate a {document_type} document based on the following project artifacts:
 {' '.join(file_contents)}
 Instructions:
 1. Create the {document_type} as a detailed document.
@@ -630,98 +698,20 @@ Instructions:
 4. Start the output immediately with the document content.
 Now, generate the {document_type}:
 """
-    else:
-        prompt = f"""Generate a {document_type} based on the following project artifacts:
+        else:
+            prompt = f"""Generate a {document_type} based on the following project artifacts:
 {' '.join(file_contents)}
 Instructions:
 {document_types.get(document_type, '')}
 Now, generate the {document_type}:
 """
-    if extra_context:
-        prompt += f"\n\n{extra_context}"
-    logging.info(f"Generating document for type: {document_type} using Gemini.")
-    return gemini_generate(prompt, max_tokens=4096, temperature=0.25)
-
-@app.callback(
-    Output('document-preview', 'children'),
-    Output('loading-output', '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'),
-    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'),
-    State({'type': 'upload-doc-type-shred', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-shred', 'index': ALL}, 'filename'),
-    State({'type': 'radio-doc-source-pink', 'index': ALL}, 'value'),
-    State({'type': 'upload-doc-type-pink', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-pink', 'index': ALL}, 'filename'),
-    State({'type': 'radio-doc-source-pink_review', 'index': ALL}, 'value'),
-    State({'type': 'upload-doc-type-pink_review', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-pink_review', 'index': ALL}, 'filename'),
-    State({'type': 'radio-doc-source-red', 'index': ALL}, 'value'),
-    State({'type': 'upload-doc-type-red', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-red', 'index': ALL}, 'filename'),
-    State({'type': 'radio-doc-source-red_review', 'index': ALL}, 'value'),
-    State({'type': 'upload-doc-type-red_review', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-red_review', 'index': ALL}, 'filename'),
-    State({'type': 'radio-doc-source-gold', 'index': ALL}, 'value'),
-    State({'type': 'upload-doc-type-gold', 'index': ALL}, 'contents'),
-    State({'type': 'upload-doc-type-gold', 'index': ALL}, 'filename'),
-    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'),
-    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 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,
-    radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames,
-    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,
-    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
-    # Default outputs
-    outputs = [dash.no_update]*12 + [None]
+        if extra_context:
+            prompt += f"\n\n{extra_context}"
+        logging.info(f"Generating document for type: {document_type} using Gemini.")
+        return gemini_generate(prompt, max_tokens=4096, temperature=0.25)
 
     # 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
@@ -749,107 +739,141 @@ def combined_doc_chat_download(
 
         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]
+                outputs[20] = html.Div("Please upload a document before shredding.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[1] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "Shred generated"
             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]
+                outputs[20] = html.Div(f"Error generating document: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         if doc_type == "Pink":
-            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            shred = get_doc_from_radio(radio_shred, up_shred_contents, up_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]
+                outputs[20] = html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[22] = generated
+                outputs[20] = markdown_narrative_preview(generated)
+                outputs[21] = "Pink generated"
             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]
+                outputs[20] = html.Div(f"Error generating Pink: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         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)
+            pink = get_doc_from_radio(radio_pink, up_pink_contents, up_pink_filenames, pink_doc)
+            shred = get_doc_from_radio(radio_shred, up_shred_contents, up_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]
+                outputs[20] = html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[23] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "Pink Review generated"
             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]
+                outputs[20] = html.Div(f"Error generating Pink Review: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         if doc_type == "Red":
-            pink_review = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_doc)
+            pink_review = get_doc_from_radio(radio_pink_review, up_pink_review_contents, up_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]
+                outputs[20] = html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[24] = generated
+                outputs[20] = markdown_narrative_preview(generated)
+                outputs[21] = "Red generated"
             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]
+                outputs[20] = html.Div(f"Error generating Red: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         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)
+            red = get_doc_from_radio(radio_red, up_red_contents, up_red_filenames, red_doc)
+            shred = get_doc_from_radio(radio_shred, up_shred_contents, up_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]
+                outputs[20] = html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[25] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "Red Review generated"
             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]
+                outputs[20] = html.Div(f"Error generating Red Review: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         if doc_type == "Gold":
-            red_review = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_doc)
+            red_review = get_doc_from_radio(radio_red_review, up_red_review_contents, up_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]
+                outputs[20] = html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[26] = generated
+                outputs[20] = markdown_narrative_preview(generated)
+                outputs[21] = "Gold generated"
             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]
+                outputs[20] = html.Div(f"Error generating Gold: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         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)
+            gold = get_doc_from_radio(radio_gold, up_gold_contents, up_gold_filenames, gold_doc)
+            shred = get_doc_from_radio(radio_shred, up_shred_contents, up_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]
+                outputs[20] = html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[27] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "Gold Review generated"
             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]
+                outputs[20] = html.Div(f"Error generating Gold Review: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         if doc_type == "LOE":
-            gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
+            gold = get_doc_from_radio(radio_gold, up_gold_contents, up_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]
+                outputs[20] = html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE.")
+                outputs[21] = ""
+                return outputs
             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]
+                outputs[28] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "LOE generated"
             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]
+                outputs[20] = html.Div(f"Error generating LOE: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
         if doc_type == "Virtual Board":
-            shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+            shred = get_doc_from_radio(radio_shred, up_shred_contents, up_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]
+                outputs[20] = html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board.")
+                outputs[21] = ""
+                return outputs
             try:
                 lm_text = ""
                 lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred, re.IGNORECASE)
@@ -858,18 +882,23 @@ def combined_doc_chat_download(
                 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]
+                outputs[29] = generated
+                outputs[20] = markdown_table_preview(generated)
+                outputs[21] = "Virtual Board generated"
             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]
+                outputs[20] = html.Div(f"Error generating Virtual Board: {str(e)}")
+                outputs[21] = "Error"
+            return outputs
 
-        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]
+        outputs[20] = html.Div("Unsupported document type or missing required sources.")
+        outputs[21] = ""
+        return outputs
 
     # 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]
+            outputs[30] = ""
+            return outputs
 
         doc_map = {
             "Shred": store_shred,
@@ -885,7 +914,8 @@ def combined_doc_chat_download(
         current_document = doc_map.get(chat_doc_type)
 
         if not chat_input or current_document is None:
-            return [dash.no_update]*11 + ["", None]
+            outputs[30] = ""
+            return outputs
 
         if chat_doc_type in spreadsheet_types:
             prompt = f"""Update the following {chat_doc_type} spreadsheet based on this instruction: {chat_input}
@@ -911,20 +941,20 @@ Now, provide the updated {chat_doc_type}:
         try:
             new_document = gemini_generate(prompt, max_tokens=4096, temperature=0.5)
             if chat_doc_type in spreadsheet_types:
-                preview = markdown_table_preview(new_document)
+                outputs[20] = markdown_table_preview(new_document)
             else:
-                preview = markdown_narrative_preview(new_document)
+                outputs[20] = 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):
+            for i, dt in enumerate(doc_types):
                 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]
+                    outputs[1 + i] = new_document
+            outputs[30] = "Document updated based on: {}".format(chat_input)
+            return outputs
         except Exception as e:
-            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]
+            outputs[20] = html.Div(f"Error updating document: {str(e)}")
+            outputs[30] = f"Error updating document: {str(e)}"
+            return outputs
 
     # Download trigger
     if ctx.triggered and ctx.triggered[0]['prop_id'] == "btn-download.n_clicks":
@@ -945,10 +975,9 @@ Now, provide the updated {chat_doc_type}:
         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")]
+                outputs[31] = 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")]
+                outputs[31] = dcc.send_string(f"Error downloading {dl_doc_type}: {str(e)}", f"{dl_doc_type}_error.txt")
         else:
             try:
                 plain = strip_markdown(current_document)
@@ -957,11 +986,12 @@ Now, provide the updated {chat_doc_type}:
                     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")]
+                outputs[31] = 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")]
+                outputs[31] = dcc.send_string(f"Error downloading document: {str(e)}", f"{dl_doc_type}_error.txt")
+        return outputs
+
     return outputs
 
 @app.callback(