Convert median to percentile in metrics (like in measures) (#433)

Towards #387

### Description

Depends on #432 

We already convert measures with agg value MEDIAN to be percentile measures.  Since we're replacing measures with simple metrics, this PR does the same for simple metrics.

Notes:
* Learning from several previous PRs, including especially #431 , we use some inheritance to keep all the good, non-legacy code in the transformation class for metrics while still allowing a lot of reuse for the measures-related class.
* I also did a little renaming and re-documenting to the test cases I added to show make it clear what was legacy and for measures and what was not.

### Checklist

- [x] I have read [the contributing guide](https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/CONTRIBUTING.md) and understand what's expected of me
- [x] I have signed the [CLA](https://docs.getdbt.com/docs/contributor-license-agreements)
- [x] This PR includes tests, or tests are not required/relevant for this PR
- [x] I have run `changie new` to [create a changelog entry](https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/CONTRIBUTING.md#adding-a-changelog-entry)

Author: theyostalservice

.changes/unreleased/Under the Hood-20250929-143250.yaml

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: Add transformation for new simple metrics that matches the one for measures with MEDIAN agg types.
+time: 2025-09-29T14:32:50.563028-07:00
+custom:
+    Author: theyostalservice
+    Issue: "387"

dbt_semantic_interfaces/transformations/convert_median.py

@@ -1,3 +1,5 @@
+from typing import Literal, NoReturn
+
 from typing_extensions import override
 
 from dbt_semantic_interfaces.errors import ModelTransformError
@@ -12,11 +14,80 @@
     SemanticManifestTransformRule,
 )
 from dbt_semantic_interfaces.type_enums import AggregationType
+from dbt_semantic_interfaces.type_enums.metric_type import MetricType
+
+
+class ConvertMedianMetricToPercentile(ProtocolHint[SemanticManifestTransformRule[PydanticSemanticManifest]]):
+    """Converts any MEDIAN metrics to percentile equivalent.
 
-MEDIAN_PERCENTILE = 0.5
+    Applies to SIMPLE metrics that aggregate an expression directly via
+    `type_params.metric_aggregation_params`.
+    """
 
+    TRANSFORMED_AGG_TYPE = AggregationType.PERCENTILE
+    MEDIAN_PERCENTILE = 0.5
+
+    @override
+    def _implements_protocol(self) -> SemanticManifestTransformRule[PydanticSemanticManifest]:  # noqa: D
+        return self
+
+    @staticmethod
+    def _throw_conflicting_percentile_error(
+        object_name: str,
+        object_type: Literal["Metric", "Measure"],
+        percentile: float,
+    ) -> NoReturn:
+        raise ModelTransformError(
+            f"{object_type} '{object_name}' uses a MEDIAN aggregation, while percentile "
+            f"is set to '{percentile}', a conflicting value. Please remove the parameter "
+            "or set to '0.5'."
+        )
+
+    @staticmethod
+    def _throw_conflicting_discrete_percentile_error(
+        object_name: str,
+        object_type: Literal["Metric", "Measure"],
+    ) -> NoReturn:
+        raise ModelTransformError(
+            f"{object_type} '{object_name}' uses a MEDIAN aggregation, while use_discrete_percentile "
+            f"is set to true. Please remove the parameter or set to False."
+        )
 
-class ConvertMedianToPercentileRule(ProtocolHint[SemanticManifestTransformRule[PydanticSemanticManifest]]):
+    @staticmethod
+    def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSemanticManifest:  # noqa: D
+        for metric in semantic_manifest.metrics:
+            if (
+                metric.type == MetricType.SIMPLE
+                and metric.type_params.metric_aggregation_params is not None
+                and metric.type_params.metric_aggregation_params.agg == AggregationType.MEDIAN
+            ):
+                # Update aggregation type first
+                metric.type_params.metric_aggregation_params.agg = ConvertMedianMetricToPercentile.TRANSFORMED_AGG_TYPE
+
+                # Ensure aggregation parameters exist, then validate
+                if metric.type_params.metric_aggregation_params.agg_params is None:
+                    metric.type_params.metric_aggregation_params.agg_params = PydanticMeasureAggregationParameters()
+                else:
+                    agg_params = metric.type_params.metric_aggregation_params.agg_params
+                    if agg_params.percentile is not None and agg_params.percentile != MEDIAN_PERCENTILE:
+                        ConvertMedianMetricToPercentile._throw_conflicting_percentile_error(
+                            object_name=metric.name,
+                            object_type="Metric",
+                            percentile=agg_params.percentile,
+                        )
+                    if agg_params.use_discrete_percentile:
+                        ConvertMedianMetricToPercentile._throw_conflicting_discrete_percentile_error(
+                            object_name=metric.name,
+                            object_type="Metric",
+                        )
+
+                # Set the median percentile
+                metric.type_params.metric_aggregation_params.agg_params.percentile = MEDIAN_PERCENTILE
+
+        return semantic_manifest
+
+
+class ConvertMedianToPercentileRule(ConvertMedianMetricToPercentile):
     """Converts any MEDIAN measures to percentile equivalent."""
 
     @override
@@ -28,22 +99,27 @@ def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSema
         for semantic_model in semantic_manifest.semantic_models:
             for measure in semantic_model.measures:
                 if measure.agg == AggregationType.MEDIAN:
-                    measure.agg = AggregationType.PERCENTILE
+                    measure.agg = ConvertMedianToPercentileRule.TRANSFORMED_AGG_TYPE
 
                     if not measure.agg_params:
                         measure.agg_params = PydanticMeasureAggregationParameters()
                     else:
                         if measure.agg_params.percentile is not None and measure.agg_params.percentile != 0.5:
-                            raise ModelTransformError(
-                                f"Measure '{measure.name}' uses a MEDIAN aggregation, while percentile is set to "
-                                f"'{measure.agg_params.percentile}', a conflicting value. Please remove the parameter "
-                                "or set to '0.5'."
+                            ConvertMedianToPercentileRule._throw_conflicting_percentile_error(
+                                object_name=measure.name,
+                                object_type="Measure",
+                                percentile=measure.agg_params.percentile,
                             )
                         if measure.agg_params.use_discrete_percentile:
-                            raise ModelTransformError(
-                                f"Measure '{measure.name}' uses a MEDIAN aggregation, while use_discrete_percentile "
-                                f"is set to true. Please remove the parameter or set to False."
+                            ConvertMedianToPercentileRule._throw_conflicting_discrete_percentile_error(
+                                object_name=measure.name,
+                                object_type="Measure",
                             )
-                    measure.agg_params.percentile = MEDIAN_PERCENTILE
+                    measure.agg_params.percentile = ConvertMedianToPercentileRule.MEDIAN_PERCENTILE
                     # let's not set use_approximate_percentile to be false due to valid performance reasons
         return semantic_manifest
+
+
+# Just left here for legacy reasons.  Maybe we can get rid of this when we remove
+# measures?
+MEDIAN_PERCENTILE = ConvertMedianMetricToPercentile.MEDIAN_PERCENTILE