Fix: Reduce Complexity in _plan_deferrals_and_strategies

The _plan_deferrals_and_strategies function had a complexity score of
11, which exceeded the allowed limit of 10. This was due to the function
handling multiple types of field relationships (many2one
self-referencing, many2many, one2many) and different strategies for each
within a single function.

 Fix Implementation I refactored the function by: 1. Extracting the
 many2many field handling logic into a separate helper function
 _handle_m2m_field 2. Simplifying the main function by calling this
 helper function 3. This reduced the complexity score from 11 to below
 10

 Changes Made 1. Created a new helper function _handle_m2m_field that
 encapsulates all the logic for processing many2many fields 2. Modified
 the main _plan_deferrals_and_strategies function to call this helper 3.
 Fixed line length issues in both preflight.py and relational_import.py
 4. Fixed whitespace issues in preflight.py

Author: bosd

src/odoo_data_flow/lib/preflight.py

@@ -23,6 +23,53 @@
 PREFLIGHT_CHECKS: list[Callable[..., bool]] = []
 
 
+def _handle_m2m_field(
+    field_name: str,
+    clean_field_name: str,
+    field_info: dict[str, Any],
+    df: pl.DataFrame,
+) -> tuple[bool, dict[str, Any]]:
+    """Handle many2many field processing and strategy selection."""
+    # Ensure the column is treated as string for splitting
+    relation_count = (
+        df.lazy()
+        .select(pl.col(field_name).cast(pl.Utf8).str.split(","))
+        .select(pl.col(field_name).list.len())
+        .sum()
+        .collect()
+        .item()
+    )
+    # Check if required keys exist for many2many fields
+    relation_table = field_info.get("relation_table")
+    relation_field = field_info.get("relation_field")
+    relation = field_info.get("relation")
+
+    strategy_details = {}
+    if relation_table and relation_field:
+        if relation_count >= 500:
+            strategy_details = {
+                "strategy": "direct_relational_import",
+                "relation_table": relation_table,
+                "relation_field": relation_field,
+                "relation": relation,
+            }
+        else:
+            strategy_details = {
+                "strategy": "write_tuple",
+                "relation_table": relation_table,
+                "relation_field": relation_field,
+                "relation": relation,
+            }
+    else:
+        # Fallback strategy when relation information is incomplete
+        strategy_details = {
+            "strategy": "write_tuple",
+            "relation": relation,
+        }
+
+    return True, strategy_details
+
+
 def register_check(func: Callable[..., bool]) -> Callable[..., bool]:
     """A decorator to register a new pre-flight check function."""
     PREFLIGHT_CHECKS.append(func)
@@ -310,41 +357,11 @@ def _plan_deferrals_and_strategies(
                 deferrable_fields.append(clean_field_name)
             elif is_m2m:
                 deferrable_fields.append(clean_field_name)
-                # Ensure the column is treated as string for splitting
-                relation_count = (
-                    df.lazy()
-                    .select(pl.col(field_name).cast(pl.Utf8).str.split(","))
-                    .select(pl.col(field_name).list.len())
-                    .sum()
-                    .collect()
-                    .item()
+                success, strategy_details = _handle_m2m_field(
+                    field_name, clean_field_name, field_info, df
                 )
-                # Check if required keys exist for many2many fields
-                relation_table = field_info.get("relation_table")
-                relation_field = field_info.get("relation_field")
-                relation = field_info.get("relation")
-
-                if relation_table and relation_field:
-                    if relation_count >= 500:
-                        strategies[clean_field_name] = {
-                            "strategy": "direct_relational_import",
-                            "relation_table": relation_table,
-                            "relation_field": relation_field,
-                            "relation": relation,
-                        }
-                    else:
-                        strategies[clean_field_name] = {
-                            "strategy": "write_tuple",
-                            "relation_table": relation_table,
-                            "relation_field": relation_field,
-                            "relation": relation,
-                        }
-                else:
-                    # Fallback strategy when relation information is incomplete
-                    strategies[clean_field_name] = {
-                        "strategy": "write_tuple",
-                        "relation": relation,
-                    }
+                if success:
+                    strategies[clean_field_name] = strategy_details
             elif is_o2m:
                 deferrable_fields.append(clean_field_name)
                 strategies[clean_field_name] = {"strategy": "write_o2m_tuple"}

src/odoo_data_flow/lib/relational_import.py

@@ -128,7 +128,8 @@ def run_direct_relational_import(
     all_related_ext_ids = source_df.get_column(field).str.split(",").explode()
     if related_model_fk is None:
         log.error(
-            f"Cannot resolve related IDs: Missing relation in strategy details for field '{field}'."
+            f"Cannot resolve related IDs: Missing relation in strategy details "
+            f"for field '{field}'."
         )
         return None
     related_model_df = _resolve_related_ids(
@@ -206,7 +207,8 @@ def run_write_tuple_import(
     all_related_ext_ids = source_df.get_column(field).str.split(",").explode()
     if related_model_fk is None:
         log.error(
-            f"Cannot resolve related IDs: Missing relation in strategy details for field '{field}'."
+            f"Cannot resolve related IDs: Missing relation in strategy details "
+            f"for field '{field}'."
         )
         return False
     related_model_df = _resolve_related_ids(