feat: Add required_metrics to CodeMetric (#435)

Author: john-weiler

src/galileo/__future__/metric.py

@@ -779,13 +779,15 @@ class CodeMetric(Metric):
     # Type annotations for code-specific attributes
     node_level: StepType | None
     code: str | None
+    required_metrics: list[str] | None
 
     def __init__(
         self,
         name: str,
         *,
         code: str | None = None,
         node_level: StepType | None = None,
+        required_metrics: list[str] | None = None,
         description: str = "",
         tags: list[str] | None = None,
         version: int | None = None,
@@ -797,6 +799,7 @@ def __init__(
             name: The name of the metric.
             code: The Python code for the scorer (optional, can be set later or loaded from file).
             node_level: Node level for the metric. Defaults to StepType.llm.
+            required_metrics: List of metric names that this code metric depends on.
             description: Description of the metric.
             tags: Tags associated with the metric.
             version: Specific version to reference (for existing metrics).
@@ -805,6 +808,7 @@ def __init__(
 
         self.code = code
         self.node_level = node_level or StepType.llm
+        self.required_metrics = required_metrics
         self.scorer_type = ScorerTypes.CODE
 
     def load_code(self, code_file_path: str) -> CodeMetric:
@@ -864,7 +868,7 @@ def _validate_code(self, config: GalileoPythonConfig) -> str:
         code_bytes = self.code.encode("utf-8")
         code_file = File(payload=code_bytes, file_name="scorer.py")
         validate_body = BodyValidateCodeScorerScorersCodeValidatePost(
-            file=code_file, scoreable_node_types=[self.node_level.value]
+            file=code_file, scoreable_node_types=[self.node_level.value], required_scorers=self.required_metrics
         )
 
         validate_response = validate_code_scorer_scorers_code_validate_post.sync(
@@ -926,6 +930,7 @@ def _validate_code(self, config: GalileoPythonConfig) -> str:
                     CODE_VALIDATION_INITIAL_DELAY * (CODE_VALIDATION_BACKOFF_MULTIPLIER**attempt),
                     CODE_VALIDATION_MAX_DELAY,
                 )
+
                 logger.debug(
                     f"CodeMetric._validate_code: task_id='{task_id}' - pending "
                     f"(elapsed: {elapsed:.1f}s/{CODE_VALIDATION_TIMEOUT:.0f}s, next delay: {delay:.2f}s)"
@@ -995,6 +1000,7 @@ def create(self) -> CodeMetric:
                 description=self.description,
                 tags=self.tags,
                 scoreable_node_types=[self.node_level.value],
+                required_scorers=self.required_metrics,
             )
 
             scorer_response = create_scorers_post.sync(client=config.api_client, body=scorer_request)

tests/future/test_metric.py

@@ -632,6 +632,16 @@ def test_init_with_all_fields(self, reset_configuration: None) -> None:
         assert metric.description == "Test code metric description"
         assert metric.tags == ["test", "code"]
 
+    def test_init_with_required_metrics(self, reset_configuration: None) -> None:
+        """Test initializing a CodeMetric with required_metrics."""
+        metric = CodeMetric(
+            name="Test Code Metric", node_level=StepType.llm, required_metrics=["context_adherence", "completeness"]
+        )
+
+        assert metric.name == "Test Code Metric"
+        assert metric.required_metrics == ["context_adherence", "completeness"]
+        assert metric.node_level == StepType.llm
+
 
 class TestCodeMetricCreate:
     """Test suite for CodeMetric.create() method."""
@@ -862,6 +872,73 @@ def test_create_with_different_node_levels(
             # Verify the node_level is set on the metric itself
             assert metric.node_level == node_level
 
+    @patch("galileo.__future__.metric.GalileoPythonConfig.get")
+    @patch("galileo.__future__.metric.get_validate_code_scorer_task_result_scorers_code_validate_task_id_get")
+    @patch("galileo.__future__.metric.validate_code_scorer_scorers_code_validate_post")
+    @patch("galileo.__future__.metric.create_code_scorer_version_scorers_scorer_id_version_code_post")
+    @patch("galileo.__future__.metric.create_scorers_post")
+    @patch("galileo.__future__.metric.Scorers")
+    def test_create_with_required_metrics(
+        self,
+        mock_scorers_class: MagicMock,
+        mock_create_scorers: MagicMock,
+        mock_create_version: MagicMock,
+        mock_validate_post: MagicMock,
+        mock_validate_get: MagicMock,
+        mock_config: MagicMock,
+        reset_configuration: None,
+        create_temp_code_file,
+        mock_api_client,
+        mock_scorer_response,
+        mock_version_response,
+        mock_scorer_full,
+        mock_validation_response,
+        mock_validation_task_result,
+    ) -> None:
+        """Test create() passes required_metrics to validation and scorer creation APIs."""
+        # Mock the config
+        mock_config.return_value.api_client = mock_api_client
+
+        # Create a temporary Python file
+        code_file = create_temp_code_file()
+
+        # Mock the validation flow
+        task_id = str(uuid4())
+        mock_validate_post.sync.return_value = mock_validation_response(task_id)
+        mock_validate_get.sync.return_value = mock_validation_task_result(TaskResultStatus.COMPLETED)
+
+        # Mock the scorer creation response
+        scorer_id = str(uuid4())
+        mock_create_scorers.sync.return_value = mock_scorer_response(scorer_id, "Test Code Metric")
+
+        # Mock the version creation response
+        mock_create_version.sync.return_value = mock_version_response(scorer_id)
+
+        # Mock the scorer list response for refresh
+        mock_scorers_service = MagicMock()
+        mock_scorers_service.list.return_value = [mock_scorer_full(scorer_id, "Test Code Metric")]
+        mock_scorers_class.return_value = mock_scorers_service
+
+        required_metrics = ["context_adherence", "completeness"]
+
+        # Create the metric with required_metrics
+        metric = (
+            CodeMetric(name="Test Code Metric", node_level=StepType.llm, required_metrics=required_metrics)
+            .load_code(str(code_file))
+            .create()
+        )
+
+        # Verify the metric was created successfully
+        assert metric.is_synced()
+
+        # Verify required_scorers was passed to validation API
+        validate_call = mock_validate_post.sync.call_args
+        assert validate_call.kwargs["body"].required_scorers == required_metrics
+
+        # Verify required_scorers was passed to scorer creation API
+        create_scorer_call = mock_create_scorers.sync.call_args
+        assert create_scorer_call.kwargs["body"].required_scorers == required_metrics
+
     @patch("galileo.__future__.metric.GalileoPythonConfig.get")
     def test_create_reads_code_file_correctly(
         self,