Update updated_word.py

updated_word.py

@@ -647,166 +647,241 @@ def fix_management_summary_details_column(table, flat_json):
 # Canonical operator declaration fixer — SAFER
 # ============================================================================
 def fix_operator_declaration_empty_values(table, flat_json):
+    """
+    IMPROVED: Better operator declaration handling with more reliable position detection
+    """
     replacements_made = 0
     print(f"    🎯 FIX: Operator Declaration empty values processing")
+    
+    # Verify this is actually an operator declaration table
     table_context = ""
     for row in table.rows:
         for cell in row.cells:
             table_context += get_clean_text(cell).lower() + " "
+    
     if not ("print name" in table_context and "position title" in table_context):
         return 0
+    
     print(f"    ✅ Confirmed Operator Declaration table")
 
     def parse_name_and_position(value):
+        """Enhanced parsing for name/position combinations"""
         if value is None:
             return None, None
+        
         if isinstance(value, list):
             if len(value) == 0:
                 return None, None
             if len(value) == 1:
                 return str(value[0]).strip(), None
-            # common [name, position] pattern
+            
+            # Handle [name, position] pattern
             first = str(value[0]).strip()
             second = str(value[1]).strip()
             if first and second:
                 return first, second
+            
+            # Join list elements
             value = " ".join(str(v).strip() for v in value if str(v).strip())
+        
         s = str(value).strip()
         if not s:
             return None, None
-        parts = re.split(r'\s+[-–—]\s+|\s*,\s*|\s*\|\s*', s)
-        if len(parts) >= 2:
+        
+        # Split on common separators
+        separators = [r'\s+[-–—]\s+', r'\s*,\s*', r'\s*\|\s*', r'\s*;\s*']
+        parts = None
+        
+        for sep_pattern in separators:
+            parts = re.split(sep_pattern, s)
+            if len(parts) >= 2:
+                break
+        
+        if parts and len(parts) >= 2:
             left = parts[0].strip()
             right = parts[1].strip()
+            
+            # Check which part is more likely to be a 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:
+                               'coordinator', 'driver', 'operator', 'representative', 'chief',
+                               'president', 'ceo', 'cfo', 'secretary', 'treasurer']
+            
+            right_has_role = any(ind in right.lower() for ind in role_indicators)
+            left_has_role = any(ind in left.lower() for ind in role_indicators)
+            
+            if right_has_role and not left_has_role:
+                return left, right  # Standard: name, position
+            elif left_has_role and not right_has_role:
+                return right, left  # Reversed: position, name
+            else:
+                # Default to left=name, right=position
                 return left, right
-            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
-            return left, right
+        
+        # Look for single word position at end
         tokens = s.split()
         if len(tokens) >= 2:
-            last = tokens[-1]
+            last_token = tokens[-1].lower()
             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
+            if any(ind == last_token for ind in role_indicators):
+                return " ".join(tokens[:-1]), tokens[-1]
+        
         return s, None
 
+    def looks_like_role(s: str) -> bool:
+        """Check if string looks like a job role/position"""
+        if not s:
+            return False
+        
+        s = s.lower().strip()
+        
+        # Common role words
+        roles = ['manager', 'auditor', 'owner', 'director', 'supervisor', 
+                 'coordinator', 'driver', 'operator', 'representative', 'chief',
+                 'president', 'ceo', 'cfo', 'secretary', 'treasurer', 'officer']
+        
+        # Direct role match
+        if any(role in s for role in roles):
+            return True
+        
+        # Short descriptive terms (likely roles)
+        if len(s.split()) <= 3 and any(c.isalpha() for c in s) and len(s) > 1:
+            return True
+            
+        return False
+
+    def looks_like_person_name(s: str) -> bool:
+        """Check if string looks like a person's name"""
+        if not s:
+            return False
+        
+        s = s.strip()
+        
+        # Exclude company-like terms
+        company_terms = ['pty ltd', 'ltd', 'inc', 'corp', 'company', 'llc', 'plc']
+        s_lower = s.lower()
+        if any(term in s_lower for term in company_terms):
+            return False
+        
+        # Should have letters and reasonable length
+        if len(s) > 1 and any(c.isalpha() for c in s):
+            return True
+            
+        return False
+
+    # Process the table
     for row_idx, row in enumerate(table.rows):
         if len(row.cells) >= 2:
             cell1_text = get_clean_text(row.cells[0]).strip().lower()
             cell2_text = get_clean_text(row.cells[1]).strip().lower()
-            # header detection
+            
+            # Detect header row
             if "print name" in cell1_text and "position" in cell2_text:
                 print(f"      📌 Found header row at {row_idx + 1}")
+                
+                # Process data row (next row after header)
                 if row_idx + 1 < len(table.rows):
                     data_row = table.rows[row_idx + 1]
                     if len(data_row.cells) >= 2:
                         name_cell = data_row.cells[0]
                         position_cell = data_row.cells[1]
-                        name_text = get_clean_text(name_cell).strip()
-                        position_text = get_clean_text(position_cell).strip()
-                        print(f"      📋 Current values: Name='{name_text}', Position='{position_text}'")
-
-                        # Prefer exact qualified keys first (use key-aware lookup)
-                        name_kv = find_matching_json_key_and_value("Operator Declaration.Print Name", flat_json) or find_matching_json_key_and_value("Print Name", flat_json)
-                        position_kv = find_matching_json_key_and_value("Operator Declaration.Position Title", flat_json) or find_matching_json_key_and_value("Position Title", flat_json)
-
-                        name_value = name_kv[1] if name_kv else None
-                        name_key = name_kv[0] if name_kv else None
-
-                        position_value = position_kv[1] if position_kv else None
-                        position_key = position_kv[0] if position_kv else None
-
-                        # 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)
-                        parsed_name_from_posval, parsed_pos_from_posval = parse_name_and_position(position_value) if position_value is not None else (None, None)
-
+                        
+                        current_name = get_clean_text(name_cell).strip()
+                        current_position = get_clean_text(position_cell).strip()
+                        
+                        print(f"      📋 Current values: Name='{current_name}', Position='{current_position}'")
+                        
+                        # IMPROVED: More comprehensive search for operator declaration data
                         final_name = None
-                        final_pos = None
-
-                        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)
-
-                        # Position acceptance policy:
-                        # - Accept position_value ONLY if matched key indicates position/title OR parsed value looks like a role
-                        def looks_like_role(s: str) -> bool:
-                            if not s:
-                                return False
-                            s = s.lower()
-                            roles = ['manager', 'auditor', 'owner', 'director', 'supervisor', 'coordinator', 'driver', 'operator', 'representative', 'chief']
-                            # short role descriptions or containing role token
-                            if any(r in s for r in roles):
-                                return True
-                            # single/short token likely role (<=4 tokens)
-                            if len(s.split()) <= 4 and any(c.isalpha() for c in s):
-                                return True
-                            return False
-
-                        # Only use position_value if the matched key strongly indicates position/title
-                        use_position = False
-                        if position_kv:
-                            k_lower = (position_key or "").lower()
-                            if ("position" in k_lower or "title" in k_lower or "role" in k_lower):
-                                use_position = True
-                        # Avoid using attendance keys or attendance text as position source
-                        if position_kv and ("attendance" in position_key.lower() or "attendance list" in position_key.lower() or "attendees" in position_key.lower()):
-                            use_position = False
-
-                        if use_position:
-                            # choose parsed pos if available
-                            if parsed_pos_from_posval:
-                                final_pos = parsed_pos_from_posval
+                        final_position = None
+                        
+                        # Search strategies in order of preference
+                        search_strategies = [
+                            # Strategy 1: Direct operator declaration keys
+                            ("Operator Declaration.Print Name", "Operator Declaration.Position Title"),
+                            
+                            # Strategy 2: Generic print name/position keys
+                            ("Print Name", "Position Title"),
+                            
+                            # Strategy 3: Look in operator information section
+                            ("Operator Information.Print Name", "Operator Information.Position Title"),
+                            
+                            # Strategy 4: Any key containing "print name" or "position"
+                            (None, None)  # Special case - will search all keys
+                        ]
+                        
+                        for name_key_pattern, pos_key_pattern in search_strategies:
+                            if final_name and final_position:
+                                break
+                                
+                            if name_key_pattern is None:
+                                # Search all keys for relevant data
+                                for key, value in flat_json.items():
+                                    key_lower = key.lower()
+                                    
+                                    # Look for name-like keys
+                                    if not final_name and ("print name" in key_lower or 
+                                                          ("name" in key_lower and "operator" in key_lower)):
+                                        if value and looks_like_person_name(str(value)):
+                                            name_from_val, pos_from_val = parse_name_and_position(value)
+                                            if name_from_val and looks_like_person_name(name_from_val):
+                                                final_name = name_from_val
+                                                if pos_from_val and looks_like_role(pos_from_val):
+                                                    final_position = pos_from_val
+                                    
+                                    # Look for position-like keys
+                                    if not final_position and ("position" in key_lower or "title" in key_lower):
+                                        if value and looks_like_role(str(value)):
+                                            final_position = str(value).strip()
                             else:
-                                final_pos = get_value_as_string(position_value) if position_value is not None else None
-                        else:
-                            # allow parsed position gleaned from name_value (if it looks like a role)
-                            if parsed_pos_from_nameval and looks_like_role(parsed_pos_from_nameval):
-                                final_pos = parsed_pos_from_nameval
-
-                        # final normalization
-                        if isinstance(final_name, list):
+                                # Search for specific key patterns
+                                name_kv = find_matching_json_key_and_value(name_key_pattern, flat_json)
+                                pos_kv = find_matching_json_key_and_value(pos_key_pattern, flat_json)
+                                
+                                if name_kv and name_kv[1]:
+                                    name_from_val, pos_from_val = parse_name_and_position(name_kv[1])
+                                    if name_from_val and looks_like_person_name(name_from_val):
+                                        final_name = name_from_val
+                                        if pos_from_val and looks_like_role(pos_from_val) and not final_position:
+                                            final_position = pos_from_val
+                                
+                                if pos_kv and pos_kv[1] and not final_position:
+                                    pos_val = str(pos_kv[1]).strip()
+                                    if looks_like_role(pos_val):
+                                        final_position = pos_val
+                        
+                        # Clean up final values
+                        if isinstance(final_name, (list, tuple)):
                             final_name = " ".join(str(x) for x in final_name).strip()
-                        if isinstance(final_pos, list):
-                            final_pos = " ".join(str(x) for x in final_pos).strip()
-                        if isinstance(final_name, str):
-                            final_name = final_name.strip()
-                        if isinstance(final_pos, str):
-                            final_pos = final_pos.strip()
-
-                        def looks_like_person(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
-                            return len(name_str) > 1 and any(c.isalpha() for c in name_str)
-
-                        # 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 isinstance(final_position, (list, tuple)):
+                            final_position = " ".join(str(x) for x in final_position).strip()
+                        
+                        final_name = str(final_name).strip() if final_name else None
+                        final_position = str(final_position).strip() if final_position else None
+                        
+                        print(f"      🎯 Final extracted values: Name='{final_name}', Position='{final_position}'")
+                        
+                        # Update name cell if needed
+                        if (not current_name or has_red_text(name_cell)) and final_name and looks_like_person_name(final_name):
                             if has_red_text(name_cell):
                                 replace_red_text_in_cell(name_cell, final_name)
                             else:
                                 name_cell.text = final_name
                             replacements_made += 1
                             print(f"      ✅ Updated Print Name -> '{final_name}'")
-
-                        # Write position if empty or red and final_pos appears role-like
-                        if (not position_text or has_red_text(position_cell)) and final_pos and looks_like_role(final_pos):
+                        
+                        # Update position cell if needed
+                        if (not current_position or has_red_text(position_cell)) and final_position and looks_like_role(final_position):
                             if has_red_text(position_cell):
-                                replace_red_text_in_cell(position_cell, final_pos)
+                                replace_red_text_in_cell(position_cell, final_position)
                             else:
-                                position_cell.text = final_pos
+                                position_cell.text = final_position
                             replacements_made += 1
-                            print(f"      ✅ Updated Position Title -> '{final_pos}'")
-
-                break
+                            print(f"      ✅ Updated Position Title -> '{final_position}'")
+                
+                break  # Found and processed the header row
 
+    # Mark table as processed
     if replacements_made > 0:
         try:
             setattr(table, "_processed_operator_declaration", True)