Update updated_word.py

updated_word.py

@@ -620,8 +620,10 @@ def fix_management_summary_details_column(table, flat_json):
 
 def fix_operator_declaration_empty_values(table, flat_json):
     """Fix Operator Declaration table when values are empty or need updating.
-    - Only update name/position cells if they're empty or contain red text.
-    - If JSON gives a combined 'Name - Position' value, split it.
+    - Prefer exact qualified keys.
+    - If JSON has combined 'Name - Position', split it safely.
+    - Only write into cells that are empty or contain red text.
+    - Mark table as processed on success.
     """
     replacements_made = 0
 
@@ -643,18 +645,17 @@ def fix_operator_declaration_empty_values(table, flat_json):
         if value is None:
             return None, None
 
-        # If it's a list of two items - treat as [name, position]
+        # If it's a list: common pattern is [name, position]
         if isinstance(value, list):
             if len(value) == 0:
                 return None, None
             if len(value) == 1:
                 return str(value[0]).strip(), None
-            # if list has more than 1, try to use first two sensible entries
+            # use first two sensible entries
             first = str(value[0]).strip()
             second = str(value[1]).strip()
             if first and second:
                 return first, second
-            # fallthrough to string join
             value = " ".join(str(v).strip() for v in value if str(v).strip())
 
         s = str(value).strip()
@@ -666,27 +667,27 @@ def fix_operator_declaration_empty_values(table, flat_json):
         if len(parts) >= 2:
             left = parts[0].strip()
             right = parts[1].strip()
-            # Heuristic: if right looks like a role (contains common role words) treat as position
             role_indicators = ['manager', 'auditor', 'owner', 'director', 'supervisor',
                                'coordinator', 'driver', 'operator', 'representative', 'chief']
             if any(ind in right.lower() for ind in role_indicators) or len(right.split()) <= 4:
                 return left, right
-            # if left looks like a role and right looks like a name, invert
             if any(ind in left.lower() for ind in role_indicators) and not any(ind in right.lower() for ind in role_indicators):
                 return right, left
-            # else assume left=name, right=position
             return left, right
 
-        # No separator - try to detect "Firstname Lastname Title" (less reliable)
-        # If contains two capitalised tokens + a short token like 'Manager', split last token as position
+        # If no separator, check trailing role token
         tokens = s.split()
-        if len(tokens) >= 3 and tokens[-1].istitle() and any(ind in tokens[-1].lower() for ind in role_indicators):
-            return " ".join(tokens[:-1]), tokens[-1]
+        if len(tokens) >= 2:
+            last = tokens[-1]
+            role_indicators = ['manager', 'auditor', 'owner', 'director', 'supervisor',
+                               'coordinator', 'driver', 'operator', 'representative', 'chief']
+            if any(ind == last.lower() for ind in role_indicators):
+                return " ".join(tokens[:-1]), last
 
-        # fallback: treat entire string as name (no position)
+        # fallback: treat entire string as name
         return s, None
 
-    # Find the header row and the data row
+    # Locate header row + data row
     for row_idx, row in enumerate(table.rows):
         if len(row.cells) >= 2:
             cell1_text = get_clean_text(row.cells[0]).strip().lower()
@@ -695,7 +696,6 @@ def fix_operator_declaration_empty_values(table, flat_json):
             if "print name" in cell1_text and "position" in cell2_text:
                 print(f"      📌 Found header row at {row_idx + 1}")
 
-                # data row is next row if present
                 if row_idx + 1 < len(table.rows):
                     data_row = table.rows[row_idx + 1]
                     if len(data_row.cells) >= 2:
@@ -706,7 +706,7 @@ def fix_operator_declaration_empty_values(table, flat_json):
                         position_text = get_clean_text(position_cell).strip()
                         print(f"      📋 Current values: Name='{name_text}', Position='{position_text}'")
 
-                        # Retrieve JSON candidates (prefer exact qualified keys)
+                        # Prefer exact qualified keys first
                         name_value = find_matching_json_value("Operator Declaration.Print Name", flat_json)
                         if name_value is None:
                             name_value = find_matching_json_value("Print Name", flat_json)
@@ -715,25 +715,20 @@ def fix_operator_declaration_empty_values(table, flat_json):
                         if position_value is None:
                             position_value = find_matching_json_value("Position Title", flat_json)
 
-                        # If name_value contains both name+position, split it
+                        # parse combined cases
                         parsed_name_from_nameval, parsed_pos_from_nameval = parse_name_and_position(name_value) if name_value is not None else (None, None)
-
-                        # If position_value also combined, parse it
                         parsed_name_from_posval, parsed_pos_from_posval = parse_name_and_position(position_value) if position_value is not None else (None, None)
 
-                        # Decide final name and position candidates
+                        # decide final candidates
                         final_name = None
                         final_pos = None
 
-                        # Priority:
-                        # - If parsed_name_from_nameval exists, use its name part as final_name and pos part as candidate for position
                         if parsed_name_from_nameval:
                             final_name = parsed_name_from_nameval
                         elif name_value is not None:
                             final_name = get_value_as_string(name_value)
 
-                        # For position: prefer explicit position_value's parsed position,
-                        # else use parsed_pos_from_nameval if present
+                        # position preference: parsed_pos_from_posval > explicit position_value > parsed_pos_from_nameval
                         if parsed_pos_from_posval:
                             final_pos = parsed_pos_from_posval
                         elif position_value is not None:
@@ -741,7 +736,7 @@ def fix_operator_declaration_empty_values(table, flat_json):
                         elif parsed_pos_from_nameval:
                             final_pos = parsed_pos_from_nameval
 
-                        # Normalize to strings (strip)
+                        # normalize
                         if isinstance(final_name, list):
                             final_name = " ".join(str(x) for x in final_name).strip()
                         if isinstance(final_pos, list):
@@ -751,19 +746,16 @@ def fix_operator_declaration_empty_values(table, flat_json):
                         if isinstance(final_pos, str):
                             final_pos = final_pos.strip()
 
-                        # Filters to avoid writing company names into name slot
                         def looks_like_person(name_str):
-                            if not name_str: 
+                            if not name_str:
                                 return False
                             bad_phrases = ["pty ltd", "company", "farming", "p/l", "plc"]
                             low = name_str.lower()
                             if any(bp in low for bp in bad_phrases):
                                 return False
-                            # also ensure there is at least one space (first + last) or common pattern
                             return len(name_str) > 1
 
-                        # Now perform replacements only if cell is empty or has red text
-                        # Update name cell
+                        # Write name if empty or red
                         if (not name_text or has_red_text(name_cell)) and final_name and looks_like_person(final_name):
                             if has_red_text(name_cell):
                                 replace_red_text_in_cell(name_cell, final_name)
@@ -772,7 +764,7 @@ def fix_operator_declaration_empty_values(table, flat_json):
                             replacements_made += 1
                             print(f"      ✅ Updated Print Name -> '{final_name}'")
 
-                        # Update position cell
+                        # Write position if empty or red
                         if (not position_text or has_red_text(position_cell)) and final_pos:
                             if has_red_text(position_cell):
                                 replace_red_text_in_cell(position_cell, final_pos)
@@ -783,7 +775,7 @@ def fix_operator_declaration_empty_values(table, flat_json):
 
                 break
 
-    # Mark table processed so other handlers skip it
+    # mark processed
     if replacements_made > 0:
         try:
             setattr(table, "_processed_operator_declaration", True)
@@ -884,40 +876,34 @@ def handle_management_summary_fix(cell, flat_json):
 # ========================================================================
 
 def handle_operator_declaration_fix(table, flat_json):
-    """Handle small Operator/Auditor Declaration tables - SKIP if already processed"""
+    """Wrapper for small declaration tables. Delegate to canonical fix first.
+    If canonical did not change anything, fall back to the small-table auditor handling.
+    """
     replacements_made = 0
 
-    # <<< PATCH: skip if marked processed
+    # skip if already processed
     if getattr(table, "_processed_operator_declaration", False):
         print(f"    ⏭️ Skipping - Operator Declaration table already processed")
         return 0
-    # <<< END PATCH
-
-    if len(table.rows) > 4:  # Only process small tables
-        return 0
-
-    # Get table context
-    table_text = ""
-    for row in table.rows:
-        for cell in row.cells:
-            table_text += get_clean_text(cell).lower() + " "
 
-    # SKIP if this is an Operator Declaration table (already handled by fix_operator_declaration_empty_values)
-    if "print name" in table_text and "position title" in table_text:
-        print(f"    ⏭️ Skipping - Operator Declaration table already processed")
+    # only intended for small tables; if large, skip (your original condition)
+    if len(table.rows) > 4:
         return 0
 
-    # Check if this is a declaration table
-    if not ("print name" in table_text or "signature" in table_text or "date" in table_text):
-        return 0
+    # First: try canonical operator declaration handler (covers primary case)
+    replaced = fix_operator_declaration_empty_values(table, flat_json)
+    replacements_made += replaced
+    if replaced:
+        # canonical handled it and set the processed flag
+        return replacements_made
 
-    print(f"    🎯 Processing other declaration table")
+    # fallback: original small-table behaviour (auditor declaration etc.)
+    # (This mirrors your earlier auditor-specific logic but will not run if canonical updated table)
+    print(f"    🎯 Processing other declaration table (fallback small-table behavior)")
 
-    # Process each cell with red text (for auditor declarations, etc.)
     for row_idx, row in enumerate(table.rows):
         for cell_idx, cell in enumerate(row.cells):
             if has_red_text(cell):
-                # Try auditor-specific fields first
                 declaration_fields = [
                     "NHVAS Approved Auditor Declaration.Print Name",
                     "Auditor name",
@@ -938,7 +924,6 @@ def handle_operator_declaration_fix(table, flat_json):
                                 replaced = True
                                 break
 
-                # If no specific field match, try generic signature/date
                 if not replaced:
                     red_text = ""
                     for paragraph in cell.paragraphs:
@@ -953,6 +938,14 @@ def handle_operator_declaration_fix(table, flat_json):
                         cell_replacements = replace_red_text_in_cell(cell, "[Date]")
                         replacements_made += cell_replacements
 
+    # if any replacements made here, mark processed
+    if replacements_made > 0:
+        try:
+            setattr(table, "_processed_operator_declaration", True)
+            print("    🔖 Marked table as processed by operator declaration fallback")
+        except Exception:
+            pass
+
     return replacements_made
 
 def handle_print_accreditation_section(table, flat_json):
@@ -1438,7 +1431,7 @@ def process_hf(json_file, docx_file, output_file):
         print(f"   📊 Tables: {table_replacements}")
         print(f"   📝 Paragraphs: {paragraph_replacements}")
         print(f"   📋 Headings: {heading_replacements}")
-        print(f"   🎯 Force fixes: {force_replacements}")
+        #print(f"   🎯 Force fixes: {force_replacements}")
         print(f"🎉 Processing complete!")
 
     except FileNotFoundError as e: