crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/orchestration/execution_strategies.py

@@ -30,8 +30,8 @@ class StreamingMode(str, Enum):
 
 
 class AICoordinationMode(str, Enum):
-    SINGLE_AGENT = "single - agent"
-    MULTI_AGENT = "multi - agent"
+    SINGLE_AGENT = "single-agent"
+    MULTI_AGENT = "multi-agent"
     COORDINATOR = "coordinator"
 
 
@@ -138,13 +138,13 @@ class StrategySelector:
 
         if len(context.previous_failures) > 5:
             self.console.print(
-                "[yellow]🧠 Switching to individual execution due to multiple failures[/yellow]",
+                "[yellow]🧠 Switching to individual execution due to multiple failures[/ yellow]",
             )
             return ExecutionStrategy.INDIVIDUAL
 
         if context.changed_files and len(context.changed_files) < 5:
             self.console.print(
-                "[cyan]🎯 Using selective execution for targeted file changes[/cyan]",
+                "[cyan]🎯 Using selective execution for targeted file changes[/ cyan]",
             )
             return ExecutionStrategy.SELECTIVE
 
@@ -174,11 +174,11 @@ class StrategySelector:
         if context.changed_files:
             for file_path in context.changed_files:
                 if file_path.suffix == ".py":
-                    priority_hooks.update(["pyright", "ruff - check", "ruff - format"])
+                    priority_hooks.update(["pyright", "ruff-check", "ruff-format"])
                 if "test" in str(file_path):
                     priority_hooks.update(["pytest", "coverage"])
                 if str(file_path).endswith(("setup.py", "pyproject.toml")):
-                    priority_hooks.update(["bandit", "creosote", "detect - secrets"])
+                    priority_hooks.update(["bandit", "creosote", "detect-secrets"])
 
         selected_hooks = [
             hook for hook in strategy.hooks if hook.name in priority_hooks
@@ -189,7 +189,7 @@ class StrategySelector:
 
         self.console.print(
             f"[cyan]🎯 Selected {len(selected_hooks)} hooks for targeted execution: "
-            f"{', '.join(h.name for h in selected_hooks)}[/cyan]",
+            f"{', '.join(h.name for h in selected_hooks)}[/ cyan]",
         )
 
         return HookStrategy(
@@ -303,35 +303,35 @@ class ExecutionPlan:
     def print_plan_summary(self, console: Console) -> None:
         console.print("\n" + "=" * 80)
         console.print(
-            "[bold bright_blue]🎯 ORCHESTRATED EXECUTION PLAN[/bold bright_blue]",
+            "[bold bright_blue]🎯 ORCHESTRATED EXECUTION PLAN[/ bold bright_blue]",
         )
         console.print("=" * 80)
 
-        console.print(f"[bold]Strategy: [/bold] {self.execution_strategy.value}")
+        console.print(f"[bold]Strategy: [/ bold] {self.execution_strategy.value}")
         console.print(
-            f"[bold]AI Mode: [/bold] {self.config.ai_coordination_mode.value}",
+            f"[bold]AI Mode: [/ bold] {self.config.ai_coordination_mode.value}",
         )
         console.print(
-            f"[bold]Progress Level: [/bold] {self.config.progress_level.value}",
+            f"[bold]Progress Level: [/ bold] {self.config.progress_level.value}",
         )
         console.print(
-            f"[bold]Estimated Duration: [/bold] {self.estimated_total_duration: .1f}s",
+            f"[bold]Estimated Duration: [/ bold] {self.estimated_total_duration: .1f}s",
         )
 
-        console.print("\n[bold cyan]Hook Execution: [/bold cyan]")
+        console.print("\n[bold cyan]Hook Execution: [/ bold cyan]")
         for i, plan in enumerate(self.hook_plans, 1):
             strategy = plan["strategy"]
             console.print(
-                f" {i}. {strategy.name} - {len(strategy.hooks)} hooks "
+                f" {i}. {strategy.name}-{len(strategy.hooks)} hooks "
                 f"({plan['estimated_duration']: .1f}s)",
             )
 
-        console.print("\n[bold green]Test Execution: [/bold green]")
+        console.print("\n[bold green]Test Execution: [/ bold green]")
         console.print(f" Mode: {self.test_plan['mode']}")
         console.print(f" Workers: {self.test_plan['parallel_workers']}")
         console.print(f" Duration: {self.test_plan['estimated_duration']: .1f}s")
 
-        console.print("\n[bold magenta]AI Coordination: [/bold magenta]")
+        console.print("\n[bold magenta]AI Coordination: [/ bold magenta]")
         console.print(f" Mode: {self.ai_plan['mode'].value}")
         console.print(f" Intelligence: {self.ai_plan['intelligence_level'].value}")
         console.print(

crackerjack/orchestration/test_progress_streamer.py

@@ -1,5 +1,4 @@
 import asyncio
-import re
 import subprocess
 import time
 import typing as t
@@ -9,6 +8,7 @@ from pathlib import Path
 from rich.console import Console
 
 from crackerjack.models.protocols import OptionsProtocol
+from crackerjack.services.regex_patterns import SAFE_PATTERNS, CompiledPatternCache
 
 
 @dataclass
@@ -104,25 +104,31 @@ class TestSuiteProgress:
 
 
 class PytestOutputParser:
-    TEST_START_PATTERN = re.compile(
-        r"^(.+?)::(.*)::(.*)(?:PASSED|FAILED|SKIPPED|ERROR)",
-    )
-    TEST_RESULT_PATTERN = re.compile(
-        r"^(.+?)(?:PASSED|FAILED|SKIPPED|ERROR)(?:\s+\[.*?\])?\s*$",
-    )
-    TEST_COLLECTION_PATTERN = re.compile(r"collected (\d+) items?")
-    TEST_SESSION_START = re.compile(r"test session starts")
-    COVERAGE_PATTERN = re.compile(r"TOTAL\s+\d+\s+\d+\s+(\d+)%")
-
-    DETAILED_TEST_PATTERN = re.compile(
-        r"^(.+?\.py)::(.*)(?:PASSED|FAILED|SKIPPED|ERROR)(?:\s+\[(\d+)%\])?\s*(?:\[(.*?)\])?\s*$",
-    )
-
     def __init__(self) -> None:
         self.current_test: str | None = None
         self.test_traceback_buffer: list[str] = []
         self.in_traceback = False
 
+        # Cache compiled patterns for optimal performance during test parsing
+        self._test_start_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_test_start"].pattern
+        )
+        self._test_result_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_test_result"].pattern
+        )
+        self._test_collection_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_collection_count"].pattern
+        )
+        self._session_start_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_session_start"].pattern
+        )
+        self._coverage_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_coverage_total"].pattern
+        )
+        self._detailed_test_pattern = CompiledPatternCache.get_compiled_pattern(
+            SAFE_PATTERNS["pytest_detailed_test"].pattern
+        )
+
     def parse_pytest_output(self, output_lines: list[str]) -> dict[str, t.Any]:
         tests: dict[str, TestProgress] = {}
         suite_info = TestSuiteProgress()
@@ -148,7 +154,7 @@ class PytestOutputParser:
         line: str,
         suite_info: TestSuiteProgress,
     ) -> None:
-        if match := self.TEST_COLLECTION_PATTERN.search(line):
+        if match := self._test_collection_pattern.search(line):
             suite_info.total_tests = int(match.group(1))
 
     def _process_test_result_line(
@@ -157,9 +163,9 @@ class PytestOutputParser:
         tests: dict[str, TestProgress],
         suite_info: TestSuiteProgress,
     ) -> None:
-        if match := self.DETAILED_TEST_PATTERN.match(line):
-            file_path, test_name, status, _progress, _timing = match.groups()
-            test_id = f"{file_path}::{test_name}"
+        if match := self._detailed_test_pattern.match(line):
+            file_path, test_name, status = match.groups()
+            test_id = f"{file_path}:: {test_name}"
 
             if test_id not in tests:
                 tests[test_id] = self._create_test_progress(
@@ -178,7 +184,7 @@ class PytestOutputParser:
         test_id: str,
     ) -> TestProgress:
         test_file = Path(file_path).name
-        test_parts = test_name.split("::")
+        test_parts = test_name.split(":: ")
         test_class = test_parts[0] if len(test_parts) > 1 else None
         test_method = test_parts[-1]
 
@@ -205,7 +211,7 @@ class PytestOutputParser:
             suite_info.error_tests += 1
 
     def _process_coverage_line(self, line: str, suite_info: TestSuiteProgress) -> None:
-        if match := self.COVERAGE_PATTERN.search(line):
+        if match := self._coverage_pattern.search(line):
             suite_info.coverage_percentage = float(match.group(1))
 
     def _process_current_test_line(
@@ -213,7 +219,7 @@ class PytestOutputParser:
         line: str,
         suite_info: TestSuiteProgress,
     ) -> None:
-        if "::" in line and any(
+        if ":: " in line and any(
             status in line for status in ("PASSED", "FAILED", "SKIPPED", "ERROR")
         ):
             suite_info.current_test = line.split()[0] if line.split() else None
@@ -248,7 +254,7 @@ class PytestOutputParser:
         return "FAILURES" in line or "ERRORS" in line
 
     def _is_test_header(self, line: str) -> bool:
-        return line.startswith("_") and "::" in line
+        return line.startswith("_") and ":: " in line
 
     def _should_add_to_traceback(self, current_test: str | None, line: str) -> bool:
         return current_test is not None and bool(line.strip())
@@ -289,7 +295,7 @@ class TestProgressStreamer:
         suite_progress = TestSuiteProgress(start_time=start_time)
 
         self.console.print(
-            "\n[bold bright_green]🧪 RUNNING TESTS WITH STREAMING PROGRESS[/bold bright_green]",
+            "\n[bold bright_green]🧪 RUNNING TESTS WITH STREAMING PROGRESS[/ bold bright_green]",
         )
 
         cmd = self.build_pytest_command(options, execution_mode)
@@ -354,7 +360,7 @@ class TestProgressStreamer:
         error: Exception,
         suite_progress: TestSuiteProgress,
     ) -> dict[str, t.Any]:
-        self.console.print(f"[red]❌ Test execution failed: {error}[/red]")
+        self.console.print(f"[red]❌ Test execution failed: {error}[/ red]")
         suite_progress.end_time = time.time()
         suite_progress.duration = suite_progress.end_time - (
             suite_progress.start_time or 0
@@ -375,23 +381,23 @@ class TestProgressStreamer:
     ) -> list[str]:
         cmd = ["uv", "run", "pytest"]
 
-        cmd.extend(["-v", "--tb=short"])
+        cmd.extend(["- v", "--tb=short"])
 
         if hasattr(options, "coverage") and options.coverage:
-            cmd.extend(["--cov=crackerjack", "--cov-report=term-missing"])
+            cmd.extend(["--cov=crackerjack", "- - cov - report=term-missing"])
 
         if execution_mode == "individual_with_progress":
-            cmd.extend(["--no-header"])
+            cmd.extend(["- - no-header"])
         elif execution_mode == "selective":
             pass
         else:
-            cmd.extend(["-q"])
+            cmd.extend(["- q"])
 
         if hasattr(options, "test_timeout"):
-            cmd.extend([f"--timeout={options.test_timeout}"])
+            cmd.extend([f"--timeout ={options.test_timeout}"])
 
         if hasattr(options, "test_workers") and options.test_workers > 1:
-            cmd.extend(["-n", str(options.test_workers)])
+            cmd.extend(["- n", str(options.test_workers)])
 
         return cmd
 
@@ -400,7 +406,7 @@ class TestProgressStreamer:
         cmd: list[str],
         suite_progress: TestSuiteProgress,
     ) -> subprocess.CompletedProcess[str]:
-        self.console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+        self.console.print(f"[dim]Running: {' '.join(cmd)}[/ dim]")
 
         process = await self._create_subprocess(cmd)
         stdout_lines: list[str] = []
@@ -517,14 +523,14 @@ class TestProgressStreamer:
         line: str,
         suite_progress: TestSuiteProgress,
     ) -> None:
-        if "::" in line and any(
+        if ":: " in line and any(
             status in line for status in ("PASSED", "FAILED", "SKIPPED", "ERROR")
         ):
             parts = line.split()
             if parts:
                 suite_progress.current_test = parts[0]
 
-        if match := self.parser.TEST_COLLECTION_PATTERN.search(line):
+        if match := self.parser._test_collection_pattern.search(line):
             suite_progress.total_tests = int(match.group(1))
 
         if "PASSED" in line:
@@ -542,17 +548,17 @@ class TestProgressStreamer:
 
     def _print_test_line(self, line: str) -> None:
         if "PASSED" in line:
-            self.console.print(f"[green]{line}[/green]")
+            self.console.print(f"[green]{line}[/ green]")
         elif "FAILED" in line:
-            self.console.print(f"[red]{line}[/red]")
+            self.console.print(f"[red]{line}[/ red]")
         elif "SKIPPED" in line:
-            self.console.print(f"[yellow]{line}[/yellow]")
+            self.console.print(f"[yellow]{line}[/ yellow]")
         elif "ERROR" in line:
-            self.console.print(f"[bright_red]{line}[/bright_red]")
+            self.console.print(f"[bright_red]{line}[/ bright_red]")
         elif line.startswith("="):
-            self.console.print(f"[bold cyan]{line}[/bold cyan]")
+            self.console.print(f"[bold cyan]{line}[/ bold cyan]")
         else:
-            self.console.print(f"[dim]{line}[/dim]")
+            self.console.print(f"[dim]{line}[/ dim]")
 
     def _print_test_summary(
         self,
@@ -569,45 +575,47 @@ class TestProgressStreamer:
     def _print_summary_header(self) -> None:
         self.console.print("\n" + "=" * 80)
         self.console.print(
-            "[bold bright_green]🧪 TEST EXECUTION SUMMARY[/bold bright_green]",
+            "[bold bright_green]🧪 TEST EXECUTION SUMMARY[/ bold bright_green]",
         )
         self.console.print("=" * 80)
 
     def _print_test_counts(self, suite_progress: TestSuiteProgress) -> None:
-        self.console.print(f"[bold]Total Tests: [/bold] {suite_progress.total_tests}")
-        self.console.print(f"[green]✅ Passed: [/green] {suite_progress.passed_tests}")
+        self.console.print(f"[bold]Total Tests: [/ bold] {suite_progress.total_tests}")
+        self.console.print(f"[green]✅ Passed: [/ green] {suite_progress.passed_tests}")
 
         if suite_progress.failed_tests > 0:
-            self.console.print(f"[red]❌ Failed: [/red] {suite_progress.failed_tests}")
+            self.console.print(f"[red]❌ Failed: [/ red] {suite_progress.failed_tests}")
 
         if suite_progress.skipped_tests > 0:
             self.console.print(
-                f"[yellow]⏭️ Skipped: [/yellow] {suite_progress.skipped_tests}",
+                f"[yellow]⏭️ Skipped: [/ yellow] {suite_progress.skipped_tests}",
             )
 
         if suite_progress.error_tests > 0:
             self.console.print(
-                f"[bright_red]💥 Errors: [/bright_red] {suite_progress.error_tests}",
+                f"[bright_red]💥 Errors: [/ bright_red] {suite_progress.error_tests}",
             )
 
     def _print_timing_stats(self, suite_progress: TestSuiteProgress) -> None:
         if not suite_progress.duration:
             return
 
-        self.console.print(f"[bold]⏱️ Duration: [/bold] {suite_progress.duration:.1f}s")
+        self.console.print(
+            f"[bold]⏱️ Duration: [/ bold] {suite_progress.duration: .1f}s"
+        )
 
         if suite_progress.total_tests > 0:
             avg_time = suite_progress.duration / suite_progress.total_tests
-            self.console.print(f"[dim]Average per test: {avg_time:.2f}s[/dim]")
+            self.console.print(f"[dim]Average per test: {avg_time: .2f}s[/ dim]")
 
         self.console.print(
-            f"[bold]📊 Success Rate: [/bold] {suite_progress.success_rate:.1f}%",
+            f"[bold]📊 Success Rate: [/ bold] {suite_progress.success_rate: .1f}%",
         )
 
     def _print_coverage_stats(self, suite_progress: TestSuiteProgress) -> None:
         if suite_progress.coverage_percentage is not None:
             self.console.print(
-                f"[bold]📈 Coverage: [/bold] {suite_progress.coverage_percentage:.1f}%",
+                f"[bold]📈 Coverage: [/ bold] {suite_progress.coverage_percentage: .1f}%",
             )
 
     def _print_failed_test_details(self, tests: list[TestProgress]) -> None:
@@ -616,16 +624,16 @@ class TestProgressStreamer:
             return
 
         self.console.print(
-            f"\n[bold red]Failed Tests ({len(failed_tests)}): [/bold red]",
+            f"\n[bold red]Failed Tests ({len(failed_tests)}): [/ bold red]",
         )
         for test in failed_tests[:5]:
             self.console.print(f" ❌ {test.test_id}")
             if test.error_message:
                 error_preview = self._format_error_preview(test.error_message)
-                self.console.print(f" [dim]{error_preview}[/dim]")
+                self.console.print(f" [dim]{error_preview}[/ dim]")
 
         if len(failed_tests) > 5:
-            self.console.print(f" [dim]... and {len(failed_tests) - 5} more[/dim]")
+            self.console.print(f" [dim]... and {len(failed_tests) - 5} more[/ dim]")
 
     def _format_error_preview(self, error_message: str) -> str:
         return (

crackerjack/plugins/base.py

@@ -21,7 +21,7 @@ class PluginMetadata:
     description: str
     author: str = ""
     license: str = ""
-    requires_python: str = ">=3.11"
+    requires_python: str = "> = 3.11"
     dependencies: list[str] = field(default_factory=list)
     entry_point: str = ""
     config_schema: dict[str, t.Any] = field(default_factory=dict)

crackerjack/plugins/managers.py

@@ -44,7 +44,7 @@ class PluginManager:
 
             if total_count > 0:
                 self.console.print(
-                    f"[green]✅[/green] Loaded {loaded_count} / {total_count} plugins",
+                    f"[green]✅[/ green] Loaded {loaded_count} / {total_count} plugins",
                 )
 
             activation_results = self.registry.activate_all()
@@ -54,7 +54,7 @@ class PluginManager:
 
             if activated_count > 0:
                 self.console.print(
-                    f"[green]✅[/green] Activated {activated_count} plugins",
+                    f"[green]✅[/ green] Activated {activated_count} plugins",
                 )
 
             hook_plugins = self.registry.get_enabled(PluginType.HOOK)
@@ -69,7 +69,7 @@ class PluginManager:
         except Exception as e:
             self.logger.exception(f"Failed to initialize plugin system: {e}")
             self.console.print(
-                f"[red]❌[/red] Plugin system initialization failed: {e}",
+                f"[red]❌[/ red] Plugin system initialization failed: {e}",
             )
             return False
 
@@ -85,7 +85,7 @@ class PluginManager:
 
             if deactivated_count > 0:
                 self.console.print(
-                    f"[yellow]⏹️[/yellow] Deactivated {deactivated_count} plugins",
+                    f"[yellow]⏹️[/ yellow] Deactivated {deactivated_count} plugins",
                 )
 
             self._initialized = False
@@ -128,12 +128,12 @@ class PluginManager:
     def enable_plugin(self, plugin_name: str) -> bool:
         plugin = self.registry.get(plugin_name)
         if not plugin:
-            self.console.print(f"[red]❌[/red] Plugin not found: {plugin_name}")
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
             return False
 
         if plugin.enabled:
             self.console.print(
-                f"[yellow]⚠️[/yellow] Plugin already enabled: {plugin_name}",
+                f"[yellow]⚠️[/ yellow] Plugin already enabled: {plugin_name}",
             )
             return True
 
@@ -142,7 +142,7 @@ class PluginManager:
             success = plugin.activate()
 
             if success:
-                self.console.print(f"[green]✅[/green] Enabled plugin: {plugin_name}")
+                self.console.print(f"[green]✅[/ green] Enabled plugin: {plugin_name}")
 
                 if plugin.plugin_type == PluginType.HOOK:
                     self.hook_registry.register_hook_plugin(plugin)
@@ -150,25 +150,25 @@ class PluginManager:
                 return True
             plugin.disable()
             self.console.print(
-                f"[red]❌[/red] Failed to activate plugin: {plugin_name}",
+                f"[red]❌[/ red] Failed to activate plugin: {plugin_name}",
             )
             return False
 
         except Exception as e:
             self.console.print(
-                f"[red]❌[/red] Error enabling plugin {plugin_name}: {e}",
+                f"[red]❌[/ red] Error enabling plugin {plugin_name}: {e}",
             )
             return False
 
     def disable_plugin(self, plugin_name: str) -> bool:
         plugin = self.registry.get(plugin_name)
         if not plugin:
-            self.console.print(f"[red]❌[/red] Plugin not found: {plugin_name}")
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
             return False
 
         if not plugin.enabled:
             self.console.print(
-                f"[yellow]⚠️[/yellow] Plugin already disabled: {plugin_name}",
+                f"[yellow]⚠️[/ yellow] Plugin already disabled: {plugin_name}",
             )
             return True
 
@@ -180,17 +180,19 @@ class PluginManager:
                 self.hook_registry.unregister_hook_plugin(plugin_name)
 
             if success:
-                self.console.print(f"[yellow]⏹️[/yellow] Disabled plugin: {plugin_name}")
+                self.console.print(
+                    f"[yellow]⏹️[/ yellow] Disabled plugin: {plugin_name}"
+                )
             else:
                 self.console.print(
-                    f"[yellow]⚠️[/yellow] Plugin disabled with warnings: {plugin_name}",
+                    f"[yellow]⚠️[/ yellow] Plugin disabled with warnings: {plugin_name}",
                 )
 
             return True
 
         except Exception as e:
             self.console.print(
-                f"[red]❌[/red] Error disabling plugin {plugin_name}: {e}",
+                f"[red]❌[/ red] Error disabling plugin {plugin_name}: {e}",
             )
             return False
 
@@ -203,16 +205,16 @@ class PluginManager:
     def configure_plugin(self, plugin_name: str, config: dict[str, t.Any]) -> bool:
         plugin = self.registry.get(plugin_name)
         if not plugin:
-            self.console.print(f"[red]❌[/red] Plugin not found: {plugin_name}")
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
             return False
 
         try:
             plugin.configure(config)
-            self.console.print(f"[green]✅[/green] Configured plugin: {plugin_name}")
+            self.console.print(f"[green]✅[/ green] Configured plugin: {plugin_name}")
             return True
         except Exception as e:
             self.console.print(
-                f"[red]❌[/red] Error configuring plugin {plugin_name}: {e}",
+                f"[red]❌[/ red] Error configuring plugin {plugin_name}: {e}",
             )
             return False
 
@@ -222,7 +224,7 @@ class PluginManager:
 
             if success:
                 self.console.print(
-                    f"[green]✅[/green] Installed plugin from: {plugin_file}",
+                    f"[green]✅[/ green] Installed plugin from: {plugin_file}",
                 )
 
                 if self._initialized:
@@ -235,14 +237,14 @@ class PluginManager:
                         self.enable_plugin(latest_plugin_name)
             else:
                 self.console.print(
-                    f"[red]❌[/red] Failed to install plugin from: {plugin_file}",
+                    f"[red]❌[/ red] Failed to install plugin from: {plugin_file}",
                 )
 
             return success
 
         except Exception as e:
             self.console.print(
-                f"[red]❌[/red] Error installing plugin {plugin_file}: {e}",
+                f"[red]❌[/ red] Error installing plugin {plugin_file}: {e}",
             )
             return False
 

crackerjack/py313.py

@@ -86,7 +86,7 @@ def categorize_file(file_path: Path) -> str:
     path_str = str(file_path)
     name = file_path
     match path_str:
-        case s if name.suffix == ".py" and "/tests/" in s:
+        case s if name.suffix == ".py" and "/ tests /" in s:
             return "Python Test File"
         case s if name.suffix == ".py" and "__init__.py" in name.name:
             return "Python Module Init"
@@ -167,24 +167,68 @@ def clean_python_code(code: str) -> str:
     lines = code.splitlines()
     cleaned_lines: list[str] = []
     for line in lines:
-        match line.strip():
-            case "":
-                if not cleaned_lines or cleaned_lines[-1].strip():
-                    cleaned_lines.append("")
-            case s if s.startswith(("import ", "from ")):
-                cleaned_lines.append(line)
-            case s if s.startswith("#"):
-                continue
-            case s if "#" in s and (
-                not any(
-                    skip in s for skip in ("# noqa", "# type: ", "# pragma", "# skip")
-                )
-            ):
-                code_part = line.split("#", 1)[0].rstrip()
-                if code_part:
-                    cleaned_lines.append(code_part)
-            case s if s.startswith(('"""', "'''")):
-                continue
-            case _:
-                cleaned_lines.append(line)
+        processed_line = _process_line_for_cleaning(line, cleaned_lines)
+        if processed_line is not None:
+            cleaned_lines.append(processed_line)
     return "\n".join(cleaned_lines)
+
+
+def _process_line_for_cleaning(line: str, cleaned_lines: list[str]) -> str | None:
+    """Process a single line for Python code cleaning.
+
+    Returns:
+        The processed line to add, or None if the line should be skipped.
+    """
+    stripped = line.strip()
+
+    if _should_handle_empty_line(stripped, cleaned_lines):
+        return ""
+
+    if _is_import_line(stripped):
+        return line
+
+    if _is_comment_to_skip(stripped):
+        return None
+
+    if _has_inline_comment_to_process(stripped):
+        return _extract_code_part(line)
+
+    if _is_docstring_line(stripped):
+        return None
+
+    return line
+
+
+def _should_handle_empty_line(stripped: str, cleaned_lines: list[str]) -> bool:
+    """Check if empty line should be preserved."""
+    return stripped == "" and (not cleaned_lines or bool(cleaned_lines[-1].strip()))
+
+
+def _is_import_line(stripped: str) -> bool:
+    """Check if line is an import statement."""
+    return stripped.startswith(("import ", "from "))
+
+
+def _is_comment_to_skip(stripped: str) -> bool:
+    """Check if line is a comment that should be skipped."""
+    return stripped.startswith("#")
+
+
+def _has_inline_comment_to_process(stripped: str) -> bool:
+    """Check if line has inline comment that should be processed."""
+    if "#" not in stripped:
+        return False
+
+    skip_markers = ("# noqa", "# type: ", "# pragma", "# skip")
+    return not any(skip in stripped for skip in skip_markers)
+
+
+def _extract_code_part(line: str) -> str | None:
+    """Extract code part from line with inline comment."""
+    code_part = line.split("#", 1)[0].rstrip()
+    return code_part or None
+
+
+def _is_docstring_line(stripped: str) -> bool:
+    """Check if line starts a docstring."""
+    return stripped.startswith(('"""', "'''"))