Fix pre-commit issues and reduce function complexity in import_threaded.py\n\n- Refactor _create_batch_individually to reduce complexity from 17 to under 10\n- Extract external ID field conversion into _convert_external_id_field helper\n- Extract external ID field processing into _process_external_id_fields helper\n- Extract error handling into _handle_create_error helper\n- Fix line length violations by breaking long lines\n- Add proper type annotations\n- Fix trailing whitespace issues\n\nAll pre-commit checks and tests now pass.

Author: bosd

src/odoo_data_flow/import_threaded.py

@@ -330,7 +330,145 @@ def __init__(
         )
 
 
-def _create_batch_individually(  # noqa: C901
+def _convert_external_id_field(
+    model: Any,
+    field_name: str,
+    field_value: str,
+    converted_vals: dict[str, Any],
+) -> list[str]:
+    """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:
+        List of external ID field names that were processed
+    """
+    external_id_fields = [field_name]
+    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
+        log.debug(
+            f"Converted empty external ID {field_name} -> {base_field_name} (False)"
+        )
+    else:
+        # Convert external ID to database ID
+        try:
+            # 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
+                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
+                log.warning(
+                    f"Could not find record for external ID '{field_value}', "
+                    f"setting {base_field_name} to False"
+                )
+        except Exception as e:
+            log.warning(
+                f"Error looking up external ID '{field_value}' for field "
+                f"'{field_name}': {e}"
+            )
+            # On error, set to False
+            converted_vals[base_field_name] = False
+
+    return external_id_fields
+
+
+def _process_external_id_fields(
+    model: Any,
+    clean_vals: dict[str, Any],
+) -> tuple[dict[str, Any], list[str]]:
+    """Process all external ID fields in the clean values.
+
+    Args:
+        model: The Odoo model object
+        clean_vals: Dictionary of clean field values
+
+    Returns:
+        Tuple of (converted_vals, external_id_fields)
+    """
+    converted_vals: dict[str, Any] = {}
+    external_id_fields: list[str] = []
+
+    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
+            )
+            external_id_fields.extend(fields)
+        else:
+            # Regular field - pass through as-is
+            converted_vals[field_name] = field_value
+
+    return converted_vals, external_id_fields
+
+
+def _handle_create_error(
+    i: int,
+    create_error: Exception,
+    line: list[Any],
+    error_summary: str,
+) -> tuple[str, list[list[Any]], str]:
+    """Handle errors during record creation.
+
+    Args:
+        i: The row index
+        create_error: The exception that occurred
+        line: The data line being processed
+        error_summary: Current error summary
+
+    Returns:
+        Tuple of (error_message, failed_lines, error_summary)
+    """
+    failed_lines = []
+
+    # Handle JSON-RPC exceptions that contain IndexErrors
+    error_str = str(create_error).lower()
+
+    # Check if this is a JSON-RPC exception containing an IndexError/tuple index error
+    if "tuple index out of range" in error_str or "indexerror" in error_str:
+        error_message = f"Tuple unpacking error in row {i + 1}: {create_error}"
+        failed_line = [*list(line), error_message]
+        failed_lines.append(failed_line)
+        if "Fell back to create" in error_summary:
+            error_summary = "Tuple unpacking error detected"
+        return error_message, failed_lines, error_summary
+
+    # Handle other specific error types
+    error_message = str(create_error).replace("\n", " | ")
+
+    # Handle "tuple index out of range" errors specifically
+    if "tuple index out of range" in error_message:
+        error_message = f"Tuple unpacking error in row {i + 1}: {error_message}"
+
+    # Handle invalid field errors (the new issue we discovered)
+    elif "Invalid field" in error_message and "/id" in error_message:
+        error_message = (
+            f"Invalid external ID field detected in row {i + 1}: {error_message}"
+        )
+
+    failed_line = [*list(line), error_message]
+    failed_lines.append(failed_line)
+    if "Fell back to create" in error_summary:
+        error_summary = error_message
+
+    return error_message, failed_lines, error_summary
+
+
+def _create_batch_individually(
     model: Any,
     batch_lines: list[list[Any]],
     batch_header: list[str],
@@ -367,59 +505,15 @@ def _create_batch_individually(  # noqa: C901
             clean_vals = {
                 k: v
                 for k, v in vals.items()
-                if k.split("/")[0]
-                not in ignore_set  # Allow external ID fields through for conversion
+                if k.split("/")[0] not in ignore_set
+                # Allow external ID fields through for conversion
             }
 
             # 3. CREATE
             # Convert external ID references to actual database IDs before creating
-            converted_vals = {}
-            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"):
-                    external_id_fields.append(field_name)
-                    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
-                        log.debug(
-                            f"Converted empty external ID {field_name} -> "
-                            f"{base_field_name} (False)"
-                        )
-                    else:
-                        # Convert external ID to database ID
-                        try:
-                            # 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
-                                log.debug(
-                                    f"Converted external ID {field_name} "
-                                    f"({field_value}) -> {base_field_name} "
-                                    f"({record_ref.id})"
-                                )
-                            else:
-                                # If we can't find the external ID, set to False
-                                converted_vals[base_field_name] = False
-                                log.warning(
-                                    f"Could not find record for external ID "
-                                    f"'{field_value}' setting {base_field_name}"
-                                    f" to False"
-                                )
-                        except Exception as e:
-                            log.warning(
-                                f"Error looking up external ID '{field_value}' "
-                                f"for field '{field_name}': {e}"
-                            )
-                            # On error, set to False
-                            converted_vals[base_field_name] = False
-                else:
-                    # Regular field - pass through as-is
-                    converted_vals[field_name] = field_value
+            converted_vals, external_id_fields = _process_external_id_fields(
+                model, clean_vals
+            )
 
             log.debug(f"External ID fields found: {external_id_fields}")
             log.debug(f"Converted vals keys: {list(converted_vals.keys())}")
@@ -433,33 +527,10 @@ def _create_batch_individually(  # noqa: C901
                 error_summary = "Malformed CSV row detected"
             continue
         except Exception as create_error:
-            # Handle JSON-RPC exceptions that contain IndexErrors
-            error_str = str(create_error).lower()
-
-            # Check if this is a JSON-RPC exception containing an
-            # IndexError/tuple index error
-            if "tuple index out of range" in error_str or "indexerror" in error_str:
-                error_message = f"Tuple unpacking error in row {i + 1}: {create_error}"
-                failed_line = [*list(line), error_message]
-                failed_lines.append(failed_line)
-                if "Fell back to create" in error_summary:
-                    error_summary = "Tuple unpacking error detected"
-                continue
-
-            # Handle other specific error types
-            error_message = str(create_error).replace("\n", " | ")
-
-            # Handle "tuple index out of range" errors specifically
-            if "tuple index out of range" in error_message:
-                error_message = f"Tuple unpacking error in row {i + 1}: {error_message}"
-
-            # Handle invalid field errors (the new issue we discovered)
-            elif "Invalid field" in error_message and "/id" in error_message:
-                error_message = "Invalid external ID field detected in row "
-                f"{i + 1}: {error_message}"
-
-            failed_line = [*list(line), error_message]
-            failed_lines.append(failed_line)
+            error_message, new_failed_lines, error_summary = _handle_create_error(
+                i, create_error, line, error_summary
+            )
+            failed_lines.extend(new_failed_lines)
             if "Fell back to create" in error_summary:
                 error_summary = error_message
     return {