Update app.py

app.py

@@ -10,81 +10,64 @@ import tempfile
 
 # Load environment variables
 load_dotenv()
-
-# Initialize OpenAI client with error handling
-try:
-    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-    if not os.getenv('OPENAI_API_KEY'):
-        st.error("OpenAI API key not found. Please check your .env file.")
-        st.stop()
-except Exception as e:
-    st.error(f"Error initializing OpenAI client: {str(e)}")
-    st.stop()
+# Initialize OpenAI client
+client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
 
 def convert_pdf_to_images(pdf_file):
     """Convert PDF to list of images using PyMuPDF"""
     images = []
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-            tmp_file.write(pdf_file.getvalue())
-            pdf_path = tmp_file.name
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
+        tmp_file.write(pdf_file.getvalue())
+        pdf_path = tmp_file.name
+        
+        pdf_document = fitz.open(pdf_path)
+        for page_number in range(pdf_document.page_count):
+            page = pdf_document[page_number]
+            pix = page.get_pixmap()
+            img_data = pix.tobytes("png")
+            image = Image.open(io.BytesIO(img_data))
+            images.append(image)
             
-            pdf_document = fitz.open(pdf_path)
-            for page_number in range(pdf_document.page_count):
-                page = pdf_document[page_number]
-                pix = page.get_pixmap()
-                img_data = pix.tobytes("png")
-                image = Image.open(io.BytesIO(img_data))
-                images.append(image)
-                
-            pdf_document.close()
-        os.unlink(pdf_path)
-        return images
-    except Exception as e:
-        st.error(f"Error converting PDF to images: {str(e)}")
-        return []
+        pdf_document.close()
+    os.unlink(pdf_path)
+    return images
+
 
 def format_response(text):
     """Format the analysis response with clean styling"""
-    try:
-        formatted_text = ""
+    formatted_text = ""
+    
+    # Split into pages
+    pages = text.split("Page")
+    
+    for page_num, page_content in enumerate(pages[1:], 1):  # Skip first empty split
+        formatted_text += f'\n### Page {page_num}\n'
         
-        # Split into pages
-        pages = text.split("Page")
+        # Process each line
+        lines = page_content.split('\n')
+        for line in lines:
+            # Skip empty lines and lines with asterisks
+            if line.strip() and not line.strip().startswith('*') and not line.strip().startswith('Here'):
+                # Remove asterisks and dashes
+                line = line.replace('**', '').replace('- ', '')
+                
+                if ':' in line:
+                    label, value = line.split(':', 1)
+                    formatted_text += f'- *{label.strip()}*: {value.strip()}\n'
         
-        for page_num, page_content in enumerate(pages[1:], 1):
-            formatted_text += f'\n### Page {page_num}\n'
-            
-            # Process each line
-            lines = page_content.split('\n')
-            for line in lines:
-                if line.strip() and not line.strip().startswith('*') and not line.strip().startswith('Here'):
-                    line = line.replace('**', '').replace('- ', '')
-                    
-                    if ':' in line:
-                        label, value = line.split(':', 1)
-                        formatted_text += f'- **{label.strip()}**: {value.strip()}\n'
-            
-        return formatted_text
-    except Exception as e:
-        st.error(f"Error formatting response: {str(e)}")
-        return text
+    return formatted_text
 
 def analyze_image(image):
     """Analyze image using OpenAI API"""
     try:
-        # Add timeout parameter for API request
-        timeout = 30  # seconds
-        
         img_byte_arr = io.BytesIO()
         image.save(img_byte_arr, format='PNG')
         img_byte_arr = img_byte_arr.getvalue()
         
         base64_image = base64.b64encode(img_byte_arr).decode("utf-8")
         
-        # Fix model name typo and add error handling for API response
         response = client.chat.completions.create(
-            model="gpt-4o-mini",  # Corrected model name
+            model="gpt-4o-mini",
             messages=[
                 {
                     "role": "user",
@@ -110,69 +93,43 @@ def analyze_image(image):
                     ],
                 }
             ],
-            max_tokens=1000,
-            timeout=timeout
+            max_tokens=1000
         )
         
         return response.choices[0].message.content
     except Exception as e:
-        error_message = str(e)
-        if "timeout" in error_message.lower():
-            return "The request timed out. Please try again."
-        elif "api key" in error_message.lower():
-            return "Invalid or missing API key. Please check your configuration."
-        else:
-            return f"An error occurred during analysis: {error_message}"
+        return f"An error occurred: {str(e)}"
 
 def main():
     st.set_page_config(page_title="Document Analysis App", layout="wide")
 
     st.title("Document Analysis App")
-    
-    # Add API key input if not in environment
-    if not os.getenv('OPENAI_API_KEY'):
-        api_key = st.text_input("Enter your OpenAI API key:", type="password")
-        if api_key:
-            os.environ['OPENAI_API_KEY'] = api_key
-            st.success("API key set successfully!")
-        else:
-            st.warning("Please enter your OpenAI API key to continue.")
-            st.stop()
-    
     uploaded_file = st.file_uploader("Upload document (PDF/Image)", type=['pdf', 'png', 'jpg', 'jpeg'])
 
     if uploaded_file is not None:
-        try:
-            if uploaded_file.type == "application/pdf":
-                # Handle PDF
-                with st.spinner("Processing PDF..."):
-                    images = convert_pdf_to_images(uploaded_file)
-                    
-                    if not images:
-                        st.error("Failed to process PDF file.")
-                        st.stop()
+        if uploaded_file.type == "application/pdf":
+            # Handle PDF
+            with st.spinner("Processing PDF..."):
+                images = convert_pdf_to_images(uploaded_file)
 
-                    if st.button("Extract Information"):
-                        with st.spinner("Analyzing document..."):
-                            all_results = []
-                            for i, image in enumerate(images, 1):
-                                result = analyze_image(image)
-                                all_results.append(f"Page {i} Information:\n{result}")
+                if st.button("Extract Information"):
+                    with st.spinner("Analyzing document..."):
+                        all_results = []
+                        for i, image in enumerate(images, 1):
+                            result = analyze_image(image)
+                            all_results.append(f"Page {i} Information:\n{result}")
 
-                            combined_results = "\n\n".join(all_results)
-                            st.markdown(format_response(combined_results))
+                        combined_results = "\n\n".join(all_results)
+                        st.markdown(format_response(combined_results))
 
-            else:
-                # Handle single image
-                image = Image.open(uploaded_file)
+        else:
+            # Handle single image
+            image = Image.open(uploaded_file)
 
-                if st.button("Extract Information"):
-                    with st.spinner("Analyzing document..."):
-                        result = analyze_image(image)
-                        st.markdown(format_response(result))
-                        
-        except Exception as e:
-            st.error(f"An error occurred while processing the file: {str(e)}")
+            if st.button("Extract Information"):
+                with st.spinner("Analyzing document..."):
+                    result = analyze_image(image)
+                    st.markdown(format_response(result))
 
-if __name__ == "__main__":
+if _name_ == "_main_":
     main()