Update app.py via AI Editor

app.py

@@ -5,7 +5,7 @@ import dash
 from dash import dcc, html, Input, Output, State, callback_context
 import dash_bootstrap_components as dbc
 import pandas as pd
-import anthropic
+import openai
 import logging
 from docx import Document
 
@@ -17,14 +17,14 @@ logging.basicConfig(
 app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
 server = app.server
 
-ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
-anthropic_client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
-CLAUDE3_SONNET_MODEL = "claude-3-7-sonnet-20250219"
-CLAUDE3_MAX_CONTEXT_TOKENS = 200_000
-CLAUDE3_MAX_OUTPUT_TOKENS = 64_000
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+openai.api_key = OPENAI_API_KEY
+OPENAI_MODEL = "gpt-4.1"
 
 uploaded_documents = {}
+uploaded_documents_fileid = {}
 uploaded_proposals = {}
+uploaded_proposals_fileid = {}
 generated_documents = {}
 shredded_documents = {}
 shredded_document = None
@@ -44,25 +44,43 @@ def decode_document(decoded_bytes):
             logging.error("Document decode failed for both utf-8 and latin-1: %s", e)
             return None
 
-def anthropic_stream_generate(prompt):
-    stream_result = []
+def upload_to_openai_file(decoded_bytes, filename):
     try:
-        logging.info("Connecting to Anthropic Claude for streaming completion...")
-        with anthropic_client.messages.create(
-            model=CLAUDE3_SONNET_MODEL,
-            max_tokens=CLAUDE3_MAX_OUTPUT_TOKENS,
-            messages=[{"role": "user", "content": prompt}],
-            stream=True
-        ) as stream:
-            for event in stream:
-                if event.type == "content_block_delta":
-                    piece = event.delta.text
-                    stream_result.append(piece)
-                    logging.debug(f"Streaming piece: {piece}")
-        logging.info("Received response from Anthropic Claude streaming.")
-        return ''.join(stream_result)
+        memfile = io.BytesIO(decoded_bytes)
+        memfile.seek(0)
+        resp = openai.files.create(file=memfile, purpose="assistants", file_name=filename)
+        logging.info(f"File uploaded to OpenAI: {filename}, file_id: {resp.id}")
+        return resp.id
     except Exception as e:
-        logging.error("Error during anthropic streaming request: %s", e)
+        logging.error(f"Failed uploading file to OpenAI API: {e}")
+        return None
+
+def openai_stream_generate(prompt, file_id=None):
+    result_text = []
+    try:
+        logging.info("Connecting to OpenAI gpt-4.1 for streaming completion...")
+        messages = [{"role": "user", "content": prompt}]
+        extra_kwargs = {}
+        if file_id:
+            extra_kwargs["files"] = [file_id]
+            logging.info(f"Passing file_id to OpenAI ChatCompletion: {file_id}")
+        stream = openai.chat.completions.create(
+            model=OPENAI_MODEL,
+            messages=messages,
+            max_tokens=64000,
+            temperature=0.2,
+            stream=True,
+            **extra_kwargs
+        )
+        for chunk in stream:
+            if hasattr(chunk, 'choices') and chunk.choices and hasattr(chunk.choices[0].delta, 'content'):
+                piece = chunk.choices[0].delta.content
+                if piece:
+                    result_text.append(piece)
+        logging.info("Received response from OpenAI streaming.")
+        return ''.join(result_text)
+    except Exception as e:
+        logging.error("Error during OpenAI streaming request: %s", e)
         return f"Error during streaming: {e}"
 
 def save_shredded_as_docx(shredded_text, rfp_filename):
@@ -90,16 +108,20 @@ def process_document(action, selected_filename=None, chat_input=None, selected_p
     logging.info(f"Process document called with action: {action}")
 
     doc_content = None
+    doc_fileid = None
     if action in ["shred", "generate"]:
         if selected_filename and selected_filename in uploaded_documents:
             doc_content = uploaded_documents[selected_filename]
+            doc_fileid = uploaded_documents_fileid.get(selected_filename)
         elif uploaded_documents:
             doc_content = next(iter(uploaded_documents.values()))
             selected_filename = next(iter(uploaded_documents.keys()))
+            doc_fileid = uploaded_documents_fileid.get(selected_filename)
         else:
             doc_content = None
+            doc_fileid = None
     elif action == "proposal":
-        pass  # handled below
+        pass
 
     if action == 'shred':
         if not doc_content:
@@ -112,15 +134,14 @@ def process_document(action, selected_filename=None, chat_input=None, selected_p
         )
         if chat_input:
             prompt += f"User additional instructions: {chat_input}\n"
-        prompt += f"\nFile Name: {selected_filename}\n\n{doc_content}"
-
+        prompt += f"\nFile Name: {selected_filename}\n\n"
         result_holder = {"text": None, "docx_bytes": None, "docx_name": None}
         def thread_shred():
             global shredded_document
             shredded_document = ""
             try:
-                logging.info("Starting streaming shredding operation with Anthropics.")
-                result = anthropic_stream_generate(prompt)
+                logging.info("Starting streaming shredding operation with OpenAI.")
+                result = openai_stream_generate(prompt, file_id=doc_fileid)
                 shredded_document = result
                 logging.info("Document shredded successfully.")
                 docx_bytes = save_shredded_as_docx(result, selected_filename)
@@ -156,8 +177,8 @@ def process_document(action, selected_filename=None, chat_input=None, selected_p
             global generated_response
             generated_response = ""
             try:
-                logging.info("Starting streaming generation operation with Anthropics.")
-                result = anthropic_stream_generate(prompt)
+                logging.info("Starting streaming generation operation with OpenAI.")
+                result = openai_stream_generate(prompt, file_id=doc_fileid)
                 generated_response = result
                 logging.info("Proposal response generated successfully.")
                 docx_bytes = save_proposal_as_docx(result, selected_filename)
@@ -181,6 +202,8 @@ def process_document(action, selected_filename=None, chat_input=None, selected_p
         generated_doc_content = None
         rfp_filename = selected_filename
         generated_docname = selected_generated
+        rfp_fileid = uploaded_documents_fileid.get(selected_filename)
+        gen_fileid = None
         if not (selected_filename and selected_filename in uploaded_documents):
             logging.warning("No RFP/SOW/PWS/RFI document selected for proposal action.")
             return "No RFP/SOW/PWS/RFI document selected.", None, None
@@ -211,15 +234,22 @@ def process_document(action, selected_filename=None, chat_input=None, selected_p
         )
         if chat_input:
             prompt += f"User additional instructions: {chat_input}\n"
-        prompt += f"\n---\nRFP/SOW/PWS/RFI ({rfp_filename}):\n{rfp_content}\n"
+        prompt += f"\n---\nRFP/SOW/PWS/RFI ({rfp_filename}):\n"
         prompt += f"\n---\nGenerated Document ({generated_docname}):\n{generated_doc_content}\n"
-        logging.info(f"Sending proposal prompt to anthropic. RFP: {rfp_filename}, Generated Doc: {generated_docname}")
+        logging.info(f"Sending proposal prompt to OpenAI. RFP: {rfp_filename}, Generated Doc: {generated_docname}")
         result_holder = {"text": None, "docx_bytes": None, "docx_name": None}
         def thread_proposal():
             try:
-                logging.info("Connecting to Anthropic Claude for proposal streaming...")
-                result = anthropic_stream_generate(prompt)
-                logging.info("Received proposal results from Anthropic Claude.")
+                logging.info("Connecting to OpenAI gpt-4.1 for proposal streaming...")
+                # Attach both files if available and not None
+                pass_files = []
+                if rfp_fileid:
+                    pass_files.append(rfp_fileid)
+                if gen_fileid:
+                    pass_files.append(gen_fileid)
+                file_arg = pass_files if pass_files else None
+                result = openai_stream_generate(prompt, file_id=file_arg[0] if file_arg else None)
+                logging.info("Received proposal results from OpenAI.")
                 docx_bytes = save_proposal_as_docx(result, rfp_filename)
                 generated_docx_name = f"{os.path.splitext(rfp_filename)[0]}_{os.path.splitext(generated_docname)[0]}_proposal.docx"
                 result_holder["text"] = result
@@ -475,8 +505,13 @@ def master_callback(
         content_type, content_string = rfp_content.split(',')
         decoded = base64.b64decode(content_string)
         text = decode_document(decoded)
+        fileid = None
+        if rfp_filename.lower().endswith(('.pdf', '.docx', '.xlsx', '.xls')):
+            fileid = upload_to_openai_file(decoded, rfp_filename)
         if text is not None:
             uploaded_documents[rfp_filename] = text
+            if fileid:
+                uploaded_documents_fileid[rfp_filename] = fileid
             logging.info(f"Document uploaded: {rfp_filename}")
         else:
             logging.error(f"Failed to decode uploaded document: {rfp_filename}")
@@ -486,8 +521,13 @@ def master_callback(
         content_type, content_string = proposal_content.split(',')
         decoded = base64.b64decode(content_string)
         text = decode_document(decoded)
+        fileid = None
+        if proposal_filename.lower().endswith(('.pdf', '.docx', '.xlsx', '.xls')):
+            fileid = upload_to_openai_file(decoded, proposal_filename)
         if text is not None:
             uploaded_proposals[proposal_filename] = text
+            if fileid:
+                uploaded_proposals_fileid[proposal_filename] = fileid
             logging.info(f"Proposal uploaded: {proposal_filename}")
         else:
             logging.error(f"Failed to decode uploaded proposal: {proposal_filename}")
@@ -500,6 +540,8 @@ def master_callback(
                 del_filename = btn_id['index']
                 if del_filename in uploaded_documents:
                     del uploaded_documents[del_filename]
+                    if del_filename in uploaded_documents_fileid:
+                        del uploaded_documents_fileid[del_filename]
                     logging.info(f"Document deleted: {del_filename}")
                     if selected_doc == del_filename:
                         selected_doc = next(iter(uploaded_documents), None)
@@ -513,6 +555,8 @@ def master_callback(
                 del_filename = btn_id['index']
                 if del_filename in uploaded_proposals:
                     del uploaded_proposals[del_filename]
+                    if del_filename in uploaded_proposals_fileid:
+                        del uploaded_proposals_fileid[del_filename]
                     logging.info(f"Proposal deleted: {del_filename}")
                     if selected_proposal == del_filename:
                         selected_proposal = next(iter(uploaded_proposals), None)