Update updated_word.py

updated_word.py

@@ -648,7 +648,7 @@ def fix_management_summary_details_column(table, flat_json):
 # ============================================================================
 def fix_operator_declaration_empty_values(table, flat_json):
     """
-    IMPROVED: Better operator declaration handling with more reliable position detection
+    FIXED: Properly distinguish between auditor and operator data for Operator Declaration table
     """
     replacements_made = 0
     print(f"    🎯 FIX: Operator Declaration empty values processing")
@@ -673,15 +673,38 @@ def fix_operator_declaration_empty_values(table, flat_json):
             if len(value) == 0:
                 return None, None
             if len(value) == 1:
-                return str(value[0]).strip(), None
+                # Check if single item looks like "Name - Position" format
+                single_item = str(value[0]).strip()
+                if ' - ' in single_item:
+                    parts = single_item.split(' - ', 1)
+                    if len(parts) == 2:
+                        return parts[0].strip(), parts[1].strip()
+                return single_item, None
             
-            # Handle [name, position] pattern
-            first = str(value[0]).strip()
-            second = str(value[1]).strip()
-            if first and second:
+            # Handle [name, position] pattern or multiple attendance entries
+            if len(value) == 2:
+                first = str(value[0]).strip()
+                second = str(value[1]).strip()
+                
+                # Check if both look like names (attendance list pattern)
+                if (' ' in first and ' ' in second and 
+                    not any(role in first.lower() for role in ['manager', 'director', 'auditor', 'officer']) and
+                    not any(role in second.lower() for role in ['manager', 'director', 'auditor', 'officer'])):
+                    # This is likely attendance list data, return first name only
+                    return first, None
+                
                 return first, second
             
-            # Join list elements
+            # Multiple items - check if it's attendance list format
+            attendance_like = any(' - ' in str(item) for item in value)
+            if attendance_like:
+                # Extract first person's name from attendance format
+                first_entry = str(value[0]).strip()
+                if ' - ' in first_entry:
+                    return first_entry.split(' - ')[0].strip(), first_entry.split(' - ')[1].strip()
+                return first_entry, None
+            
+            # Join list elements as fallback
             value = " ".join(str(v).strip() for v in value if str(v).strip())
         
         s = str(value).strip()
@@ -704,7 +727,8 @@ def fix_operator_declaration_empty_values(table, flat_json):
             # Check which part is more likely to be a position
             role_indicators = ['manager', 'auditor', 'owner', 'director', 'supervisor',
                                'coordinator', 'driver', 'operator', 'representative', 'chief',
-                               'president', 'ceo', 'cfo', 'secretary', 'treasurer']
+                               'president', 'ceo', 'cfo', 'secretary', 'treasurer', 'officer',
+                               'compliance']
             
             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)
@@ -722,7 +746,7 @@ def fix_operator_declaration_empty_values(table, flat_json):
         if len(tokens) >= 2:
             last_token = tokens[-1].lower()
             role_indicators = ['manager', 'auditor', 'owner', 'director', 'supervisor',
-                               'coordinator', 'driver', 'operator', 'representative', 'chief']
+                               'coordinator', 'driver', 'operator', 'representative', 'chief', 'officer']
             if any(ind == last_token for ind in role_indicators):
                 return " ".join(tokens[:-1]), tokens[-1]
         
@@ -795,60 +819,114 @@ def fix_operator_declaration_empty_values(table, flat_json):
                         final_name = None
                         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"),
+                        # IMPROVED: Better strategy to find OPERATOR (not auditor) data
+                        final_name = None
+                        final_position = None
+                        
+                        # Strategy 1: Look specifically in Attendance List for operator names
+                        attendance_kv = find_matching_json_key_and_value("Attendance List (Names and Position Titles)", flat_json)
+                        if attendance_kv and attendance_kv[1]:
+                            attendance_data = attendance_kv[1]
+                            print(f"      📋 Found attendance data: {attendance_data}")
                             
-                            # Strategy 4: Any key containing "print name" or "position"
-                            (None, None)  # Special case - will search all keys
-                        ]
+                            # Parse attendance list to find non-auditor names
+                            if isinstance(attendance_data, list):
+                                for entry in attendance_data:
+                                    entry_str = str(entry).strip()
+                                    if 'auditor' not in entry_str.lower() and entry_str:
+                                        # Parse this entry for name and position
+                                        parsed_name, parsed_pos = parse_name_and_position(entry_str)
+                                        if parsed_name and looks_like_person_name(parsed_name):
+                                            final_name = parsed_name
+                                            if parsed_pos and looks_like_role(parsed_pos):
+                                                final_position = parsed_pos
+                                            break
                         
-                        for name_key_pattern, pos_key_pattern in search_strategies:
-                            if final_name and final_position:
-                                break
+                        # Strategy 2: If no good name from attendance, try nested attendance keys
+                        if not final_name:
+                            nested_attendance_kv = find_matching_json_key_and_value("Attendance List (Names and Position Titles).Attendance List (Names and Position Titles)", flat_json)
+                            if nested_attendance_kv and nested_attendance_kv[1]:
+                                nested_data = nested_attendance_kv[1]
+                                print(f"      📋 Found nested attendance data: {nested_data}")
                                 
-                            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:
-                                # Search for specific key patterns
+                                if isinstance(nested_data, list):
+                                    for entry in nested_data:
+                                        entry_str = str(entry).strip()
+                                        if 'auditor' not in entry_str.lower() and entry_str:
+                                            parsed_name, parsed_pos = parse_name_and_position(entry_str)
+                                            if parsed_name and looks_like_person_name(parsed_name):
+                                                final_name = parsed_name
+                                                if parsed_pos and looks_like_role(parsed_pos):
+                                                    final_position = parsed_pos
+                                                break
+                        
+                        # Strategy 3: Direct operator declaration keys (with filtering)
+                        if not final_name:
+                            search_strategies = [
+                                ("Operator Declaration.Print Name", "Operator Declaration.Position Title"),
+                                ("Print Name", "Position Title"),
+                            ]
+                            
+                            for name_key_pattern, pos_key_pattern in search_strategies:
                                 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]:
+                                    # Filter out auditor names
+                                    potential_name = str(name_kv[1]).strip()
+                                    
+                                    # Skip if this is clearly auditor data
+                                    if name_kv[0] and 'auditor' in name_kv[0].lower():
+                                        continue
+                                    
+                                    # Skip common auditor names that appear in our data
+                                    auditor_names = ['greg dyer', 'greg', 'dyer']
+                                    if any(aud_name in potential_name.lower() for aud_name in auditor_names):
+                                        continue
+                                    
                                     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
+                                        # Additional check - avoid auditor names
+                                        if not any(aud_name in name_from_val.lower() for aud_name in auditor_names):
+                                            final_name = name_from_val
+                                            if pos_from_val and looks_like_role(pos_from_val):
+                                                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
+                                    # Only use if key doesn't indicate auditor data
+                                    if not (pos_kv[0] and 'auditor' in pos_kv[0].lower()):
+                                        pos_val = str(pos_kv[1]).strip()
+                                        if looks_like_role(pos_val) and 'auditor' not in pos_val.lower():
+                                            final_position = pos_val
+                                
+                                if final_name:
+                                    break
+                        
+                        # Strategy 4: Last resort - search all keys but with strict filtering
+                        if not final_name:
+                            print(f"      🔍 Searching all keys with strict operator filtering...")
+                            for key, value in flat_json.items():
+                                key_lower = key.lower()
+                                
+                                # Skip keys that clearly relate to auditor
+                                if 'auditor' in key_lower:
+                                    continue
+                                
+                                # Look for operator-related keys
+                                if (("operator" in key_lower and "name" in key_lower) or 
+                                    ("print name" in key_lower and "operator" in key_lower)):
+                                    
+                                    if value and looks_like_person_name(str(value)):
+                                        potential_name = str(value).strip()
+                                        # Skip auditor names
+                                        auditor_names = ['greg dyer', 'greg', 'dyer']
+                                        if not any(aud_name in potential_name.lower() for aud_name in auditor_names):
+                                            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
+                                                break
                         
                         # Clean up final values
                         if isinstance(final_name, (list, tuple)):