Update app.py

app.py

@@ -2,11 +2,9 @@ import gradio as gr
 import pdfplumber
 import matplotlib.pyplot as plt
 import numpy as np
-import re
 from word2number import w2n
-from simple_salesforce import Salesforce
+import re
 from typing import Tuple, List, Dict
-import os
 
 # Custom CSS for styling
 css = """
@@ -112,11 +110,6 @@ css = """
 }
 """
 
-# Salesforce Authentication (Make sure your credentials are stored securely)
-sf = Salesforce(username='Kushalpavansekharm503@agentforce.com', 
-                password='Kushal@123', 
-                security_token='WwUIFWBVUjeKn9VPKyWJmawY0')
-
 def extract_text_from_pdf(pdf_path: str) -> str:
     """Extract text from PDF using pdfplumber"""
     text = ""
@@ -183,22 +176,90 @@ def calculate_risk_score(penalty_count: int, penalty_values: List[float], obliga
     else:
         return score, "High"
 
-def save_to_salesforce(risk_score: float, risk_level: str, penalty_examples: str, penalty_details: str, penalty_amounts: str, obligation_details: str, delay_details: str) -> str:
-    """Save the results into Salesforce"""
-    try:
-        custom_risk = sf.Custom_Risk_Analysis__c.create({
-            'Sentiment_Score__c': risk_score,
-            'Risk_Score__c': risk_score,
-            'Risk_Level__c': risk_level,
-            'Penalty_Examples__c': penalty_examples,
-            'Penalty_Details__c': penalty_details,
-            'Penalty_Amounts__c': penalty_amounts,
-            'Obligation_Details__c': obligation_details,
-            'Delay_Details__c': delay_details
-        })
-        return f"Successfully saved to Salesforce with Record ID: {custom_risk['id']}"
-    except Exception as e:
-        return f"Error saving to Salesforce: {str(e)}"
+def generate_combined_risk_display(risk_score: float, risk_level: str) -> Tuple[str, plt.Figure]:
+    """Generate a combined display with all three risk levels in one layout"""
+    fig, ax = plt.subplots(figsize=(10, 3))
+    ax.axis('off')
+    
+    risk_levels = ["Low", "Medium", "High"]
+    colors = ['#28a745', '#ffc107', '#dc3545']
+    
+    # Create HTML for the text display
+    html_parts = []
+    html_parts.append("<div class='combined-risk-container'>")
+    
+    for i, level in enumerate(risk_levels):
+        active = level == risk_level
+        score = risk_score if active else 0
+        
+        # Add to HTML
+        html_parts.append(f"""
+        <div class='risk-row'>
+            <div class='risk-label risk-{level.lower()}'>{level} Risk</div>
+            <div class='risk-score risk-{level.lower()}'>{score:.1f}%</div>
+            <div class='heatmap-wrapper'>
+                <img src='data:image/png;base64,{create_mini_heatmap(score, colors[i])}' style='width:100%'>
+            </div>
+        </div>
+        """)
+    
+    html_parts.append("</div>")
+    
+    return "\n".join(html_parts), fig
+
+def create_mini_heatmap(score: float, color: str) -> str:
+    """Create a small heatmap for one risk level"""
+    fig, ax = plt.subplots(figsize=(8, 0.5))
+    
+    if score > 0:
+        gradient = np.linspace(0, score/100, 256).reshape(1, -1)
+    else:
+        gradient = np.zeros((1, 256))
+    
+    gradient = np.vstack((gradient, gradient))
+    
+    ax.imshow(gradient, aspect='auto', cmap=plt.cm.colors.LinearSegmentedColormap.from_list('custom', ['white', color]))
+    ax.set_axis_off()
+    plt.tight_layout()
+    
+    # Save to base64 string
+    from io import BytesIO
+    buf = BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
+    plt.close(fig)
+    import base64
+    return base64.b64encode(buf.getvalue()).decode('utf-8')
+
+def format_warning_message(count: int, items: str, item_type: str) -> str:
+    """Format warning message based on count"""
+    if count == 0:
+        return f"""<div class="success-box">✓ No {item_type} clauses detected - Good!</div>"""
+    elif count < 5:
+        return f"""<div class="warning-box">⚠️ {count} {item_type} clauses detected</div>"""
+    else:
+        return f"""<div class="danger-box">⚠️⚠️ {count} {item_type} clauses detected - High Risk!</div>"""
+
+def create_vertical_count_display(counts: Dict[str, int], total: int, section_type: str) -> str:
+    """Create a vertical display for counts with section styling"""
+    items_html = []
+    for kw, count in counts.items():
+        items_html.append(f"""
+        <div class="count-item">
+            <span class="count-label">{kw.title()}:</span>
+            <span class="count-value">{count}</span>
+        </div>
+        """)
+    
+    return f"""
+    <div class="section-container {section_type}-box">
+        <div class="section-title">{section_type.title()} Analysis</div>
+        <div style="margin-bottom: 10px;">
+            <span style="font-weight: bold;">Total:</span>
+            <span style="margin-left: 10px;">{total}</span>
+        </div>
+        {"".join(items_html)}
+    </div>
+    """
 
 def analyze_pdf(file_obj) -> List:
     """Main analysis function for Gradio interface"""
@@ -229,32 +290,85 @@ def analyze_pdf(file_obj) -> List:
             total_penalties, penalty_values, total_obligations, total_delays
         )
         
-        # Save to Salesforce
-        save_message = save_to_salesforce(
-            risk_score, risk_level, str(penalty_counts), str(penalty_values), str(penalty_values), 
-            str(obligation_counts), str(delay_counts)
-        )
+        # Generate combined risk display
+        risk_display, _ = generate_combined_risk_display(risk_score, risk_level)
         
-        # Return results
-        return [f"Analysis complete! {save_message}"]
-
+        # Prepare warning/success messages
+        penalty_warning = format_warning_message(total_penalties, "penalty", "penalty")
+        obligation_warning = format_warning_message(total_obligations, "obligation", "obligation")
+        delay_warning = format_warning_message(total_delays, "delay", "delay")
+        
+        # Create vertical displays
+        penalty_display = create_vertical_count_display(penalty_counts, total_penalties, "penalty")
+        obligation_display = create_vertical_count_display(obligation_counts, total_obligations, "obligation")
+        delay_display = create_vertical_count_display(delay_counts, total_delays, "delay")
+        
+        # Combine warnings with displays
+        penalty_output = f"{penalty_warning}\n{penalty_display}"
+        obligation_output = f"{obligation_warning}\n{obligation_display}"
+        delay_output = f"{delay_warning}\n{delay_display}"
+        
+        penalty_amounts = "\n".join([f"- ${amt:,.2f}" for amt in penalty_values[:5]]) if penalty_values else "No specific penalty amounts found"
+        
+        # Find example sentences with penalties
+        penalty_sentences = []
+        for sentence in re.split(r'(?<=[.!?])\s+', text):
+            if any(kw.lower() in sentence.lower() for kw in penalty_keywords):
+                penalty_sentences.append(sentence.strip())
+        
+        penalty_examples = "\n\n".join([f"{i+1}. {sent}" for i, sent in enumerate(penalty_sentences[:3])]) if penalty_sentences else "No penalty clauses found"
+        
+        # Return all results
+        return [
+            risk_display,
+            penalty_output,
+            f"{len(penalty_values)} amounts found\n\n{penalty_amounts}",
+            obligation_output,
+            delay_output,
+            penalty_examples
+        ]
     except Exception as e:
         return [f"Error: {str(e)}"] * 6
 
-# Create Gradio interface (updated with correct output component)
+# Create Gradio interface
 with gr.Blocks(css=css, title="PDF Contract Risk Analyzer") as demo:
     gr.Markdown("# 📄 PDF Contract Risk Analyzer")
     gr.Markdown("Upload a contract PDF to analyze penalties, obligations, and delays.")
     
     with gr.Row():
-        file_input = gr.File(label="Upload PDF", file_types=[".pdf"])
-        submit_btn = gr.Button("Analyze PDF", variant="primary")
+        with gr.Column():
+            file_input = gr.File(label="Upload PDF", file_types=[".pdf"])
+            submit_btn = gr.Button("Analyze PDF", variant="primary")
+        
+        with gr.Column():
+            gr.Markdown("### 🔍 Overall Risk Assessment")
+            risk_display = gr.HTML(label="Risk Analysis")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📊 Penalties Analysis")
+            penalty_count = gr.HTML(label="Penalty Clauses")
+            gr.Markdown("### Penalty Amounts")
+            penalty_amounts = gr.Textbox(label="", lines=5)
+        
+        with gr.Column():
+            gr.Markdown("### ⚖️ Obligations Analysis")
+            obligation_count = gr.HTML(label="Obligation Clauses")
+        
+        with gr.Column():
+            gr.Markdown("### ⏱️ Delays Analysis")
+            delay_count = gr.HTML(label="Delay Clauses")
     
     with gr.Row():
-        # Update the output to use gr.HTML (or gr.Textbox depending on your needs)
-        result_output = gr.HTML(label="Analysis Result")
+        gr.Markdown("### 🔎 Extracted Penalty Clauses")
+        penalty_examples = gr.Textbox(label="Example Penalty Clauses", lines=5)
     
-    submit_btn.click(fn=analyze_pdf, inputs=file_input, outputs=result_output)
+    submit_btn.click(
+        fn=analyze_pdf,
+        inputs=file_input,
+        outputs=[risk_display, penalty_count, penalty_amounts, 
+                obligation_count, delay_count, penalty_examples]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()