Update app.py

app.py

@@ -1,4 +1,4 @@
-# code v13
+# Code v15
 
 import gradio as gr
 import torch
@@ -680,11 +680,19 @@ def extract_text_from_docx(file_path: str) -> Tuple[str, list]:
             if text:
                 paragraphs.append(text)
                 
+                # Store comprehensive paragraph formatting
                 para_format = {
                     'alignment': para.alignment,
+                    'left_indent': para.paragraph_format.left_indent,
+                    'right_indent': para.paragraph_format.right_indent,
+                    'first_line_indent': para.paragraph_format.first_line_indent,
+                    'space_before': para.paragraph_format.space_before,
+                    'space_after': para.paragraph_format.space_after,
+                    'line_spacing': para.paragraph_format.line_spacing,
                     'runs': []
                 }
                 
+                # Store detailed run-level formatting
                 for run in para.runs:
                     if run.text.strip():
                         run_format = {
@@ -693,8 +701,50 @@ def extract_text_from_docx(file_path: str) -> Tuple[str, list]:
                             'italic': run.italic,
                             'underline': run.underline,
                             'font_name': run.font.name,
-                            'font_size': run.font.size
+                            'font_size': run.font.size,
+                            'font_color_rgb': None,
+                            'font_color_theme': None,
+                            'highlight_color': None,
+                            'superscript': None,
+                            'subscript': None,
+                            'strike': None,
+                            'double_strike': None,
+                            'all_caps': None,
+                            'small_caps': None
                         }
+                        
+                        # Get font color (RGB)
+                        try:
+                            if run.font.color and run.font.color.rgb:
+                                run_format['font_color_rgb'] = run.font.color.rgb
+                        except:
+                            pass
+                        
+                        # Get font color (theme color)
+                        try:
+                            if run.font.color and run.font.color.theme_color:
+                                run_format['font_color_theme'] = run.font.color.theme_color
+                        except:
+                            pass
+                            
+                        # Get highlight color
+                        try:
+                            if run.font.highlight_color:
+                                run_format['highlight_color'] = run.font.highlight_color
+                        except:
+                            pass
+                        
+                        # Get additional formatting
+                        try:
+                            run_format['superscript'] = run.font.superscript
+                            run_format['subscript'] = run.font.subscript
+                            run_format['strike'] = run.font.strike
+                            run_format['double_strike'] = run.font.double_strike
+                            run_format['all_caps'] = run.font.all_caps
+                            run_format['small_caps'] = run.font.small_caps
+                        except:
+                            pass
+                            
                         para_format['runs'].append(run_format)
                 
                 formatting_info.append(para_format)
@@ -722,38 +772,110 @@ def create_formatted_docx(translated_paragraphs: list, formatting_info: list, fi
                 
             paragraph = doc.add_paragraph()
             
-            # Apply paragraph formatting
+            # Apply paragraph-level formatting
             try:
                 if para_format.get('alignment') is not None:
                     paragraph.alignment = para_format['alignment']
+                if para_format.get('left_indent') is not None:
+                    paragraph.paragraph_format.left_indent = para_format['left_indent']
+                if para_format.get('right_indent') is not None:
+                    paragraph.paragraph_format.right_indent = para_format['right_indent']
+                if para_format.get('first_line_indent') is not None:
+                    paragraph.paragraph_format.first_line_indent = para_format['first_line_indent']
+                if para_format.get('space_before') is not None:
+                    paragraph.paragraph_format.space_before = para_format['space_before']
+                if para_format.get('space_after') is not None:
+                    paragraph.paragraph_format.space_after = para_format['space_after']
+                if para_format.get('line_spacing') is not None:
+                    paragraph.paragraph_format.line_spacing = para_format['line_spacing']
             except Exception as e:
                 logger.warning(f"Could not apply paragraph formatting: {e}")
             
-            # Apply run formatting
+            # Apply run-level formatting with full preservation
             runs_info = para_format.get('runs', [])
             
             if runs_info:
-                # Get dominant formatting
+                # Analyze the dominant formatting for the paragraph
                 total_runs = len(runs_info)
+                
+                # Count formatting occurrences
                 bold_count = sum(1 for r in runs_info if r.get('bold'))
                 italic_count = sum(1 for r in runs_info if r.get('italic'))
                 underline_count = sum(1 for r in runs_info if r.get('underline'))
                 
+                # Get most common formatting values
+                font_names = [r.get('font_name') for r in runs_info if r.get('font_name')]
+                font_sizes = [r.get('font_size') for r in runs_info if r.get('font_size')]
+                font_colors_rgb = [r.get('font_color_rgb') for r in runs_info if r.get('font_color_rgb')]
+                font_colors_theme = [r.get('font_color_theme') for r in runs_info if r.get('font_color_theme')]
+                highlight_colors = [r.get('highlight_color') for r in runs_info if r.get('highlight_color')]
+                
+                # Create run with translated text
                 run = paragraph.add_run(para_text)
                 
                 try:
+                    # Apply basic formatting (use majority rule)
                     if bold_count > total_runs / 2:
                         run.bold = True
                     if italic_count > total_runs / 2:
                         run.italic = True
                     if underline_count > total_runs / 2:
                         run.underline = True
+                    
+                    # Apply font name (most common)
+                    if font_names:
+                        most_common_font = max(set(font_names), key=font_names.count)
+                        run.font.name = most_common_font
+                    
+                    # Apply font size (most common)
+                    if font_sizes:
+                        most_common_size = max(set(font_sizes), key=font_sizes.count)
+                        run.font.size = most_common_size
+                    
+                    # Apply font color (RGB - most common)
+                    if font_colors_rgb:
+                        most_common_color = max(set(font_colors_rgb), key=font_colors_rgb.count)
+                        run.font.color.rgb = most_common_color
+                    
+                    # Apply font color (theme - most common)
+                    elif font_colors_theme:
+                        most_common_theme = max(set(font_colors_theme), key=font_colors_theme.count)
+                        run.font.color.theme_color = most_common_theme
+                    
+                    # Apply highlight color (most common)
+                    if highlight_colors:
+                        most_common_highlight = max(set(highlight_colors), key=highlight_colors.count)
+                        run.font.highlight_color = most_common_highlight
+                    
+                    # Apply additional formatting if majority of runs have it
+                    superscript_count = sum(1 for r in runs_info if r.get('superscript'))
+                    subscript_count = sum(1 for r in runs_info if r.get('subscript'))
+                    strike_count = sum(1 for r in runs_info if r.get('strike'))
+                    double_strike_count = sum(1 for r in runs_info if r.get('double_strike'))
+                    all_caps_count = sum(1 for r in runs_info if r.get('all_caps'))
+                    small_caps_count = sum(1 for r in runs_info if r.get('small_caps'))
+                    
+                    if superscript_count > total_runs / 2:
+                        run.font.superscript = True
+                    if subscript_count > total_runs / 2:
+                        run.font.subscript = True
+                    if strike_count > total_runs / 2:
+                        run.font.strike = True
+                    if double_strike_count > total_runs / 2:
+                        run.font.double_strike = True
+                    if all_caps_count > total_runs / 2:
+                        run.font.all_caps = True
+                    if small_caps_count > total_runs / 2:
+                        run.font.small_caps = True
+                        
                 except Exception as e:
-                    logger.warning(f"Could not apply run formatting: {e}")
+                    logger.warning(f"Could not apply some run formatting: {e}")
             else:
+                # No run formatting info, just add the text
                 paragraph.add_run(para_text)
         
         doc.save(filename)
+        logger.info(f"Created formatted DOCX with full formatting preservation: {filename}")
         return filename
         
     except Exception as e: