chore: Source component/pipeline name from decorator params

- Prefer value from metadata.yaml but fall back to decorator param
- If both of these don't exist, instead use function name

Signed-off-by: Giulio Frasca <gfrasca@redhat.com>

Author: gmfrasca

scripts/generate_readme/metadata_parser.py

@@ -77,6 +77,53 @@ def _get_type_string(self, annotation: Any) -> str:
         # and clean up the typing module prefix
         return str(annotation).replace('typing.', '')
 
+    def _extract_decorator_name(self, decorator: ast.AST) -> Optional[str]:
+        """Extract the 'name' parameter from a decorator if present.
+        
+        Args:
+            decorator: AST node representing the decorator.
+            
+        Returns:
+            The name parameter value if found, None otherwise.
+        """
+        # Check if decorator is a Call node (has arguments)
+        if isinstance(decorator, ast.Call):
+            # Look for name parameter in keyword arguments
+            for keyword in decorator.keywords:
+                if keyword.arg == 'name':
+                    # Extract the string value
+                    if isinstance(keyword.value, ast.Constant):
+                        return keyword.value.value
+        return None
+    
+    def _get_name_from_decorator_if_exists(self, function_name: str) -> Optional[str]:
+        """Get the decorator's name parameter for a specific function.
+        
+        Args:
+            function_name: Name of the function to find.
+            
+        Returns:
+            The name parameter from the decorator if found, None otherwise.
+        """
+        try:
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                source = f.read()
+            
+            tree = ast.parse(source)
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef) and node.name == function_name:
+                    # Check decorators for name parameter
+                    for decorator in node.decorator_list:
+                        decorator_name = self._extract_decorator_name(decorator)
+                        if decorator_name:
+                            return decorator_name
+            
+            return None
+        except Exception as e:
+            logger.debug(f"Could not extract decorator name from AST: {e}")
+            return None
+    
     def _extract_function_metadata(self, function_name: str, module_name: str = "module") -> Dict[str, Any]:
         """Extract metadata from a KFP function (component or pipeline).
         
@@ -105,9 +152,13 @@ def _extract_function_metadata(self, function_name: str, module_name: str = "mod
                 # Fallback to the object itself if neither attribute is available
                 func = func_obj
 
+            # Try to get name from decorator, fall back to function name
+            decorator_name = self._get_name_from_decorator_if_exists(function_name)
+            component_name = decorator_name if decorator_name else function_name
+            
             # Extract basic function information
             metadata = {
-                'name': function_name,
+                'name': component_name,
                 'docstring': inspect.getdoc(func) or '',
                 'signature': inspect.signature(func),
                 'parameters': {},

scripts/generate_readme/tests/test_metadata_parser.py

@@ -201,6 +201,57 @@ def test_is_component_decorator_wrong_decorator(self):
         decorator = tree.body[0].decorator_list[0]
 
         assert parser._is_component_decorator(decorator) is False
+    
+    def test_extract_decorator_name_component(self, temp_dir):
+        """Test extracting name parameter from @dsl.component decorator."""
+        component_file = temp_dir / "component.py"
+        component_file.write_text("""
+from kfp import dsl
+
+@dsl.component(name='custom-component-name', base_image='python:3.10')
+def my_component(param: str) -> str:
+    '''A component with custom name in decorator.
+    
+    Args:
+        param: Input parameter.
+        
+    Returns:
+        Output value.
+    '''
+    return param
+""")
+        
+        parser = ComponentMetadataParser(component_file)
+        
+        # Test finding the function
+        function_name = parser.find_function()
+        assert function_name == 'my_component'
+        
+        # Test extracting decorator name from AST (without executing the code)
+        decorator_name = parser._get_name_from_decorator_if_exists('my_component')
+        
+        # Should extract the decorator name
+        assert decorator_name == 'custom-component-name'
+    
+    def test_extract_decorator_name_component_no_name(self, temp_dir):
+        """Test extracting name when decorator has no name parameter."""
+        component_file = temp_dir / "component.py"
+        component_file.write_text("""
+from kfp import dsl
+
+@dsl.component(base_image='python:3.10')
+def my_component(param: str) -> str:
+    '''A component without custom name in decorator.'''
+    return param
+""")
+        
+        parser = ComponentMetadataParser(component_file)
+        
+        # Test extracting decorator name (should return None)
+        decorator_name = parser._get_name_from_decorator_if_exists('my_component')
+        
+        # Should return None when no name in decorator
+        assert decorator_name is None
 
 
 class TestPipelineMetadataParser:
@@ -283,4 +334,55 @@ def test_is_pipeline_decorator_wrong_decorator(self):
         decorator = tree.body[0].decorator_list[0]
 
         assert parser._is_pipeline_decorator(decorator) is False
+    
+    def test_extract_decorator_name_pipeline(self, temp_dir):
+        """Test extracting name parameter from @dsl.pipeline decorator."""
+        pipeline_file = temp_dir / "pipeline.py"
+        pipeline_file.write_text("""
+from kfp import dsl
+
+@dsl.pipeline(name='custom-pipeline-name', description='A test pipeline')
+def my_pipeline(input_data: str) -> str:
+    '''A pipeline with custom name in decorator.
+    
+    Args:
+        input_data: Input data path.
+        
+    Returns:
+        Output data path.
+    '''
+    return input_data
+""")
+        
+        parser = PipelineMetadataParser(pipeline_file)
+        
+        # Test finding the function
+        function_name = parser.find_function()
+        assert function_name == 'my_pipeline'
+        
+        # Test extracting decorator name from AST (without executing the code)
+        decorator_name = parser._get_name_from_decorator_if_exists('my_pipeline')
+        
+        # Should extract the decorator name
+        assert decorator_name == 'custom-pipeline-name'
+    
+    def test_extract_decorator_name_pipeline_no_name(self, temp_dir):
+        """Test extracting name when decorator has no name parameter."""
+        pipeline_file = temp_dir / "pipeline.py"
+        pipeline_file.write_text("""
+from kfp import dsl
+
+@dsl.pipeline(description='A test pipeline')
+def my_pipeline(input_data: str) -> str:
+    '''A pipeline without custom name in decorator.'''
+    return input_data
+""")
+        
+        parser = PipelineMetadataParser(pipeline_file)
+        
+        # Test extracting decorator name (should return None)
+        decorator_name = parser._get_name_from_decorator_if_exists('my_pipeline')
+        
+        # Should return None when no name in decorator
+        assert decorator_name is None