refactor: split _run_compression to fix C901 complexity

Extract the parallel and serial execution paths into _run_parallel and
_run_serial helpers so _run_compression itself stays under flake8's
max-complexity = 10.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: galenlynch

src/aind_behavior_video_transformation/etl.py

@@ -98,61 +98,72 @@ class BehaviorVideoJob(GenericEtl[BehaviorVideoJobSettings]):
     run_job() -> JobResponse
     """
 
-    def _run_compression(
+    def _run_parallel(
         self,
         convert_video_args: list[tuple[Path, Path, tuple[str, str] | None]],
-    ) -> None:
-        """
-        Runs CompressionRequests at the specified paths.
-        """
+    ) -> list[tuple[Path, CalledProcessError]]:
+        """Run conversions in a ProcessPoolExecutor, collecting failures."""
         errors: list[tuple[Path, CalledProcessError]] = []
-        if self.job_settings.parallel_compression:
-            # Execute in-parallel
-            if len(convert_video_args) == 0:
-                return
-
-            num_jobs = len(convert_video_args)
-            with ProcessPoolExecutor(max_workers=num_jobs) as executor:
-                futures = {
-                    executor.submit(
-                        convert_video,
-                        *params,
-                        self.job_settings.ffmpeg_thread_cnt,
-                    ): params
-                    for params in convert_video_args
-                }
-                for future in as_completed(futures):
-                    video_path = futures[future][0]
-                    try:
-                        result = future.result()
-                    except CalledProcessError as exc:
-                        errors.append((video_path, exc))
-                    else:
-                        logger.info("FFmpeg job completed: %s", result)
-        else:
-            # Execute serially
-            for params in convert_video_args:
-                video_path = params[0]
+        if not convert_video_args:
+            return errors
+        thread_cnt = self.job_settings.ffmpeg_thread_cnt
+        with ProcessPoolExecutor(max_workers=len(convert_video_args)) as ex:
+            futures = {
+                ex.submit(convert_video, *params, thread_cnt): params
+                for params in convert_video_args
+            }
+            for future in as_completed(futures):
+                video_path = futures[future][0]
                 try:
-                    result = convert_video(
-                        *params, self.job_settings.ffmpeg_thread_cnt
-                    )
+                    result = future.result()
                 except CalledProcessError as exc:
                     errors.append((video_path, exc))
                 else:
                     logger.info("FFmpeg job completed: %s", result)
+        return errors
+
+    def _run_serial(
+        self,
+        convert_video_args: list[tuple[Path, Path, tuple[str, str] | None]],
+    ) -> list[tuple[Path, CalledProcessError]]:
+        """Run conversions one at a time, collecting failures."""
+        errors: list[tuple[Path, CalledProcessError]] = []
+        thread_cnt = self.job_settings.ffmpeg_thread_cnt
+        for params in convert_video_args:
+            video_path = params[0]
+            try:
+                result = convert_video(*params, thread_cnt)
+            except CalledProcessError as exc:
+                errors.append((video_path, exc))
+            else:
+                logger.info("FFmpeg job completed: %s", result)
+        return errors
 
-        if errors:
-            formatted = [
-                _format_ffmpeg_error(video_path, exc)
-                for video_path, exc in errors
-            ]
-            for block in formatted:
-                logger.error(block)
-            raise RuntimeError(
-                f"{len(errors)} ffmpeg job(s) failed:\n\n"
-                + "\n\n".join(formatted)
-            )
+    def _run_compression(
+        self,
+        convert_video_args: list[tuple[Path, Path, tuple[str, str] | None]],
+    ) -> None:
+        """
+        Runs CompressionRequests at the specified paths.
+        """
+        if self.job_settings.parallel_compression:
+            errors = self._run_parallel(convert_video_args)
+        else:
+            errors = self._run_serial(convert_video_args)
+
+        if not errors:
+            return
+
+        formatted = [
+            _format_ffmpeg_error(video_path, exc)
+            for video_path, exc in errors
+        ]
+        for block in formatted:
+            logger.error(block)
+        raise RuntimeError(
+            f"{len(errors)} ffmpeg job(s) failed:\n\n"
+            + "\n\n".join(formatted)
+        )
 
     def run_job(self) -> JobResponse:
         """