Update app.py

app.py

@@ -3,127 +3,134 @@ import PyPDF2
 from docx import Document
 import json
 from google import genai
+from dotenv import load_dotenv
+import os
+import re
 
-# -------------------------------
-# Utility Functions
-# -------------------------------
+# Load API Key from .env
+load_dotenv()
+api_key = os.getenv("GEMINI_API_KEY")
 
+if not api_key:
+    st.error("❌ Gemini API key not found in .env.")
+    st.stop()
+
+# Utility: Extract text from PDF
 def extract_text_from_pdf(file):
-    """
-    Extracts textual content from a PDF document.
-    """
-    pdf_reader = PyPDF2.PdfReader(file)
+    reader = PyPDF2.PdfReader(file)
     text = ""
-    for page in pdf_reader.pages:
-        page_text = page.extract_text()
-        if page_text:
-            text += page_text + "\n"
-    return text
+    for page in reader.pages:
+        content = page.extract_text()
+        if content:
+            text += content + "\n"
+    return text.strip()
 
+# Utility: Extract text from DOCX
 def extract_text_from_docx(file):
-    """
-    Extracts textual content from a DOCX document.
-    """
-    document = Document(file)
-    text = ""
-    for para in document.paragraphs:
-        text += para.text + "\n"
-    return text
-
-def call_gemini_api(document_content):
-    """
-    Calls the Google GenAI Gemini API (gemini-2.0-flash) with a prompt to analyze and summarize
-    the legal document, extracting key points, highlighting obligations/rights, and simplifying
-    complex legal terms.
-    
-    The prompt instructs the model to return the output in JSON format with three keys:
-      - summary: A concise summary of the document.
-      - highlights: Key obligations, rights, and clauses.
-      - glossary: Simplified explanations of complex legal terms.
-    """
-    # Initialize the Gemini client using your API key stored in Streamlit secrets.
-    api_key = st.secrets["GEMINI_API_KEY"]
+    doc = Document(file)
+    return "\n".join([para.text for para in doc.paragraphs]).strip()
+
+# Utility: Parse Gemini JSON response
+def safe_parse_json(response_text):
+    try:
+        clean_text = re.sub(r"^```(?:json)?|```$", "", response_text.strip(), flags=re.MULTILINE)
+        return json.loads(clean_text)
+    except Exception as e:
+        st.error("⚠️ Could not parse Gemini response as JSON. Showing raw response.")
+        return {
+            "summary": response_text,
+            "highlights": None,
+            "glossary": None
+        }
+
+# Call Gemini API
+def call_gemini_api(document_text):
     client = genai.Client(api_key=api_key)
-    
-    # Construct the prompt with clear instructions
+
     prompt = (
-        f"Analyze the following legal document:\n\n"
-        f"{document_content}\n\n"
+        f"Analyze the following legal document:\n\n{document_text}\n\n"
         "Instructions:\n"
-        "1. Summarize the key points of the document.\n"
-        "2. Highlight obligations, rights, and critical clauses.\n"
-        "3. Provide simplified explanations of complex legal terms.\n"
-        "Output the results as a valid JSON object with the following keys: "
-        "'summary', 'highlights', 'glossary'."
+        "- Summarize the key points of the document.\n"
+        "- Highlight obligations, rights, and critical clauses (as a list of objects with 'clause' and 'description').\n"
+        "- Provide simplified explanations of complex legal terms (as a dictionary).\n"
+        "Return the result as JSON with keys: 'summary', 'highlights', 'glossary'."
     )
-    
-    # Call the Gemini API using the google.genai client
+
     response = client.models.generate_content(
         model="gemini-2.0-flash",
-        contents=prompt,
+        contents=prompt
     )
-    
-    # Try parsing the output JSON; if parsing fails, return the text as the summary.
-    try:
-        result = json.loads(response.text)
-    except Exception as e:
-        st.error("Failed to parse Gemini API response as JSON. Returning raw text instead.")
-        result = {"summary": response.text, "highlights": "N/A", "glossary": "N/A"}
-    
-    return result
 
-# -------------------------------
-# Main Application
-# -------------------------------
+    return safe_parse_json(response.text)
 
+# Render Highlights Beautifully
+def render_highlights(highlights):
+    if isinstance(highlights, list) and all(isinstance(item, dict) for item in highlights):
+        for idx, item in enumerate(highlights, 1):
+            clause = item.get("clause", "").strip()
+            desc = item.get("description", "").strip()
+            if clause and desc:
+                st.markdown(f"""
+                <div style="background-color:#f5f5f5;padding:10px;border-radius:8px;margin-bottom:10px">
+                    <strong>{idx}. {clause}</strong><br>
+                    <span style="font-size: 0.95rem;">{desc}</span>
+                </div>
+                """, unsafe_allow_html=True)
+    elif isinstance(highlights, str):
+        st.markdown(highlights)
+    else:
+        st.info("No highlights available.")
+
+# Render Glossary Beautifully
+def render_glossary(glossary):
+    if isinstance(glossary, dict):
+        for term, explanation in glossary.items():
+            st.markdown(f"""
+            <div style="margin-bottom: 8px;">
+                <strong>{term}:</strong> {explanation}
+            </div>
+            """, unsafe_allow_html=True)
+    elif isinstance(glossary, str):
+        st.markdown(glossary)
+    else:
+        st.info("No glossary available.")
+
+# Main App
 def main():
-    st.title("Legal Document Summarizer")
-    st.write("Upload a legal document (PDF or DOCX) to receive a concise summary, key highlights, and a glossary of complex legal terms.")
+    st.set_page_config(page_title="Legal Document Summarizer", layout="wide")
+    st.title("📄 Legal Document Summarizer")
+    st.caption("Upload a legal document (PDF or DOCX) to get a summary, key highlights, and glossary of legal terms.")
 
-    uploaded_file = st.file_uploader("Upload Legal Document", type=["pdf", "docx"])
+    uploaded_file = st.file_uploader("Upload your document", type=["pdf", "docx"])
 
-    if uploaded_file is not None:
-        # Display file details
-        file_details = {
-            "Filename": uploaded_file.name,
-            "File Type": uploaded_file.type,
-            "File Size (bytes)": uploaded_file.size
-        }
-        st.write("**Uploaded File Details**", file_details)
-        
-        # Extract text from the document based on the file type
-        document_text = ""
+    if uploaded_file:
         if uploaded_file.type == "application/pdf":
             document_text = extract_text_from_pdf(uploaded_file)
         elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
             document_text = extract_text_from_docx(uploaded_file)
         else:
-            st.error("Unsupported file type.")
-
-        if document_text.strip():
-            st.subheader("Extracted Document Text")
-            st.text_area("Document Text", document_text, height=300)
-            
-            if st.button("Summarize Document"):
-                with st.spinner("Analyzing document via Gemini API..."):
-                    result = call_gemini_api(document_text)
-                    if result:
-                        summary = result.get("summary", "No summary provided by the API.")
-                        highlights = result.get("highlights", "No highlights provided by the API.")
-                        glossary = result.get("glossary", "No glossary provided by the API.")
-                        
-                        st.subheader("Document Summary")
-                        st.write(summary)
-                        
-                        st.subheader("Highlights (Obligations, Rights, Critical Clauses)")
-                        st.write(highlights)
-                        
-                        st.subheader("Glossary (Simplified Legal Terms)")
-                        st.write(glossary)
-                    else:
-                        st.error("Failed to retrieve a valid response from the Gemini API.")
-        else:
-            st.error("No text could be extracted from the document.")
+            st.error("Unsupported file format.")
+            return
+
+        if not document_text.strip():
+            st.error("No text extracted from the document.")
+            return
+
+        st.subheader("📄 Document Preview")
+        st.text_area("Extracted Text", document_text, height=300)
+
+        if st.button("Summarize Document"):
+            with st.spinner("Calling Gemini..."):
+                result = call_gemini_api(document_text)
+
+                st.subheader("📝 Summary")
+                st.write(result.get("summary", "No summary found."))
+
+                st.subheader("📌 Highlights")
+                render_highlights(result.get("highlights"))
+
+                st.subheader("📘 Glossary")
+                render_glossary(result.get("glossary"))
 
 if __name__ == "__main__":
     main()