From b7ce0aa3d83be469d066c4007f66c802e9fb48d9 Mon Sep 17 00:00:00 2001
From: William Deng <33618746+WilliamDee@users.noreply.github.com>
Date: Tue, 12 Nov 2024 02:19:33 -0500
Subject: [PATCH 1/2] Update support for custom granularity in other types
 (#365)

<!---
Include the number of the issue addressed by this PR above if
applicable.
  PRs for code changes without an associated issue *will not be merged*.
  See CONTRIBUTING.md for more information.
-->

### Description
Support custom grain by switching the typing to be not on
`TimeGranularity`
- `Metric.time_granularity` - `TimeGranularity -> str`
- `Metric.type_params.cumulative_type_params.grain_to_date` -
`TimeGranularity -> str`
- `MetricInput.offset_to_grain` - `TimeGranularity -> str`
- `MetricTimeWindow.granularity` - `TimeGranularity -> str` affects the
following
  - `Metric.type_params.conversion_type_params.window`
  - `Metric.type_params.cumulative_type_params.window`
  - `MetricInput.offset_window`

#### Changes to `MetricTimeWindow`
Because `MetricTimeWindow.granularity` is now a string, we allow it to
be not as strict when ensuring it's a valid granularity during initial
yaml parsing (since we don't have access to the custom granularities).
Then during validations, we will properly validate that it's a valid
grain, and during the transformation step we will remove trailing 's'.


<!---
Describe the Pull Request here. Add any references and info to help
reviewers
  understand your changes. Include any tradeoffs you considered.
-->

### 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)

Resolves SL-2826
---
 .../Breaking Changes-20241108-215906.yaml     |   6 +
 .../implementations/metric.py                 |  45 ++-
 .../default_explicit_schema.json              |  50 +---
 dbt_semantic_interfaces/parsing/schemas.py    |   4 +-
 dbt_semantic_interfaces/protocols/metric.py   |  18 +-
 dbt_semantic_interfaces/test_utils.py         |   4 +-
 .../transformations/cumulative_type_params.py |   2 +-
 .../transformations/pydantic_rule_set.py      |   4 +
 .../remove_plural_from_window_granularity.py  |  89 ++++++
 .../validations/metrics.py                    |  37 ++-
 tests/parsing/test_metric_parsing.py          |  32 +--
 .../test_metric_parsing_with_custom_grain.py  | 262 ++++++++++++++++++
 tests/validations/test_metrics.py             | 123 ++++++--
 13 files changed, 552 insertions(+), 124 deletions(-)
 create mode 100644 .changes/unreleased/Breaking Changes-20241108-215906.yaml
 create mode 100644 dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py
 create mode 100644 tests/parsing/test_metric_parsing_with_custom_grain.py

diff --git a/.changes/unreleased/Breaking Changes-20241108-215906.yaml b/.changes/unreleased/Breaking Changes-20241108-215906.yaml
new file mode 100644
index 00000000..bd9906ff
--- /dev/null
+++ b/.changes/unreleased/Breaking Changes-20241108-215906.yaml	
@@ -0,0 +1,6 @@
+kind: Breaking Changes
+body: Adding support for custom grain in windows/grain_to_dates
+time: 2024-11-08T21:59:06.162076-05:00
+custom:
+    Author: WilliamDee
+    Issue: None
diff --git a/dbt_semantic_interfaces/implementations/metric.py b/dbt_semantic_interfaces/implementations/metric.py
index 02933e5a..204337a7 100644
--- a/dbt_semantic_interfaces/implementations/metric.py
+++ b/dbt_semantic_interfaces/implementations/metric.py
@@ -71,7 +71,7 @@ class PydanticMetricTimeWindow(PydanticCustomInputParser, HashableBaseModel):
     """Describes the window of time the metric should be accumulated over, e.g., '1 day', '2 weeks', etc."""
 
     count: int
-    granularity: TimeGranularity
+    granularity: str
 
     @classmethod
     def _from_yaml_value(cls, input: PydanticParseableValueType) -> PydanticMetricTimeWindow:
@@ -80,21 +80,31 @@ def _from_yaml_value(cls, input: PydanticParseableValueType) -> PydanticMetricTi
         The MetricTimeWindow is always expected to be provided as a string in user-defined YAML configs.
         """
         if isinstance(input, str):
-            return PydanticMetricTimeWindow.parse(input)
+            return PydanticMetricTimeWindow.parse(window=input.lower(), custom_granularity_names=(), strict=False)
         else:
             raise ValueError(
                 f"MetricTimeWindow inputs from model configs are expected to always be of type string, but got "
                 f"type {type(input)} with value: {input}"
             )
 
+    @property
+    def is_standard_granularity(self) -> bool:
+        """Returns whether the window uses standard TimeGranularity."""
+        return self.granularity.casefold() in {item.value.casefold() for item in TimeGranularity}
+
+    @property
+    def window_string(self) -> str:
+        """Returns the string value of the time window."""
+        return f"{self.count} {self.granularity}"
+
     @staticmethod
-    def parse(window: str) -> PydanticMetricTimeWindow:
+    def parse(window: str, custom_granularity_names: Sequence[str], strict: bool = True) -> PydanticMetricTimeWindow:
         """Returns window values if parsing succeeds, None otherwise.
 
-        Output of the form: (<time unit count>, <time granularity>, <error message>) - error message is None if window
-        is formatted properly
+        If strict=True, then the granularity in the window must exist as a valid granularity.
+        Use strict=True for when you have all valid granularities, otherwise use strict=False.
         """
-        parts = window.split(" ")
+        parts = window.lower().split(" ")
         if len(parts) != 2:
             raise ParsingException(
                 f"Invalid window ({window}) in cumulative metric. Should be of the form `<count> <granularity>`, "
@@ -102,14 +112,21 @@ def parse(window: str) -> PydanticMetricTimeWindow:
             )
 
         granularity = parts[1]
+
+        valid_time_granularities = {item.value.lower() for item in TimeGranularity} | set(
+            c.lower() for c in custom_granularity_names
+        )
+
         # if we switched to python 3.9 this could just be `granularity = parts[0].removesuffix('s')
-        if granularity.endswith("s"):
+        if granularity.endswith("s") and granularity[:-1] in valid_time_granularities:
             # months -> month
             granularity = granularity[:-1]
-        if granularity not in [item.value for item in TimeGranularity]:
+
+        if strict and granularity not in valid_time_granularities:
             raise ParsingException(
-                f"Invalid time granularity {granularity} in cumulative metric window string: ({window})",
+                f"Invalid time granularity {granularity} in metric window string: ({window})",
             )
+        # If not strict and not standard granularity, it may be a custom grain, so validations happens later
 
         count = parts[0]
         if not count.isdigit():
@@ -117,7 +134,7 @@ def parse(window: str) -> PydanticMetricTimeWindow:
 
         return PydanticMetricTimeWindow(
             count=int(count),
-            granularity=TimeGranularity(granularity),
+            granularity=granularity,
         )
 
 
@@ -135,7 +152,7 @@ class PydanticMetricInput(HashableBaseModel):
     filter: Optional[PydanticWhereFilterIntersection]
     alias: Optional[str]
     offset_window: Optional[PydanticMetricTimeWindow]
-    offset_to_grain: Optional[TimeGranularity]
+    offset_to_grain: Optional[str]
 
     @property
     def as_reference(self) -> MetricReference:
@@ -163,7 +180,7 @@ class PydanticCumulativeTypeParams(HashableBaseModel):
     """Type params to provide context for cumulative metrics properties."""
 
     window: Optional[PydanticMetricTimeWindow]
-    grain_to_date: Optional[TimeGranularity]
+    grain_to_date: Optional[str]
     period_agg: PeriodAggregation = PeriodAggregation.FIRST
 
 
@@ -174,7 +191,9 @@ class PydanticMetricTypeParams(HashableBaseModel):
     numerator: Optional[PydanticMetricInput]
     denominator: Optional[PydanticMetricInput]
     expr: Optional[str]
+    # Legacy, supports custom grain through PydanticMetricTimeWindow changes (should deprecate though)
     window: Optional[PydanticMetricTimeWindow]
+    # Legacy, will not support custom granularity
     grain_to_date: Optional[TimeGranularity]
     metrics: Optional[List[PydanticMetricInput]]
     conversion_type_params: Optional[PydanticConversionTypeParams]
@@ -206,7 +225,7 @@ def _implements_protocol(self) -> Metric:  # noqa: D
     metadata: Optional[PydanticMetadata]
     label: Optional[str] = None
     config: Optional[PydanticMetricConfig]
-    time_granularity: Optional[TimeGranularity] = None
+    time_granularity: Optional[str] = None
 
     @property
     def input_measures(self) -> Sequence[PydanticMetricInputMeasure]:
diff --git a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
index 613bffd7..62b682a6 100644
--- a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
+++ b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
@@ -77,30 +77,7 @@
             "additionalProperties": false,
             "properties": {
                 "grain_to_date": {
-                    "enum": [
-                        "NANOSECOND",
-                        "MICROSECOND",
-                        "MILLISECOND",
-                        "SECOND",
-                        "MINUTE",
-                        "HOUR",
-                        "DAY",
-                        "WEEK",
-                        "MONTH",
-                        "QUARTER",
-                        "YEAR",
-                        "nanosecond",
-                        "microsecond",
-                        "millisecond",
-                        "second",
-                        "minute",
-                        "hour",
-                        "day",
-                        "week",
-                        "month",
-                        "quarter",
-                        "year"
-                    ]
+                    "type": "string"
                 },
                 "period_agg": {
                     "enum": [
@@ -488,30 +465,7 @@
                     "type": "string"
                 },
                 "time_granularity": {
-                    "enum": [
-                        "NANOSECOND",
-                        "MICROSECOND",
-                        "MILLISECOND",
-                        "SECOND",
-                        "MINUTE",
-                        "HOUR",
-                        "DAY",
-                        "WEEK",
-                        "MONTH",
-                        "QUARTER",
-                        "YEAR",
-                        "nanosecond",
-                        "microsecond",
-                        "millisecond",
-                        "second",
-                        "minute",
-                        "hour",
-                        "day",
-                        "week",
-                        "month",
-                        "quarter",
-                        "year"
-                    ]
+                    "type": "string"
                 },
                 "type": {
                     "enum": [
diff --git a/dbt_semantic_interfaces/parsing/schemas.py b/dbt_semantic_interfaces/parsing/schemas.py
index 66652535..16d1e8bd 100644
--- a/dbt_semantic_interfaces/parsing/schemas.py
+++ b/dbt_semantic_interfaces/parsing/schemas.py
@@ -123,7 +123,7 @@
     "type": "object",
     "properties": {
         "window": {"type": "string"},
-        "grain_to_date": {"enum": time_granularity_values},
+        "grain_to_date": {"type": "string"},
         "period_agg": {"enum": period_agg_values},
     },
     "additionalProperties": False,
@@ -304,7 +304,7 @@
         "description": {"type": "string"},
         "label": {"type": "string"},
         "config": {"$ref": "metric_config_schema"},
-        "time_granularity": {"enum": time_granularity_values},
+        "time_granularity": {"type": "string"},
     },
     "additionalProperties": False,
     "required": ["name", "type", "type_params"],
diff --git a/dbt_semantic_interfaces/protocols/metric.py b/dbt_semantic_interfaces/protocols/metric.py
index 9ccf931e..a53d4102 100644
--- a/dbt_semantic_interfaces/protocols/metric.py
+++ b/dbt_semantic_interfaces/protocols/metric.py
@@ -72,7 +72,17 @@ def count(self) -> int:  # noqa: D
 
     @property
     @abstractmethod
-    def granularity(self) -> TimeGranularity:  # noqa: D
+    def granularity(self) -> str:  # noqa: D
+        pass
+
+    @property
+    @abstractmethod
+    def window_string(self) -> str:  # noqa: D
+        pass
+
+    @property
+    @abstractmethod
+    def is_standard_granularity(self) -> bool:  # noqa: D
         pass
 
 
@@ -102,7 +112,7 @@ def offset_window(self) -> Optional[MetricTimeWindow]:  # noqa: D
 
     @property
     @abstractmethod
-    def offset_to_grain(self) -> Optional[TimeGranularity]:  # noqa: D
+    def offset_to_grain(self) -> Optional[str]:  # noqa: D
         pass
 
     @property
@@ -189,7 +199,7 @@ def window(self) -> Optional[MetricTimeWindow]:  # noqa: D
 
     @property
     @abstractmethod
-    def grain_to_date(self) -> Optional[TimeGranularity]:  # noqa: D
+    def grain_to_date(self) -> Optional[str]:  # noqa: D
         pass
 
     @property
@@ -328,7 +338,7 @@ def label(self) -> Optional[str]:
 
     @property
     @abstractmethod
-    def time_granularity(self) -> Optional[TimeGranularity]:
+    def time_granularity(self) -> Optional[str]:
         """Default grain used for the metric.
 
         This will be used in a couple of circumstances:
diff --git a/dbt_semantic_interfaces/test_utils.py b/dbt_semantic_interfaces/test_utils.py
index fc9a01b2..a6912fac 100644
--- a/dbt_semantic_interfaces/test_utils.py
+++ b/dbt_semantic_interfaces/test_utils.py
@@ -24,7 +24,7 @@
     PydanticSemanticModel,
 )
 from dbt_semantic_interfaces.parsing.objects import YamlConfigFile
-from dbt_semantic_interfaces.type_enums import MetricType, TimeGranularity
+from dbt_semantic_interfaces.type_enums import MetricType
 from dbt_semantic_interfaces.validations.validator_helpers import (
     SemanticManifestValidationResults,
     ValidationIssue,
@@ -127,7 +127,7 @@ def metric_with_guaranteed_meta(
     type_params: PydanticMetricTypeParams,
     metadata: PydanticMetadata = default_meta(),
     description: str = "adhoc metric",
-    time_granularity: Optional[TimeGranularity] = None,
+    time_granularity: Optional[str] = None,
 ) -> PydanticMetric:
     """Creates a metric with the given input.
 
diff --git a/dbt_semantic_interfaces/transformations/cumulative_type_params.py b/dbt_semantic_interfaces/transformations/cumulative_type_params.py
index 7526aaca..2a40ff4c 100644
--- a/dbt_semantic_interfaces/transformations/cumulative_type_params.py
+++ b/dbt_semantic_interfaces/transformations/cumulative_type_params.py
@@ -36,6 +36,6 @@ def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSema
                 if metric.type_params.window and not metric.type_params.cumulative_type_params.window:
                     metric.type_params.cumulative_type_params.window = metric.type_params.window
                 if metric.type_params.grain_to_date and not metric.type_params.cumulative_type_params.grain_to_date:
-                    metric.type_params.cumulative_type_params.grain_to_date = metric.type_params.grain_to_date
+                    metric.type_params.cumulative_type_params.grain_to_date = metric.type_params.grain_to_date.value
 
         return semantic_manifest
diff --git a/dbt_semantic_interfaces/transformations/pydantic_rule_set.py b/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
index 7c2f4568..f8cf43ff 100644
--- a/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
+++ b/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
@@ -22,6 +22,9 @@
 )
 from dbt_semantic_interfaces.transformations.names import LowerCaseNamesRule
 from dbt_semantic_interfaces.transformations.proxy_measure import CreateProxyMeasureRule
+from dbt_semantic_interfaces.transformations.remove_plural_from_window_granularity import (
+    RemovePluralFromWindowGranularityRule,
+)
 from dbt_semantic_interfaces.transformations.rule_set import (
     SemanticManifestTransformRuleSet,
 )
@@ -54,6 +57,7 @@ def secondary_rules(self) -> Sequence[SemanticManifestTransformRule[PydanticSema
             ConvertMedianToPercentileRule(),
             AddInputMetricMeasuresRule(),
             SetCumulativeTypeParamsRule(),
+            RemovePluralFromWindowGranularityRule(),
         )
 
     @property
diff --git a/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py b/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py
new file mode 100644
index 00000000..9e5fb5f4
--- /dev/null
+++ b/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py
@@ -0,0 +1,89 @@
+from typing import Sequence
+
+from typing_extensions import override
+
+from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
+from dbt_semantic_interfaces.errors import ModelTransformError
+from dbt_semantic_interfaces.implementations.metric import PydanticMetricTimeWindow
+from dbt_semantic_interfaces.implementations.semantic_manifest import (
+    PydanticSemanticManifest,
+)
+from dbt_semantic_interfaces.protocols import ProtocolHint
+from dbt_semantic_interfaces.transformations.transform_rule import (
+    SemanticManifestTransformRule,
+)
+from dbt_semantic_interfaces.type_enums import MetricType
+
+
+class RemovePluralFromWindowGranularityRule(ProtocolHint[SemanticManifestTransformRule[PydanticSemanticManifest]]):
+    """Remove trailing s from granularity in MetricTimeWindow.
+
+    During parsing, MetricTimeWindow.granularity can still contain he trailing 's' (ie., 3 days).
+    This is because with the introduction of custom granularities, we don't have access to the valid
+    custom grains during parsing. This transformation rule is introduced to remove the trailing 's'
+    from `MetricTimeWindow.granularity` if necessary.
+    """
+
+    @override
+    def _implements_protocol(self) -> SemanticManifestTransformRule[PydanticSemanticManifest]:  # noqa: D
+        return self
+
+    @staticmethod
+    def _update_metric(
+        semantic_manifest: PydanticSemanticManifest, metric_name: str, custom_granularity_names: Sequence[str]
+    ) -> None:
+        """Mutates all the MetricTimeWindow by reparsing to remove the trailing 's'."""
+
+        def reparse_window(window: PydanticMetricTimeWindow) -> PydanticMetricTimeWindow:
+            """Reparse the window to remove the trailing 's'."""
+            return PydanticMetricTimeWindow.parse(
+                window=window.window_string, custom_granularity_names=custom_granularity_names
+            )
+
+        matched_metric = next(
+            iter((metric for metric in semantic_manifest.metrics if metric.name == metric_name)), None
+        )
+        if matched_metric:
+            if matched_metric.type is MetricType.CUMULATIVE:
+                if (
+                    matched_metric.type_params.cumulative_type_params
+                    and matched_metric.type_params.cumulative_type_params.window
+                ):
+                    matched_metric.type_params.cumulative_type_params.window = reparse_window(
+                        matched_metric.type_params.cumulative_type_params.window
+                    )
+            elif matched_metric.type is MetricType.CONVERSION:
+                if (
+                    matched_metric.type_params.conversion_type_params
+                    and matched_metric.type_params.conversion_type_params.window
+                ):
+                    matched_metric.type_params.conversion_type_params.window = reparse_window(
+                        matched_metric.type_params.conversion_type_params.window
+                    )
+
+            elif matched_metric.type is MetricType.DERIVED or matched_metric.type is MetricType.RATIO:
+                for input_metric in matched_metric.input_metrics:
+                    if input_metric.offset_window:
+                        input_metric.offset_window = reparse_window(input_metric.offset_window)
+            elif matched_metric.type is MetricType.SIMPLE:
+                pass
+            else:
+                assert_values_exhausted(matched_metric.type)
+        else:
+            raise ModelTransformError(f"Metric '{metric_name}' is not configured as a metric in the model.")
+
+    @staticmethod
+    def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSemanticManifest:  # noqa: D
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
+        for metric in semantic_manifest.metrics:
+            RemovePluralFromWindowGranularityRule._update_metric(
+                semantic_manifest=semantic_manifest,
+                metric_name=metric.name,
+                custom_granularity_names=custom_granularity_names,
+            )
+        return semantic_manifest
diff --git a/dbt_semantic_interfaces/validations/metrics.py b/dbt_semantic_interfaces/validations/metrics.py
index 80278a51..83c9b0ee 100644
--- a/dbt_semantic_interfaces/validations/metrics.py
+++ b/dbt_semantic_interfaces/validations/metrics.py
@@ -51,6 +51,12 @@ class CumulativeMetricRule(SemanticManifestValidationRule[SemanticManifestT], Ge
     def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[ValidationIssue]:  # noqa: D
         issues: List[ValidationIssue] = []
 
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
         for metric in semantic_manifest.metrics or []:
             if metric.type != MetricType.CUMULATIVE:
                 continue
@@ -90,7 +96,7 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
             window = metric.type_params.window
             if metric.type_params.cumulative_type_params and metric.type_params.cumulative_type_params.window:
                 window = metric.type_params.cumulative_type_params.window
-            grain_to_date = metric.type_params.grain_to_date
+            grain_to_date = metric.type_params.grain_to_date.value if metric.type_params.grain_to_date else None
             if metric.type_params.cumulative_type_params and metric.type_params.cumulative_type_params.grain_to_date:
                 grain_to_date = metric.type_params.cumulative_type_params.grain_to_date
             if window and grain_to_date:
@@ -103,9 +109,10 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
 
             if window:
                 try:
-                    window_str = f"{window.count} {window.granularity.value}"
                     # TODO: Should not call an implementation class.
-                    PydanticMetricTimeWindow.parse(window_str)
+                    PydanticMetricTimeWindow.parse(
+                        window=window.window_string, custom_granularity_names=custom_granularity_names
+                    )
                 except ParsingException as e:
                     issues.append(
                         ValidationError(
@@ -252,14 +259,16 @@ class ConversionMetricRule(SemanticManifestValidationRule[SemanticManifestT], Ge
 
     @staticmethod
     @validate_safely(whats_being_done="checking that the params of metric are valid if it is a conversion metric")
-    def _validate_type_params(metric: Metric, conversion_type_params: ConversionTypeParams) -> List[ValidationIssue]:
+    def _validate_type_params(
+        metric: Metric, conversion_type_params: ConversionTypeParams, custom_granularity_names: Sequence[str]
+    ) -> List[ValidationIssue]:
         issues: List[ValidationIssue] = []
 
         window = conversion_type_params.window
         if window:
             try:
-                window_str = f"{window.count} {window.granularity.value}"
-                PydanticMetricTimeWindow.parse(window_str)
+                window_str = f"{window.count} {window.granularity}"
+                PydanticMetricTimeWindow.parse(window=window_str, custom_granularity_names=custom_granularity_names)
             except ParsingException as e:
                 issues.append(
                     ValidationError(
@@ -421,6 +430,12 @@ def _get_semantic_model_from_measure(
     def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[ValidationIssue]:  # noqa: D
         issues: List[ValidationIssue] = []
 
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
         for metric in semantic_manifest.metrics or []:
             if metric.type == MetricType.CONVERSION:
                 # Validates that the measure exists and corresponds to a semantic model
@@ -461,7 +476,9 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
                     conversion_semantic_model=conversion_semantic_model,
                 )
                 issues += ConversionMetricRule._validate_type_params(
-                    metric=metric, conversion_type_params=metric.type_params.conversion_type_params
+                    metric=metric,
+                    conversion_type_params=metric.type_params.conversion_type_params,
+                    custom_granularity_names=custom_granularity_names,
                 )
                 issues += ConversionMetricRule._validate_constant_properties(
                     metric=metric,
@@ -532,11 +549,11 @@ def _validate_metric(
                 )
                 return issues
             valid_granularities = [
-                granularity.name
+                granularity.value
                 for granularity in TimeGranularity
                 if granularity.to_int() >= min_queryable_granularity.to_int()
             ]
-            if metric.time_granularity.name not in valid_granularities:
+            if metric.time_granularity not in valid_granularities:
                 issues.append(
                     ValidationError(
                         context=context,
@@ -544,7 +561,7 @@ def _validate_metric(
                             f"`time_granularity` for metric '{metric.name}' must be >= "
                             f"{min_queryable_granularity.name}. Valid options are those that are >= the largest "
                             f"granularity defined for the metric's measures' agg_time_dimensions. Got: "
-                            f"{metric.time_granularity.name}. Valid options: {valid_granularities}"
+                            f"{metric.time_granularity}. Valid options: {valid_granularities}"
                         ),
                     )
                 )
diff --git a/tests/parsing/test_metric_parsing.py b/tests/parsing/test_metric_parsing.py
index f35262b5..79064519 100644
--- a/tests/parsing/test_metric_parsing.py
+++ b/tests/parsing/test_metric_parsing.py
@@ -212,7 +212,7 @@ def test_cumulative_window_metric_parsing() -> None:
           type_params:
             measure:
               name: cumulative_measure
-            window: "7 days"
+            window: "7 Days"
         """
     )
     file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
@@ -224,7 +224,7 @@ def test_cumulative_window_metric_parsing() -> None:
     assert metric.name == "cumulative_test"
     assert metric.type is MetricType.CUMULATIVE
     assert metric.type_params.measure == PydanticMetricInputMeasure(name="cumulative_measure")
-    assert metric.type_params.window == PydanticMetricTimeWindow(count=7, granularity=TimeGranularity.DAY)
+    assert metric.type_params.window == PydanticMetricTimeWindow(count=7, granularity=TimeGranularity.DAY.value)
 
 
 def test_grain_to_date_metric_parsing() -> None:
@@ -237,7 +237,7 @@ def test_grain_to_date_metric_parsing() -> None:
           type_params:
             measure:
               name: cumulative_measure
-            grain_to_date: "week"
+            grain_to_date: "weEk"
         """
     )
     file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
@@ -281,7 +281,7 @@ def test_derived_metric_offset_window_parsing() -> None:
     assert metric.type_params.metrics and len(metric.type_params.metrics) == 2
     metric1, metric2 = metric.type_params.metrics
     assert metric1.offset_window is None
-    assert metric2.offset_window == PydanticMetricTimeWindow(count=14, granularity=TimeGranularity.DAY)
+    assert metric2.offset_window == PydanticMetricTimeWindow(count=14, granularity=TimeGranularity.DAY.value)
     assert metric1.alias is None
     assert metric2.alias == "bookings_2_weeks_ago"
     assert metric.type_params.expr == "bookings / bookings_2_weeks_ago"
@@ -315,7 +315,7 @@ def test_derive_metric_offset_to_grain_parsing() -> None:
     assert metric.type_params.metrics and len(metric.type_params.metrics) == 2
     metric1, metric2 = metric.type_params.metrics
     assert metric1.offset_to_grain is None
-    assert metric2.offset_to_grain == TimeGranularity.MONTH
+    assert metric2.offset_to_grain == TimeGranularity.MONTH.value
     assert metric1.alias is None
     assert metric2.alias == "bookings_at_start_of_month"
     assert metric.type_params.expr == "bookings / bookings_at_start_of_month"
@@ -449,7 +449,7 @@ def test_conversion_metric_parsing() -> None:
         name="conversions"
     )
     assert metric.type_params.conversion_type_params.window == PydanticMetricTimeWindow(
-        count=7, granularity=TimeGranularity.DAY
+        count=7, granularity=TimeGranularity.DAY.value
     )
     assert metric.type_params.conversion_type_params.entity == "user"
     assert metric.type_params.conversion_type_params.calculation == ConversionCalculationType.CONVERSION_RATE
@@ -538,26 +538,6 @@ def test_invalid_cumulative_metric_window_format_parsing_error() -> None:
     assert "Invalid window" in str(SemanticManifestValidationException(build_result.issues.all_issues))
 
 
-def test_invalid_cumulative_metric_window_granularity_parsing_error() -> None:
-    """Test for errror detection when parsing malformed cumulative metric window entries."""
-    yaml_contents = textwrap.dedent(
-        """\
-        metric:
-          name: invalid_cumulative_granularity_test
-          type: cumulative
-          type_params:
-            measure:
-              name: cumulative_measure
-            window: "7 moons"
-        """
-    )
-    file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
-
-    build_result = parse_yaml_files_to_semantic_manifest(files=[file, EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE])
-    assert build_result.issues.has_blocking_issues
-    assert "Invalid time granularity" in str(SemanticManifestValidationException(build_result.issues.all_issues))
-
-
 def test_invalid_cumulative_metric_window_count_parsing_error() -> None:
     """Test for errror detection when parsing malformed cumulative metric window entries."""
     yaml_contents = textwrap.dedent(
diff --git a/tests/parsing/test_metric_parsing_with_custom_grain.py b/tests/parsing/test_metric_parsing_with_custom_grain.py
new file mode 100644
index 00000000..2100829e
--- /dev/null
+++ b/tests/parsing/test_metric_parsing_with_custom_grain.py
@@ -0,0 +1,262 @@
+import textwrap
+
+from dbt_semantic_interfaces.parsing.dir_to_model import (
+    parse_yaml_files_to_validation_ready_semantic_manifest,
+)
+from dbt_semantic_interfaces.parsing.objects import YamlConfigFile
+from dbt_semantic_interfaces.test_utils import base_semantic_manifest_file
+from tests.example_project_configuration import (
+    EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE,
+)
+
+
+def test_cumulative_metric_with_custom_grain_to_date() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_cumulative_metric_with_custom_grain_to_date"
+          description: "Test cumulative grain to date with custom granularity"
+          type: cumulative
+          type_params:
+            measure:
+              name: bookings
+            cumulative_type_params:
+              grain_to_date: martian_week
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next(
+        (m for m in semantic_manifest.metrics if m.name == "test_cumulative_metric_with_custom_grain_to_date"), None
+    )
+    assert metric is not None, "Can't find metric"
+    assert (
+        metric.type_params.cumulative_type_params
+        and metric.type_params.cumulative_type_params.grain_to_date == "martian_week"
+    )
+
+
+def test_cumulative_metric_with_custom_window() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_cumulative_metric_with_custom_window"
+          description: "Test cumulative window with custom granularity"
+          type: cumulative
+          time_granularity: martian_week
+          type_params:
+            measure:
+              name: bookings
+            cumulative_type_params:
+              window: 5 martian_weeks
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next((m for m in semantic_manifest.metrics if m.name == "test_cumulative_metric_with_custom_window"), None)
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert (
+        metric.type_params.cumulative_type_params
+        and metric.type_params.cumulative_type_params.window
+        and metric.type_params.cumulative_type_params.window.window_string == "5 martian_week"
+    )
+
+
+def test_conversion_metric_with_custom_grain_window() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_conversion_metric_with_custom_grain_window"
+          description: "Test conversion metric window with custom granularity"
+          type: conversion
+          type_params:
+            conversion_type_params:
+              base_measure: bookings
+              conversion_measure: bookings
+              window: 7 martian_weeks
+              entity: user
+              calculation: conversion_rate
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next(
+        (m for m in semantic_manifest.metrics if m.name == "test_conversion_metric_with_custom_grain_window"), None
+    )
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert (
+        metric.type_params.conversion_type_params
+        and metric.type_params.conversion_type_params.window
+        and metric.type_params.conversion_type_params.window.window_string == "7 martian_week"
+    )
+
+
+def test_input_metric_custom_grains() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_input_metric_custom_grains"
+          description: "Test custom granularity support in input metrics"
+          type: derived
+          type_params:
+            expr: bookings_offset_to_grain - bookings_offset_window
+            metrics:
+              - name: bookings
+                offset_to_grain: martian_week
+                alias: bookings_offset_to_grain
+              - name: bookings
+                offset_window: 14 martian_weeks
+                alias: bookings_offset_window
+        """
+    )
+
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next((m for m in semantic_manifest.metrics if m.name == "test_input_metric_custom_grains"), None)
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert metric.type_params.metrics and {
+        m.offset_to_grain or (m.offset_window.window_string if m.offset_window else None)
+        for m in metric.type_params.metrics
+    } == {
+        "martian_week",
+        "14 martian_week",
+    }
diff --git a/tests/validations/test_metrics.py b/tests/validations/test_metrics.py
index c96d23b3..3e02ce65 100644
--- a/tests/validations/test_metrics.py
+++ b/tests/validations/test_metrics.py
@@ -303,10 +303,13 @@ def test_derived_metric() -> None:  # noqa: D
                         expr="random_metric / random_metric3",
                         metrics=[
                             PydanticMetricInput(
-                                name="random_metric", offset_window=PydanticMetricTimeWindow.parse("3 weeks")
+                                name="random_metric",
+                                offset_window=PydanticMetricTimeWindow.parse("3 weeks", custom_granularity_names=()),
                             ),
                             PydanticMetricInput(
-                                name="random_metric", offset_to_grain=TimeGranularity.MONTH, alias="random_metric3"
+                                name="random_metric",
+                                offset_to_grain=TimeGranularity.MONTH.value,
+                                alias="random_metric3",
                             ),
                         ],
                     ),
@@ -319,8 +322,8 @@ def test_derived_metric() -> None:  # noqa: D
                         metrics=[
                             PydanticMetricInput(
                                 name="random_metric",
-                                offset_window=PydanticMetricTimeWindow.parse("3 weeks"),
-                                offset_to_grain=TimeGranularity.MONTH,
+                                offset_window=PydanticMetricTimeWindow.parse("3 weeks", custom_granularity_names=()),
+                                offset_to_grain=TimeGranularity.MONTH.value,
                             )
                         ],
                     ),
@@ -348,7 +351,7 @@ def test_conversion_metrics() -> None:  # noqa: D
     entity = "entity"
     invalid_entity = "bad"
     invalid_measure = "invalid_measure"
-    window = PydanticMetricTimeWindow.parse("7 days")
+    window = PydanticMetricTimeWindow.parse("7 days", custom_granularity_names=())
     validator = SemanticManifestValidator[PydanticSemanticManifest]([ConversionMetricRule()])
     result = validator.validate_semantic_manifest(
         PydanticSemanticManifest(
@@ -466,13 +469,59 @@ def test_conversion_metrics() -> None:  # noqa: D
                         )
                     ),
                 ),
+                metric_with_guaranteed_meta(
+                    name="bad_window",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse("7 moons", custom_granularity_names=(), strict=False),
+                            entity=entity,
+                        )
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse(
+                                "7 martian_week", custom_granularity_names=("martian_week",)
+                            ),
+                            entity=entity,
+                        )
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window_plural",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse(
+                                "7 martian_weeks", custom_granularity_names=("martian_week",)
+                            ),
+                            entity=entity,
+                        )
+                    ),
+                ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,
         )
     )
 
     build_issues = result.all_issues
-    assert len(result.errors) == 5
+    assert len(result.errors) == 6
     assert len(result.warnings) == 1
 
     expected_substrings = [
@@ -482,6 +531,7 @@ def test_conversion_metrics() -> None:  # noqa: D
         "The provided constant property: bad_dim, cannot be found",
         "The provided constant property: bad_dim2, cannot be found",
         "filtering on a conversion input measure is not fully supported yet",
+        "Invalid time granularity",
     ]
     check_error_in_issues(error_substrings=expected_substrings, issues=build_issues)
 
@@ -519,7 +569,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                        window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                         cumulative_type_params=PydanticCumulativeTypeParams(period_agg=PeriodAggregation.LAST),
                     ),
                 ),
@@ -538,7 +588,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                             period_agg=PeriodAggregation.AVERAGE,
                         ),
                     ),
@@ -548,7 +598,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        cumulative_type_params=PydanticCumulativeTypeParams(grain_to_date=TimeGranularity.MONTH),
+                        cumulative_type_params=PydanticCumulativeTypeParams(grain_to_date=TimeGranularity.MONTH.value),
                     ),
                 ),
                 # Metric with both window & grain across both type_params - should get warning
@@ -559,7 +609,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         grain_to_date=TimeGranularity.MONTH,
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                             period_agg=PeriodAggregation.FIRST,
                         ),
                     ),
@@ -572,7 +622,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         grain_to_date=TimeGranularity.YEAR,
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            grain_to_date=TimeGranularity.HOUR,
+                            grain_to_date=TimeGranularity.HOUR.value,
                         ),
                     ),
                 ),
@@ -581,9 +631,9 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        window=PydanticMetricTimeWindow(count=2, granularity=TimeGranularity.QUARTER),
+                        window=PydanticMetricTimeWindow(count=2, granularity=TimeGranularity.QUARTER.value),
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.QUARTER),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.QUARTER.value),
                         ),
                     ),
                 ),
@@ -596,14 +646,51 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         cumulative_type_params=PydanticCumulativeTypeParams(period_agg=PeriodAggregation.FIRST),
                     ),
                 ),
+                metric_with_guaranteed_meta(
+                    name="bad_window",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 moons", custom_granularity_names=(), strict=False
+                            ),
+                        ),
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 martian_week", custom_granularity_names=("martian_week",), strict=False
+                            ),
+                        ),
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window_plural",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 martian_weeks", custom_granularity_names=("martian_week",), strict=False
+                            ),
+                        ),
+                    ),
+                ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,
         )
     )
 
     build_issues = validation_results.all_issues
-    assert len(build_issues) == 3
+    assert len(build_issues) == 4
     expected_substrings = [
+        "Invalid time granularity",
         "Both window and grain_to_date set for cumulative metric. Please set one or the other.",
         "Got differing values for `window`",
         "Got differing values for `grain_to_date`",
@@ -660,7 +747,7 @@ def test_time_granularity() -> None:
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=week_measure_name),
                     ),
-                    time_granularity=TimeGranularity.MONTH,
+                    time_granularity=TimeGranularity.MONTH.value,
                 ),
                 metric_with_guaranteed_meta(
                     name="month_metric_with_invalid_time_granularity",
@@ -668,7 +755,7 @@ def test_time_granularity() -> None:
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=month_measure_name),
                     ),
-                    time_granularity=TimeGranularity.WEEK,
+                    time_granularity=TimeGranularity.WEEK.value,
                 ),
                 # Derived metrics
                 metric_with_guaranteed_meta(
@@ -691,7 +778,7 @@ def test_time_granularity() -> None:
                         ],
                         expr=("week_metric_with_valid_time_granularity + month_metric_with_no_time_granularity_set"),
                     ),
-                    time_granularity=TimeGranularity.YEAR,
+                    time_granularity=TimeGranularity.YEAR.value,
                 ),
                 metric_with_guaranteed_meta(
                     name="derived_metric_with_invalid_time_granularity",
@@ -703,7 +790,7 @@ def test_time_granularity() -> None:
                         ],
                         expr=("week_metric_with_valid_time_granularity + month_metric_with_no_time_granularity_set"),
                     ),
-                    time_granularity=TimeGranularity.DAY,
+                    time_granularity=TimeGranularity.DAY.value,
                 ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,

From c833632025d30455149d0b6b24311c650639a16b Mon Sep 17 00:00:00 2001
From: Devon Fulcher <24593113+DevonFulcher@users.noreply.github.com>
Date: Tue, 12 Nov 2024 13:36:25 -0600
Subject: [PATCH 2/2] Add meta to measures, entities, and dimensions (#358)

### Description

This PR is modeled off of
[this](https://github.com/dbt-labs/dbt-semantic-interfaces/pull/250)
prior PR. This PR adds meta to measures, entities, and dimensions.

### 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)
---
 .../unreleased/Features-20241023-113450.yaml  |  6 +++
 .../implementations/element_config.py         | 18 +++++++
 .../implementations/elements/dimension.py     |  4 ++
 .../implementations/elements/entity.py        |  4 ++
 .../implementations/elements/measure.py       |  4 ++
 .../default_explicit_schema.json              | 48 +++++++++++++++++++
 dbt_semantic_interfaces/parsing/schemas.py    | 34 +++++++++++++
 .../protocols/dimension.py                    |  6 +++
 dbt_semantic_interfaces/protocols/entity.py   |  6 +++
 dbt_semantic_interfaces/protocols/measure.py  |  6 +++
 dbt_semantic_interfaces/protocols/meta.py     | 12 +++++
 tests/parsing/test_semantic_model_parsing.py  | 11 ++++-
 tests/test_implements_satisfy_protocols.py    |  7 +++
 13 files changed, 164 insertions(+), 2 deletions(-)
 create mode 100644 .changes/unreleased/Features-20241023-113450.yaml
 create mode 100644 dbt_semantic_interfaces/implementations/element_config.py
 create mode 100644 dbt_semantic_interfaces/protocols/meta.py

diff --git a/.changes/unreleased/Features-20241023-113450.yaml b/.changes/unreleased/Features-20241023-113450.yaml
new file mode 100644
index 00000000..0eda8b80
--- /dev/null
+++ b/.changes/unreleased/Features-20241023-113450.yaml
@@ -0,0 +1,6 @@
+kind: Features
+body: Support meta for dimensions, entities, and measures
+time: 2024-10-23T11:34:50.577294-05:00
+custom:
+    Author: DevonFulcher
+    Issue: None
diff --git a/dbt_semantic_interfaces/implementations/element_config.py b/dbt_semantic_interfaces/implementations/element_config.py
new file mode 100644
index 00000000..d8ec41dd
--- /dev/null
+++ b/dbt_semantic_interfaces/implementations/element_config.py
@@ -0,0 +1,18 @@
+from typing import Any, Dict
+
+from pydantic import Field
+from typing_extensions import override
+
+from dbt_semantic_interfaces.implementations.base import HashableBaseModel
+from dbt_semantic_interfaces.protocols.meta import SemanticLayerElementConfig
+from dbt_semantic_interfaces.protocols.protocol_hint import ProtocolHint
+
+
+class PydanticSemanticLayerElementConfig(HashableBaseModel, ProtocolHint[SemanticLayerElementConfig]):
+    """PydanticDimension config."""
+
+    @override
+    def _implements_protocol(self) -> SemanticLayerElementConfig:  # noqa: D
+        return self
+
+    meta: Dict[str, Any] = Field(default_factory=dict)
diff --git a/dbt_semantic_interfaces/implementations/elements/dimension.py b/dbt_semantic_interfaces/implementations/elements/dimension.py
index c3cfa2e4..a4cb5a03 100644
--- a/dbt_semantic_interfaces/implementations/elements/dimension.py
+++ b/dbt_semantic_interfaces/implementations/elements/dimension.py
@@ -6,6 +6,9 @@
     HashableBaseModel,
     ModelWithMetadataParsing,
 )
+from dbt_semantic_interfaces.implementations.element_config import (
+    PydanticSemanticLayerElementConfig,
+)
 from dbt_semantic_interfaces.implementations.metadata import PydanticMetadata
 from dbt_semantic_interfaces.references import (
     DimensionReference,
@@ -48,6 +51,7 @@ class PydanticDimension(HashableBaseModel, ModelWithMetadataParsing):
     expr: Optional[str] = None
     metadata: Optional[PydanticMetadata]
     label: Optional[str] = None
+    config: Optional[PydanticSemanticLayerElementConfig]
 
     @property
     def reference(self) -> DimensionReference:  # noqa: D
diff --git a/dbt_semantic_interfaces/implementations/elements/entity.py b/dbt_semantic_interfaces/implementations/elements/entity.py
index ac98e4db..9a6557e8 100644
--- a/dbt_semantic_interfaces/implementations/elements/entity.py
+++ b/dbt_semantic_interfaces/implementations/elements/entity.py
@@ -6,6 +6,9 @@
     HashableBaseModel,
     ModelWithMetadataParsing,
 )
+from dbt_semantic_interfaces.implementations.element_config import (
+    PydanticSemanticLayerElementConfig,
+)
 from dbt_semantic_interfaces.implementations.metadata import PydanticMetadata
 from dbt_semantic_interfaces.references import EntityReference
 from dbt_semantic_interfaces.type_enums import EntityType
@@ -21,6 +24,7 @@ class PydanticEntity(HashableBaseModel, ModelWithMetadataParsing):
     expr: Optional[str] = None
     metadata: Optional[PydanticMetadata] = None
     label: Optional[str] = None
+    config: Optional[PydanticSemanticLayerElementConfig]
 
     @property
     def reference(self) -> EntityReference:  # noqa: D
diff --git a/dbt_semantic_interfaces/implementations/elements/measure.py b/dbt_semantic_interfaces/implementations/elements/measure.py
index 5da1da4f..f3c88c00 100644
--- a/dbt_semantic_interfaces/implementations/elements/measure.py
+++ b/dbt_semantic_interfaces/implementations/elements/measure.py
@@ -6,6 +6,9 @@
     HashableBaseModel,
     ModelWithMetadataParsing,
 )
+from dbt_semantic_interfaces.implementations.element_config import (
+    PydanticSemanticLayerElementConfig,
+)
 from dbt_semantic_interfaces.implementations.metadata import PydanticMetadata
 from dbt_semantic_interfaces.references import MeasureReference
 from dbt_semantic_interfaces.type_enums import AggregationType
@@ -46,6 +49,7 @@ class PydanticMeasure(HashableBaseModel, ModelWithMetadataParsing):
     non_additive_dimension: Optional[PydanticNonAdditiveDimensionParameters] = None
     agg_time_dimension: Optional[str] = None
     label: Optional[str] = None
+    config: Optional[PydanticSemanticLayerElementConfig] = None
 
     @property
     def reference(self) -> MeasureReference:  # noqa: D
diff --git a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
index 62b682a6..5e247886 100644
--- a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
+++ b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
@@ -112,6 +112,19 @@
             ],
             "type": "object"
         },
+        "dimension_config_schema": {
+            "$id": "dimension_config_schema",
+            "additionalProperties": false,
+            "properties": {
+                "meta": {
+                    "propertyNames": {
+                        "type": "string"
+                    },
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
         "dimension_schema": {
             "$id": "dimension_schema",
             "additionalProperties": false,
@@ -128,6 +141,9 @@
                 }
             ],
             "properties": {
+                "config": {
+                    "$ref": "#/definitions/dimension_config_schema"
+                },
                 "description": {
                     "type": "string"
                 },
@@ -204,10 +220,26 @@
             ],
             "type": "object"
         },
+        "entity_config_schema": {
+            "$id": "entity_config_schema",
+            "additionalProperties": false,
+            "properties": {
+                "meta": {
+                    "propertyNames": {
+                        "type": "string"
+                    },
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
         "entity_schema": {
             "$id": "entity_schema",
             "additionalProperties": false,
             "properties": {
+                "config": {
+                    "$ref": "#/definitions/entity_config_schema"
+                },
                 "entity": {
                     "type": "string"
                 },
@@ -314,6 +346,19 @@
                 "type"
             ]
         },
+        "measure_config_schema": {
+            "$id": "measure_config_schema",
+            "additionalProperties": false,
+            "properties": {
+                "meta": {
+                    "propertyNames": {
+                        "type": "string"
+                    },
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
         "measure_schema": {
             "$id": "measure_schema",
             "additionalProperties": false,
@@ -347,6 +392,9 @@
                     "pattern": "(?!.*__).*^[a-z][a-z0-9_]*[a-z0-9]$",
                     "type": "string"
                 },
+                "config": {
+                    "$ref": "#/definitions/measure_config_schema"
+                },
                 "create_metric": {
                     "type": "boolean"
                 },
diff --git a/dbt_semantic_interfaces/parsing/schemas.py b/dbt_semantic_interfaces/parsing/schemas.py
index 16d1e8bd..21ff8d3e 100644
--- a/dbt_semantic_interfaces/parsing/schemas.py
+++ b/dbt_semantic_interfaces/parsing/schemas.py
@@ -161,6 +161,16 @@
     "additionalProperties": False,
 }
 
+
+entity_config_schema = {
+    "$id": "entity_config_schema",
+    "type": "object",
+    "properties": {
+        "meta": {"type": "object", "propertyNames": {"type": "string"}},
+    },
+    "additionalProperties": False,
+}
+
 entity_schema = {
     "$id": "entity_schema",
     "type": "object",
@@ -174,6 +184,7 @@
         "expr": {"type": ["string", "boolean"]},
         "entity": {"type": "string"},
         "label": {"type": "string"},
+        "config": {"$ref": "entity_config_schema"},
     },
     "additionalProperties": False,
     "required": ["name", "type"],
@@ -226,6 +237,15 @@
     "additionalProperties": False,
 }
 
+measure_config_schema = {
+    "$id": "measure_config_schema",
+    "type": "object",
+    "properties": {
+        "meta": {"type": "object", "propertyNames": {"type": "string"}},
+    },
+    "additionalProperties": False,
+}
+
 measure_schema = {
     "$id": "measure_schema",
     "type": "object",
@@ -248,11 +268,21 @@
         },
         "description": {"type": "string"},
         "label": {"type": "string"},
+        "config": {"$ref": "measure_config_schema"},
     },
     "additionalProperties": False,
     "required": ["name", "agg"],
 }
 
+dimension_config_schema = {
+    "$id": "dimension_config_schema",
+    "type": "object",
+    "properties": {
+        "meta": {"type": "object", "propertyNames": {"type": "string"}},
+    },
+    "additionalProperties": False,
+}
+
 dimension_schema = {
     "$id": "dimension_schema",
     "type": "object",
@@ -267,6 +297,7 @@
         "expr": {"type": ["string", "boolean"]},
         "type_params": {"$ref": "dimension_type_params_schema"},
         "label": {"type": "string"},
+        "config": {"$ref": "dimension_config_schema"},
     },
     # dimension must have type_params if its a time dimension
     "anyOf": [{"not": {"$ref": "#/definitions/is-time-dimension"}}, {"required": ["type_params"]}],
@@ -529,6 +560,9 @@
     saved_query_query_params_schema["$id"]: saved_query_query_params_schema,
     semantic_model_config_schema["$id"]: semantic_model_config_schema,
     metric_config_schema["$id"]: metric_config_schema,
+    dimension_config_schema["$id"]: dimension_config_schema,
+    entity_config_schema["$id"]: entity_config_schema,
+    measure_config_schema["$id"]: measure_config_schema,
 }
 
 resources: List[Tuple[str, Resource]] = [(str(k), DRAFT7.create_resource(v)) for k, v in schema_store.items()]
diff --git a/dbt_semantic_interfaces/protocols/dimension.py b/dbt_semantic_interfaces/protocols/dimension.py
index 5cf8cbfe..f0ac3b67 100644
--- a/dbt_semantic_interfaces/protocols/dimension.py
+++ b/dbt_semantic_interfaces/protocols/dimension.py
@@ -3,6 +3,7 @@
 from abc import abstractmethod
 from typing import Optional, Protocol
 
+from dbt_semantic_interfaces.protocols.meta import SemanticLayerElementConfig
 from dbt_semantic_interfaces.protocols.metadata import Metadata
 from dbt_semantic_interfaces.references import (
     DimensionReference,
@@ -107,3 +108,8 @@ def validity_params(self) -> Optional[DimensionValidityParams]:
     def label(self) -> Optional[str]:
         """Returns a string representing a human readable label for the dimension."""
         pass
+
+    @property
+    @abstractmethod
+    def config(self) -> Optional[SemanticLayerElementConfig]:  # noqa: D
+        pass
diff --git a/dbt_semantic_interfaces/protocols/entity.py b/dbt_semantic_interfaces/protocols/entity.py
index 356e6803..27719d1a 100644
--- a/dbt_semantic_interfaces/protocols/entity.py
+++ b/dbt_semantic_interfaces/protocols/entity.py
@@ -3,6 +3,7 @@
 from abc import abstractmethod
 from typing import Optional, Protocol
 
+from dbt_semantic_interfaces.protocols.meta import SemanticLayerElementConfig
 from dbt_semantic_interfaces.references import EntityReference
 from dbt_semantic_interfaces.type_enums import EntityType
 
@@ -60,3 +61,8 @@ def is_linkable_entity_type(self) -> bool:
     def label(self) -> Optional[str]:
         """Returns a string representing a human readable label for the entity."""
         pass
+
+    @property
+    @abstractmethod
+    def config(self) -> Optional[SemanticLayerElementConfig]:  # noqa: D
+        pass
diff --git a/dbt_semantic_interfaces/protocols/measure.py b/dbt_semantic_interfaces/protocols/measure.py
index a7588cfb..7d8606f8 100644
--- a/dbt_semantic_interfaces/protocols/measure.py
+++ b/dbt_semantic_interfaces/protocols/measure.py
@@ -3,6 +3,7 @@
 from abc import abstractmethod
 from typing import Optional, Protocol, Sequence
 
+from dbt_semantic_interfaces.protocols.meta import SemanticLayerElementConfig
 from dbt_semantic_interfaces.references import MeasureReference
 from dbt_semantic_interfaces.type_enums import AggregationType
 
@@ -98,3 +99,8 @@ def reference(self) -> MeasureReference:
     def label(self) -> Optional[str]:
         """Returns a string representing a human readable label for the measure."""
         pass
+
+    @property
+    @abstractmethod
+    def config(self) -> Optional[SemanticLayerElementConfig]:  # noqa: D
+        pass
diff --git a/dbt_semantic_interfaces/protocols/meta.py b/dbt_semantic_interfaces/protocols/meta.py
new file mode 100644
index 00000000..08a1eef8
--- /dev/null
+++ b/dbt_semantic_interfaces/protocols/meta.py
@@ -0,0 +1,12 @@
+from abc import abstractmethod
+from typing import Any, Dict, Protocol
+
+
+class SemanticLayerElementConfig(Protocol):  # noqa: D
+    """The config property allows you to configure additional resources/metadata."""
+
+    @property
+    @abstractmethod
+    def meta(self) -> Dict[str, Any]:
+        """The meta field can be used to set metadata for a resource."""
+        pass
diff --git a/tests/parsing/test_semantic_model_parsing.py b/tests/parsing/test_semantic_model_parsing.py
index 8faec41f..34ad851f 100644
--- a/tests/parsing/test_semantic_model_parsing.py
+++ b/tests/parsing/test_semantic_model_parsing.py
@@ -110,7 +110,9 @@ def test_base_semantic_model_entity_parsing() -> None:
               role: test_role
               expr: example_id
               label: {label}
-
+              config:
+                meta:
+                  random: metadata
         """
     )
     file = YamlConfigFile(filepath="test_dir/inline_for_test", contents=yaml_contents)
@@ -206,7 +208,9 @@ def test_base_semantic_model_measure_parsing() -> None:
               expr: example_input
               description: {description}
               label: {label}
-
+              config:
+                meta:
+                  random: metadata
         """
     )
     file = YamlConfigFile(filepath="test_dir/inline_for_test", contents=yaml_contents)
@@ -325,6 +329,9 @@ def test_semantic_model_categorical_dimension_parsing() -> None:
             - name: example_categorical_dimension
               type: categorical
               expr: dimension_input
+              config:
+                meta:
+                  random: metadata
         """
     )
     file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
diff --git a/tests/test_implements_satisfy_protocols.py b/tests/test_implements_satisfy_protocols.py
index b37b5ca7..0c4ec8e7 100644
--- a/tests/test_implements_satisfy_protocols.py
+++ b/tests/test_implements_satisfy_protocols.py
@@ -3,6 +3,9 @@
 from hypothesis import given
 from hypothesis.strategies import booleans, builds, from_type, just, lists, none, text
 
+from dbt_semantic_interfaces.implementations.element_config import (
+    PydanticSemanticLayerElementConfig,
+)
 from dbt_semantic_interfaces.implementations.elements.dimension import (
     PydanticDimension,
     PydanticDimensionTypeParams,
@@ -66,6 +69,7 @@
     expr=OPTIONAL_STR_STRATEGY,
     metadata=OPTIONAL_METADATA_STRATEGY,
     label=OPTIONAL_STR_STRATEGY,
+    config=builds(PydanticSemanticLayerElementConfig),
 )
 
 DIMENSION_VALIDITY_PARAMS_STRATEGY = builds(
@@ -82,6 +86,7 @@
     expr=OPTIONAL_STR_STRATEGY,
     metadata=OPTIONAL_METADATA_STRATEGY,
     label=OPTIONAL_STR_STRATEGY,
+    config=builds(PydanticSemanticLayerElementConfig),
 )
 
 DIMENSION_STRATEGY = TIME_DIMENSION_STRATEGY | CATEGORICAL_DIMENSION_STRATEGY
@@ -93,6 +98,7 @@
     expr=OPTIONAL_STR_STRATEGY,
     metadata=OPTIONAL_METADATA_STRATEGY,
     label=OPTIONAL_STR_STRATEGY,
+    config=builds(PydanticSemanticLayerElementConfig),
 )
 
 MEASURE_STRATEGY = builds(
@@ -104,6 +110,7 @@
     non_additive_dimesnion=builds(PydanticNonAdditiveDimensionParameters) | none(),
     agg_time_dimension=OPTIONAL_STR_STRATEGY,
     label=OPTIONAL_STR_STRATEGY,
+    config=builds(PydanticSemanticLayerElementConfig),
 )
 
 SEMANTIC_MODEL_STRATEGY = builds(