Add new-syle YAML (Parsed) Metric

Author: theyostalservice

core/dbt/artifacts/resources/v1/metric.py

@@ -83,9 +83,11 @@ class ConstantPropertyInput(dbtClassMixin):
 
 @dataclass
 class ConversionTypeParams(dbtClassMixin):
-    base_measure: MetricInputMeasure
-    conversion_measure: MetricInputMeasure
     entity: str
+    base_measure: Optional[MetricInputMeasure] = None
+    conversion_measure: Optional[MetricInputMeasure] = None
+    base_metric: Optional[MetricInput] = None
+    conversion_metric: Optional[MetricInput] = None
     calculation: ConversionCalculationType = ConversionCalculationType.CONVERSION_RATE
     window: Optional[MetricTimeWindow] = None
     constant_properties: Optional[List[ConstantPropertyInput]] = None
@@ -106,13 +108,15 @@ class MetricAggregationParams(dbtClassMixin):
     agg_params: Optional[MeasureAggregationParameters] = None
     agg_time_dimension: Optional[str] = None
     non_additive_dimension: Optional[NonAdditiveDimension] = None
-    expr: Optional[str] = None
 
 
 @dataclass
 class MetricTypeParams(dbtClassMixin):
+    # Only used in old-style YAML (pre-November 2025)
     measure: Optional[MetricInputMeasure] = None
+    # Only used in old-style YAML (pre-November 2025)
     input_measures: List[MetricInputMeasure] = field(default_factory=list)
+
     numerator: Optional[MetricInput] = None
     denominator: Optional[MetricInput] = None
     expr: Optional[str] = None
@@ -123,7 +127,12 @@ class MetricTypeParams(dbtClassMixin):
     metrics: Optional[List[MetricInput]] = None
     conversion_type_params: Optional[ConversionTypeParams] = None
     cumulative_type_params: Optional[CumulativeTypeParams] = None
+
+    # Only used in v2 YAML
     metric_aggregation_params: Optional[MetricAggregationParams] = None
+    fill_nulls_with: Optional[int] = None
+    join_to_timespine: Optional[bool] = None
+    is_private: Optional[bool] = None  # populated by "hidden" field in YAML
 
 
 @dataclass
@@ -148,8 +157,6 @@ class Metric(GraphResource):
     metadata: Optional[SourceFileMetadata] = None
     time_granularity: Optional[str] = None
     resource_type: Literal[NodeType.Metric]
-    meta: Dict[str, Any] = field(default_factory=dict, metadata=MergeBehavior.Update.meta())
-    tags: List[str] = field(default_factory=list)
     config: MetricConfig = field(default_factory=MetricConfig)
     unrendered_config: Dict[str, Any] = field(default_factory=dict)
     sources: List[List[str]] = field(default_factory=list)
@@ -159,14 +166,18 @@ class Metric(GraphResource):
     created_at: float = field(default_factory=lambda: time.time())
     group: Optional[str] = None
 
+    # These fields are only used in v1 metrics.
+    meta: Dict[str, Any] = field(default_factory=dict, metadata=MergeBehavior.Update.meta())
+    tags: List[str] = field(default_factory=list)
+
+    @property
+    def input_metrics(self) -> List[MetricInput]:
+        return self.type_params.metrics or []
+
     @property
     def input_measures(self) -> List[MetricInputMeasure]:
         return self.type_params.input_measures
 
     @property
     def measure_references(self) -> List[MeasureReference]:
         return [x.measure_reference() for x in self.input_measures]
-
-    @property
-    def input_metrics(self) -> List[MetricInput]:
-        return self.type_params.metrics or []

core/dbt/contracts/graph/unparsed.py

@@ -1,9 +1,12 @@
 import datetime
 import re
 from dataclasses import dataclass, field
+from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Sequence, Union
 
+from typing_extensions import override
+
 # trigger the PathEncoder
 import dbt_common.helper_types  # noqa:F401
 from dbt import deprecations
@@ -580,15 +583,34 @@ class UnparsedMetricInput(dbtClassMixin):
 
 @dataclass
 class UnparsedConversionTypeParams(dbtClassMixin):
-    base_measure: Union[UnparsedMetricInputMeasure, str]
-    conversion_measure: Union[UnparsedMetricInputMeasure, str]
     entity: str
+
+    # *_measure params are for old-style YAML.
+    base_measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None
+    conversion_measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None
+    # *_metric params are for v2-style metrics.
+    base_metric: Optional[Union[UnparsedMetricInput, str]] = None
+    conversion_metric: Optional[Union[UnparsedMetricInput, str]] = None
+
     calculation: str = (
         ConversionCalculationType.CONVERSION_RATE.value
     )  # ConversionCalculationType Enum
     window: Optional[str] = None
     constant_properties: Optional[List[ConstantPropertyInput]] = None
 
+    @override
+    @classmethod
+    def validate(cls, data):
+        super().validate(data)
+        if data.get("base_measure") is None and data.get("base_metric") is None:
+            raise ValidationError(
+                "Conversion metrics must define a base_measure or base_metric parameter."
+            )
+        if data.get("conversion_measure") is None and data.get("conversion_metric") is None:
+            raise ValidationError(
+                "Conversion metrics must define a conversion_measure or conversion_metric parameter."
+            )
+
 
 @dataclass
 class UnparsedCumulativeTypeParams(dbtClassMixin):
@@ -674,30 +696,37 @@ class UnparsedMetricV2(UnparsedMetricBase):
 
     join_to_timespine: Optional[bool] = None
     fill_nulls_with: Optional[int] = None
-    expr: Optional[Union[str, int]] = None
+    expr: Optional[Union[str, bool]] = None
 
     non_additive_dimension: Optional[UnparsedNonAdditiveDimensionV2] = None
     agg_time_dimension: Optional[str] = None
 
     # For cumulative metrics
     window: Optional[str] = None
     grain_to_date: Optional[str] = None
-    period_agg: Optional[str] = None
+    period_agg: str = PeriodAggregation.FIRST.value
     input_metric: Optional[Union[str, Dict[str, Any]]] = None
 
     # For ratio metrics
-    numerator: Optional[Union[str, Dict[str, Any]]] = None
-    denominator: Optional[Union[str, Dict[str, Any]]] = None
+    numerator: Optional[Union[UnparsedMetricInput, str]] = None
+    denominator: Optional[Union[UnparsedMetricInput, str]] = None
 
     # For derived metrics
-    input_metrics: Optional[List[Dict[str, Any]]] = None
+    input_metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None
 
     # For conversion metrics
     entity: Optional[str] = None
     calculation: Optional[str] = None
-    base_metric: Optional[Union[str, Dict[str, Any]]] = None
-    conversion_metric: Optional[Union[str, Dict[str, Any]]] = None
-    constant_properties: Optional[List[Dict[str, Any]]] = None
+    base_metric: Optional[Union[UnparsedMetricInput, str]] = None
+    conversion_metric: Optional[Union[UnparsedMetricInput, str]] = None
+    constant_properties: Optional[List[ConstantPropertyInput]] = None
+
+    @classmethod
+    @override
+    def validate(cls, data):
+        super().validate(data)
+        if data["type"] == "simple" and data.get("agg") is None:
+            raise ValidationError("Simple metrics must have an agg param.")
 
 
 @dataclass
@@ -748,6 +777,11 @@ class UnparsedNonAdditiveDimension(dbtClassMixin):
     window_groupings: List[str] = field(default_factory=list)
 
 
+class PercentileType(str, Enum):
+    DISCRETE = "discrete"
+    CONTINUOUS = "continuous"
+
+
 @dataclass
 class UnparsedMeasure(dbtClassMixin):
     name: str

core/dbt/parser/manifest.py

@@ -1867,7 +1867,7 @@ def _process_metric_depends_on(
 ) -> None:
     """For a given metric, set the `depends_on` property"""
 
-    assert len(metric.type_params.input_measures) > 0
+    # assert len(metric.type_params.input_measures) > 0 or metric.type_params.metric_aggregation_params is not None, f"{metric} should have a measure or agg type defined, but it does not."
     for input_measure in metric.type_params.input_measures:
         target_semantic_model = manifest.resolve_semantic_model_for_measure(
             target_measure_name=input_measure.name,
@@ -1903,10 +1903,16 @@ def _process_metric_node(
         return
 
     if metric.type is MetricType.SIMPLE or metric.type is MetricType.CUMULATIVE:
-        assert (
-            metric.type_params.measure is not None
-        ), f"{metric} should have a measure defined, but it does not."
-        metric.add_input_measure(metric.type_params.measure)
+        if (
+            metric.type_params.measure is None
+            and metric.type_params.metric_aggregation_params is None
+        ):
+            raise dbt.exceptions.ParsingError(
+                f"{metric} should have a measure or agg type defined, but it does not.",
+                node=metric,
+            )
+        if metric.type_params.measure is not None:
+            metric.add_input_measure(metric.type_params.measure)
         _process_metric_depends_on(
             manifest=manifest, current_project=current_project, metric=metric
         )
@@ -1915,8 +1921,11 @@ def _process_metric_node(
         assert (
             conversion_type_params
         ), f"{metric.name} is a conversion metric and must have conversion_type_params defined."
-        metric.add_input_measure(conversion_type_params.base_measure)
-        metric.add_input_measure(conversion_type_params.conversion_measure)
+        if conversion_type_params.base_measure is not None:
+            metric.add_input_measure(conversion_type_params.base_measure)
+        if conversion_type_params.conversion_measure is not None:
+            metric.add_input_measure(conversion_type_params.conversion_measure)
+        # TODO : process input metrics' input measures recursively, like in derived metrics.
         _process_metric_depends_on(
             manifest=manifest, current_project=current_project, metric=metric
         )