Update app.py via AI Editor

app.py

@@ -29,6 +29,11 @@ current_document = None
 document_type = None
 shredded_document = None
 pink_review_document = None
+pink_document = None
+red_review_document = None
+red_document = None
+gold_review_document = None
+gold_document = None
 uploaded_doc_contents = {}
 
 spreadsheet_types = ["Shred", "Pink Review", "Red Review", "Gold Review", "Virtual Board", "LOE"]
@@ -46,6 +51,18 @@ document_types = {
     "LOE": "Ignore all other instructions and generate and generate a Level of Effort (LOE) breakdown and produce only spreadsheet"
 }
 
+# Document dependency rules: mapping doc type to allowed sources for generation and review
+doc_dependencies = {
+    "Pink": {"source": ["shred"], "require": True},
+    "Pink Review": {"source": ["pink", "shred"], "require": True},
+    "Red": {"source": ["pink_review"], "require": True},
+    "Red Review": {"source": ["red", "shred"], "require": True},
+    "Gold": {"source": ["red_review"], "require": True},
+    "Gold Review": {"source": ["gold", "shred"], "require": True},
+    "LOE": {"source": ["gold"], "require": True},
+    "Virtual Board": {"source": ["shred"], "require": True},
+}
+
 def get_right_col_content(selected_type):
     controls = []
     controls.append(html.Div([
@@ -56,6 +73,7 @@ def get_right_col_content(selected_type):
         type="dot",
         children=[html.Div(id="loading-output")]
     ))
+    # Shred: can always upload
     if selected_type == "Shred":
         controls.append(
             html.Div([
@@ -80,6 +98,61 @@ def get_right_col_content(selected_type):
                 file_list_component()
             ])
         )
+    # For all proposal/response/review types, show only allowed upload controls
+    elif selected_type in doc_dependencies:
+        sources = doc_dependencies[selected_type]["source"]
+        # For each source, show upload and radio if loaded/generated exists
+        for src in sources:
+            label = ""
+            store_var = None
+            if src == "shred":
+                label = "Shred (Requirements)"
+                store_var = shredded_document
+            elif src == "pink":
+                label = "Pink Document"
+                store_var = pink_document
+            elif src == "pink_review":
+                label = "Pink Review"
+                store_var = pink_review_document
+            elif src == "red":
+                label = "Red Document"
+                store_var = red_document
+            elif src == "red_review":
+                label = "Red Review"
+                store_var = red_review_document
+            elif src == "gold":
+                label = "Gold Document"
+                store_var = gold_document
+            # Upload control for this source
+            controls.append(html.Div([
+                html.Label(f"Upload {label}"),
+                dcc.Upload(
+                    id={'type': f'upload-doc-type-{src}', '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': f'uploaded-doc-name-{src}', 'index': selected_type}),
+                dbc.RadioItems(
+                    id={'type': f'radio-doc-source-{src}', 'index': selected_type},
+                    options=[
+                        {'label': 'Loaded Document', 'value': 'loaded'},
+                        {'label': 'Uploaded Document', 'value': 'uploaded'}
+                    ] if store_var else [{'label': 'Uploaded Document', 'value': 'uploaded'}],
+                    value='loaded' if store_var else 'uploaded',
+                    inline=True,
+                    className="mb-2"
+                ),
+            ], id={'type': f'doc-type-controls-{src}', 'index': selected_type}))
     controls.append(
         dbc.Row([
             dbc.Col(
@@ -95,36 +168,6 @@ def get_right_col_content(selected_type):
     )
     controls.append(html.Hr())
     controls.append(html.Div(id='document-preview', className="border p-3 mb-3"))
-    if selected_type != "Shred":
-        controls.append(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"
-            ),
-        ], id={'type': 'doc-type-controls', 'index': selected_type}))
     return dbc.Card(dbc.CardBody(controls))
 
 def get_left_col_content():
@@ -361,127 +404,25 @@ def remove_file(n_clicks, existing_files):
                 filtered_files.append(file)
     return filtered_files
 
-@app.callback(
-    Output('document-preview', 'children'),
-    Output('loading-output', 'children'),
-    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_any_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
-    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']
-    document_type = doc_type
-
-    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."), ""
-        file_contents = list(uploaded_files.values())
-        logging.info(f"Calling OpenAI for Shred with {len(file_contents)} files: {list(uploaded_files.keys())}")
-        try:
-            generated = generate_document(doc_type, file_contents)
-            current_document = generated
-            shredded_document = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Shred document generated.")
-            return preview, "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 shredded_document is None:
-        logging.info("Shredded document is None. Aborting.")
-        return html.Div("Please shred a document first."), ""
-
-    source = None
-    if radio_values and len(radio_values) > idx:
-        source = radio_values[idx]
-    else:
-        source = '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:
-            logging.info("No uploaded doc content for this doc type. Aborting.")
-            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
-
-    try:
-        if doc_type == "Pink Review":
-            generated = generate_document(doc_type, [doc_content, shredded_document])
-            pink_review_document = generated
-            current_document = generated
-            preview = markdown_table_preview(generated)
-            logging.info("Pink Review document generated.")
-            return preview, f"{doc_type} generated"
-        elif doc_type in ["Red Review", "Gold Review", "Virtual Board", "LOE"]:
-            generated = generate_document(doc_type, [doc_content, shredded_document])
-            current_document = generated
-            preview = markdown_table_preview(generated)
-            logging.info(f"{doc_type} document generated.")
-            return preview, f"{doc_type} generated"
-        elif doc_type in ["Pink", "Red", "Gold"]:
-            generated = generate_document(doc_type, [doc_content])
-            current_document = generated
-            preview = markdown_narrative_preview(generated)
-            logging.info(f"{doc_type} document generated.")
-            return preview, f"{doc_type} generated"
-        else:
-            generated = generate_document(doc_type, [doc_content])
-            current_document = generated
-            preview = markdown_narrative_preview(generated)
-            logging.info(f"{doc_type} document generated.")
-            return preview, 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"
-
-@app.callback(
-    Output({'type': 'uploaded-doc-name', 'index': MATCH}, 'children'),
-    Output({'type': 'upload-doc-type', 'index': MATCH}, 'contents'),
-    Output({'type': 'radio-doc-source', 'index': MATCH}, 'value'),
-    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, "uploaded"
-    return "", None, "loaded"
+# Upload callbacks for all doc dependencies (Pink, Pink Review, Red, Red Review, Gold, Gold Review, LOE, Virtual Board)
+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)
 
 def extract_markdown_tables(md_text):
     tables = []
@@ -578,7 +519,7 @@ def strip_markdown(text):
     text = text.replace('***', '')
     return text.strip()
 
-def generate_document(document_type, file_contents):
+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]}
@@ -602,6 +543,8 @@ 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}")
     try:
         response = openai.ChatCompletion.create(
@@ -620,6 +563,217 @@ Now, generate the {document_type}:
         logging.error(f"Error generating document: {str(e)}")
         raise
 
+@app.callback(
+    Output('document-preview', 'children'),
+    Output('loading-output', 'children'),
+    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'),
+    prevent_initial_call=True
+)
+def generate_any_doc(
+    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
+):
+    global current_document, document_type, shredded_document, pink_review_document, pink_document, red_review_document, red_document, gold_review_document, gold_document
+    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']
+    document_type = doc_type
+
+    # SHRED - always allowed
+    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."), ""
+        file_contents = list(uploaded_files.values())
+        try:
+            generated = generate_document(doc_type, file_contents)
+            current_document = generated
+            shredded_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("Shred document generated.")
+            return preview, "Shred generated"
+        except Exception as e:
+            logging.error(f"Error generating document: {str(e)}")
+            return html.Div(f"Error generating document: {str(e)}"), "Error"
+
+    # Dependency rules
+    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 loaded_var
+
+    # Pink: can only use Shred (requirements), loaded or uploaded
+    if doc_type == "Pink":
+        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
+        if not shred_doc:
+            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink."), ""
+        try:
+            generated = generate_document(doc_type, [shred_doc])
+            current_document = generated
+            pink_document = generated
+            preview = markdown_narrative_preview(generated)
+            logging.info("Pink document generated.")
+            return preview, "Pink generated"
+        except Exception as e:
+            logging.error(f"Error generating Pink: {str(e)}")
+            return html.Div(f"Error generating Pink: {str(e)}"), "Error"
+
+    # Pink Review: must compare Pink (uploaded or generated) with Shred (uploaded or generated)
+    if doc_type == "Pink Review":
+        pink_doc = get_doc_from_radio(radio_pink, upload_pink_contents, upload_pink_filenames, pink_document)
+        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
+        if not pink_doc or not shred_doc:
+            return html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review."), ""
+        try:
+            generated = generate_document(doc_type, [pink_doc, shred_doc])
+            current_document = generated
+            pink_review_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("Pink Review document generated.")
+            return preview, "Pink Review generated"
+        except Exception as e:
+            logging.error(f"Error generating Pink Review: {str(e)}")
+            return html.Div(f"Error generating Pink Review: {str(e)}"), "Error"
+
+    # Red: can only use Pink Review (uploaded or generated)
+    if doc_type == "Red":
+        pink_review_doc = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_document)
+        if not pink_review_doc:
+            return html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red."), ""
+        try:
+            generated = generate_document(doc_type, [pink_review_doc])
+            current_document = generated
+            red_document = generated
+            preview = markdown_narrative_preview(generated)
+            logging.info("Red document generated.")
+            return preview, "Red generated"
+        except Exception as e:
+            logging.error(f"Error generating Red: {str(e)}")
+            return html.Div(f"Error generating Red: {str(e)}"), "Error"
+
+    # Red Review: must compare Red (uploaded or generated) with Shred (uploaded or generated)
+    if doc_type == "Red Review":
+        red_doc = get_doc_from_radio(radio_red, upload_red_contents, upload_red_filenames, red_document)
+        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
+        if not red_doc or not shred_doc:
+            return html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review."), ""
+        try:
+            generated = generate_document(doc_type, [red_doc, shred_doc])
+            current_document = generated
+            red_review_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("Red Review document generated.")
+            return preview, "Red Review generated"
+        except Exception as e:
+            logging.error(f"Error generating Red Review: {str(e)}")
+            return html.Div(f"Error generating Red Review: {str(e)}"), "Error"
+
+    # Gold: can only use Red Review (uploaded or generated)
+    if doc_type == "Gold":
+        red_review_doc = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_document)
+        if not red_review_doc:
+            return html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold."), ""
+        try:
+            generated = generate_document(doc_type, [red_review_doc])
+            current_document = generated
+            gold_document = generated
+            preview = markdown_narrative_preview(generated)
+            logging.info("Gold document generated.")
+            return preview, "Gold generated"
+        except Exception as e:
+            logging.error(f"Error generating Gold: {str(e)}")
+            return html.Div(f"Error generating Gold: {str(e)}"), "Error"
+
+    # Gold Review: must compare Gold (uploaded or generated) with Shred (uploaded or generated)
+    if doc_type == "Gold Review":
+        gold_doc = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_document)
+        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
+        if not gold_doc or not shred_doc:
+            return html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review."), ""
+        try:
+            generated = generate_document(doc_type, [gold_doc, shred_doc])
+            current_document = generated
+            gold_review_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("Gold Review document generated.")
+            return preview, "Gold Review generated"
+        except Exception as e:
+            logging.error(f"Error generating Gold Review: {str(e)}")
+            return html.Div(f"Error generating Gold Review: {str(e)}"), "Error"
+
+    # LOE: can only use Gold (uploaded or generated)
+    if doc_type == "LOE":
+        gold_doc = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_document)
+        if not gold_doc:
+            return html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE."), ""
+        try:
+            generated = generate_document(doc_type, [gold_doc])
+            current_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("LOE document generated.")
+            return preview, "LOE generated"
+        except Exception as e:
+            logging.error(f"Error generating LOE: {str(e)}")
+            return html.Div(f"Error generating LOE: {str(e)}"), "Error"
+
+    # Virtual Board: can only use Shred (L&M evaluation criteria)
+    if doc_type == "Virtual Board":
+        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
+        if not shred_doc:
+            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board."), ""
+        try:
+            # Extract section L&M if possible
+            lm_text = ""
+            lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred_doc, re.IGNORECASE)
+            if lm_match:
+                lm_text = lm_match.group(1)
+            else:
+                lm_text = shred_doc
+            generated = generate_document(doc_type, [lm_text])
+            current_document = generated
+            preview = markdown_table_preview(generated)
+            logging.info("Virtual Board document generated.")
+            return preview, "Virtual Board generated"
+        except Exception as e:
+            logging.error(f"Error generating Virtual Board: {str(e)}")
+            return html.Div(f"Error generating Virtual Board: {str(e)}"), "Error"
+
+    return html.Div("Unsupported document type or missing required sources."), ""
+
 @app.callback(
     Output('chat-output', 'children'),
     Output('document-preview', 'children', allow_duplicate=True),