Update tools/form_filler_server.py

tools/form_filler_server.py

@@ -29,21 +29,32 @@ async def fill_form(template_path: str, data: Dict[str, Any]) -> dict:
             return await fill_text_form(template_path, data, output_path)
             
     except Exception as e:
-        return {'error': str(e), 'success': False}
+        import traceback
+        return {'error': f"{str(e)}\n\n{traceback.format_exc()}", 'success': False}
 
 
 async def fill_docx_form(template_path: str, data: Dict[str, Any], output_path: str) -> dict:
-    """Fill DOCX form template - Enhanced to handle table-based forms"""
+    """Fill DOCX form template - Enhanced with comprehensive matching"""
     try:
         doc = Document(template_path)
         fields_filled = []
+        debug_info = []
+        
+        # Normalize data keys for better matching
+        normalized_data = {}
+        for key, value in data.items():
+            # Store original
+            normalized_data[key] = value
+            # Store lowercase
+            normalized_data[key.lower()] = value
+            # Store with underscores
+            normalized_data[key.lower().replace(" ", "_")] = value
+            # Store without spaces
+            normalized_data[key.lower().replace(" ", "")] = value
         
         # First, try to replace placeholders in paragraphs
         for paragraph in doc.paragraphs:
-            original_text = paragraph.text
-            
-            for key, value in data.items():
-                # Try multiple placeholder formats
+            for key, value in normalized_data.items():
                 placeholders = [
                     f"{{{{{key}}}}}",  # {{field_name}}
                     f"{{{key}}}",      # {field_name}
@@ -55,60 +66,68 @@ async def fill_docx_form(template_path: str, data: Dict[str, Any], output_path:
                         if key not in fields_filled:
                             fields_filled.append(key)
         
-        # Enhanced table processing - match field labels to values
-        for table in doc.tables:
-            for row in table.rows:
-                cells = row.cells
+        # Enhanced table processing
+        for table_idx, table in enumerate(doc.tables):
+            for row_idx, row in enumerate(table.rows):
+                cells_text = [cell.text.strip() for cell in row.cells]
                 
                 # Process each cell
-                for cell_idx, cell in enumerate(cells):
-                    cell_text = cell.text.strip()
+                for cell_idx, cell in enumerate(row.cells):
+                    cell_text = cell.text.strip().lower()
                     
-                    # Check if this cell contains a field label
-                    for key, value in data.items():
-                        # Create variations of the key to match
-                        key_variations = [
-                            key.lower(),
-                            key.replace("_", " ").lower(),
-                            key.replace("_", " ").title(),
-                            key.title(),
-                        ]
+                    # Skip empty cells
+                    if not cell_text:
+                        continue
+                    
+                    # Check each field
+                    for original_key, value in data.items():
+                        key_lower = original_key.lower()
+                        key_normalized = key_lower.replace(" ", "").replace("_", "")
+                        cell_normalized = cell_text.replace(" ", "").replace(":", "").replace("_", "")
+                        
+                        # Method 1: Exact match (case-insensitive)
+                        if key_lower in cell_text or cell_text in key_lower:
+                            # Fill next cell if exists and is empty
+                            if cell_idx + 1 < len(row.cells):
+                                next_cell = row.cells[cell_idx + 1]
+                                if not next_cell.text.strip() or len(next_cell.text.strip()) < 3:
+                                    next_cell.text = str(value)
+                                    if original_key not in fields_filled:
+                                        fields_filled.append(original_key)
+                                        debug_info.append(f"Filled '{original_key}' in cell after '{cell.text.strip()}'")
+                            
+                            # Method 2: Fill after colon in same cell
+                            if ":" in cell.text:
+                                parts = cell.text.split(":", 1)
+                                label = parts[0].strip()
+                                cell.text = f"{label}: {value}"
+                                if original_key not in fields_filled:
+                                    fields_filled.append(original_key)
+                                    debug_info.append(f"Filled '{original_key}' after colon in '{label}'")
                         
-                        # If cell text matches a field label
-                        for key_var in key_variations:
-                            if key_var in cell_text.lower():
-                                # Try to fill the next cell (common form pattern)
-                                if cell_idx + 1 < len(cells):
-                                    next_cell = cells[cell_idx + 1]
-                                    # Only fill if the next cell is empty or has placeholder
-                                    if not next_cell.text.strip() or next_cell.text.strip() in ["", "_____", "..."]:
-                                        next_cell.text = str(value)
-                                        if key not in fields_filled:
-                                            fields_filled.append(key)
-                                        break
-                                
-                                # Also check if there's text after the label in same cell
-                                # Pattern: "First Name: _____" or "First Name:"
-                                if ":" in cell_text:
-                                    # Replace everything after the colon
-                                    label_part = cell_text.split(":")[0] + ":"
-                                    cell.text = f"{label_part} {value}"
-                                    if key not in fields_filled:
-                                        fields_filled.append(key)
-                                    break
+                        # Method 3: Fuzzy match (normalized)
+                        elif key_normalized in cell_normalized or cell_normalized in key_normalized:
+                            if cell_idx + 1 < len(row.cells):
+                                next_cell = row.cells[cell_idx + 1]
+                                if not next_cell.text.strip() or len(next_cell.text.strip()) < 3:
+                                    next_cell.text = str(value)
+                                    if original_key not in fields_filled:
+                                        fields_filled.append(original_key)
+                                        debug_info.append(f"Filled '{original_key}' (fuzzy) after '{cell.text.strip()}'")
                     
-                    # Also check for placeholder patterns in the cell
-                    for key, value in data.items():
+                    # Check for placeholders
+                    for key, value in normalized_data.items():
                         placeholders = [
                             f"{{{{{key}}}}}",
                             f"{{{key}}}",
                         ]
                         
                         for placeholder in placeholders:
-                            if placeholder in cell.text:
+                            if placeholder.lower() in cell.text.lower():
                                 cell.text = cell.text.replace(placeholder, str(value))
                                 if key not in fields_filled:
                                     fields_filled.append(key)
+                                    debug_info.append(f"Filled placeholder '{placeholder}' with '{key}'")
         
         # Ensure output directory exists
         Path(output_path).parent.mkdir(parents=True, exist_ok=True)
@@ -117,8 +136,9 @@ async def fill_docx_form(template_path: str, data: Dict[str, Any], output_path:
         return {
             'success': True,
             'output_path': output_path,
-            'fields_filled': fields_filled,
-            'total_fields': len(fields_filled)
+            'fields_filled': list(set(fields_filled)),
+            'total_fields': len(set(fields_filled)),
+            'debug_info': debug_info
         }
         
     except Exception as e:
@@ -141,7 +161,6 @@ async def fill_excel_form(template_path: str, data: Dict[str, Any], output_path:
                         placeholders = [
                             f"{{{{{key}}}}}",
                             f"{{{key}}}",
-                            key
                         ]
                         
                         for placeholder in placeholders:
@@ -162,7 +181,8 @@ async def fill_excel_form(template_path: str, data: Dict[str, Any], output_path:
         }
         
     except Exception as e:
-        return {'error': str(e), 'success': False}
+        import traceback
+        return {'error': f"{str(e)}\n\n{traceback.format_exc()}", 'success': False}
 
 
 async def fill_text_form(template_path: str, data: Dict[str, Any], output_path: str) -> dict:
@@ -198,7 +218,8 @@ async def fill_text_form(template_path: str, data: Dict[str, Any], output_path:
         }
         
     except Exception as e:
-        return {'error': str(e), 'success': False}
+        import traceback
+        return {'error': f"{str(e)}\n\n{traceback.format_exc()}", 'success': False}
 
 
 async def generate_form_template(fields: list) -> dict:
@@ -224,4 +245,5 @@ async def generate_form_template(fields: list) -> dict:
         }
         
     except Exception as e:
-        return {'error': str(e), 'success': False}
+        import traceback
+        return {'error': f"{str(e)}\n\n{traceback.format_exc()}", 'success': False}