[MAINTENANCE] Require Metric.name instead of using name inference (#10953)

Author: NathanFarmer

great_expectations/metrics/batch/batch.py

@@ -3,7 +3,8 @@
 from great_expectations.metrics.metric_results import MetricResult
 
 
-class BatchRowCount(Metric, Batch): ...
+class BatchRowCount(Metric, Batch):
+    name = "table.row_count"
 
 
 class BatchRowCountResult(MetricResult[int]): ...

great_expectations/metrics/column_values/between.py

@@ -6,6 +6,8 @@
 
 
 class ColumnValuesBetween(Metric, ColumnValues):
+    name = "column_values.between.condition"
+
     min_value: Optional[Comparable] = None
     max_value: Optional[Comparable] = None
     strict_min: bool = False

great_expectations/metrics/metric.py

@@ -1,10 +1,9 @@
-import re
 from functools import cache
 from typing import ClassVar, Final
 
 from typing_extensions import dataclass_transform
 
-from great_expectations.compatibility.pydantic import BaseModel, ModelMetaclass
+from great_expectations.compatibility.pydantic import BaseModel, ModelMetaclass, StrictStr
 from great_expectations.metrics.domain import AbstractClassInstantiationError, Domain
 from great_expectations.validator.metric_configuration import (
     MetricConfiguration,
@@ -61,7 +60,7 @@ class Metric(BaseModel, metaclass=MetaMetric):
         MetricConfiguration: Configuration class for metric computation
     """
 
-    name: ClassVar[str]
+    name: ClassVar[StrictStr]
 
     class Config:
         arbitrary_types_allowed = True
@@ -70,7 +69,6 @@ class Config:
     def __new__(cls, *args, **kwargs):
         if cls is Metric:
             raise AbstractClassInstantiationError(cls.__name__)
-        cls.name = cls._get_metric_name()
         return super().__new__(cls)
 
     @property
@@ -84,41 +82,6 @@ def config(self) -> MetricConfiguration:
             metric_value_set=frozenset(self.dict().items()),
         )
 
-    @staticmethod
-    def _pascal_to_snake(class_name: str) -> str:
-        # Adds an underscore between a sequence of uppercase letters and an uppercase-lowercase pair
-        # APIFunctionMetric -> API_FunctionMetric
-        class_name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", class_name)
-        # Adds an underscore between a lowercase letter/digit and an uppercase letter
-        # APIFunctionMetric -> API_Function_Metric
-        class_name = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", class_name)
-        # Convert the entire string to lowercase
-        # API_Function_Metric -> api_function_metric
-        return class_name.lower()
-
-    @classmethod
-    def _get_metric_name(cls) -> str:
-        """The name of the metric as it exists in the registry."""
-        for base_type in cls.__bases__:
-            if issubclass(base_type, Domain):
-                domain_class_name = str(base_type.__name__)
-                metric_class_name = str(cls.__name__)
-                domain_class_snake_case = Metric._pascal_to_snake(domain_class_name)
-                translated_domain_name = domain_class_snake_case.replace("batch", "table")
-                metric_class_snake_case = Metric._pascal_to_snake(metric_class_name)
-                # the convention is that the metric class name includes the domain class name
-                # but the metric names don't repeat the domain name, so we remove it
-                return ".".join(
-                    [
-                        translated_domain_name,
-                        metric_class_snake_case.replace(domain_class_snake_case, "").strip("_"),
-                    ]
-                )
-
-        # this should never be reached
-        # that a Domain exists in __bases__ should have been confirmed in MetaMetric.__new__
-        raise MixinTypeError(cls.__name__, "Domain")
-
     @staticmethod
     @cache
     def _to_config(

tests/metrics/test_metric.py

@@ -34,6 +34,8 @@ class TestMetricDefinition:
     @pytest.mark.unit
     def test_success(self):
         class ColumnValuesAbove(Metric, ColumnValues):
+            name = FULLY_QUALIFIED_METRIC_NAME
+
             min_value: Comparable
             strict_min: bool = False
 
@@ -42,6 +44,8 @@ def test_missing_domain_mixin_raises(self):
         with pytest.raises(MixinTypeError):
 
             class ColumnValuesAbove(Metric):
+                name = FULLY_QUALIFIED_METRIC_NAME
+
                 min_value: Comparable
                 strict_min: bool = False
 
@@ -50,6 +54,8 @@ def test_more_than_one_domain_mixin_raises(self):
         with pytest.raises(MixinTypeError):
 
             class ColumnValuesAbove(Metric, ColumnValues, MockDomain):
+                name = FULLY_QUALIFIED_METRIC_NAME
+
                 min_value: Comparable
                 strict_min: bool = False
 
@@ -58,28 +64,16 @@ def test_non_domain_mixin_raises(self):
         with pytest.raises(MixinTypeError):
 
             class ColumnValuesAbove(Metric, NotADomain):
+                name = FULLY_QUALIFIED_METRIC_NAME
+
                 min_value: Comparable
                 strict_min: bool = False
 
-    @pytest.mark.unit
-    def test_metric_name_inference(self):
-        class ColumnValuesAbove(Metric, ColumnValues):
-            min_value: Comparable
-            strict_min: bool = False
-
-        assert (
-            ColumnValuesAbove(
-                batch_id=BATCH_ID,
-                table=TABLE,
-                column=COLUMN,
-                min_value=42,
-            ).name
-            == FULLY_QUALIFIED_METRIC_NAME
-        )
-
 
 class TestMetricInstantiation:
     class ColumnValuesAbove(Metric, ColumnValues):
+        name = FULLY_QUALIFIED_METRIC_NAME
+
         min_value: Comparable
         strict_min: bool = False
 
@@ -100,6 +94,8 @@ def test_instantiation_missing_domain_parameters_raises(self):
 
 class TestMetricConfig:
     class ColumnValuesAbove(Metric, ColumnValues):
+        name = FULLY_QUALIFIED_METRIC_NAME
+
         min_value: Comparable
         strict_min: bool = False
 
@@ -134,6 +130,8 @@ def test_success(self):
 
 class TestMetricImmutability:
     class ColumnValuesAbove(Metric, ColumnValues):
+        name = FULLY_QUALIFIED_METRIC_NAME
+
         min_value: Comparable
         strict_min: bool = False