style: Fix ruff formatting issues in test files

- Add blank lines after docstrings in all test files
- Break long lines to comply with line length limits
- Reformat multi-line assert statements
- Reformat long conditional expressions
- Remove trailing blank lines

All formatting issues resolved to pass ruff format checks.

Author: andrewdonheiser

tests/knowledge-tuning/__init__.py

@@ -1,2 +1 @@
 """Push tests for knowledge-tuning directory."""
-

tests/knowledge-tuning/conftest.py

@@ -1,4 +1,5 @@
 """Pytest configuration and fixtures for knowledge-tuning tests."""
+
 import json
 from pathlib import Path
 
@@ -54,4 +55,3 @@ def load_notebook(path: Path) -> dict:
 def notebook_loader():
     """Return a function to load notebook files."""
     return load_notebook
-

tests/knowledge-tuning/mocks/__init__.py

@@ -1,2 +1 @@
 """Mock utilities for knowledge-tuning tests."""
-

tests/knowledge-tuning/mocks/transformers_mock.py

@@ -1,4 +1,5 @@
 """Mock classes for HuggingFace transformers."""
+
 from unittest.mock import MagicMock
 
 
@@ -69,4 +70,3 @@ def create_mock_torch():
     mock_torch.cuda.is_available = MagicMock(return_value=False)
     mock_torch.no_grad = MagicMock()
     return mock_torch
-

tests/knowledge-tuning/run_push_tests.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """Runner script for push tests targeting knowledge-tuning directory."""
+
 import sys
 from pathlib import Path
 
@@ -24,9 +25,12 @@
         str(test_path),
         "-v",
         "--tb=short",
-        "-n", "auto",  # Use pytest-xdist for parallel execution (auto-detect workers)
-        "--junit-xml", str(results_dir / "junit.xml"),  # JUnit XML for CI integration
-        "--html", str(results_dir / "report.html"),  # HTML report
+        "-n",
+        "auto",  # Use pytest-xdist for parallel execution (auto-detect workers)
+        "--junit-xml",
+        str(results_dir / "junit.xml"),  # JUnit XML for CI integration
+        "--html",
+        str(results_dir / "report.html"),  # HTML report
         "--self-contained-html",  # Include CSS/JS in HTML file
         # Ensure tests run quickly - timeout handled by GitHub Actions workflow
     ])
@@ -36,4 +40,3 @@
     print(f"   - HTML Report: {results_dir / 'report.html'}")
 
     sys.exit(exit_code)
-

tests/knowledge-tuning/test_environment.py

@@ -1,4 +1,5 @@
 """Tests for environment and dependency validation."""
+
 import pytest
 
 # Try to import tomllib (Python 3.11+) or fall back to tomli
@@ -89,7 +90,6 @@ def test_no_obviously_deprecated_patterns(self, pyproject_files):
             requires_python = project.get("requires-python", "")
 
             for pattern in deprecated_patterns:
-                assert (
-                    pattern.lower() not in requires_python.lower()
-                ), f"pyproject.toml {pyproject_path} contains deprecated pattern: {pattern}"
-
+                assert pattern.lower() not in requires_python.lower(), (
+                    f"pyproject.toml {pyproject_path} contains deprecated pattern: {pattern}"
+                )

tests/knowledge-tuning/test_notebook_imports.py

@@ -1,4 +1,5 @@
 """Tests for notebook import validation."""
+
 import ast
 import json
 import tokenize
@@ -112,9 +113,10 @@ def test_no_obvious_import_errors(self, notebook_files):
                 for _line_num, line in enumerate(lines, 1):
                     stripped = line.strip()
                     # Check for incomplete imports
-                    if stripped.startswith("import ") and not stripped.endswith(
-                        (";", "\\")
-                    ):
+                    if stripped.startswith("import ") and not stripped.endswith((
+                        ";",
+                        "\\",
+                    )):
                         # Check if it's actually complete by trying to parse
                         try:
                             ast.parse(stripped)
@@ -169,7 +171,9 @@ def test_code_cells_are_tokenizable(self, notebook_files):
 
                 # Skip shell commands and magic commands
                 lines = source_str.split("\n")
-                if lines and (lines[0].strip().startswith("!") or lines[0].strip().startswith("%")):
+                if lines and (
+                    lines[0].strip().startswith("!") or lines[0].strip().startswith("%")
+                ):
                     continue
 
                 try:
@@ -179,4 +183,3 @@ def test_code_cells_are_tokenizable(self, notebook_files):
                     pytest.fail(
                         f"Notebook {notebook_path} cell {i} has tokenization error: {e}"
                     )
-

tests/knowledge-tuning/test_notebook_structure.py

@@ -1,4 +1,5 @@
 """Tests for notebook structure validation."""
+
 import json
 
 import nbformat
@@ -16,9 +17,9 @@ def test_no_execution_counts(self, notebook_files):
 
             for cell in nb.get("cells", []):
                 execution_count = cell.get("execution_count")
-                assert (
-                    execution_count is None
-                ), f"Notebook {notebook_path} has execution_count {execution_count} in cell"
+                assert execution_count is None, (
+                    f"Notebook {notebook_path} has execution_count {execution_count} in cell"
+                )
 
     def test_no_stored_outputs(self, notebook_files):
         """Test that notebooks have no stored outputs."""
@@ -28,9 +29,9 @@ def test_no_stored_outputs(self, notebook_files):
 
             for i, cell in enumerate(nb.get("cells", [])):
                 outputs = cell.get("outputs", [])
-                assert (
-                    len(outputs) == 0
-                ), f"Notebook {notebook_path} has {len(outputs)} outputs in cell {i}"
+                assert len(outputs) == 0, (
+                    f"Notebook {notebook_path} has {len(outputs)} outputs in cell {i}"
+                )
 
     def test_kernelspec_consistency(self, notebook_files):
         """Test that all notebooks have consistent kernelspec.name."""
@@ -51,9 +52,9 @@ def test_kernelspec_consistency(self, notebook_files):
             # Get the first kernelspec name as the reference
             first_name = kernelspecs[0][1]
             for notebook_path, name in kernelspecs:
-                assert (
-                    name == first_name
-                ), f"Notebook {notebook_path} has kernelspec.name '{name}', expected '{first_name}'"
+                assert name == first_name, (
+                    f"Notebook {notebook_path} has kernelspec.name '{name}', expected '{first_name}'"
+                )
 
     def test_language_info_version_consistency(self, notebook_files):
         """Test that all notebooks have consistent language_info.version."""
@@ -74,9 +75,9 @@ def test_language_info_version_consistency(self, notebook_files):
             # Get the first version as the reference
             first_version = versions[0][1]
             for notebook_path, version in versions:
-                assert (
-                    version == first_version
-                ), f"Notebook {notebook_path} has language_info.version '{version}', expected '{first_version}'"
+                assert version == first_version, (
+                    f"Notebook {notebook_path} has language_info.version '{version}', expected '{first_version}'"
+                )
 
     def test_no_environment_specific_metadata(self, notebook_files):
         """Test that notebooks don't contain environment-specific metadata."""
@@ -130,9 +131,9 @@ def test_standardized_metadata_schema(self, notebook_files):
             first_core = first_metadata_keys & core_keys
             current_core = metadata_keys & core_keys
 
-            assert (
-                first_core == current_core
-            ), f"Notebook {notebook_path} has different core metadata keys. Expected {first_core}, got {current_core}"
+            assert first_core == current_core, (
+                f"Notebook {notebook_path} has different core metadata keys. Expected {first_core}, got {current_core}"
+            )
 
     def test_required_sections_exist(self, notebook_files):
         """Test that notebooks contain required sections."""
@@ -163,9 +164,9 @@ def test_required_sections_exist(self, notebook_files):
                 keyword for keyword in required_keywords if keyword in content_lower
             ]
             # At minimum, should have import or install/setup
-            assert (
-                len(found_keywords) > 0
-            ), f"Notebook {notebook_path} missing required sections (imports, setup, or install)"
+            assert len(found_keywords) > 0, (
+                f"Notebook {notebook_path} missing required sections (imports, setup, or install)"
+            )
 
     def test_cell_type_ordering(self, notebook_files):
         """Test that notebooks have logical ordering of markdown and code cells."""
@@ -182,7 +183,9 @@ def test_cell_type_ordering(self, notebook_files):
             assert first_cell_type in [
                 "markdown",
                 "code",
-            ], f"Notebook {notebook_path} first cell has unexpected type: {first_cell_type}"
+            ], (
+                f"Notebook {notebook_path} first cell has unexpected type: {first_cell_type}"
+            )
 
     def test_no_empty_cells(self, notebook_files):
         """Test that notebooks have no empty cells."""
@@ -210,17 +213,12 @@ def test_notebooks_are_valid_json(self, notebook_files):
                 with open(notebook_path, encoding="utf-8") as f:
                     json.load(f)
             except json.JSONDecodeError as e:
-                pytest.fail(
-                    f"Notebook {notebook_path} is not valid JSON: {e}"
-                )
+                pytest.fail(f"Notebook {notebook_path} is not valid JSON: {e}")
 
     def test_notebooks_are_valid_nbformat(self, notebook_files):
         """Test that all notebook files are valid nbformat."""
         for notebook_path in notebook_files:
             try:
                 nbformat.read(str(notebook_path), as_version=4)
             except Exception as e:
-                pytest.fail(
-                    f"Notebook {notebook_path} is not valid nbformat: {e}"
-                )
-
+                pytest.fail(f"Notebook {notebook_path} is not valid nbformat: {e}")

tests/knowledge-tuning/test_utils.py

@@ -1,4 +1,5 @@
 """Tests for utility functions in knowledge-tuning."""
+
 import json
 import sys
 from pathlib import Path
@@ -9,7 +10,9 @@
 
 # Add the knowledge-tuning utils to path
 repo_root = Path(__file__).parent.parent.parent
-utils_path = repo_root / "examples" / "knowledge-tuning" / "04_Knowledge_Mixing" / "utils"
+utils_path = (
+    repo_root / "examples" / "knowledge-tuning" / "04_Knowledge_Mixing" / "utils"
+)
 sys.path.insert(0, str(utils_path))
 
 from knowledge_utils import (  # noqa: E402
@@ -142,7 +145,11 @@ def test_json_schema_validation(self):
         # Check messages structure - extract from Polars Series
         messages_series = result["messages"]
         # Convert to list and get first item
-        messages_list = messages_series.to_list() if isinstance(messages_series, pl.Series) else list(messages_series)
+        messages_list = (
+            messages_series.to_list()
+            if isinstance(messages_series, pl.Series)
+            else list(messages_series)
+        )
         messages = messages_list[0]
         assert isinstance(messages, list)
         assert len(messages) >= 1
@@ -151,7 +158,11 @@ def test_json_schema_validation(self):
 
         # Check metadata structure - extract from Polars Series
         metadata_series = result["metadata"]
-        metadata_list = metadata_series.to_list() if isinstance(metadata_series, pl.Series) else list(metadata_series)
+        metadata_list = (
+            metadata_series.to_list()
+            if isinstance(metadata_series, pl.Series)
+            else list(metadata_series)
+        )
         metadata = metadata_list[0]
         # Metadata should be a JSON string
         assert isinstance(metadata, str)
@@ -252,4 +263,3 @@ def test_tokenizer_mock_behavior(self):
         messages = [{"role": "user", "content": "test"}]
         template = tokenizer.apply_chat_template(messages, tokenize=False)
         assert isinstance(template, str)
-

tests/knowledge-tuning/test_venv_build.py

@@ -1,4 +1,5 @@
 """Tests for virtual environment build validation."""
+
 import subprocess
 import sys
 
@@ -72,7 +73,9 @@ def test_no_gpu_specific_packages_in_required(self, pyproject_files):
                 # We're looking for obvious cases like "torch[cuda]" or explicit GPU packages
                 if any(keyword in dep_lower for keyword in gpu_specific_keywords):
                     # Allow torch but flag explicit GPU extras
-                    if "torch" in dep_lower and ("cuda" in dep_lower or "gpu" in dep_lower):
+                    if "torch" in dep_lower and (
+                        "cuda" in dep_lower or "gpu" in dep_lower
+                    ):
                         # This is acceptable - torch with cuda extras is common
                         pass
                     elif any(
@@ -122,9 +125,9 @@ def test_requires_python_is_valid(self, pyproject_files):
                 # Should contain version specifiers
                 assert len(requires_python) > 0
                 # Should start with comparison operator or version number
-                assert requires_python[0] in ">=<~!0123456789" or requires_python.startswith(
-                    "python"
-                )
+                assert requires_python[
+                    0
+                ] in ">=<~!0123456789" or requires_python.startswith("python")
 
     def test_venv_builds_cleanly(self, pyproject_files, repo_root):
         """Test that virtual environment builds cleanly for each pyproject.toml."""
@@ -173,9 +176,7 @@ def test_venv_builds_cleanly(self, pyproject_files, repo_root):
                     f"Timeout resolving dependencies for {pyproject_path} (exceeded 1 minute)"
                 )
             except Exception as e:
-                pytest.fail(
-                    f"Error resolving dependencies for {pyproject_path}: {e}"
-                )
+                pytest.fail(f"Error resolving dependencies for {pyproject_path}: {e}")
 
     def test_dependencies_resolve_without_conflicts(self, pyproject_files, repo_root):
         """Test that dependencies resolve without conflicts."""
@@ -215,13 +216,9 @@ def test_dependencies_resolve_without_conflicts(self, pyproject_files, repo_root
                     # Other errors are handled by test_venv_builds_cleanly
 
             except subprocess.TimeoutExpired:
-                pytest.fail(
-                    f"Timeout resolving dependencies for {pyproject_path}"
-                )
+                pytest.fail(f"Timeout resolving dependencies for {pyproject_path}")
             except Exception as e:
-                pytest.fail(
-                    f"Error checking dependencies for {pyproject_path}: {e}"
-                )
+                pytest.fail(f"Error checking dependencies for {pyproject_path}: {e}")
 
     def test_modules_can_be_imported(self, pyproject_files, notebook_files, repo_root):
         """Test that modules referenced by notebooks can be imported (syntax validation only)."""
@@ -270,12 +267,15 @@ def test_modules_can_be_imported(self, pyproject_files, notebook_files, repo_roo
         for pyproject_path in pyproject_files:
             # Just verify the pyproject.toml exists and is valid
             # The actual import validation is done in test_notebook_imports
-            assert pyproject_path.exists(), f"pyproject.toml not found: {pyproject_path}"
+            assert pyproject_path.exists(), (
+                f"pyproject.toml not found: {pyproject_path}"
+            )
 
             # Verify dependencies are listed (basic check)
             with open(pyproject_path, "rb") as f:
                 data = tomllib.load(f)
             project = data.get("project", {})
             dependencies = project.get("dependencies", [])
-            assert isinstance(dependencies, list), f"Invalid dependencies in {pyproject_path}"
-
+            assert isinstance(dependencies, list), (
+                f"Invalid dependencies in {pyproject_path}"
+            )