Refactor external ID field processing to eliminate side effects\n\n- Make _convert_external_id_field a pure function that returns (base_field_name, converted_value)\n instead of modifying converted_vals as a side effect\n- Update _process_external_id_fields to handle the return value properly\n- Improve separation of concerns between conversion logic and state management\n- Make the code more testable and easier to follow\n- Eliminate misleading variable name 'fields' that actually holds a single string\n\nThis refactoring improves the clarity and maintainability of the external ID field\nprocessing logic by following functional programming principles.

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

Author: bosd

src/odoo_data_flow/import_threaded.py

@@ -334,25 +334,23 @@ def _convert_external_id_field(
     model: Any,
     field_name: str,
     field_value: str,
-    converted_vals: dict[str, Any],
-) -> str:
+) -> tuple[str, Any]:
     """Convert an external ID field to a database ID.
 
     Args:
         model: The Odoo model object
         field_name: The field name (e.g., 'parent_id/id')
         field_value: The external ID value
-        converted_vals: Dictionary to store converted values
 
     Returns:
-        The external ID field name that was processed.
+        Tuple of (base_field_name, converted_value)
     """
     base_field_name = field_name[:-3]  # Remove '/id' suffix
 
     # Handle empty external ID references
     if not field_value:
         # Empty external ID means no value for this field
-        converted_vals[base_field_name] = False
+        converted_value = False
         log.debug(
             f"Converted empty external ID {field_name} -> {base_field_name} (False)"
         )
@@ -362,14 +360,14 @@ def _convert_external_id_field(
             # Look up the database ID for this external ID
             record_ref = model.browse().env.ref(field_value, raise_if_not_found=False)
             if record_ref:
-                converted_vals[base_field_name] = record_ref.id
+                converted_value = record_ref.id
                 log.debug(
                     f"Converted external ID {field_name} ({field_value}) -> "
                     f"{base_field_name} ({record_ref.id})"
                 )
             else:
                 # If we can't find the external ID, set to False
-                converted_vals[base_field_name] = False
+                converted_value = False
                 log.warning(
                     f"Could not find record for external ID '{field_value}', "
                     f"setting {base_field_name} to False"
@@ -380,9 +378,9 @@ def _convert_external_id_field(
                 f"'{field_name}': {e}"
             )
             # On error, set to False
-            converted_vals[base_field_name] = False
+            converted_value = False
 
-    return field_name
+    return base_field_name, converted_value
 
 
 def _process_external_id_fields(
@@ -404,10 +402,14 @@ def _process_external_id_fields(
     for field_name, field_value in clean_vals.items():
         # Handle external ID references (e.g., 'parent_id/id' -> 'parent_id')
         if field_name.endswith("/id"):
-            fields = _convert_external_id_field(
-                model, field_name, field_value, converted_vals
+            # _convert_external_id_field is now a pure function that returns
+            # (base_field_name, converted_value) instead of modifying
+            # converted_vals as side effect
+            base_name, value = _convert_external_id_field(
+                model, field_name, field_value
             )
-            external_id_fields.append(fields)
+            converted_vals[base_name] = value
+            external_id_fields.append(field_name)
         else:
             # Regular field - pass through as-is
             converted_vals[field_name] = field_value