pdf_generator function fixed

reporter/report_generator.py

@@ -84,15 +84,30 @@ class ReportGenerator:
         
         # DEBUG: Check structure
         logger.debug(f"detection_dict keys: {list(detection_dict.keys())}")
+        logger.debug(f"detection_dict type: {type(detection_dict)}")
         
-        # Extract the actual detection data from the structure: The full response has 'detection_result' key, but we need the inner data
+        # Check if this is the full analysis result or just partial data
+        # From your logs, it seems like during report generation, you're getting
+        # a different/shorter text than the original analysis
+        
+        # Extract the actual detection data from the structure
         if ("detection_result" in detection_dict):
             detection_data = detection_dict["detection_result"]
             logger.debug("Extracted detection_result from outer dict")
-
+            logger.debug(f"Detection data has analysis keys: {list(detection_data.get('analysis', {}).keys())}")
+            logger.debug(f"Text length in analysis: {detection_data.get('analysis', {}).get('text_length', 'Unknown')}")
         else:
             detection_data = detection_dict
             logger.debug("Using detection_dict directly")
+            logger.debug(f"Detection data has analysis keys: {list(detection_data.get('analysis', {}).keys())}")
+        
+        # Validate we have the correct data (not the short text)
+        analysis_data = detection_data.get("analysis", {})
+        text_length = analysis_data.get("text_length", 0)
+        
+        if text_length < 50:  # Less than minimum
+            logger.warning(f"WARNING: Report generation received short text ({text_length} chars). "
+                         f"This might be partial data instead of full analysis results.")
         
         # Generate detailed reasoning
         reasoning        = self.reasoning_generator.generate(ensemble_result    = detection_result.ensemble_result,
@@ -164,8 +179,9 @@ class ReportGenerator:
                 logger.warning(f"Metric {metric_name} is not a dict: {type(metric_result)}")
                 continue
                 
-            if (metric_result.get("error") is not None):
-                logger.warning(f"Metric {metric_name} has error: {metric_result.get('error')}")
+            error_msg = metric_result.get("error")
+            if (error_msg is not None):
+                logger.warning(f"Metric {metric_name} has error: {error_msg}")
                 continue
                 
             # Get actual probabilities and confidence
@@ -424,6 +440,17 @@ class ReportGenerator:
         GRAY_DARK         = colors.HexColor('#334155')  # Gray-700
         TEXT_COLOR        = colors.HexColor('#1e293b')  # Gray-800
         
+        # Helper function to get hex color string
+        def get_hex_color(color_obj):
+            """Convert color object to hex string"""
+            if hasattr(color_obj, 'hexval'):
+                return color_obj.hexval()
+            elif hasattr(color_obj, 'rgb'):
+                r, g, b = color_obj.rgb()
+                return f"#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}"
+            else:
+                return "#3b82f6"  # Default blue
+        
         # Premium Custom Styles
         title_style       = ParagraphStyle('PremiumTitle',
                                            parent     = styles['Heading1'],
@@ -450,8 +477,6 @@ class ReportGenerator:
                                            textColor   = TEXT_COLOR,
                                            spaceAfter  = 12,
                                            spaceBefore = 20,
-                                           underlineWidth = 1,
-                                           underlineColor = PRIMARY_COLOR,
                                           )
         
         subsection_style  = ParagraphStyle('PremiumSubSection',
@@ -472,21 +497,6 @@ class ReportGenerator:
                                            spaceAfter = 8,
                                           )
         
-        verdict_style     = ParagraphStyle('VerdictStyle',
-                                           parent     = styles['Heading2'],
-                                           fontName   = 'Helvetica-Bold',
-                                           fontSize   = 22,
-                                           spaceAfter = 5,
-                                          )
-        
-        metric_name_style = ParagraphStyle('MetricNameStyle',
-                                          parent     = styles['Heading3'],
-                                          fontName   = 'Helvetica-Bold',
-                                          fontSize   = 13,
-                                          textColor  = GRAY_DARK,
-                                          spaceAfter = 4,
-                                         )
-        
         # Use detection results from detection_data
         ensemble_data     = detection_data.get("ensemble", {})
         analysis_data     = detection_data.get("analysis", {})
@@ -504,124 +514,115 @@ class ReportGenerator:
         # Determine colors based on verdict
         if ("Human".lower() in final_verdict.lower()):
             verdict_color = SUCCESS_COLOR
-
         elif ("AI".lower() in final_verdict.lower()):
             verdict_color = DANGER_COLOR
-
         elif ("Mixed".lower() in final_verdict.lower()):
             verdict_color = WARNING_COLOR
-
         else:
             verdict_color = PRIMARY_COLOR
         
-        # Create header with logo/company name
-        header_style      = ParagraphStyle('HeaderStyle',
-                                           parent     = styles['Normal'],
-                                           fontName   = 'Helvetica-Bold',
-                                           fontSize   = 10,
-                                           textColor  = GRAY_DARK,
-                                           alignment  = TA_RIGHT,
-                                          )
+        # Get hex strings for colors
+        primary_hex = get_hex_color(PRIMARY_COLOR)
+        success_hex = get_hex_color(SUCCESS_COLOR)
+        warning_hex = get_hex_color(WARNING_COLOR)
+        danger_hex = get_hex_color(DANGER_COLOR)
+        info_hex = get_hex_color(INFO_COLOR)
+        verdict_hex = get_hex_color(verdict_color)
         
         # Header
-        elements.append(Paragraph("AI DETECTION ANALYTICS", header_style))
-        elements.append(HRFlowable(width      = "100%", 
-                                   thickness  = 1, 
-                                   color      = PRIMARY_COLOR, 
-                                   spaceAfter = 20,
-                                  )
-                       )
+        elements.append(Paragraph("AI DETECTION ANALYTICS", 
+                         ParagraphStyle('HeaderStyle', parent=styles['Normal'], fontName='Helvetica-Bold', fontSize=10, textColor=GRAY_DARK, alignment=TA_RIGHT)))
+        
+        elements.append(HRFlowable(width="100%", thickness=1, color=PRIMARY_COLOR, spaceAfter=20))
         
         # Title and main sections
         elements.append(Paragraph("AI Text Detection Analysis Report", title_style))
         elements.append(Paragraph(f"Generated on {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", subtitle_style))
         
         # Add decorative line
-        elements.append(HRFlowable(width       = "80%", 
-                                   thickness   = 2, 
-                                   color       = PRIMARY_COLOR, 
-                                   spaceBefore = 10, 
-                                   spaceAfter  = 30, 
-                                   hAlign      = 'CENTER',
-                                  )
-                       )
+        elements.append(HRFlowable(width="80%", thickness=2, color=PRIMARY_COLOR, spaceBefore=10, spaceAfter=30, hAlign='CENTER'))
         
         # Quick Stats Banner
         stats_data  = [['', 'AI', 'HUMAN', 'MIXED'],
-                       ['Probability', f"{ai_prob:.1%}", f"{human_prob:.1%}", f"{mixed_prob:.1%}"]
-                      ]
-        
-        stats_table = Table(stats_data, colWidths = [1.5*inch, 1*inch, 1*inch, 1*inch])
-        stats_table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), PRIMARY_COLOR),
-                                         ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
-                                         ('BACKGROUND', (1, 1), (1, 1), DANGER_COLOR),
-                                         ('BACKGROUND', (2, 1), (2, 1), SUCCESS_COLOR),
-                                         ('BACKGROUND', (3, 1), (3, 1), WARNING_COLOR),
-                                         ('TEXTCOLOR', (1, 1), (-1, 1), colors.white),
-                                         ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                                         ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                                         ('FONTSIZE', (0, 0), (-1, -1), 11),
-                                         ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
-                                         ('TOPPADDING', (0, 0), (-1, -1), 8),
-                                         ('GRID', (0, 0), (-1, -1), 0.5, colors.white),
-                                         ('BOX', (0, 0), (-1, -1), 1, PRIMARY_COLOR),
-                                       ])
-                            )
-
+                       ['Probability', f"{ai_prob:.1%}", f"{human_prob:.1%}", f"{mixed_prob:.1%}"]]
+        
+        stats_table = Table(stats_data, colWidths=[1.5*inch, 1*inch, 1*inch, 1*inch])
+        stats_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), PRIMARY_COLOR),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+            ('BACKGROUND', (1, 1), (1, 1), DANGER_COLOR),
+            ('BACKGROUND', (2, 1), (2, 1), SUCCESS_COLOR),
+            ('BACKGROUND', (3, 1), (3, 1), WARNING_COLOR),
+            ('TEXTCOLOR', (1, 1), (-1, 1), colors.white),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 11),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
+            ('TOPPADDING', (0, 0), (-1, -1), 8),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.white),
+            ('BOX', (0, 0), (-1, -1), 1, PRIMARY_COLOR),
+        ]))
+        
         elements.append(stats_table)
         elements.append(Spacer(1, 0.3*inch))
         
         # Main Verdict Section with colored badge
         elements.append(Paragraph("DETECTION VERDICT", section_style))
         
-        verdict_box_data = [[Paragraph(f"<font size=18 color='{colors.toHex(verdict_color)}'><b>{final_verdict.upper()}</b></font>", ParagraphStyle('VerdictText', alignment=TA_CENTER)),
-                             Paragraph(f"<font size=12>Confidence: <b>{confidence:.1%}</b></font><br/>" f"<font size=10>Uncertainty: {uncertainty:.1%} | Consensus: {consensus:.1%}</font>", ParagraphStyle('VerdictDetails', alignment=TA_CENTER))
-                           ]]
+        verdict_box_data = [[
+            Paragraph(f"<font size=18 color='{verdict_hex}'><b>{final_verdict.upper()}</b></font>", 
+                     ParagraphStyle('VerdictText', alignment=TA_CENTER)),
+            Paragraph(f"<font size=12>Confidence: <b>{confidence:.1%}</b></font><br/>"
+                     f"<font size=10>Uncertainty: {uncertainty:.1%} | Consensus: {consensus:.1%}</font>",
+                     ParagraphStyle('VerdictDetails', alignment=TA_CENTER))
+        ]]
+        
+        verdict_box = Table(verdict_box_data, colWidths=[2.5*inch, 3*inch])
+        verdict_box.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (0, 0), GRAY_LIGHT),
+            ('BACKGROUND', (1, 0), (1, 0), GRAY_LIGHT),
+            ('BOX', (0, 0), (-1, -1), 1, verdict_color),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 15),
+            ('TOPPADDING', (0, 0), (-1, -1), 15),
+        ]))
         
-        verdict_box      = Table(verdict_box_data, colWidths=[2.5*inch, 3*inch])
-
-        verdict_box.setStyle(TableStyle([('BACKGROUND', (0, 0), (0, 0), GRAY_LIGHT),
-                                         ('BACKGROUND', (1, 0), (1, 0), GRAY_LIGHT),
-                                         ('BOX', (0, 0), (-1, -1), 1, verdict_color),
-                                         ('ROUNDEDCORNERS', [10, 10, 10, 10]),
-                                         ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                                         ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
-                                         ('BOTTOMPADDING', (0, 0), (-1, -1), 15),
-                                         ('TOPPADDING', (0, 0), (-1, -1), 15),
-                                       ])
-                            )
-
         elements.append(verdict_box)
         elements.append(Spacer(1, 0.3*inch))
         
         # Content Analysis in a sleek table
         elements.append(Paragraph("CONTENT ANALYSIS", section_style))
         
-        domain            = analysis_data.get("domain", "general").title().replace('_', ' ')
+        domain = analysis_data.get("domain", "general").title().replace('_', ' ')
         domain_confidence = analysis_data.get("domain_confidence", 0)
-        text_length       = analysis_data.get("text_length", 0)
-        sentence_count    = analysis_data.get("sentence_count", 0)
-        total_time        = performance_data.get("total_time", 0)
+        text_length = analysis_data.get("text_length", 0)
+        sentence_count = analysis_data.get("sentence_count", 0)
+        total_time = performance_data.get("total_time", 0)
         
         # Create two-column layout for content analysis
-        content_data      = [[Paragraph("<b>Content Domain</b>", body_style), Paragraph(f"<font color='{colors.toHex(INFO_COLOR)}'><b>{domain}</b></font> ({domain_confidence:.1%} confidence)", body_style)],
-                             [Paragraph("<b>Text Statistics</b>", body_style), Paragraph(f"{text_length:,} words | {sentence_count:,} sentences", body_style)],
-                             [Paragraph("<b>Processing Time</b>", body_style), Paragraph(f"{total_time:.2f} seconds", body_style)],
-                             [Paragraph("<b>Analysis Method</b>", body_style), Paragraph("Confidence-Weighted Ensemble Aggregation", body_style)],
-                            ]
-        
-        content_table     = Table(content_data, colWidths = [2*inch, 4*inch])
-        
-        content_table.setStyle(TableStyle([('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
-                                           ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
-                                           ('FONTSIZE', (0, 0), (-1, -1), 10),
-                                           ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
-                                           ('TOPPADDING', (0, 0), (-1, -1), 6),
-                                           ('GRID', (0, 0), (-1, -1), 0.25, GRAY_MEDIUM),
-                                           ('BACKGROUND', (0, 0), (0, -1), GRAY_LIGHT),
-                                         ])
-                              )
-
+        content_data = [
+            [Paragraph("<b>Content Domain</b>", body_style), 
+             Paragraph(f"<font color='{info_hex}'><b>{domain}</b></font> ({domain_confidence:.1%} confidence)", body_style)],
+            [Paragraph("<b>Text Statistics</b>", body_style), 
+             Paragraph(f"{text_length:,} words | {sentence_count:,} sentences", body_style)],
+            [Paragraph("<b>Processing Time</b>", body_style), 
+             Paragraph(f"{total_time:.2f} seconds", body_style)],
+            [Paragraph("<b>Analysis Method</b>", body_style), 
+             Paragraph("Confidence-Weighted Ensemble Aggregation", body_style)],
+        ]
+        
+        content_table = Table(content_data, colWidths=[2*inch, 4*inch])
+        content_table.setStyle(TableStyle([
+            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+            ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
+            ('FONTSIZE', (0, 0), (-1, -1), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+            ('TOPPADDING', (0, 0), (-1, -1), 6),
+            ('GRID', (0, 0), (-1, -1), 0.25, GRAY_MEDIUM),
+            ('BACKGROUND', (0, 0), (0, -1), GRAY_LIGHT),
+        ]))
+        
         elements.append(content_table)
         elements.append(Spacer(1, 0.3*inch))
         
@@ -629,35 +630,34 @@ class ReportGenerator:
         elements.append(Paragraph("METRIC CONTRIBUTIONS", section_style))
         
         metric_contributions = ensemble_data.get("metric_contributions", {})
-
         if metric_contributions and len(metric_contributions) > 0:
             # Create horizontal bar chart effect with table
             weight_data = [['METRIC', 'WEIGHT', '']]
             
             for metric_name, contribution in metric_contributions.items():
-                weight       = contribution.get("weight", 0)
+                weight = contribution.get("weight", 0)
                 display_name = metric_name.title().replace('_', ' ')
                 
                 # Create visual bar representation
-                bar_width    = int(weight * 100)
-                bar_cell     = f"[{'█' * bar_width}{'░' * (100-bar_width)}] {weight:.1%}"
+                bar_width = int(weight * 50)  # Use 50 chars max for better fit
+                bar_cell = f"[{'█' * bar_width}{'░' * (50-bar_width)}] {weight:.1%}"
                 
                 weight_data.append([display_name, f"{weight:.1%}", bar_cell])
             
-            weight_table = Table(weight_data, colWidths=[2*inch, 1*inch, 3*inch])
-            weight_table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), PRIMARY_COLOR),
-                                              ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
-                                              ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
-                                              ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                                              ('FONTSIZE', (0, 0), (-1, -1), 9),
-                                              ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
-                                              ('TOPPADDING', (0, 0), (-1, -1), 6),
-                                              ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
-                                              ('TEXTCOLOR', (2, 1), (2, -1), PRIMARY_COLOR),
-                                              ('FONTNAME', (2, 1), (2, -1), 'Courier'),
-                                            ])
-                                  )
-
+            weight_table = Table(weight_data, colWidths=[2*inch, 1*inch, 2.5*inch])
+            weight_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), PRIMARY_COLOR),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 9),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                ('TOPPADDING', (0, 0), (-1, -1), 6),
+                ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
+                ('TEXTCOLOR', (2, 1), (2, -1), PRIMARY_COLOR),
+                ('FONTNAME', (2, 1), (2, -1), 'Courier'),
+            ]))
+            
             elements.append(weight_table)
             elements.append(Spacer(1, 0.3*inch))
         
@@ -667,51 +667,48 @@ class ReportGenerator:
         if detailed_metrics:
             for metric in detailed_metrics:
                 # Determine metric color based on verdict
-                if (metric.verdict == "HUMAN"):
+                if metric.verdict == "HUMAN":
                     metric_color = SUCCESS_COLOR
-                    prob_color   = SUCCESS_COLOR
-
-                elif( metric.verdict == "AI"):
+                    prob_color = SUCCESS_COLOR
+                elif metric.verdict == "AI":
                     metric_color = DANGER_COLOR
-                    prob_color   = DANGER_COLOR
-
+                    prob_color = DANGER_COLOR
                 else:
                     metric_color = WARNING_COLOR
-                    prob_color   = WARNING_COLOR
+                    prob_color = WARNING_COLOR
+                
+                metric_color_hex = get_hex_color(metric_color)
+                prob_color_hex = get_hex_color(prob_color)
                 
                 # Create metric card
-                metric_card_data = [[Paragraph(f"<font color='{colors.toHex(metric_color)}' size=12><b>{metric.name.upper().replace('_', ' ')}</b></font><br/>"
-                                               f"<font size=9>{metric.description}</font>", 
-                                               ParagraphStyle('MetricTitle', alignment=TA_LEFT)),
-                                    
-                                     Paragraph(f"<font size=11><b>VERDICT</b></font><br/>"
-                                               f"<font color='{colors.toHex(metric_color)}' size=12><b>{metric.verdict}</b></font>",
-                                               ParagraphStyle('MetricVerdict', alignment=TA_CENTER)),
-                                    
-                                     Paragraph(f"<font size=11><b>AI PROBABILITY</b></font><br/>"
-                                               f"<font color='{colors.toHex(prob_color)}' size=12><b>{metric.ai_probability:.1f}%</b></font>",
-                                               ParagraphStyle('MetricProbability', alignment=TA_CENTER)),
-                                    
-                                     Paragraph(f"<font size=11><b>WEIGHT</b></font><br/>"
-                                               f"<font size=12><b>{metric.weight:.1f}%</b></font>",
-                                               ParagraphStyle('MetricWeight', alignment=TA_CENTER)),
-                                    
-                                     Paragraph(f"<font size=11><b>CONFIDENCE</b></font><br/>"
-                                               f"<font size=12><b>{metric.confidence:.1f}%</b></font>",
-                                               ParagraphStyle('MetricConfidence', alignment=TA_CENTER)),
-                                   ]]
-                                
-                metric_table     = Table(metric_card_data, colWidths = [2.5*inch, 1*inch, 1*inch, 0.8*inch, 0.8*inch])
+                metric_card_data = [[
+                    Paragraph(f"<font color='{metric_color_hex}' size=12><b>{metric.name.upper().replace('_', ' ')}</b></font><br/>"
+                             f"<font size=9>{metric.description}</font>", 
+                             ParagraphStyle('MetricTitle', alignment=TA_LEFT)),
+                    
+                    Paragraph(f"<font size=11><b>VERDICT</b></font><br/>"
+                             f"<font color='{metric_color_hex}' size=12><b>{metric.verdict}</b></font>",
+                             ParagraphStyle('MetricVerdict', alignment=TA_CENTER)),
+                    
+                    Paragraph(f"<font size=11><b>AI PROBABILITY</b></font><br/>"
+                             f"<font color='{prob_color_hex}' size=12><b>{metric.ai_probability:.1f}%</b></font>",
+                             ParagraphStyle('MetricProbability', alignment=TA_CENTER)),
+                    
+                    Paragraph(f"<font size=11><b>WEIGHT</b></font><br/>"
+                             f"<font size=12><b>{metric.weight:.1f}%</b></font>",
+                             ParagraphStyle('MetricWeight', alignment=TA_CENTER)),
+                ]]
                 
-                metric_table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), GRAY_LIGHT),
-                                                  ('BOX', (0, 0), (-1, 0), 1, metric_color),
-                                                  ('LINEABOVE', (0, 0), (-1, 0), 2, metric_color),
-                                                  ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
-                                                  ('VALIGN', (0, 0), (-1, 0), 'MIDDLE'),
-                                                  ('BOTTOMPADDING', (0, 0), (-1, 0), 10),
-                                                  ('TOPPADDING', (0, 0), (-1, 0), 10),
-                                                ])
-                                     )
+                metric_table = Table(metric_card_data, colWidths=[2.5*inch, 1.2*inch, 1.2*inch, 1*inch])
+                metric_table.setStyle(TableStyle([
+                    ('BACKGROUND', (0, 0), (-1, 0), GRAY_LIGHT),
+                    ('BOX', (0, 0), (-1, 0), 1, metric_color),
+                    ('LINEABOVE', (0, 0), (-1, 0), 2, metric_color),
+                    ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
+                    ('VALIGN', (0, 0), (-1, 0), 'MIDDLE'),
+                    ('BOTTOMPADDING', (0, 0), (-1, 0), 10),
+                    ('TOPPADDING', (0, 0), (-1, 0), 10),
+                ]))
                 
                 elements.append(metric_table)
                 
@@ -721,62 +718,58 @@ class ReportGenerator:
                     
                     # Create a grid of sub-metrics
                     sub_items = list(metric.detailed_metrics.items())[:6]
-                    sub_data  = list()
+                    sub_data = []
                     
                     for i in range(0, len(sub_items), 3):
-                        row = list()
+                        row = []
                         for j in range(3):
-                            if (i + j < len(sub_items)):
+                            if i + j < len(sub_items):
                                 sub_name, sub_value = sub_items[i + j]
-                                
                                 # Format the value
                                 if isinstance(sub_value, (int, float)):
-                                    if (sub_name.endswith('_score') or sub_name.endswith('_probability')):
+                                    if sub_name.endswith('_score') or sub_name.endswith('_probability'):
                                         formatted_value = f"{sub_value:.1f}%"
-
-                                    elif (sub_name.endswith('_ratio') or sub_name.endswith('_frequency')):
+                                    elif sub_name.endswith('_ratio') or sub_name.endswith('_frequency'):
                                         formatted_value = f"{sub_value:.3f}"
-                                    
-                                    elif (sub_name.endswith('_entropy') or sub_name.endswith('_perplexity')):
+                                    elif sub_name.endswith('_entropy') or sub_name.endswith('_perplexity'):
                                         formatted_value = f"{sub_value:.2f}"
-                                    
                                     else:
                                         formatted_value = f"{sub_value:.2f}"
-                                
                                 else:
                                     formatted_value = str(sub_value)
                                 
                                 row.append(f"<b>{sub_name.replace('_', ' ').title()}:</b> {formatted_value}")
-                            
                             else:
                                 row.append("")
                         
                         sub_data.append(row)
                     
                     if sub_data:
-                        sub_table = Table(sub_data, colWidths = [1.8*inch, 1.8*inch, 1.8*inch])
-
-                        sub_table.setStyle(TableStyle([('FONTSIZE', (0, 0), (-1, -1), 8),
-                                                       ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
-                                                       ('TOPPADDING', (0, 0), (-1, -1), 4),
-                                                       ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
-                                                     ])
-                                          )
+                        sub_table = Table(sub_data, colWidths=[1.8*inch, 1.8*inch, 1.8*inch])
+                        sub_table.setStyle(TableStyle([
+                            ('FONTSIZE', (0, 0), (-1, -1), 8),
+                            ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+                            ('TOPPADDING', (0, 0), (-1, -1), 4),
+                            ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+                        ]))
                         elements.append(sub_table)
                 
                 elements.append(Spacer(1, 0.2*inch))
+        else:
+            elements.append(Paragraph("No detailed metrics available for this analysis.", body_style))
+            elements.append(Spacer(1, 0.2*inch))
         
         # Detection Reasoning
         elements.append(Paragraph("DETECTION REASONING", section_style))
         
         # Summary in a colored box
-        summary_box = Table([[Paragraph(f"<font size=11>{reasoning.summary}</font>", body_style)]], colWidths = [6.5*inch])
-        summary_box.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, -1), GRAY_LIGHT),
-                                         ('BOX', (0, 0), (-1, -1), 1, PRIMARY_COLOR),
-                                         ('PADDING', (0, 0), (-1, -1), 10),
-                                       ])
-                            )
-
+        summary_box = Table([[Paragraph(f"<font size=11>{reasoning.summary}</font>", body_style)]], colWidths=[6.5*inch])
+        summary_box.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, -1), GRAY_LIGHT),
+            ('BOX', (0, 0), (-1, -1), 1, PRIMARY_COLOR),
+            ('PADDING', (0, 0), (-1, -1), 10),
+        ]))
+        
         elements.append(summary_box)
         elements.append(Spacer(1, 0.2*inch))
         
@@ -784,36 +777,31 @@ class ReportGenerator:
         if reasoning.key_indicators:
             elements.append(Paragraph("KEY INDICATORS", subsection_style))
             
-            indicators_data = list()
-
+            indicators_data = []
             for i in range(0, len(reasoning.key_indicators), 2):
-                row = list()
-
+                row = []
                 for j in range(2):
-                    if (i + j < len(reasoning.key_indicators)):
+                    if i + j < len(reasoning.key_indicators):
                         indicator = reasoning.key_indicators[i + j]
                         # Add checkmark for positive indicators
-                        if (indicator.startswith("✅") or indicator.startswith("✓")):
-                            icon_color = SUCCESS_COLOR
-
-                        elif (indicator.startswith("⚠️") or indicator.startswith("❌")):
-                            icon_color = WARNING_COLOR
-
+                        if indicator.startswith("✅") or indicator.startswith("✓"):
+                            icon_color = success_hex
+                        elif indicator.startswith("⚠️") or indicator.startswith("❌"):
+                            icon_color = warning_hex
                         else:
-                            icon_color = PRIMARY_COLOR
+                            icon_color = primary_hex
                         
-                        row.append(Paragraph(f"<font color='{colors.toHex(icon_color)}'>•</font> {indicator}", body_style))
-                    
+                        row.append(Paragraph(f"<font color='{icon_color}'>•</font> {indicator}", body_style))
                     else:
                         row.append("")
                 indicators_data.append(row)
             
             indicators_table = Table(indicators_data, colWidths=[3*inch, 3*inch])
-            indicators_table.setStyle(TableStyle([('VALIGN', (0, 0), (-1, -1), 'TOP'),
-                                                  ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
-                                                ])
-                                     )
-
+            indicators_table.setStyle(TableStyle([
+                ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+            ]))
+            
             elements.append(indicators_table)
             elements.append(Spacer(1, 0.2*inch))
         
@@ -824,25 +812,28 @@ class ReportGenerator:
         if attribution_result:
             elements.append(Paragraph("AI MODEL ATTRIBUTION", section_style))
             
-            predicted_model        = attribution_result.predicted_model.value.replace("_", " ").title()
+            predicted_model = attribution_result.predicted_model.value.replace("_", " ").title()
             attribution_confidence = attribution_result.confidence * 100
             
-            attribution_card_data  = [[Paragraph("<b>PREDICTED MODEL</b>", subsection_style), Paragraph(f"<font size=14 color='{colors.toHex(INFO_COLOR)}'><b>{predicted_model}</b></font>", subsection_style)],
-                                      [Paragraph("<b>ATTRIBUTION CONFIDENCE</b>", subsection_style), Paragraph(f"<font size=14><b>{attribution_confidence:.1f}%</b></font>", subsection_style)],
-                                      [Paragraph("<b>DOMAIN USED</b>", subsection_style), Paragraph(f"<b>{attribution_result.domain_used.value.title()}</b>", subsection_style)],
-                                     ]
+            attribution_card_data = [
+                [Paragraph("<b>PREDICTED MODEL</b>", subsection_style), 
+                 Paragraph(f"<font size=14 color='{info_hex}'><b>{predicted_model}</b></font>", subsection_style)],
+                [Paragraph("<b>ATTRIBUTION CONFIDENCE</b>", subsection_style), 
+                 Paragraph(f"<font size=14><b>{attribution_confidence:.1f}%</b></font>", subsection_style)],
+                [Paragraph("<b>DOMAIN USED</b>", subsection_style), 
+                 Paragraph(f"<b>{attribution_result.domain_used.value.title()}</b>", subsection_style)],
+            ]
             
-            attribution_table      = Table(attribution_card_data, colWidths = [2.5*inch, 3.5*inch])
+            attribution_table = Table(attribution_card_data, colWidths=[2.5*inch, 3.5*inch])
+            attribution_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), GRAY_LIGHT),
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 11),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
+                ('TOPPADDING', (0, 0), (-1, -1), 8),
+                ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
+            ]))
             
-            attribution_table.setStyle(TableStyle([('BACKGROUND', (0, 0), (0, -1), GRAY_LIGHT),
-                                                   ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
-                                                   ('FONTSIZE', (0, 0), (-1, -1), 11),
-                                                   ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
-                                                   ('TOPPADDING', (0, 0), (-1, -1), 8),
-                                                   ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
-                                                 ])
-                                      )
-
             elements.append(attribution_table)
             elements.append(Spacer(1, 0.3*inch))
             
@@ -850,36 +841,36 @@ class ReportGenerator:
             if attribution_result.model_probabilities:
                 elements.append(Paragraph("MODEL PROBABILITY DISTRIBUTION", subsection_style))
                 
-                prob_data     = [['MODEL', 'PROBABILITY', '']]
+                prob_data = [['MODEL', 'PROBABILITY', '']]
                 
-                # Show top 8 models
-                sorted_models = sorted(attribution_result.model_probabilities.items(), key = lambda x: x[1], reverse=True)[:8]
+                # Show top 6 models
+                sorted_models = sorted(attribution_result.model_probabilities.items(),
+                                       key=lambda x: x[1], reverse=True)[:6]
                 
                 for model_name, probability in sorted_models:
                     display_name = model_name.replace("_", " ").replace("-", " ").title()
-                    bar_width    = int(probability * 100)
-                    
-                    prob_data.append([display_name,
-                                      f"{probability:.1%}",
-                                      f"[{'█' * bar_width}{'░' * (100-bar_width)}]"
-                                    ])
-                                
-                prob_table = Table(prob_data, colWidths = [2.5*inch, 1*inch, 2.5*inch])
-
-                prob_table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), INFO_COLOR),
-                                                ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
-                                                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
-                                                ('ALIGN', (1, 1), (1, -1), 'RIGHT'),
-                                                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                                                ('FONTSIZE', (0, 0), (-1, -1), 9),
-                                                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
-                                                ('TOPPADDING', (0, 0), (-1, -1), 6),
-                                                ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
-                                                ('FONTNAME', (2, 1), (2, -1), 'Courier'),
-                                                ('TEXTCOLOR', (2, 1), (2, -1), INFO_COLOR),
-                                              ])
-                                   )
-
+                    bar_width = int(probability * 40)  # 40 chars max
+                    prob_data.append([
+                        display_name,
+                        f"{probability:.1%}",
+                        f"[{'█' * bar_width}{'░' * (40-bar_width)}]"
+                    ])
+                
+                prob_table = Table(prob_data, colWidths=[2.5*inch, 1*inch, 2*inch])
+                prob_table.setStyle(TableStyle([
+                    ('BACKGROUND', (0, 0), (-1, 0), INFO_COLOR),
+                    ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+                    ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                    ('ALIGN', (1, 1), (1, -1), 'RIGHT'),
+                    ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                    ('FONTSIZE', (0, 0), (-1, -1), 9),
+                    ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                    ('TOPPADDING', (0, 0), (-1, -1), 6),
+                    ('GRID', (0, 0), (-1, -1), 0.5, GRAY_MEDIUM),
+                    ('FONTNAME', (2, 1), (2, -1), 'Courier'),
+                    ('TEXTCOLOR', (2, 1), (2, -1), INFO_COLOR),
+                ]))
+                
                 elements.append(prob_table)
                 elements.append(Spacer(1, 0.3*inch))
         
@@ -889,42 +880,38 @@ class ReportGenerator:
             
             for i, recommendation in enumerate(reasoning.recommendations):
                 # Alternate colors for visual interest
-                if (i % 3 == 0):
-                    rec_color = SUCCESS_COLOR
-
-                elif (i % 3 == 1):
-                    rec_color = INFO_COLOR
-
+                if i % 3 == 0:
+                    rec_color = success_hex
+                elif i % 3 == 1:
+                    rec_color = info_hex
                 else:
-                    rec_color = WARNING_COLOR
+                    rec_color = warning_hex
                 
-                rec_box = Table([[Paragraph(f"<font color='{colors.toHex(rec_color)}'>✓</font> {recommendation}", body_style)]], colWidths=[6.5*inch])
+                rec_box = Table([[Paragraph(f"<font color='{rec_color}'>✓</font> {recommendation}", body_style)]], colWidths=[6.5*inch])
+                rec_box.setStyle(TableStyle([
+                    ('BACKGROUND', (0, 0), (-1, -1), GRAY_LIGHT),
+                    ('PADDING', (0, 0), (-1, -1), 8),
+                    ('BOTTOMMARGIN', (0, 0), (-1, -1), 5),
+                ]))
                 
-                rec_box.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, -1), GRAY_LIGHT),
-                                             ('BOX', (0, 0), (-1, -1), 1, rec_color),
-                                             ('PADDING', (0, 0), (-1, -1), 8),
-                                             ('BOTTOMMARGIN', (0, 0), (-1, -1), 5),
-                                           ])
-                                )
-
                 elements.append(rec_box)
                 elements.append(Spacer(1, 0.1*inch))
         
         # Footer with watermark
         footer_style = ParagraphStyle('FooterStyle',
-                                      parent     = styles['Normal'],
-                                      fontName   = 'Helvetica',
-                                      fontSize   = 9,
-                                      textColor  = GRAY_DARK,
-                                      alignment  = TA_CENTER,
-                                     )
+                                     parent     = styles['Normal'],
+                                     fontName   = 'Helvetica',
+                                     fontSize   = 9,
+                                     textColor  = GRAY_DARK,
+                                     alignment  = TA_CENTER,
+                                    )
         
         elements.append(Spacer(1, 0.5*inch))
         elements.append(HRFlowable(width="100%", thickness=0.5, color=GRAY_MEDIUM, spaceAfter=10))
         
         footer_text = (f"Generated by AI Text Detector v2.0 | "
-                       f"Processing Time: {total_time:.2f}s | "
-                       f"Report ID: {filename.replace('.pdf', '')}")
+                      f"Processing Time: {total_time:.2f}s | "
+                      f"Report ID: {filename.replace('.pdf', '')}")
         
         elements.append(Paragraph(footer_text, footer_style))
         elements.append(Paragraph("Confidential Analysis Report • © 2025 AI Detection Analytics",