Add reformatted compile_check for ruff verification

Signed-off-by: sduvvuri1603 <[email protected]>

Author: sduvvuri1603

.github/scripts/compile_check/__init__.py

@@ -0,0 +1 @@
+"""compile_check GitHub scripts package."""

.github/scripts/compile_check/compile_check.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
-"""
-Compile and dependency validation tool for Kubeflow Pipelines components.
+"""Compile and dependency validation tool for Kubeflow Pipelines components.
 
 This script discovers component and pipeline modules based on the presence of
 `metadata.yaml` files, validates declared dependencies, and ensures each target
@@ -27,9 +26,7 @@
     SpecifierSet = None  # type: ignore[assignment]
 
 from kfp import compiler as pipeline_compiler
-from kfp.dsl import base_component
-from kfp.dsl import graph_component
-
+from kfp.dsl import base_component, graph_component
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 
@@ -48,26 +45,29 @@ class MetadataTarget:
 
 @dataclass
 class ValidationResult:
+    """Stores the outcome of validating a single metadata target."""
+
     target: MetadataTarget
     success: bool
     compiled_objects: List[str] = field(default_factory=list)
     warnings: List[str] = field(default_factory=list)
     errors: List[str] = field(default_factory=list)
 
     def add_error(self, message: str) -> None:
+        """Record a validation error and mark the result unsuccessful."""
         logging.error(message)
         self.errors.append(message)
         self.success = False
 
     def add_warning(self, message: str) -> None:
+        """Record a non-fatal validation warning."""
         logging.warning(message)
         self.warnings.append(message)
 
 
 def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Compile Kubeflow components and pipelines."
-    )
+    """Parse command-line arguments for the compile check tool."""
+    parser = argparse.ArgumentParser(description="Compile Kubeflow components and pipelines.")
     parser.add_argument(
         "--tier",
         choices=["core", "all"],
@@ -99,6 +99,7 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
 
 
 def configure_logging(verbose: bool) -> None:
+    """Configure logging verbosity for the script."""
     level = logging.DEBUG if verbose else logging.INFO
     logging.basicConfig(
         level=level,
@@ -129,18 +130,21 @@ def should_include_target(
     metadata: Dict,
     include_flagless: bool,
 ) -> bool:
+    """Return whether a metadata entry should be considered for compilation."""
     ci_config = metadata.get("ci") or {}
     if "compile_check" in ci_config:
         return bool(ci_config["compile_check"])
     return include_flagless
 
 
 def build_module_import_path(module_path: Path) -> str:
+    """Convert a module path to a dotted import path."""
     relative = module_path.relative_to(REPO_ROOT)
     return ".".join(relative.with_suffix("").parts)
 
 
 def load_metadata(metadata_path: Path) -> Dict:
+    """Load and validate metadata from the given path."""
     with metadata_path.open("r", encoding="utf-8") as handle:
         data = yaml.safe_load(handle) or {}
         if not isinstance(data, dict):
@@ -153,15 +157,14 @@ def create_targets(
     include_flagless: bool,
     path_filters: Sequence[str],
 ) -> List[MetadataTarget]:
+    """Build MetadataTarget objects from discovered metadata files."""
     normalized_filters = [Path(p).resolve() for p in path_filters]
     targets: List[MetadataTarget] = []
 
     for metadata_path, tier, target_kind in discovered:
         if normalized_filters:
             absolute_metadata_dir = metadata_path.parent.resolve()
-            if not any(
-                absolute_metadata_dir.is_relative_to(f) for f in normalized_filters
-            ):
+            if not any(absolute_metadata_dir.is_relative_to(f) for f in normalized_filters):
                 continue
 
         try:
@@ -174,9 +177,7 @@ def create_targets(
             logging.debug("Skipping %s (compile_check disabled).", metadata_path)
             continue
 
-        module_filename = (
-            "component.py" if target_kind == "component" else "pipeline.py"
-        )
+        module_filename = "component.py" if target_kind == "component" else "pipeline.py"
         module_path = metadata_path.with_name(module_filename)
         if not module_path.exists():
             logging.error(
@@ -200,24 +201,22 @@ def create_targets(
     return targets
 
 
-def find_objects(
-    module, target_kind: str
-) -> List[Tuple[str, base_component.BaseComponent]]:
+def find_objects(module, target_kind: str) -> List[Tuple[str, base_component.BaseComponent]]:
+    """Locate pipeline or component factory functions within a module."""
     found: List[Tuple[str, base_component.BaseComponent]] = []
     for attr_name in dir(module):
         attr = getattr(module, attr_name)
         if target_kind == "pipeline":
             if isinstance(attr, graph_component.GraphComponent):
                 found.append((attr_name, attr))
         else:
-            if isinstance(attr, base_component.BaseComponent) and not isinstance(
-                attr, graph_component.GraphComponent
-            ):
+            if isinstance(attr, base_component.BaseComponent) and not isinstance(attr, graph_component.GraphComponent):
                 found.append((attr_name, attr))
     return found
 
 
 def validate_dependencies(metadata: Dict, result: ValidationResult) -> None:
+    """Validate dependency metadata declared for a target."""
     dependencies = metadata.get("dependencies") or {}
     if not isinstance(dependencies, dict):
         result.add_error("`dependencies` must be a mapping.")
@@ -244,25 +243,21 @@ def validate_dependencies(metadata: Dict, result: ValidationResult) -> None:
             if not name:
                 result.add_error(f"{label} is missing a `name` field.")
             if not version:
-                result.add_error(
-                    f"{label} for {name or '<unknown>'} is missing a `version` field."
-                )
+                result.add_error(f"{label} for {name or '<unknown>'} is missing a `version` field.")
             elif SpecifierSet is not None:
                 try:
                     SpecifierSet(str(version))
                 except Exception as exc:
                     result.add_error(
-                        f"{label} for {name or '<unknown>'} has an invalid version specifier "
-                        f"{version!r}: {exc}"
+                        f"{label} for {name or '<unknown>'} has an invalid version specifier {version!r}: {exc}"
                     )
             else:
-                result.add_warning(
-                    "packaging module not available; skipping validation for dependency versions."
-                )
+                result.add_warning("packaging module not available; skipping validation for dependency versions.")
                 return
 
 
 def compile_pipeline(obj: graph_component.GraphComponent, output_dir: Path) -> Path:
+    """Compile a pipeline function and return the output path."""
     output_path = output_dir / f"{obj.name or 'pipeline'}.json"
     pipeline_compiler.Compiler().compile(
         pipeline_func=obj,
@@ -272,12 +267,14 @@ def compile_pipeline(obj: graph_component.GraphComponent, output_dir: Path) -> P
 
 
 def compile_component(obj: base_component.BaseComponent, output_dir: Path) -> Path:
+    """Compile a component function and return the output path."""
     output_path = output_dir / f"{obj.name or 'component'}.yaml"
     obj.component_spec.save_to_component_yaml(str(output_path))
     return output_path
 
 
 def validate_target(target: MetadataTarget) -> ValidationResult:
+    """Validate a single metadata target by compiling exposed objects."""
     result = ValidationResult(target=target, success=True)
     validate_dependencies(target.metadata, result)
     if not result.success and result.errors:
@@ -289,16 +286,13 @@ def validate_target(target: MetadataTarget) -> ValidationResult:
         module = importlib.import_module(target.module_import)
     except Exception:
         result.add_error(
-            f"Failed to import module {target.module_import} defined in {target.module_path}.\n"
-            f"{traceback.format_exc()}"
+            f"Failed to import module {target.module_import} defined in {target.module_path}.\n{traceback.format_exc()}"
         )
         return result
 
     objects = find_objects(module, target.target_kind)
     if not objects:
-        result.add_error(
-            f"No {target.target_kind} objects discovered in module {target.module_import}."
-        )
+        result.add_error(f"No {target.target_kind} objects discovered in module {target.module_import}.")
         return result
 
     with tempfile.TemporaryDirectory() as temp_dir:
@@ -329,6 +323,7 @@ def validate_target(target: MetadataTarget) -> ValidationResult:
 
 
 def run_validation(args: argparse.Namespace) -> int:
+    """Validate all discovered metadata targets."""
     configure_logging(args.verbose)
     sys.path.insert(0, str(REPO_ROOT))
 
@@ -354,9 +349,7 @@ def run_validation(args: argparse.Namespace) -> int:
             logging.info(
                 "✓ %s compiled successfully (%s)",
                 target.metadata.get("name", target.module_import),
-                ", ".join(result.compiled_objects)
-                if result.compiled_objects
-                else "no output",
+                ", ".join(result.compiled_objects) if result.compiled_objects else "no output",
             )
         else:
             logging.error(
@@ -381,6 +374,7 @@ def run_validation(args: argparse.Namespace) -> int:
 
 
 def main(argv: Optional[Sequence[str]] = None) -> int:
+    """Entrypoint for running compile checks via the CLI."""
     args = parse_args(argv)
     try:
         return run_validation(args)

.github/scripts/compile_check/tests/test_compile_check.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import argparse
+import sys
 import tempfile
 import textwrap
 import unittest
@@ -12,12 +13,6 @@
 
 import yaml
 
-import sys
-
-SCRIPTS_ROOT = Path(__file__).resolve().parents[2]
-if str(SCRIPTS_ROOT) not in sys.path:
-    sys.path.insert(0, str(SCRIPTS_ROOT))
-
 from compile_check import compile_check
 
 
@@ -38,12 +33,14 @@ class CompileCheckTestCase(unittest.TestCase):
     """Unit tests covering compile_check’s discovery, dependency, and compile paths."""
 
     def setUp(self) -> None:
+        """Create a temporary repository root for each test case."""
         self._tempdir = tempfile.TemporaryDirectory()
         self.repo_root = Path(self._tempdir.name)
         self.original_repo_root = compile_check.REPO_ROOT
         compile_check.REPO_ROOT = self.repo_root
 
     def tearDown(self) -> None:
+        """Clean up temporary directories and restore global state."""
         compile_check.REPO_ROOT = self.original_repo_root
         self._tempdir.cleanup()
 

__init__.py

@@ -1,5 +1,4 @@
-"""
-Kubeflow Pipelines Components
+"""Kubeflow Pipelines Components
 
 A collection of reusable components and pipelines for Kubeflow Pipelines.
 
@@ -20,5 +19,5 @@
     components = import_module("kubeflow.pipelines.components.components")
     pipelines = import_module("kubeflow.pipelines.components.pipelines")
 else:
-    from . import components  # type: ignore[F401]  # re-export for consumers
-    from . import pipelines  # type: ignore[F401]
+    from . import components as components
+    from . import pipelines as pipelines