style: Apply black formatting fixes

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: Socratic Developer

src/socratic_docs/code_extractor.py

@@ -57,7 +57,9 @@ def is_markdown_format(content: str) -> bool:
             return True
 
         # Check for multiple markdown headers
-        header_count = sum(1 for line in lines if re.match(CodeExtractor.MARKDOWN_HEADER_PATTERN, line))
+        header_count = sum(
+            1 for line in lines if re.match(CodeExtractor.MARKDOWN_HEADER_PATTERN, line)
+        )
         if header_count >= 2:
             logger.debug(f"Detected {header_count} markdown headers (##)")
             return True
@@ -98,11 +100,7 @@ def extract_from_markdown(content: str) -> str:
         logger.info("Extracting Python code from markdown format")
 
         # Find all code fences with python/py language
-        code_blocks = re.findall(
-            CodeExtractor.CODE_FENCE_PATTERN,
-            content,
-            re.DOTALL
-        )
+        code_blocks = re.findall(CodeExtractor.CODE_FENCE_PATTERN, content, re.DOTALL)
 
         if code_blocks:
             logger.info(f"Found {len(code_blocks)} code block(s) in markdown")
@@ -238,13 +236,17 @@ def get_code_statistics(content: str) -> dict:
             tree = ast.parse(content)
             classes = [node for node in ast.walk(tree) if isinstance(node, ast.ClassDef)]
             functions = [node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)]
-            imports = [node for node in ast.walk(tree) if isinstance(node, (ast.Import, ast.ImportFrom))]
-
-            stats.update({
-                "class_count": len(classes),
-                "function_count": len(functions),
-                "import_count": len(imports),
-            })
+            imports = [
+                node for node in ast.walk(tree) if isinstance(node, (ast.Import, ast.ImportFrom))
+            ]
+
+            stats.update(
+                {
+                    "class_count": len(classes),
+                    "function_count": len(functions),
+                    "import_count": len(imports),
+                }
+            )
         except Exception as e:
             logger.warning(f"Could not parse AST for statistics: {e}")
 

src/socratic_docs/extractors/base.py

@@ -148,16 +148,14 @@ def extract_from_markdown(self, content: str) -> ExtractionResult:
             ExtractionResult with extracted code and metadata
         """
         if not content:
-            return ExtractionResult(extracted_code="", is_valid=False, validation_error="Empty content")
+            return ExtractionResult(
+                extracted_code="", is_valid=False, validation_error="Empty content"
+            )
 
         # Check if this looks like markdown
         if not self.is_markdown_format(content):
             self.logger.debug("Content doesn't appear to be markdown, returning as-is")
-            return ExtractionResult(
-                extracted_code=content,
-                is_valid=True,
-                was_markdown=False
-            )
+            return ExtractionResult(extracted_code=content, is_valid=True, was_markdown=False)
 
         self.logger.info(f"Extracting {self.language} code from markdown format")
 
@@ -185,7 +183,7 @@ def extract_from_markdown(self, content: str) -> ExtractionResult:
                 is_valid=validation.is_valid,
                 validation_error=validation.error_message,
                 was_markdown=True,
-                code_blocks_found=len(code_blocks)
+                code_blocks_found=len(code_blocks),
             )
 
         # If no code fences found but content looks like markdown,
@@ -219,7 +217,7 @@ def extract_from_markdown(self, content: str) -> ExtractionResult:
                 is_valid=validation.is_valid,
                 validation_error=validation.error_message,
                 was_markdown=True,
-                code_blocks_found=0
+                code_blocks_found=0,
             )
 
         # Fallback: return original if extraction failed
@@ -229,7 +227,7 @@ def extract_from_markdown(self, content: str) -> ExtractionResult:
             is_valid=False,
             validation_error="Could not extract valid code from markdown",
             was_markdown=True,
-            code_blocks_found=0
+            code_blocks_found=0,
         )
 
     def extract_and_validate(self, content: str) -> ExtractionResult:
@@ -259,7 +257,7 @@ def extract_and_validate(self, content: str) -> ExtractionResult:
             is_valid=validation.is_valid,
             validation_error=validation.error_message,
             was_markdown=extracted.was_markdown,
-            code_blocks_found=extracted.code_blocks_found
+            code_blocks_found=extracted.code_blocks_found,
         )
 
     def get_code_statistics(self, code: str) -> dict:

src/socratic_docs/extractors/generic_extractor.py

@@ -58,18 +58,12 @@ def validate_syntax(self, code: str) -> ValidationResult:
             ValidationResult indicating code is valid (with warning)
         """
         if not code or not code.strip():
-            return ValidationResult(
-                is_valid=False,
-                error_message="Empty code"
-            )
+            return ValidationResult(is_valid=False, error_message="Empty code")
 
         # No validation available - assume code is valid but warn user
         warnings = [f"No syntax validation available for {self.language}"]
 
-        return ValidationResult(
-            is_valid=True,
-            warnings=warnings
-        )
+        return ValidationResult(is_valid=True, warnings=warnings)
 
     def get_import_statements(self, code: str) -> List[str]:
         """
@@ -87,21 +81,21 @@ def get_import_statements(self, code: str) -> List[str]:
         imports = []
 
         # Simple pattern matching for common import styles
-        for line in code.split('\n'):
+        for line in code.split("\n"):
             line = line.strip()
 
             # Match various import styles
-            if line.startswith('import '):  # import x (Java, Go, etc.)
+            if line.startswith("import "):  # import x (Java, Go, etc.)
                 imports.append(line)
-            elif line.startswith('require('):  # require('x') (Node.js)
+            elif line.startswith("require("):  # require('x') (Node.js)
                 imports.append(line)
-            elif line.startswith('use '):  # use x (Perl, Rust)
+            elif line.startswith("use "):  # use x (Perl, Rust)
                 imports.append(line)
-            elif line.startswith('use std::'):  # use std::x (Rust)
+            elif line.startswith("use std::"):  # use std::x (Rust)
                 imports.append(line)
-            elif line.startswith('from '):  # from x import y (Python)
+            elif line.startswith("from "):  # from x import y (Python)
                 imports.append(line)
-            elif line.startswith('#include '):  # #include (C/C++)
+            elif line.startswith("#include "):  # #include (C/C++)
                 imports.append(line)
 
         return imports

src/socratic_docs/extractors/python_extractor.py

@@ -42,10 +42,7 @@ def validate_syntax(self, code: str) -> ValidationResult:
             ValidationResult with validation status and error details
         """
         if not code or not code.strip():
-            return ValidationResult(
-                is_valid=False,
-                error_message="Empty code"
-            )
+            return ValidationResult(is_valid=False, error_message="Empty code")
 
         try:
             ast.parse(code)
@@ -57,27 +54,17 @@ def validate_syntax(self, code: str) -> ValidationResult:
             if e.text:
                 error_msg += f"\n  {e.text.strip()}"
             logger.error(f"Python code validation failed: {error_msg}")
-            return ValidationResult(
-                is_valid=False,
-                error_message=error_msg,
-                line_number=e.lineno
-            )
+            return ValidationResult(is_valid=False, error_message=error_msg, line_number=e.lineno)
 
         except ValueError as e:
             error_msg = f"ValueError: {str(e)}"
             logger.error(f"Python code validation failed: {error_msg}")
-            return ValidationResult(
-                is_valid=False,
-                error_message=error_msg
-            )
+            return ValidationResult(is_valid=False, error_message=error_msg)
 
         except Exception as e:
             error_msg = f"{type(e).__name__}: {str(e)}"
             logger.error(f"Unexpected error during Python validation: {error_msg}")
-            return ValidationResult(
-                is_valid=False,
-                error_message=error_msg
-            )
+            return ValidationResult(is_valid=False, error_message=error_msg)
 
     def get_import_statements(self, code: str) -> List[str]:
         """
@@ -99,13 +86,13 @@ def get_import_statements(self, code: str) -> List[str]:
                 if isinstance(node, ast.Import):
                     # import x, y, z
                     for alias in node.names:
-                        module_name = alias.name.split('.')[0]
+                        module_name = alias.name.split(".")[0]
                         imports.append(module_name)
 
                 elif isinstance(node, ast.ImportFrom):
                     # from x import y
                     if node.module:
-                        module_name = node.module.split('.')[0]
+                        module_name = node.module.split(".")[0]
                         imports.append(module_name)
 
             # Deduplicate and sort
@@ -135,11 +122,13 @@ def get_code_statistics(self, code: str) -> dict:
             functions = [node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)]
             imports = self.get_import_statements(code)
 
-            stats.update({
-                "class_count": len(classes),
-                "function_count": len(functions),
-                "import_count": len(imports),
-            })
+            stats.update(
+                {
+                    "class_count": len(classes),
+                    "function_count": len(functions),
+                    "import_count": len(imports),
+                }
+            )
 
         except Exception as e:
             logger.warning(f"Could not parse AST for statistics: {e}")

src/socratic_docs/extractors/registry.py

@@ -220,7 +220,7 @@ def auto_register_extractors() -> None:
                 supports_ast=True,
                 supports_linting=True,
                 available=True,
-                description="Python code extraction and validation using ast module"
+                description="Python code extraction and validation using ast module",
             )
         )
         logger.info("Registered Python extractor")
@@ -244,7 +244,7 @@ def auto_register_extractors() -> None:
                 available=True,
                 description="JavaScript code extraction using esprima parser",
                 requires_external_tool=False,
-                dependencies=["esprima"]
+                dependencies=["esprima"],
             )
         )
         logger.info("Registered JavaScript extractor")
@@ -263,7 +263,7 @@ def auto_register_extractors() -> None:
                 available=False,
                 description="JavaScript extraction (requires: pip install esprima)",
                 requires_external_tool=False,
-                dependencies=["esprima"]
+                dependencies=["esprima"],
             )
         )
         logger.debug("JavaScript extractor not available (esprima not installed)")

src/socratic_docs/git_initializer.py

@@ -409,7 +409,9 @@ def get_repository_status(project_root: Path) -> Dict[str, Any]:
                     timeout=5,
                     text=True,
                 )
-                remote_lines = [line.split()[0] for line in result.stdout.strip().split("\n") if line]
+                remote_lines = [
+                    line.split()[0] for line in result.stdout.strip().split("\n") if line
+                ]
                 status["remotes"] = list(set(remote_lines))  # Remove duplicates
             except subprocess.CalledProcessError:
                 pass

src/socratic_docs/multi_file_splitter.py

@@ -77,7 +77,7 @@ def _split_python(self) -> Dict[str, str]:
                         "- Review the content in `main.py`\n"
                         "- Extract the actual Python code from the markdown\n"
                         "- Re-save as proper Python modules\n"
-                    )
+                    ),
                 }
 
             # Not markdown - regular syntax error
@@ -469,19 +469,15 @@ def create_structure(
             complete_structure["README.md"] = f"# {project_name}\n\nProject description.\n"
 
         if "main.py" not in complete_structure and "src/__init__.py" in complete_structure:
-            complete_structure[
-                "main.py"
-            ] = '''"""Entry point"""
+            complete_structure["main.py"] = '''"""Entry point"""
 
 if __name__ == "__main__":
     print("Starting application...")
 '''
 
         # Add .gitignore if not present
         if ".gitignore" not in complete_structure:
-            complete_structure[
-                ".gitignore"
-            ] = """# Python
+            complete_structure[".gitignore"] = """# Python
 __pycache__/
 *.py[cod]
 *$py.class

tests/test_module_imports.py

@@ -2,15 +2,19 @@
 Basic import tests for module verification.
 """
 
+
 def test_module_import():
     """Test that the module can be imported."""
     import socratic_docs
+
     assert socratic_docs is not None
 
+
 def test_main_exports():
     """Test that main exports are available."""
     try:
         from socratic_docs import DocumentationGenerator
+
         assert DocumentationGenerator is not None
     except ImportError:
         # Optional - some modules might not export the main class