Update app.py via AI Editor

app.py

@@ -1,428 +1,472 @@
+import base64
+import io
+import os
+import pandas as pd
+from docx import Document
+from io import BytesIO, StringIO
 import dash
-from dash import dcc, html, Input, Output, State, callback_context, no_update
 import dash_bootstrap_components as dbc
+from dash import html, dcc, Input, Output, State, callback_context, MATCH, ALL
+from docx.shared import Pt
+from docx.enum.style import WD_STYLE_TYPE
+from PyPDF2 import PdfReader
+import openai
 import logging
 import threading
-import os
-import base64
-import io
-import uuid
-import time
-from flask import Flask
-
-import requests
-
-ALLOWED_EXTENSIONS = ('pdf', 'doc', 'docx', 'txt')
-
-logging.basicConfig(
-    format="%(asctime)s %(levelname)s:%(message)s",
-    level=logging.INFO
-)
-logger = logging.getLogger(__name__)
-
-uploaded_documents = {}
-generated_content = {}
-
-ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages"
-ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "YOUR_ANTHROPIC_API_KEY")
 
-server = Flask(__name__)
-
-os.environ["CUDA_VISIBLE_DEVICES"] = "0"
-
-external_stylesheets = [dbc.themes.BOOTSTRAP]
-
-app = dash.Dash(
-    __name__,
-    server=server,
-    external_stylesheets=external_stylesheets,
-    suppress_callback_exceptions=True,
-    title="Proposal Writing Assistant"
-)
-
-def allowed_file(filename):
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
-
-def save_uploaded_file(file_content, filename):
-    doc_id = str(uuid.uuid4())
-    uploaded_documents[doc_id] = {
-        "filename": filename,
-        "content": file_content
-    }
-    logger.info(f"Uploaded document saved: {filename} with id {doc_id}")
-    return doc_id
-
-def anthropic_api_call(prompt, files=None, task_type=None, extra_instructions=""):
-    logger.info(f"Calling Anthropic API for task: {task_type}")
-    headers = {
-        "x-api-key": ANTHROPIC_API_KEY,
-        "content-type": "application/json"
-    }
-    data = {
-        "model": "claude-3-opus-20240229",
-        "messages": [
-            {"role": "user", "content": prompt + "\n" + extra_instructions}
-        ],
-        "max_tokens": 4096,
-        "temperature": 0.2
-    }
-    try:
-        # response = requests.post(ANTHROPIC_API_URL, headers=headers, json=data, timeout=120)
-        # result = response.json().get('content', ['[Anthropic response placeholder]'])[0]
-        time.sleep(2)
-        result = f"[Simulated response for {task_type}]"
-        logger.info(f"Anthropic API success for task: {task_type}")
-        return result
-    except Exception as e:
-        logger.error(f"Anthropic API error: {str(e)}")
-        return f"Error: {str(e)}"
-
-def parse_contents(contents, filename):
-    content_type, content_string = contents.split(',')
-    decoded = base64.b64decode(content_string)
-    try:
-        if filename.lower().endswith('.txt'):
-            preview = decoded.decode('utf-8')[:2048]
-        else:
-            preview = f"Preview not available for {filename}"
-        return preview
-    except Exception as e:
-        logger.error(f"Could not decode file {filename}: {e}")
-        return f"Error decoding {filename}"
-
-def navbar():
-    return dbc.Card(
-        [
-            dbc.Nav(
-                [
-                    dbc.Button("Shred RFP/PWS/SOW/RFI", id="btn-shred", className="mb-2 btn-primary", style={"width": "100%"}),
-                    dbc.Button("Generate Proposal Response", id="btn-generate", className="mb-2 btn-secondary", style={"width": "100%"}),
-                    dbc.Button("Check Compliance", id="btn-compliance", className="mb-2 btn-tertiary", style={"width": "100%"}),
-                    dbc.Button("Recover Document", id="btn-recover", className="mb-2 btn-primary", style={"width": "100%"}),
-                    dbc.Button("Virtual Board", id="btn-virtual-board", className="mb-2 btn-secondary", style={"width": "100%"}),
-                    dbc.Button("Estimate LOE", id="btn-loe", className="mb-2 btn-tertiary", style={"width": "100%"}),
-                ],
-                vertical=True,
-                pills=False
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+
+app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_callback_exceptions=True)
+
+openai.api_key = os.environ.get("OPENAI_API_KEY", "")
+
+uploaded_files = {}
+current_document = None
+document_type = None
+shredded_document = None
+pink_review_document = None
+uploaded_doc_contents = {}
+
+document_types = {
+    "Shred": "Generate a requirements spreadsheet of the Project Work Statement (PWS) identified by action words like shall, will, perform etc. by pws section, requirement.  Do not write as if you're responding to the proposal.  Its a spreadsheet to distill the requirements, not microhealth's approach",
+    "Pink": "Create a Pink Team document based on the PWS outline.  Your goal is to be compliant and compelling.",
+    "Pink Review": "Evaluate compliance of the Pink Team document against the requirements and output a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery",
+    "Red": "Produce a Red Team document based on the Pink Review by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Pink Review",
+    "Red Review": "Evaluate compliance of the Red Team document against the requirements and output a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery",
+    "Gold": "Create a Pink Team document based on the PWS response by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Red Review",
+    "Gold Review": "Perform a final compliance review against the requirements and output a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery",
+    "Virtual Board": "Based on the requirements and in particular the evaulation criteria, you will evaluate the proposal as if you were a contracting office and provide section by section evaluation as unsatisfactory, satisfactory, good, very good, excellent and why in a spreadsheet",
+    "LOE": "Generate a Level of Effort (LOE) breakdown as a spreadsheet"
+}
+
+def get_right_col_content(selected_type):
+    if selected_type == "Shred":
+        return [
+            html.Div([
+                html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
+            ], style={'textAlign':'center', 'marginBottom':'10px'}),
+            dcc.Loading(
+                id="loading-indicator",
+                type="dot",
+                children=[html.Div(id="loading-output")]
             ),
+            html.Div(id='document-preview', className="border p-3 mb-3"),
+            dbc.Button("Download Document", id="btn-download", color="success", className="mt-3"),
+            dcc.Download(id="download-document"),
             html.Hr(),
-            html.Div(
-                [
-                    html.H6("Uploaded Documents"),
-                    html.Ul(
-                        id="uploaded-doc-list",
-                        style={"listStyleType": "none", "paddingLeft": "0"}
-                    ),
+            dcc.Loading(
+                id="chat-loading",
+                type="dot",
+                children=[
+                    dbc.Input(id="chat-input", type="text", placeholder="Chat with AI to update document...", className="mb-2", style={'whiteSpace':'pre-wrap'}),
+                    dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3"),
+                    html.Div(id="chat-output")
                 ]
+            )
+        ]
+    else:
+        return [
+            html.Div([
+                html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
+            ], style={'textAlign':'center', 'marginBottom':'10px'}),
+            dcc.Loading(
+                id="loading-indicator",
+                type="dot",
+                children=[html.Div(id="loading-output")]
             ),
-        ],
-        body=True
-    )
-
-def chat_window():
-    return dbc.Card(
-        [
-            html.Div(
-                [
-                    html.Div(id="chat-history", style={"height": "160px", "overflowY": "auto", "padding": "0.5rem"}),
-                    dbc.InputGroup(
-                        [
-                            dbc.Textarea(id="chat-input", placeholder="Send additional instructions...", style={"resize":"vertical", "wordWrap":"break-word", "width": "100%", "height": "60px"}),
-                            dbc.Button("Send", id="btn-send-chat", className="btn-secondary", n_clicks=0),
-                        ],
-                        className="mt-2"
-                    ),
+            html.Div(id='document-preview', className="border p-3 mb-3"),
+            dbc.Button("Download Document", id="btn-download", color="success", className="mt-3"),
+            dcc.Download(id="download-document"),
+            html.Hr(),
+            html.Div([
+                html.Label(f"Upload {selected_type} Document"),
+                dcc.Upload(
+                    id={'type': 'upload-doc-type', 'index': selected_type},
+                    children=html.Div(['Drag and Drop or ', html.A('Select File')]),
+                    style={
+                        'width': '100%',
+                        'height': '60px',
+                        'lineHeight': '60px',
+                        'borderWidth': '1px',
+                        'borderStyle': 'dashed',
+                        'borderRadius': '5px',
+                        'textAlign': 'center',
+                        'margin': '10px 0'
+                    },
+                    multiple=False
+                ),
+                html.Div(id={'type': 'uploaded-doc-name', 'index': selected_type}),
+                dbc.RadioItems(
+                    id={'type': 'radio-doc-source', 'index': selected_type},
+                    options=[
+                        {'label': 'Loaded Document', 'value': 'loaded'},
+                        {'label': 'Uploaded Document', 'value': 'uploaded'}
+                    ],
+                    value='loaded',
+                    inline=True,
+                    className="mb-2"
+                ),
+                dbc.Button("Generate Document", id={'type': 'btn-generate-doc', 'index': selected_type}, color="primary", className="mb-3"),
+            ], id={'type': 'doc-type-controls', 'index': selected_type}),
+            dcc.Loading(
+                id="chat-loading",
+                type="dot",
+                children=[
+                    dbc.Input(id="chat-input", type="text", placeholder="Chat with AI to update document...", className="mb-2", style={'whiteSpace':'pre-wrap'}),
+                    dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3"),
+                    html.Div(id="chat-output")
                 ]
-            ),
-        ],
-        body=True,
-        style={"marginBottom": "10px"}
-    )
-
-def top_action_buttons():
-    return html.Div(
-        [
-            dbc.Button("Shred", id="action-shred", className="me-2 btn-primary", n_clicks=0, style={"minWidth": "120px"}),
-            dbc.Button("Generate Response", id="action-generate", className="me-2 btn-secondary", n_clicks=0, style={"minWidth": "180px"}),
-            dbc.Button("Check Compliance", id="action-compliance", className="me-2 btn-tertiary", n_clicks=0, style={"minWidth": "160px"}),
-            dbc.Button("Recover", id="action-recover", className="me-2 btn-primary", n_clicks=0, style={"minWidth": "120px"}),
-            dbc.Button("Virtual Board", id="action-virtual-board", className="me-2 btn-secondary", n_clicks=0, style={"minWidth": "160px"}),
-            dbc.Button("Estimate LOE", id="action-loe", className="btn-tertiary", n_clicks=0, style={"minWidth": "140px"}),
-        ],
-        className="mb-3",
-        style={"display": "flex", "flexWrap": "wrap"}
-    )
+            )
+        ]
 
-def upload_area():
-    return html.Div(
-        [
+app.layout = dbc.Container([
+    dbc.Row([
+        dbc.Col([
+            html.H4("Proposal Documents", className="mt-3 mb-4"),
+            html.Div([
+                html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
+            ], style={'textAlign':'center', 'marginBottom':'10px'}),
             dcc.Upload(
-                id="upload-document",
-                children=html.Div(["Drag & drop or click to select a file."]),
-                multiple=False,
+                id='upload-document',
+                children=html.Div([
+                    'Drag and Drop or ',
+                    html.A('Select Files')
+                ]),
                 style={
-                    "width": "100%",
-                    "height": "70px",
-                    "lineHeight": "70px",
-                    "borderWidth": "1px",
-                    "borderStyle": "dashed",
-                    "borderRadius": "4px",
-                    "textAlign": "center",
-                    "marginBottom": "8px"
-                }
+                    'width': '100%',
+                    'height': '60px',
+                    'lineHeight': '60px',
+                    'borderWidth': '1px',
+                    'borderStyle': 'dashed',
+                    'borderRadius': '5px',
+                    'textAlign': 'center',
+                    'margin': '10px 0'
+                },
+                multiple=True
             ),
-            html.Div(id="upload-feedback")
-        ]
-    )
-
-def preview_area():
-    return dbc.Card(
-        [
-            html.H6("Document Preview / Output"),
-            html.Pre(id="preview-content", style={"whiteSpace": "pre-wrap", "wordWrap": "break-word", "maxHeight": "340px", "overflowY": "auto"})
-        ],
-        body=True
-    )
-
-def main_layout():
-    return dbc.Container(
-        [
-            dbc.Row(
-                [
-                    dbc.Col(
-                        html.H2("Proposal Writing Assistant", style={"margin": "12px 0"}),
-                        width=12
-                    ),
-                ],
-                align="center",
-                style={"marginBottom": "8px"}
-            ),
-            dbc.Row(
-                [
-                    dbc.Col(
-                        navbar(),
-                        width=3,
-                        style={"minWidth": "220px", "maxWidth": "400px"}
-                    ),
-                    dbc.Col(
-                        dbc.Card(
-                            [
-                                chat_window(),
-                                top_action_buttons(),
-                                upload_area(),
-                                preview_area(),
-                                dcc.Loading(
-                                    id="loading",
-                                    type="default",
-                                    children=html.Div(id="loading-output"),
-                                    style={"position": "absolute", "top": "6px", "left": "50%"}
-                                ),
-                            ],
-                            body=True
-                        ),
-                        width=9
-                    ),
-                ],
-                style={"minHeight": "90vh"}
-            ),
-        ],
-        fluid=True
-    )
+            html.Div(id='file-list'),
+            html.Hr(),
+            html.Div([
+                dbc.Button(
+                    doc_type,
+                    id={'type': 'btn-doc-type', 'index': doc_type},
+                    color="link",
+                    className="mb-2 w-100 text-left custom-button",
+                    style={'overflow': 'hidden', 'text-overflow': 'ellipsis', 'white-space': 'nowrap'}
+                ) for doc_type in document_types.keys()
+            ])
+        ], width=3),
+        dbc.Col([
+            html.Div(id='right-col-content')
+        ], width=9)
+    ])
+], fluid=True)
+
+def process_document(contents, filename):
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+    try:
+        if filename.lower().endswith('.docx'):
+            doc = Document(BytesIO(decoded))
+            text = "\n".join([para.text for para in doc.paragraphs])
+            return text
+        elif filename.lower().endswith('.pdf'):
+            pdf = PdfReader(BytesIO(decoded))
+            text = ""
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text
+            return text
+        else:
+            return f"Unsupported file format: {filename}. Please upload a PDF or DOCX file."
+    except Exception as e:
+        logging.error(f"Error processing document: {str(e)}")
+        return f"Error processing document: {str(e)}"
 
-app.layout = main_layout
+@app.callback(
+    Output('file-list', 'children'),
+    Input('upload-document', 'contents'),
+    State('upload-document', 'filename'),
+    State('file-list', 'children')
+)
+def update_output(list_of_contents, list_of_names, existing_files):
+    global uploaded_files, shredded_document
+    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(html.Div([
+                html.Button('×', id={'type': 'remove-file', 'index': name}, style={'marginRight': '5px', 'fontSize': '10px'}),
+                html.Span(name)
+            ]))
+        if existing_files is None:
+            existing_files = []
+        shredded_document = None
+        logging.info("Documents uploaded and file list updated.")
+        return existing_files + new_files
+    return existing_files
 
 @app.callback(
-    Output("uploaded-doc-list", "children"),
-    Output("preview-content", "children"),
-    Output("upload-feedback", "children"),
-    Output("loading-output", "children"),
-    Output("chat-history", "children"),
-    [
-        Input("upload-document", "contents"),
-        Input("action-shred", "n_clicks"),
-        Input("action-generate", "n_clicks"),
-        Input("action-compliance", "n_clicks"),
-        Input("action-recover", "n_clicks"),
-        Input("action-virtual-board", "n_clicks"),
-        Input("action-loe", "n_clicks"),
-        Input("btn-send-chat", "n_clicks"),
-        Input({"type": "delete-doc-btn", "index": dash.ALL}, "n_clicks"),
-    ],
-    [
-        State("upload-document", "filename"),
-        State("chat-input", "value"),
-        State("chat-history", "children"),
-        State("preview-content", "children"),
-        State("uploaded-doc-list", "children"),
-    ],
+    Output('file-list', 'children', allow_duplicate=True),
+    Input({'type': 'remove-file', 'index': ALL}, 'n_clicks'),
+    State('file-list', 'children'),
     prevent_initial_call=True
 )
-def main_callback(
-    upload_contents, shred, generate, compliance, recover, virtual_board, loe, send_chat, delete_doc_clicks,
-    upload_filename, chat_input, chat_history, preview_content, uploaded_doc_list
-):
-    triggered_id = callback_context.triggered[0]["prop_id"].split(".")[0] if callback_context.triggered else None
-    logger.info(f"Triggered callback: {triggered_id}")
-
-    feedback = no_update
-    loading_message = ""
-    new_preview_content = no_update
-    new_chat_history = chat_history if chat_history else []
-    doc_list_items = []
+def remove_file(n_clicks, existing_files):
+    global uploaded_files, shredded_document
+    ctx = dash.callback_context
+    if not ctx.triggered:
+        raise dash.exceptions.PreventUpdate
+    removed_file = ctx.triggered[0]['prop_id'].split(',')[0].split(':')[-1].strip('}')
+    uploaded_files.pop(removed_file, None)
+    shredded_document = None
+    logging.info(f"Removed file: {removed_file}")
+    return [file for file in existing_files if file['props']['children'][1]['props']['children'] != removed_file]
 
-    if triggered_id == "upload-document" and upload_contents and upload_filename:
-        if not allowed_file(upload_filename):
-            feedback = dbc.Alert("Unsupported file type. Please upload PDF, Word, or TXT.", color="danger", dismissable=True)
+@app.callback(
+    Output('right-col-content', 'children'),
+    [Input({'type': 'btn-doc-type', 'index': ALL}, 'n_clicks')],
+    [State({'type': 'btn-doc-type', 'index': ALL}, 'id')]
+)
+def update_right_col(n_clicks_list, btn_ids):
+    triggered = callback_context.triggered
+    if not triggered or all(x is None for x in n_clicks_list):
+        selected_type = "Shred"
+    else:
+        idx = [i for i, x in enumerate(n_clicks_list) if x]
+        if idx:
+            selected_type = btn_ids[idx[-1]]['index']
         else:
-            doc_id = save_uploaded_file(upload_contents, upload_filename)
-            preview = parse_contents(upload_contents, upload_filename)
-            new_preview_content = f"{upload_filename}:\n\n{preview}"
-            feedback = dbc.Alert(f"Uploaded {upload_filename}", color="success", dismissable=True)
-            logger.info(f"File uploaded: {upload_filename}")
-
-    for doc_id, doc in uploaded_documents.items():
-        doc_list_items.append(
-            html.Li(
-                [
-                    html.Span(doc['filename'], style={"marginRight": "8px"}),
-                    dbc.Button("Delete", id={"type": "delete-doc-btn", "index": doc_id}, color="danger", size="sm", n_clicks=0)
-                ],
-                style={"display": "flex", "justifyContent": "space-between", "alignItems": "center", "marginBottom": "5px"}
-            )
+            selected_type = "Shred"
+    return get_right_col_content(selected_type)
+
+def generate_document(document_type, file_contents):
+    prompt = f"""Generate a {document_type} based on the following project artifacts:
+{' '.join(file_contents)}
+Instructions:
+1. Create the {document_type} as a detailed document.
+2. Use proper formatting and structure.
+3. Include all necessary sections and details.
+4. Start the output immediately with the document content.
+5. IMPORTANT: If the document type is Pink, Red, Gold and not 
+Pink Review, Red Review, Gold Review, or spreadsheet, loe or virtual board
+then your goal is to be compliant and compelling based on the
+requrements, write in paragraph in active voice as
+MicroHealth, limit bullets, answer the
+requirement with what MicroHealth will do 
+to satisfy the requirement, the technical 
+approach with innovation for efficiency, 
+productivity, quality and measurable 
+outcomes, the industry standard that 
+methodology is based on if applicable, 
+detail the workflow or steps to accomplish 
+the requirement with labor categories that 
+will do those tasks in that workflow, 
+reference reputable research like gartner, 
+forrester, IDC, Deloitte, Accenture etc 
+with measures of success and substantiation 
+of MicroHealth's approach. Never use soft words
+like maybe, could be, should, possible be definitive in your language and confident.
+6. you must also take into account section L&M of the document which is the evaluation criteria
+to be sure we address them.
+Now, generate the {document_type}:
+"""
+
+    logging.info(f"Generating document for type: {document_type}")
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4-1106-preview",
+            messages=[
+                {"role": "system", "content": "You are a helpful, expert government proposal writer."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=4096,
+            temperature=0.25,
         )
+        generated_text = response['choices'][0]['message']['content']
+        logging.info("Document generated successfully.")
+        return generated_text
+    except Exception as e:
+        logging.error(f"Error generating document: {str(e)}")
+        raise
 
-    if isinstance(delete_doc_clicks, list) and any(delete_doc_clicks):
-        idx = delete_doc_clicks.index(max(delete_doc_clicks))
-        doc_ids = list(uploaded_documents.keys())
-        if idx < len(doc_ids):
-            deleted_doc = uploaded_documents.pop(doc_ids[idx])
-            feedback = dbc.Alert(f"Deleted {deleted_doc['filename']}", color="info", dismissable=True)
-            logger.info(f"Document deleted: {deleted_doc['filename']}")
-            doc_list_items = [
-                html.Li(
-                    [
-                        html.Span(doc['filename'], style={"marginRight": "8px"}),
-                        dbc.Button("Delete", id={"type": "delete-doc-btn", "index": doc_id}, color="danger", size="sm", n_clicks=0)
-                    ],
-                    style={"display": "flex", "justifyContent": "space-between", "alignItems": "center", "marginBottom": "5px"}
-                )
-                for doc_id, doc in uploaded_documents.items()
-            ]
-            new_preview_content = "" if not uploaded_documents else no_update
+@app.callback(
+    Output('document-preview', 'children'),
+    Output('loading-output', 'children'),
+    Input({'type': 'btn-doc-type', 'index': 'Shred'}, 'n_clicks'),
+    prevent_initial_call=True
+)
+def generate_shred_doc(n_clicks):
+    global current_document, document_type, shredded_document
+    if not uploaded_files:
+        return html.Div("Please upload a document before shredding."), ""
+    file_contents = list(uploaded_files.values())
+    try:
+        shredded_document = generate_document("Shred", file_contents)
+        current_document = shredded_document
+        return dcc.Markdown(shredded_document), "Shred generated"
+    except Exception as e:
+        logging.error(f"Error generating document: {str(e)}")
+        return html.Div(f"Error generating document: {str(e)}"), "Error"
 
-    if len(uploaded_documents) == 0 and triggered_id not in ["upload-document", "btn-send-chat"]:
-        feedback = dbc.Alert("Please upload a document before performing actions.", color="warning", dismissable=True)
-        logger.warning("Attempted action without documents.")
-        return doc_list_items, new_preview_content, feedback, loading_message, new_chat_history
+@app.callback(
+    Output({'type': 'uploaded-doc-name', 'index': MATCH}, 'children'),
+    Output({'type': 'upload-doc-type', 'index': MATCH}, 'contents'),
+    Input({'type': 'upload-doc-type', 'index': MATCH}, 'contents'),
+    State({'type': 'upload-doc-type', 'index': MATCH}, 'filename'),
+    State({'type': 'upload-doc-type', 'index': MATCH}, 'id')
+)
+def update_uploaded_doc_name(contents, filename, id_dict):
+    if contents is not None:
+        uploaded_doc_contents[id_dict['index']] = (contents, filename)
+        logging.info(f"{id_dict['index']} file uploaded: {filename}")
+        return filename, contents
+    return "", None
 
-    if triggered_id == "btn-send-chat" and chat_input and chat_input.strip():
-        if not isinstance(new_chat_history, list):
-            new_chat_history = []
-        new_chat_history.append(html.Div([
-            html.Strong("You: "), html.Span(chat_input)
-        ], style={"marginBottom": "0.25rem"}))
-        feedback = dbc.Alert("Chat message sent. Instructions will be used in next action.", color="info", dismissable=True)
-        logger.info(f"Chat message sent: {chat_input}")
+@app.callback(
+    Output('document-preview', 'children', allow_duplicate=True),
+    Output('loading-output', 'children', allow_duplicate=True),
+    Input({'type': 'btn-generate-doc', 'index': ALL}, 'n_clicks'),
+    State({'type': 'btn-generate-doc', 'index': ALL}, 'id'),
+    State({'type': 'radio-doc-source', 'index': ALL}, 'value'),
+    State({'type': 'upload-doc-type', 'index': ALL}, 'contents'),
+    State({'type': 'upload-doc-type', 'index': ALL}, 'filename'),
+    prevent_initial_call=True
+)
+def generate_other_doc(n_clicks_list, btn_ids, radio_values, upload_contents, upload_filenames):
+    global current_document, document_type, shredded_document, pink_review_document
+    ctx = callback_context
+    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']
+    document_type = doc_type
+
+    if doc_type == "Shred":
+        raise dash.exceptions.PreventUpdate
+
+    if shredded_document is None:
+        return html.Div("Please shred a document first."), ""
+
+    source = radio_values[idx] if radio_values and len(radio_values) > idx else 'loaded'
+    doc_content = None
+
+    if source == 'uploaded':
+        if upload_contents and len(upload_contents) > idx and upload_contents[idx] and upload_filenames and len(upload_filenames) > idx and upload_filenames[idx]:
+            doc_content = process_document(upload_contents[idx], upload_filenames[idx])
+        else:
+            return html.Div("Please upload a document to use as source."), ""
+    else:
+        if doc_type == "Pink":
+            doc_content = shredded_document
+        elif doc_type == "Pink Review":
+            doc_content = pink_review_document if pink_review_document else ""
+        elif doc_type == "Red":
+            doc_content = pink_review_document if pink_review_document else ""
+        elif doc_type == "Red Review":
+            doc_content = pink_review_document if pink_review_document else ""
+        elif doc_type == "Gold":
+            doc_content = shredded_document
+        elif doc_type == "Gold Review":
+            doc_content = shredded_document
+        elif doc_type == "Virtual Board":
+            doc_content = shredded_document
+        elif doc_type == "LOE":
+            doc_content = shredded_document
+        else:
+            doc_content = shredded_document
 
-    last_chat = ""
-    if isinstance(new_chat_history, list) and new_chat_history:
-        for item in reversed(new_chat_history):
-            if isinstance(item, html.Div):
-                children = item.children
-                if len(children) > 1 and isinstance(children[1], html.Span):
-                    last_chat = children[1].children
-                    break
-    elif isinstance(chat_input, str):
-        last_chat = chat_input
+    try:
+        if doc_type == "Pink Review":
+            current_document = generate_document(doc_type, [doc_content, shredded_document])
+            pink_review_document = current_document
+        elif doc_type in ["Red", "Red Review"]:
+            current_document = generate_document(doc_type, [doc_content, shredded_document])
+        else:
+            current_document = generate_document(doc_type, [doc_content])
+        logging.info(f"{doc_type} document generated successfully.")
+        return dcc.Markdown(current_document), f"{doc_type} generated"
+    except Exception as e:
+        logging.error(f"Error generating document: {str(e)}")
+        return html.Div(f"Error generating document: {str(e)}"), "Error"
 
-    if triggered_id in ["action-shred", "action-generate", "action-compliance", "action-recover", "action-virtual-board", "action-loe"]:
-        loading_message = dbc.Alert("Processing request, please wait...", color="primary", dismissable=False, style={"textAlign": "center"})
-        doc_id, doc = next(iter(uploaded_documents.items()))
-        file_name = doc['filename']
-        file_content = doc['content']
-        action_type = triggered_id.replace("action-", "").replace("-", " ").title()
+@app.callback(
+    Output('chat-output', 'children'),
+    Output('document-preview', 'children', allow_duplicate=True),
+    Input('btn-send-chat', 'n_clicks'),
+    State('chat-input', 'value'),
+    prevent_initial_call=True
+)
+def update_document_via_chat(n_clicks, chat_input):
+    global current_document, document_type
+    if not chat_input or current_document is None:
+        raise dash.exceptions.PreventUpdate
+    
+    prompt = f"""Update the following {document_type} 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.
+Now, provide the updated {document_type}:
+"""
+
+    logging.info(f"Updating document via chat for {document_type} instruction: {chat_input}")
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4-1106-preview",
+            messages=[
+                {"role": "system", "content": "You are a helpful, expert government proposal writer."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=4096,
+            temperature=0.2,
+        )
+        current_document = response['choices'][0]['message']['content']
+        logging.info("Document updated via chat successfully.")
+        return f"Document updated based on: {chat_input}", dcc.Markdown(current_document)
+    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)}")
 
-        # DECODE the document content for use in the prompt
+@app.callback(
+    Output("download-document", "data"),
+    Input("btn-download", "n_clicks"),
+    prevent_initial_call=True
+)
+def download_document(n_clicks):
+    global current_document, document_type
+    if current_document is None:
+        raise dash.exceptions.PreventUpdate
+    
+    if document_type == "LOE":
         try:
-            content_type, content_string = file_content.split(',')
-            decoded = base64.b64decode(content_string)
-            if file_name.lower().endswith('.txt'):
-                document_text = decoded.decode('utf-8', errors='replace')
-            else:
-                document_text = f"[Start of document {file_name} as base64]\n{decoded[:350].hex()}...[truncated]\n[End of document]"
+            df = pd.read_csv(StringIO(current_document))
+            output = BytesIO()
+            with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                df.to_excel(writer, sheet_name='LOE', index=False)
+            logging.info("LOE document downloaded as Excel.")
+            return dcc.send_bytes(output.getvalue(), f"{document_type}.xlsx")
         except Exception as e:
-            logger.error(f"Could not decode document {file_name} for Anthropic: {e}")
-            document_text = f"[Could not decode {file_name}]"
-
-        logger.info(f"Sending document content of length {len(document_text)} to Anthropic for {action_type}")
-
-        result_holder = {}
-
-        def threaded_api_call():
-            if triggered_id == "action-shred":
-                prompt = (
-                    "Shred this document into requirements, organized by section. "
-                    "Identify requirements by action words (shall, will, perform, etc). "
-                    "Output as spreadsheet: PWS Section, Requirement.\n\n"
-                    f"Document Content:\n{document_text}\n"
-                )
-                task_type = "Shred"
-            elif triggered_id == "action-generate":
-                prompt = (
-                    "Generate a detailed proposal response, organized by section/subsection. "
-                    "Focus on approach, steps, workflow, people, processes, technology. "
-                    "Include research validation and citations. Address Red Review findings.\n\n"
-                    f"Document Content:\n{document_text}\n"
-                )
-                task_type = "Generate Proposal Response"
-            elif triggered_id == "action-compliance":
-                prompt = (
-                    "Check compliance of the proposal response against the shredded requirements. "
-                    "Produce a spreadsheet: PWS number, requirement, finding, recommendation.\n\n"
-                    f"Proposal Response Document Content:\n{document_text}\n"
-                )
-                task_type = "Check Compliance"
-            elif triggered_id == "action-recover":
-                prompt = (
-                    "Using the compliance spreadsheet, improve the document sections. "
-                    "Address recommendations without materially changing content. "
-                    "Organize improvements by PWS section headers/subheaders.\n\n"
-                    f"Document Content:\n{document_text}\n"
-                )
-                task_type = "Recover Document"
-            elif triggered_id == "action-virtual-board":
-                prompt = (
-                    "Evaluate the proposal based on requirements and evaluation criteria. "
-                    "Generate a section-by-section evaluation spreadsheet using ratings: "
-                    "unsatisfactory, satisfactory, good, very good, excellent. Include explanations. "
-                    "Base evaluation on sections L and M.\n\n"
-                    f"Document Content:\n{document_text}\n"
-                )
-                task_type = "Virtual Board"
-            elif triggered_id == "action-loe":
-                prompt = (
-                    "Estimate Level of Effort for the proposal. Output spreadsheet: "
-                    "PWS task area, brief description, labor categories, estimated hours per category.\n\n"
-                    f"Document Content:\n{document_text}\n"
-                )
-                task_type = "Estimate LOE"
-            else:
-                prompt = ""
-                task_type = "Unknown"
-            logger.info(f"Prompt to Anthropic for {action_type}: {prompt[:400]}...[truncated]")
-            result_holder["result"] = anthropic_api_call(prompt, files=[file_content], task_type=task_type, extra_instructions=last_chat or "")
-
-        thread = threading.Thread(target=threaded_api_call)
-        thread.start()
-        thread.join()
-
-        result = result_holder.get("result", "[No result]")
-        generated_content[triggered_id] = result
-        new_preview_content = f"{action_type} Output for {file_name}:\n\n{result}"
-        feedback = dbc.Alert(f"{action_type} completed.", color="success", dismissable=True)
-        logger.info(f"{action_type} completed for {file_name}")
-
-    return doc_list_items, new_preview_content, feedback, loading_message, new_chat_history
+            logging.error(f"Error downloading LOE document: {str(e)}")
+            return dcc.send_string(f"Error downloading LOE: {str(e)}", f"{document_type}_error.txt")
+    else:
+        try:
+            doc = Document()
+            doc.add_paragraph(current_document)
+            output = BytesIO()
+            doc.save(output)
+            logging.info("Document downloaded as Word.")
+            return dcc.send_bytes(output.getvalue(), f"{document_type}.docx")
+        except Exception as e:
+            logging.error(f"Error downloading document: {str(e)}")
+            return dcc.send_string(f"Error downloading document: {str(e)}", f"{document_type}_error.txt")
 
 if __name__ == '__main__':
     print("Starting the Dash application...")