Update app.py

app.py

@@ -347,8 +347,279 @@ def get_hugging_face_sentiment(text: str) -> float:
         logger.error(f"Hugging Face sentiment analysis failed: {str(e)}. Using fallback score.")
         return 0.5
 
+def extract_text_from_pdf(pdf_path: str) -> str:
+    """Extract text from PDF using pdfplumber"""
+    try:
+        text = ""
+        with pdfplumber.open(pdf_path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n"
+        return text
+    except Exception as e:
+        logger.error(f"PDF text extraction failed: {str(e)}")
+        raise Exception(f"PDF text extraction failed: {str(e)}")
+
+def extract_penalty_clauses(text: str) -> List[Dict]:
+    """Extract detailed penalty information including exact amounts and percentages"""
+    penalty_patterns = [
+        (r'(penalty|fine|forfeit|liquidated damages|breach damages?)\s*(?:of|:)?\s*(\$?\s*[\d,]+(?:\.\d+)?|\d+\s*%)', 
+         "Standard monetary penalty"),
+        (r'(penalty|fine)\s*(?:shall be|of|is)\s*(\d+\s*%\s*of)', "Percentage penalty"),
+        (r'(?:not to exceed|up to|maximum of)\s*(\$?\s*[\d,]+(?:\.\d+)?)', "Maximum penalty"),
+        (r'(?:sum of|amount of)\s*(\$?\s*[\d,]+(?:\.\d+)?)\s*(?:per\s*(?:day|month|year|violation))', "Recurring penalty"),
+        (r'(?:penalty of|fine of)\s*([a-zA-Z\s]+)\s*dollars', "Word-form penalty")
+    ]
+    
+    penalties = []
+    for pattern, penalty_type in penalty_patterns:
+        matches = re.finditer(pattern, text, flags=re.IGNORECASE)
+        for match in matches:
+            full_match = match.group(0)
+            amount_match = match.group(1) if len(match.groups()) > 1 else match.group(0)
+            
+            # Get context (2 sentences around the match)
+            sentences = re.split(r'(?<=[.!?])\s+', text)
+            for i, sentence in enumerate(sentences):
+                if match.group(0) in sentence:
+                    context = " ".join(sentences[max(0,i-1):min(len(sentences),i+2)])
+                    break
+            
+            penalty = {
+                'type': penalty_type,
+                'clause': full_match.strip(),
+                'amount': amount_match.strip(),
+                'context': context,
+                'numeric_value': None,
+                'is_percentage': False
+            }
+            
+            # Convert amount to numeric value
+            try:
+                if '%' in amount_match:
+                    penalty['numeric_value'] = float(re.sub(r'[^\d.]', '', amount_match))
+                    penalty['is_percentage'] = True
+                elif any(word in amount_match.lower() for word in ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'hundred', 'thousand', 'million']):
+                    penalty['numeric_value'] = w2n.word_to_num(amount_match.split('dollars')[0].strip())
+                else:
+                    penalty['numeric_value'] = float(re.sub(r'[^\d.]', '', amount_match))
+                
+                penalties.append(penalty)
+            except Exception as e:
+                logger.warning(f"Couldn't convert penalty amount: {amount_match} - {str(e)}")
+                continue
+    
+    return penalties
+
+def extract_obligation_clauses(text: str) -> List[Dict]:
+    """Extract detailed obligation information with context and subjects"""
+    obligation_keywords = ["shall", "must", "required to", "obligated to", "duty", "responsibility", "covenant"]
+    obligations = []
+    
+    for keyword in obligation_keywords:
+        matches = re.finditer(r'([^.]*?\b' + re.escape(keyword) + r'\b[^.]*\.)', text, flags=re.IGNORECASE)
+        for match in matches:
+            clause = match.group(1).strip()
+            
+            # Find the subject of the obligation (who is obligated)
+            subject = "Party"
+            subject_match = re.search(r'(\b[A-Z][a-zA-Z\s,]+\b)\s+(?:shall|must|is required to)', clause)
+            if subject_match:
+                subject = subject_match.group(1)
+            
+            obligations.append({
+                'keyword': keyword,
+                'clause': clause,
+                'subject': subject,
+                'timeframe': extract_timeframe(clause)
+            })
+    
+    return obligations
+
+def extract_delay_clauses(text: str) -> List[Dict]:
+    """Extract detailed delay information with context and consequences"""
+    delay_keywords = ["delay", "late", "overdue", "extension", "time is of the essence", "timely performance"]
+    delays = []
+    
+    for keyword in delay_keywords:
+        matches = re.finditer(r'([^.]*?\b' + re.escape(keyword) + r'\b[^.]*\.)', text, flags=re.IGNORECASE)
+        for match in matches:
+            clause = match.group(1).strip()
+            
+            # Extract timeframe if mentioned
+            timeframe = extract_timeframe(clause)
+            
+            # Extract consequences
+            consequences = "Not specified"
+            if "penalty" in clause.lower():
+                consequences = "Monetary penalty"
+            elif "termination" in clause.lower():
+                consequences = "Contract termination"
+            elif "damages" in clause.lower():
+                consequences = "Liability for damages"
+            
+            delays.append({
+                'keyword': keyword,
+                'clause': clause,
+                'timeframe': timeframe,
+                'consequences': consequences
+            })
+    
+    return delays
+
+def extract_timeframe(text: str) -> str:
+    """Extract timeframe from a clause"""
+    timeframe_patterns = [
+        r'within\s*(\d+\s*(?:days?|months?|years?|hours?))',
+        r'no\s*more\s*than\s*(\d+\s*(?:days?|months?|years?))',
+        r'(\d+\s*(?:days?|months?|years?)\s*from\s*the\s*date)',
+        r'(\d+\s*-\s*(?:day|month|year)\s*period)'
+    ]
+    
+    for pattern in timeframe_patterns:
+        match = re.search(pattern, text, flags=re.IGNORECASE)
+        if match:
+            return match.group(1)
+    
+    return "Not specified"
+
+def calculate_risk_score(penalties: List[Dict], obligations: List[Dict], delays: List[Dict]) -> Tuple[float, str]:
+    """Calculate comprehensive risk score based on detailed analysis"""
+    score = 0
+    
+    # Penalty factors (40% of total score)
+    penalty_score = 0
+    for penalty in penalties:
+        if penalty['numeric_value'] is not None:
+            if penalty['is_percentage']:
+                # Percentage penalties are considered more severe
+                penalty_score += min(penalty['numeric_value'] * 2, 50)
+            else:
+                if penalty['numeric_value'] > 1000000:
+                    penalty_score += 40
+                elif penalty['numeric_value'] > 100000:
+                    penalty_score += 25
+                elif penalty['numeric_value'] > 10000:
+                    penalty_score += 15
+                else:
+                    penalty_score += 5
+        else:
+            penalty_score += 5  # Penalty without specified amount
+    
+    score += min(penalty_score * 0.4, 40)
+    
+    # Obligation factors (30% of total score)
+    obligation_score = 0
+    for obligation in obligations:
+        if "shall" in obligation['keyword'].lower():
+            obligation_score += 3
+        elif "must" in obligation['keyword'].lower():
+            obligation_score += 4
+        elif "required" in obligation['keyword'].lower():
+            obligation_score += 2
+        else:
+            obligation_score += 1
+            
+        # More points for strict timeframes
+        if "days" in obligation['timeframe'].lower():
+            obligation_score += 2
+        elif "hours" in obligation['timeframe'].lower():
+            obligation_score += 3
+    
+    score += min(obligation_score * 0.3, 30)
+    
+    # Delay factors (30% of total score)
+    delay_score = 0
+    for delay in delays:
+        if "termination" in delay['consequences'].lower():
+            delay_score += 15
+        elif "penalty" in delay['consequences'].lower():
+            delay_score += 10
+        elif "damages" in delay['consequences'].lower():
+            delay_score += 8
+        else:
+            delay_score += 5
+    
+    score += min(delay_score * 0.3, 30)
+    
+    score = min(score, 100)
+    
+    if score < 30:
+        return score, "Low"
+    elif score < 70:
+        return score, "Medium"
+    else:
+        return score, "High"
+
+def generate_risk_meter(risk_score: float) -> str:
+    """Generate a visual risk meter with indicator"""
+    position = risk_score
+    return f"""
+    <div class="risk-meter">
+        <div class="risk-meter-indicator" style="left: {position}%"></div>
+    </div>
+    <div class="risk-meter-labels">
+        <span>Low (0-30)</span>
+        <span>Medium (31-69)</span>
+        <span>High (70-100)</span>
+    </div>
+    """
+
+def generate_sentiment_meter(sentiment_score: float) -> str:
+    """Generate a visual sentiment meter"""
+    width = sentiment_score * 100
+    return f"""
+    <div class="sentiment-meter">
+        <div class="sentiment-score" style="width: {width}%"></div>
+    </div>
+    <div style="display: flex; justify-content: space-between; margin-top: 5px;">
+        <span>Negative</span>
+        <span>Neutral</span>
+        <span>Positive</span>
+    </div>
+    """
+
+def generate_heatmap(risk_level: str):
+    """Generate a simple heatmap based on risk level"""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 2))
+        
+        if risk_level == "Low":
+            cmap = plt.cm.Blues
+            color = '#4CAF50'
+        elif risk_level == "Medium":
+            cmap = plt.cm.Oranges
+            color = '#FF9800'
+        else:
+            cmap = plt.cm.Reds
+            color = '#F44336'
+        
+        gradient = np.linspace(0, 1, 256).reshape(1, -1)
+        gradient = np.vstack((gradient, gradient))
+        
+        ax.imshow(gradient, aspect='auto', cmap=cmap)
+        ax.text(128, 0.5, f"{risk_level} Risk", color='white' if risk_level in ["High", "Medium"] else 'black',
+                ha='center', va='center', fontsize=24, fontweight="bold")
+        
+        ax.set_axis_off()
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logger.error(f"Heatmap generation failed: {str(e)}")
+        raise Exception(f"Heatmap generation failed: {str(e)}")
+
+def format_clause_example(example: str, index: int) -> str:
+    """Format a clause example with proper wrapping and styling"""
+    wrapped_text = textwrap.fill(example, width=80)
+    return f"""
+    <div class="clause-example">
+        <span class="clause-number">{index}.</span> {wrapped_text}
+    </div>
+    """
+
 def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
-    """Generate a comprehensive PDF report with analysis results"""
+    """Generate a comprehensive PDF report with detailed analysis results"""
     try:
         pdf_file = BytesIO()
         c = canvas.Canvas(pdf_file, pagesize=letter)
@@ -359,8 +630,6 @@ def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
         c.setFont("Helvetica", 10)
         c.drawString(1 * inch, 10.2 * inch, f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         c.drawString(1 * inch, 10 * inch, f"Document: {analysis_data.get('document_name', 'Unknown')}")
-        
-        # Add a line separator
         c.line(1 * inch, 9.8 * inch, 7.5 * inch, 9.8 * inch)
         
         # Risk Summary Section
@@ -369,7 +638,6 @@ def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
         c.drawString(1 * inch, y_position, "1. Risk Summary")
         y_position -= 0.3 * inch
         
-        c.setFont("Helvetica", 10)
         risk_level = analysis_data['risk_level']
         risk_color = {
             "Low": "#4CAF50",
@@ -403,59 +671,156 @@ def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
         # Detailed Metrics Section
         y_position -= 0.3 * inch
         c.setFont("Helvetica-Bold", 14)
-        c.drawString(1 * inch, y_position, "2. Detailed Metrics")
+        c.drawString(1 * inch, y_position, "2. Detailed Analysis")
         y_position -= 0.3 * inch
         
-        # Sentiment Analysis
+        # Penalty Details
         c.setFont("Helvetica-Bold", 12)
-        c.drawString(1 * inch, y_position, "Sentiment Analysis:")
+        c.drawString(1 * inch, y_position, "2.1 Penalty Clauses")
         y_position -= 0.2 * inch
         c.setFont("Helvetica", 10)
-        sentiment_score = analysis_data['sentiment_score']
-        sentiment_text = (
-            "Positive (favorable language)" if sentiment_score > 0.6 else
-            "Negative (adversarial language)" if sentiment_score < 0.4 else
-            "Neutral (balanced language)"
-        )
-        c.drawString(1.2 * inch, y_position, f"Score: {sentiment_score:.2f} - {sentiment_text}")
+        c.drawString(1.2 * inch, y_position, f"Total penalty clauses found: {len(analysis_data['penalties'])}")
         y_position -= 0.2 * inch
-        c.drawString(1.2 * inch, y_position, "Interpretation: Measures the overall tone of the contract language.")
-        y_position -= 0.25 * inch
         
-        # Penalty Analysis
+        if analysis_data['penalties']:
+            # Find max, min, and average penalties
+            numeric_penalties = [p['numeric_value'] for p in analysis_data['penalties'] if p['numeric_value'] is not None]
+            if numeric_penalties:
+                max_penalty = max(numeric_penalties)
+                min_penalty = min(numeric_penalties)
+                avg_penalty = sum(numeric_penalties)/len(numeric_penalties)
+                
+                c.drawString(1.2 * inch, y_position, f"Highest penalty amount: {max_penalty:,.2f}{'%' if analysis_data['penalties'][numeric_penalties.index(max_penalty)]['is_percentage'] else '$'}")
+                y_position -= 0.2 * inch
+                c.drawString(1.2 * inch, y_position, f"Average penalty amount: {avg_penalty:,.2f}{'%' if any(p['is_percentage'] for p in analysis_data['penalties']) else '$'}")
+                y_position -= 0.2 * inch
+                c.drawString(1.2 * inch, y_position, f"Lowest penalty amount: {min_penalty:,.2f}{'%' if analysis_data['penalties'][numeric_penalties.index(min_penalty)]['is_percentage'] else '$'}")
+                y_position -= 0.2 * inch
+            
+            # Example penalty clauses
+            c.drawString(1.2 * inch, y_position, "Example Penalty Clauses:")
+            y_position -= 0.2 * inch
+            
+            for i, penalty in enumerate(analysis_data['penalties'][:3]):
+                c.drawString(1.4 * inch, y_position, f"{i+1}. {penalty['type']}: {penalty['amount']}")
+                y_position -= 0.2 * inch
+                for line in textwrap.wrap(penalty['clause'], width=90):
+                    c.drawString(1.6 * inch, y_position, line)
+                    y_position -= 0.2 * inch
+                y_position -= 0.1 * inch
+        else:
+            c.drawString(1.2 * inch, y_position, "No penalty clauses detected.")
+            y_position -= 0.2 * inch
+        
+        y_position -= 0.3 * inch
+        
+        # Obligation Details
+        if y_position < 2 * inch:
+            c.showPage()
+            y_position = 10.5 * inch
+            
         c.setFont("Helvetica-Bold", 12)
-        c.drawString(1 * inch, y_position, "Penalty Analysis:")
+        c.drawString(1 * inch, y_position, "2.2 Obligation Clauses")
         y_position -= 0.2 * inch
         c.setFont("Helvetica", 10)
-        c.drawString(1.2 * inch, y_position, f"Total penalty clauses found: {analysis_data['penalty_count']}")
+        c.drawString(1.2 * inch, y_position, f"Total obligation clauses found: {len(analysis_data['obligations'])}")
         y_position -= 0.2 * inch
-        if analysis_data['penalty_values']:
-            c.drawString(1.2 * inch, y_position, f"Highest penalty amount: ${max(analysis_data['penalty_values']):,.2f}")
+        
+        if analysis_data['obligations']:
+            # Count by keyword
+            keyword_counts = {}
+            for obligation in analysis_data['obligations']:
+                keyword = obligation['keyword']
+                keyword_counts[keyword] = keyword_counts.get(keyword, 0) + 1
+            
+            c.drawString(1.2 * inch, y_position, "Obligation Keywords:")
             y_position -= 0.2 * inch
-            c.drawString(1.2 * inch, y_position, f"Average penalty amount: ${sum(analysis_data['penalty_values'])/len(analysis_data['penalty_values']):,.2f}")
+            for keyword, count in keyword_counts.items():
+                c.drawString(1.4 * inch, y_position, f"- {keyword}: {count}")
+                y_position -= 0.2 * inch
+            
+            # Example obligations
+            c.drawString(1.2 * inch, y_position, "Example Obligation Clauses:")
             y_position -= 0.2 * inch
-        c.drawString(1.2 * inch, y_position, "Interpretation: Penalties are financial consequences for non-compliance.")
-        y_position -= 0.25 * inch
+            
+            for i, obligation in enumerate(analysis_data['obligations'][:3]):
+                c.drawString(1.4 * inch, y_position, f"{i+1}. {obligation['keyword']} (Subject: {obligation['subject']})")
+                y_position -= 0.2 * inch
+                c.drawString(1.4 * inch, y_position, f"Timeframe: {obligation['timeframe']}")
+                y_position -= 0.2 * inch
+                for line in textwrap.wrap(obligation['clause'], width=90):
+                    c.drawString(1.6 * inch, y_position, line)
+                    y_position -= 0.2 * inch
+                y_position -= 0.1 * inch
+        else:
+            c.drawString(1.2 * inch, y_position, "No obligation clauses detected.")
+            y_position -= 0.2 * inch
+        
+        y_position -= 0.3 * inch
         
-        # Obligation Analysis
+        # Delay Details
+        if y_position < 2 * inch:
+            c.showPage()
+            y_position = 10.5 * inch
+            
         c.setFont("Helvetica-Bold", 12)
-        c.drawString(1 * inch, y_position, "Obligation Analysis:")
+        c.drawString(1 * inch, y_position, "2.3 Delay Clauses")
         y_position -= 0.2 * inch
         c.setFont("Helvetica", 10)
-        c.drawString(1.2 * inch, y_position, f"Total obligation clauses found: {analysis_data['obligation_count']}")
+        c.drawString(1.2 * inch, y_position, f"Total delay clauses found: {len(analysis_data['delays'])}")
         y_position -= 0.2 * inch
-        c.drawString(1.2 * inch, y_position, "Interpretation: Obligations are requirements that must be fulfilled.")
-        y_position -= 0.25 * inch
         
-        # Delay Analysis
+        if analysis_data['delays']:
+            # Count by consequence
+            consequence_counts = {}
+            for delay in analysis_data['delays']:
+                consequence = delay['consequences']
+                consequence_counts[consequence] = consequence_counts.get(consequence, 0) + 1
+            
+            c.drawString(1.2 * inch, y_position, "Delay Consequences:")
+            y_position -= 0.2 * inch
+            for consequence, count in consequence_counts.items():
+                c.drawString(1.4 * inch, y_position, f"- {consequence}: {count}")
+                y_position -= 0.2 * inch
+            
+            # Example delays
+            c.drawString(1.2 * inch, y_position, "Example Delay Clauses:")
+            y_position -= 0.2 * inch
+            
+            for i, delay in enumerate(analysis_data['delays'][:3]):
+                c.drawString(1.4 * inch, y_position, f"{i+1}. {delay['keyword']} (Consequence: {delay['consequences']})")
+                y_position -= 0.2 * inch
+                c.drawString(1.4 * inch, y_position, f"Timeframe: {delay['timeframe']}")
+                y_position -= 0.2 * inch
+                for line in textwrap.wrap(delay['clause'], width=90):
+                    c.drawString(1.6 * inch, y_position, line)
+                    y_position -= 0.2 * inch
+                y_position -= 0.1 * inch
+        else:
+            c.drawString(1.2 * inch, y_position, "No delay clauses detected.")
+            y_position -= 0.2 * inch
+        
+        y_position -= 0.3 * inch
+        
+        # Sentiment Analysis
+        if y_position < 2 * inch:
+            c.showPage()
+            y_position = 10.5 * inch
+            
         c.setFont("Helvetica-Bold", 12)
-        c.drawString(1 * inch, y_position, "Delay Analysis:")
+        c.drawString(1 * inch, y_position, "2.4 Sentiment Analysis")
         y_position -= 0.2 * inch
         c.setFont("Helvetica", 10)
-        c.drawString(1.2 * inch, y_position, f"Total delay clauses found: {analysis_data['delay_count']}")
+        sentiment_score = analysis_data['sentiment_score']
+        sentiment_text = (
+            "Positive (favorable language)" if sentiment_score > 0.6 else
+            "Negative (adversarial language)" if sentiment_score < 0.4 else
+            "Neutral (balanced language)"
+        )
+        c.drawString(1.2 * inch, y_position, f"Score: {sentiment_score:.2f} - {sentiment_text}")
+        y_position -= 0.2 * inch
+        c.drawString(1.2 * inch, y_position, "Interpretation: Measures the overall tone of the contract language.")
         y_position -= 0.2 * inch
-        c.drawString(1.2 * inch, y_position, "Interpretation: Delay clauses specify timelines and consequences for delays.")
-        y_position -= 0.3 * inch
         
         # Key Findings Section
         if y_position < 2 * inch:
@@ -471,10 +836,12 @@ def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
         findings = []
         if analysis_data['risk_level'] == "High":
             findings.append("⚠️ High-risk contract requiring immediate legal review")
-        if analysis_data['penalty_count'] > 5:
-            findings.append(f"⚠️ High number of penalty clauses ({analysis_data['penalty_count']})")
-        if analysis_data['obligation_count'] > 10:
-            findings.append(f"📝 Numerous obligations ({analysis_data['obligation_count']}) that may require tracking")
+        if len(analysis_data['penalties']) > 5:
+            findings.append(f"⚠️ High number of penalty clauses ({len(analysis_data['penalties'])})")
+        if any(p['is_percentage'] for p in analysis_data['penalties']):
+            findings.append("⚠️ Percentage-based penalties detected (may have significant impact)")
+        if len(analysis_data['obligations']) > 10:
+            findings.append(f"📝 Numerous obligations ({len(analysis_data['obligations'])}) that may require tracking")
         if analysis_data['sentiment_score'] < 0.4:
             findings.append("🔍 Contract language appears adversarial (low sentiment score)")
             
@@ -496,9 +863,11 @@ def generate_analysis_pdf(analysis_data: Dict) -> BytesIO:
         if analysis_data['risk_level'] == "High":
             recommendations.append("• Engage legal counsel for comprehensive review")
             recommendations.append("• Negotiate penalty clauses and liability terms")
-        if analysis_data['penalty_count'] > 0:
+        if len(analysis_data['penalties']) > 0:
             recommendations.append("• Review all penalty clauses for fairness and applicability")
-        if analysis_data['obligation_count'] > 10:
+            if any(p['is_percentage'] for p in analysis_data['penalties']):
+                recommendations.append("• Pay special attention to percentage-based penalties which may have significant impact")
+        if len(analysis_data['obligations']) > 10:
             recommendations.append("• Create an obligation tracking system")
         if analysis_data['sentiment_score'] < 0.4:
             recommendations.append("• Consider negotiating more balanced language")
@@ -543,152 +912,210 @@ def save_to_salesforce(sf: Salesforce, data: Dict) -> str:
         logger.error(f"Failed to save to Salesforce: {str(e)}")
         raise Exception(f"Salesforce record creation failed: {str(e)}")
 
-def extract_text_from_pdf(pdf_path: str) -> str:
-    """Extract text from PDF using pdfplumber"""
-    try:
-        text = ""
-        with pdfplumber.open(pdf_path) as pdf:
-            for page in pdf.pages:
-                page_text = page.extract_text()
-                if page_text:
-                    text += page_text
-        return text
-    except Exception as e:
-        logger.error(f"PDF text extraction failed: {str(e)}")
-        raise Exception(f"PDF text extraction failed: {str(e)}")
-
-def count_keywords(text: str, keywords: List[str]) -> Dict[str, int]:
-    """Count occurrences of keywords in text"""
-    counts = {}
-    for keyword in keywords:
-        counts[keyword] = len(re.findall(r'\b' + re.escape(keyword) + r'\b', text, flags=re.IGNORECASE))
-    return counts
-
-def find_penalty_values(text: str) -> List[float]:
-    """Find penalty amounts in the text"""
-    patterns = [
-        r'\$\s*[\d,]+(?:\.\d+)?',
-        r'(?:USD|usd)\s*[\d,]+(?:\.\d+)?',
-        r'\d+\s*(?:percent|%)',
-        r'(?:\b[a-z]+\s*)+dollars',
-    ]
-    
-    penalties = []
-    for pattern in patterns:
-        matches = re.finditer(pattern, text, flags=re.IGNORECASE)
-        for match in matches:
-            penalty_text = match.group()
-            try:
-                if any(word in penalty_text.lower() for word in ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'hundred', 'thousand', 'million']):
-                    penalty_value = w2n.word_to_num(penalty_text.split('dollars')[0].strip())
-                else:
-                    penalty_value = float(re.sub(r'[^\d.]', '', penalty_text))
-                penalties.append(penalty_value)
-            except:
-                continue
-    return penalties
-
-def calculate_risk_score(penalty_count: int, penalty_values: List[float], obligation_count: int, delay_count: int) -> Tuple[float, str]:
-    """Calculate risk score based on various factors"""
-    score = 0
-    score += min(penalty_count * 5, 30)
-    
-    if penalty_values:
-        avg_penalty = sum(penalty_values) / len(penalty_values)
-        if avg_penalty > 1000000:
-            score += 40
-        elif avg_penalty > 100000:
-            score += 25
-        elif avg_penalty > 10000:
-            score += 15
-        else:
-            score += 5
+def format_penalty_details(penalties: List[Dict]) -> str:
+    """Format penalty details for HTML display with exact amounts"""
+    if not penalties:
+        return """
+        <div class='penalty-box'>
+            <div class='section-title'>💰 Penalty Clauses Analysis</div>
+            <div class='success-box'>✅ No penalty clauses detected!</div>
+        </div>
+        """
     
-    score += min(obligation_count * 2, 20)
-    score += min(delay_count * 10, 30)
-    score = min(score, 100)
+    penalty_count = len(penalties)
+    warning_level = "success-box" if penalty_count == 0 else "info-box" if penalty_count < 3 else "warning-box" if penalty_count < 5 else "danger-box"
+    warning_emoji = "✅" if penalty_count == 0 else "🛈" if penalty_count < 3 else "⚠" if penalty_count < 5 else "🚨"
     
-    if score < 30:
-        return score, "Low"
-    elif score < 70:
-        return score, "Medium"
+    # Calculate statistics
+    numeric_penalties = [p['numeric_value'] for p in penalties if p['numeric_value'] is not None]
+    if numeric_penalties:
+        max_penalty = max(numeric_penalties)
+        min_penalty = min(numeric_penalties)
+        avg_penalty = sum(numeric_penalties)/len(numeric_penalties)
+        max_penalty_obj = penalties[[p['numeric_value'] for p in penalties].index(max_penalty)]
+        min_penalty_obj = penalties[[p['numeric_value'] for p in penalties].index(min_penalty)]
+        
+        stats_html = f"""
+        <div class='count-item'>
+            <span class='count-label'>Highest Penalty</span>
+            <span class='count-value'>{max_penalty:,.2f}{'%' if max_penalty_obj['is_percentage'] else '$'}</span>
+        </div>
+        <div class='count-item'>
+            <span class='count-label'>Average Penalty</span>
+            <span class='count-value'>{avg_penalty:,.2f}{'%' if any(p['is_percentage'] for p in penalties) else '$'}</span>
+        </div>
+        <div class='count-item'>
+            <span class='count-label'>Lowest Penalty</span>
+            <span class='count-value'>{min_penalty:,.2f}{'%' if min_penalty_obj['is_percentage'] else '$'}</span>
+        </div>
+        """
     else:
-        return score, "High"
-
-def generate_risk_meter(risk_score: float) -> str:
-    """Generate a visual risk meter with indicator"""
-    position = risk_score
+        stats_html = "<div class='info-box'>🛈 Penalty amounts could not be quantified</div>"
+    
+    # Penalty types breakdown
+    type_counts = {}
+    for penalty in penalties:
+        p_type = penalty['type']
+        type_counts[p_type] = type_counts.get(p_type, 0) + 1
+    
+    types_html = "\n".join([
+        f"<div class='count-item'><span class='count-label'>{p_type}</span><span class='count-value'>{count}</span></div>"
+        for p_type, count in type_counts.items()
+    ])
+    
+    # Example clauses
+    example_clauses = "\n".join([
+        format_clause_example(penalty['clause'], i+1)
+        for i, penalty in enumerate(penalties[:3])
+    ])
+    
     return f"""
-    <div class="risk-meter">
-        <div class="risk-meter-indicator" style="left: {position}%"></div>
-    </div>
-    <div class="risk-meter-labels">
-        <span>Low (0-30)</span>
-        <span>Medium (31-69)</span>
-        <span>High (70-100)</span>
+    <div class='penalty-box'>
+        <div class='section-title'>💰 Penalty Clauses Analysis</div>
+        <div class='{warning_level}'>{warning_emoji} {penalty_count} penalty clauses detected!</div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📊 Penalty Statistics</div>
+            {stats_html}
+        </div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📝 Penalty Types</div>
+            {types_html}
+        </div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📜 Example Penalty Clauses</div>
+            {example_clauses if example_clauses else "<div class='info-box'>No example clauses available</div>"}
+        </div>
     </div>
     """
 
-def generate_sentiment_meter(sentiment_score: float) -> str:
-    """Generate a visual sentiment meter"""
-    width = sentiment_score * 100
+def format_obligation_details(obligations: List[Dict]) -> str:
+    """Format obligation details for HTML display"""
+    if not obligations:
+        return """
+        <div class='obligation-box'>
+            <div class='section-title'>📝 Obligation Clauses Analysis</div>
+            <div class='success-box'>✅ No obligation clauses detected!</div>
+        </div>
+        """
+    
+    obligation_count = len(obligations)
+    warning_level = "success-box" if obligation_count == 0 else "info-box" if obligation_count < 5 else "warning-box" if obligation_count < 10 else "danger-box"
+    warning_emoji = "✅" if obligation_count == 0 else "🛈" if obligation_count < 5 else "⚠" if obligation_count < 10 else "🚨"
+    
+    # Keyword breakdown
+    keyword_counts = {}
+    for obligation in obligations:
+        keyword = obligation['keyword']
+        keyword_counts[keyword] = keyword_counts.get(keyword, 0) + 1
+    
+    keywords_html = "\n".join([
+        f"<div class='count-item'><span class='count-label'>{kw}</span><span class='count-value'>{count}</span></div>"
+        for kw, count in keyword_counts.items()
+    ])
+    
+    # Timeframe analysis
+    timeframe_counts = {}
+    for obligation in obligations:
+        timeframe = obligation['timeframe']
+        timeframe_counts[timeframe] = timeframe_counts.get(timeframe, 0) + 1
+    
+    timeframes_html = "\n".join([
+        f"<div class='count-item'><span class='count-label'>{tf}</span><span class='count-value'>{count}</span></div>"
+        for tf, count in timeframe_counts.items()
+    ]) if len(timeframe_counts) > 1 else "<div class='info-box'>Most obligations don't specify exact timeframes</div>"
+    
+    # Example clauses
+    example_clauses = "\n".join([
+        format_clause_example(obligation['clause'], i+1)
+        for i, obligation in enumerate(obligations[:3])
+    ])
+    
     return f"""
-    <div class="sentiment-meter">
-        <div class="sentiment-score" style="width: {width}%"></div>
-    </div>
-    <div style="display: flex; justify-content: space-between; margin-top: 5px;">
-        <span>Negative</span>
-        <span>Neutral</span>
-        <span>Positive</span>
+    <div class='obligation-box'>
+        <div class='section-title'>📝 Obligation Clauses Analysis</div>
+        <div class='{warning_level}'>{warning_emoji} {obligation_count} obligation clauses detected!</div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📊 Obligation Keywords</div>
+            {keywords_html}
+        </div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>⏱ Timeframes</div>
+            {timeframes_html}
+        </div>
+        
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📜 Example Obligation Clauses</div>
+            {example_clauses if example_clauses else "<div class='info-box'>No example clauses available</div>"}
+        </div>
     </div>
     """
 
-def generate_heatmap(risk_level: str):
-    """Generate a simple heatmap based on risk level"""
-    try:
-        fig, ax = plt.subplots(figsize=(8, 2))
-        
-        if risk_level == "Low":
-            cmap = plt.cm.Blues
-            color = '#4CAF50'
-        elif risk_level == "Medium":
-            cmap = plt.cm.Oranges
-            color = '#FF9800'
-        else:
-            cmap = plt.cm.Reds
-            color = '#F44336'
+def format_delay_details(delays: List[Dict]) -> str:
+    """Format delay details for HTML display"""
+    if not delays:
+        return """
+        <div class='delay-box'>
+            <div class='section-title'>⏱ Delay Clauses Analysis</div>
+            <div class='success-box'>✅ No delay clauses detected!</div>
+        </div>
+        """
+    
+    delay_count = len(delays)
+    warning_level = "success-box" if delay_count == 0 else "info-box" if delay_count < 3 else "warning-box" if delay_count < 5 else "danger-box"
+    warning_emoji = "✅" if delay_count == 0 else "🛈" if delay_count < 3 else "⚠" if delay_count < 5 else "🚨"
+    
+    # Consequences breakdown
+    consequence_counts = {}
+    for delay in delays:
+        consequence = delay['consequences']
+        consequence_counts[consequence] = consequence_counts.get(consequence, 0) + 1
+    
+    consequences_html = "\n".join([
+        f"<div class='count-item'><span class='count-label'>{cons}</span><span class='count-value'>{count}</span></div>"
+        for cons, count in consequence_counts.items()
+    ])
+    
+    # Timeframe analysis
+    timeframe_counts = {}
+    for delay in delays:
+        timeframe = delay['timeframe']
+        timeframe_counts[timeframe] = timeframe_counts.get(timeframe, 0) + 1
+    
+    timeframes_html = "\n".join([
+        f"<div class='count-item'><span class='count-label'>{tf}</span><span class='count-value'>{count}</span></div>"
+        for tf, count in timeframe_counts.items()
+    ]) if len(timeframe_counts) > 1 else "<div class='info-box'>Most delay clauses don't specify exact timeframes</div>"
+    
+    # Example clauses
+    example_clauses = "\n".join([
+        format_clause_example(delay['clause'], i+1)
+        for i, delay in enumerate(delays[:3])
+    ])
+    
+    return f"""
+    <div class='delay-box'>
+        <div class='section-title'>⏱ Delay Clauses Analysis</div>
+        <div class='{warning_level}'>{warning_emoji} {delay_count} delay clauses detected!</div>
         
-        gradient = np.linspace(0, 1, 256).reshape(1, -1)
-        gradient = np.vstack((gradient, gradient))
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>⚠️ Consequences</div>
+            {consequences_html}
+        </div>
         
-        ax.imshow(gradient, aspect='auto', cmap=cmap)
-        ax.text(128, 0.5, f"{risk_level} Risk", color='white' if risk_level in ["High", "Medium"] else 'black',
-                ha='center', va='center', fontsize=24, fontweight="bold")
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>⏱ Timeframes</div>
+            {timeframes_html}
+        </div>
         
-        ax.set_axis_off()
-        plt.tight_layout()
-        return fig
-    except Exception as e:
-        logger.error(f"Heatmap generation failed: {str(e)}")
-        raise Exception(f"Heatmap generation failed: {str(e)}")
-
-def format_warning_message(count: int, item_type: str, emoji: str) -> str:
-    """Format warning message based on count with appropriate color coding"""
-    if count == 0:
-        return f"""<div class="success-box">✅ {emoji} No {item_type} clauses detected!</div>"""
-    elif count < 3:
-        return f"""<div class="info-box">🛈 {emoji} {count} {item_type} clauses detected</div>"""
-    elif count < 5:
-        return f"""<div class="warning-box">⚠ {emoji} {count} {item_type} clauses detected!</div>"""
-    else:
-        return f"""<div class="danger-box">🚨 {emoji} {count} {item_type} clauses detected!</div>"""
-
-def format_clause_example(example: str, index: int) -> str:
-    """Format a clause example with proper wrapping and styling"""
-    wrapped_text = textwrap.fill(example, width=80)
-    return f"""
-    <div class="clause-example">
-        <span class="clause-number">{index}.</span> {wrapped_text}
+        <div style='margin-top: 15px;'>
+            <div class='section-title' style='font-size: 16px;'>📜 Example Delay Clauses</div>
+            {example_clauses if example_clauses else "<div class='info-box'>No example clauses available</div>"}
+        </div>
     </div>
     """
 
@@ -716,29 +1143,13 @@ def analyze_pdf(file_obj) -> List:
             logger.warning(f"Sentiment analysis failed: {str(e)}. Using fallback score of 0.5.")
             sentiment_score = 0.5
 
-        penalty_keywords = ["penalty", "fine", "forfeit", "liquidated damages", "breach"]
-        obligation_keywords = ["shall", "must", "required to", "obligated to", "duty"]
-        delay_keywords = ["delay", "late", "overdue", "extension", "time is of the essence"]
-        
-        penalty_counts = count_keywords(text, penalty_keywords)
-        obligation_counts = count_keywords(text, obligation_keywords)
-        delay_counts = count_keywords(text, delay_keywords)
+        # Extract detailed information
+        penalties = extract_penalty_clauses(text)
+        obligations = extract_obligation_clauses(text)
+        delays = extract_delay_clauses(text)
         
-        penalty_values = find_penalty_values(text)
-        
-        total_penalties = sum(penalty_counts.values())
-        total_obligations = sum(obligation_counts.values())
-        total_delays = sum(delay_counts.values())
-        
-        # Generate warning messages with emojis
-        penalty_warning = format_warning_message(total_penalties, "penalty", "💰")
-        obligation_warning = format_warning_message(total_obligations, "obligation", "📝")
-        delay_warning = format_warning_message(total_delays, "delay", "⏱")
-
         try:
-            risk_score, risk_level = calculate_risk_score(
-                total_penalties, penalty_values, total_obligations, total_delays
-            )
+            risk_score, risk_level = calculate_risk_score(penalties, obligations, delays)
         except Exception as e:
             raise Exception(f"Risk score calculation failed: {str(e)}")
 
@@ -749,51 +1160,34 @@ def analyze_pdf(file_obj) -> List:
         except Exception as e:
             raise Exception(f"Visual generation failed: {str(e)}")
 
-        # Format details with warning messages and emojis
-        penalty_details = f"""
-        {penalty_warning}
-        <div class='penalty-box'>
-            <div class='section-title'>💰 Penalty Clause Details</div>
-            {"".join([f"<div class='count-item'><span class='count-label'><span style='color: var(--danger-color)'>•</span> {kw}</span><span class='count-value'>{count}</span></div>" for kw, count in penalty_counts.items()])}
-        </div>
-        """
-
-        obligation_details = f"""
-        {obligation_warning}
-        <div class='obligation-box'>
-            <div class='section-title'>📝 Obligation Clause Details</div>
-            {"".join([f"<div class='count-item'><span class='count-label'><span style='color: var(--warning-color)'>•</span> {kw}</span><span class='count-value'>{count}</span></div>" for kw, count in obligation_counts.items()])}
-        </div>
-        """
-
-        delay_details = f"""
-        {delay_warning}
-        <div class='delay-box'>
-            <div class='section-title'>⏱ Delay Clause Details</div>
-            {"".join([f"<div class='count-item'><span class='count-label'><span style='color: var(--info-color)'>•</span> {kw}</span><span class='count-value'>{count}</span></div>" for kw, count in delay_counts.items()])}
-        </div>
-        """
-
-        penalty_amounts = "\n".join([f"<div class='count-item'><span class='count-label'>💰 Amount</span><span class='count-value'>${amt:,.2f}</span></div>" for amt in penalty_values[:5]]) if penalty_values else "<div class='success-box'>✅ No penalties found!</div>"
-        
-        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())
-        
-        extracted_data = "\n".join([format_clause_example(sent, i+1) for i, sent in enumerate(penalty_sentences[:3])]) if penalty_sentences else "<div class='success-box'>✅ No penalty clauses found!</div>"
+        # Format details for display
+        penalty_html = format_penalty_details(penalties)
+        obligation_html = format_obligation_details(obligations)
+        delay_html = format_delay_details(delays)
         
+        # Prepare data for PDF report
+        analysis_data = {
+            'document_name': os.path.basename(file_obj.name),
+            'sentiment_score': sentiment_score,
+            'risk_score': risk_score,
+            'risk_level': risk_level,
+            'penalties': penalties,
+            'obligations': obligations,
+            'delays': delays
+        }
+
+        # Prepare data for Salesforce
         record_id = str(uuid.uuid4())
         sf_data = {
             'sentiment_score': sentiment_score,
             'risk_score': risk_score,
             'risk_level': risk_level,
             'record_id': record_id,
-            'penalty_examples': extracted_data,
-            'penalty_details': "\n".join([f"{kw}: {count}" for kw, count in penalty_counts.items()]),
-            'penalty_amounts': "\n".join([f"${amt:,.2f}" for amt in penalty_values[:5]]) if penalty_values else "",
-            'obligation_details': "\n".join([f"{kw}: {count}" for kw, count in obligation_counts.items()]),
-            'delay_details': "\n".join([f"{kw}: {count}" for kw, count in delay_counts.items()])
+            'penalty_examples': "\n".join([p['clause'] for p in penalties[:5]]),
+            'penalty_details': "\n".join([f"{p['type']}: {p['amount']}" for p in penalties[:5]]),
+            'penalty_amounts': "\n".join([f"{p['amount']} ({'%' if p['is_percentage'] else '$'})" for p in penalties[:5] if p['numeric_value']]),
+            'obligation_details': "\n".join([f"{o['keyword']}: {o['subject']}" for o in obligations[:5]]),
+            'delay_details': "\n".join([f"{d['keyword']}: {d['consequences']}" for d in delays[:5]])
         }
         
         try:
@@ -803,19 +1197,6 @@ def analyze_pdf(file_obj) -> List:
             logger.error(f"Salesforce record creation failed: {str(e)}")
             salesforce_id = "N/A"
 
-        # Prepare data for PDF report
-        analysis_data = {
-            'document_name': os.path.basename(file_obj.name),
-            'sentiment_score': sentiment_score,
-            'risk_score': risk_score,
-            'risk_level': risk_level,
-            'penalty_count': total_penalties,
-            'penalty_values': penalty_values,
-            'obligation_count': total_obligations,
-            'delay_count': total_delays,
-            'record_id': record_id
-        }
-
         try:
             pdf_buffer = generate_analysis_pdf(analysis_data)
             if pdf_buffer is None:
@@ -873,11 +1254,9 @@ def analyze_pdf(file_obj) -> List:
             </div>
             """,
             "",  # Empty string for hidden risk visualization
-            penalty_details,
-            f"<div class='penalty-box'><div class='section-title'>💰 Penalty Amounts Found</div>{penalty_amounts}</div>",
-            obligation_details,
-            delay_details,
-            f"<div class='result-box'><div class='section-title'>📜 Extracted Data</div>{extracted_data}</div>",
+            penalty_html,
+            obligation_html,
+            delay_html,
             sentiment_analysis_output,
             temp_file_path  # Return temporary file path for PDF download
         ]
@@ -895,15 +1274,15 @@ def analyze_pdf(file_obj) -> List:
             </div>
         </div>
         """
-        return [error_message] * 9
+        return [error_message] * 6
 
 # Create Gradio interface with dark mode compatibility
 with gr.Blocks(css=css, title="PDF Contract Risk Analyzer", theme=gr.themes.Default(primary_hue="blue")) as demo:
     gr.Markdown("""
         <div style='text-align: center; margin-bottom: 30px;'>
-            <h1 style='color: var(--primary-color); margin-bottom: 10px;'>PDF Contract Analysis</h1>
+            <h1 style='color: var(--primary-color); margin-bottom: 10px;'>Advanced Contract Risk Analyzer</h1>
             <p style='color: var(--secondary-color); font-size: 16px;'>
-                Upload a contract PDF to analyze risks, obligations, and sentiment.
+                Upload a contract PDF to analyze risks, obligations, penalties, and sentiment with detailed reporting.
             </p>
         </div>
     """)
@@ -920,38 +1299,38 @@ with gr.Blocks(css=css, title="PDF Contract Risk Analyzer", theme=gr.themes.Defa
                     Drag and drop your contract PDF file here.
                 </div>
             """)
-            submit_btn = gr.Button("Analyze", variant="primary")
+            submit_btn = gr.Button("Analyze Contract", variant="primary")
         
         with gr.Column(scale=3):
             risk_summary = gr.HTML(label="Contract Risk Summary")
             risk_visualization = gr.HTML(label="Risk Visualization", visible=False, elem_id="risk-visualization")
     
     with gr.Row():
-        with gr.Column():
-            penalty_count = gr.HTML(label="Penalty Clauses Analysis")
-            penalty_amounts = gr.HTML(label="Penalty Amounts Found")
-        
-        with gr.Column():
-            obligation_count = gr.HTML(label="Obligation Clauses Analysis")
-        
-        with gr.Column():
-            delay_count = gr.HTML(label="Delay Clauses Analysis")
+        penalty_analysis = gr.HTML(label="Penalty Clauses Analysis")
+    
+    with gr.Row():
+        obligation_analysis = gr.HTML(label="Obligation Clauses Analysis")
     
     with gr.Row():
-        extracted_data = gr.HTML(label="Extracted Data")
+        delay_analysis = gr.HTML(label="Delay Clauses Analysis")
     
     with gr.Row():
         sentiment_analysis = gr.HTML(label="Sentiment Analysis")
+    
+    with gr.Row():
         pdf_output = gr.File(label="Download Full Analysis Report (PDF)", file_types=[".pdf"])
     
     submit_btn.click(
         fn=analyze_pdf,
         inputs=[file_input],
         outputs=[
-            risk_summary, risk_visualization,
-            penalty_count, penalty_amounts,
-            obligation_count, delay_count,
-            extracted_data, sentiment_analysis, pdf_output
+            risk_summary, 
+            risk_visualization,
+            penalty_analysis,
+            obligation_analysis,
+            delay_analysis,
+            sentiment_analysis,
+            pdf_output
         ]
     )