dvt-core 0.52.2__cp310-cp310-macosx_10_9_x86_64.whl

dbt/artifacts/resources/v1/model.py

@@ -0,0 +1,145 @@
+import enum
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Literal, Optional
+
+from dbt.artifacts.resources.types import AccessType, NodeType, TimePeriod
+from dbt.artifacts.resources.v1.components import (
+    CompiledResource,
+    DeferRelation,
+    NodeVersion,
+)
+from dbt.artifacts.resources.v1.config import NodeConfig
+from dbt_common.contracts.config.base import MergeBehavior
+from dbt_common.contracts.constraints import ModelLevelConstraint
+from dbt_common.contracts.util import Mergeable
+from dbt_common.dataclass_schema import (
+    ExtensibleDbtClassMixin,
+    ValidationError,
+    dbtClassMixin,
+)
+
+
+class ModelFreshnessUpdatesOnOptions(enum.Enum):
+    all = "all"
+    any = "any"
+
+
+@dataclass
+class ModelBuildAfter(ExtensibleDbtClassMixin):
+    count: Optional[int] = None
+    period: Optional[TimePeriod] = None
+    updates_on: ModelFreshnessUpdatesOnOptions = ModelFreshnessUpdatesOnOptions.any
+
+
+@dataclass
+class ModelFreshness(ExtensibleDbtClassMixin, Mergeable):
+    build_after: ModelBuildAfter
+
+
+def merge_model_freshness(*thresholds: Optional[ModelFreshness]) -> Optional[ModelFreshness]:
+    if not thresholds:
+        return None
+
+    current_merged_value: Optional[ModelFreshness] = thresholds[0]
+
+    for i in range(1, len(thresholds)):
+        base = current_merged_value
+        update = thresholds[i]
+
+        if base is not None and update is not None:
+            # When both base and update freshness are defined,
+            # create a new ModelFreshness instance using the build_after from the 'update'.
+            # This effectively means 'update's build_after configuration takes precedence.
+            merged_freshness_obj = base.merged(update)
+            if (
+                base.build_after.updates_on == ModelFreshnessUpdatesOnOptions.all
+                or update.build_after.updates_on == ModelFreshnessUpdatesOnOptions.all
+            ):
+                merged_freshness_obj.build_after.updates_on = ModelFreshnessUpdatesOnOptions.all
+            current_merged_value = merged_freshness_obj
+        elif base is None and update is not None:
+            # If the current merged value is None but the new update is defined,
+            # take the update.
+            current_merged_value = update
+        else:
+            # This covers cases where 'update' is None (regardless of 'base'),
+            # or both 'base' and 'update' are None.
+            # The result of the pair-merge is None.
+            current_merged_value = base
+
+    return current_merged_value
+
+
+@dataclass
+class ModelConfig(NodeConfig):
+    access: AccessType = field(
+        default=AccessType.Protected,
+        metadata=MergeBehavior.Clobber.meta(),
+    )
+    freshness: Optional[ModelFreshness] = None
+
+    def __post_init__(self):
+        super().__post_init__()
+        if (
+            self.freshness
+            and self.freshness.build_after.period
+            and self.freshness.build_after.count is None
+        ):
+            raise ValidationError(
+                "`freshness.build_after` must have a value for `count` if a `period` is provided"
+            )
+        elif (
+            self.freshness
+            and self.freshness.build_after.count is not None
+            and not self.freshness.build_after.period
+        ):
+            raise ValidationError(
+                "`freshness.build_after` must have a value for `period` if a `count` is provided"
+            )
+
+    @classmethod
+    def __pre_deserialize__(cls, data):
+        data = super().__pre_deserialize__(data)
+        # scrub out model configs where "build_after" is not defined
+        if (
+            "freshness" in data
+            and isinstance(data["freshness"], dict)
+            and "build_after" in data["freshness"]
+        ):
+            data["freshness"] = ModelFreshness.from_dict(data["freshness"]).to_dict()
+        else:
+            data.pop("freshness", None)
+        return data
+
+
+@dataclass
+class CustomGranularity(dbtClassMixin):
+    name: str
+    column_name: Optional[str] = None
+
+
+@dataclass
+class TimeSpine(dbtClassMixin):
+    standard_granularity_column: str
+    custom_granularities: List[CustomGranularity] = field(default_factory=list)
+
+
+@dataclass
+class Model(CompiledResource):
+    resource_type: Literal[NodeType.Model]
+    access: AccessType = AccessType.Protected
+    config: ModelConfig = field(default_factory=ModelConfig)
+    constraints: List[ModelLevelConstraint] = field(default_factory=list)
+    version: Optional[NodeVersion] = None
+    latest_version: Optional[NodeVersion] = None
+    deprecation_date: Optional[datetime] = None
+    defer_relation: Optional[DeferRelation] = None
+    primary_key: List[str] = field(default_factory=list)
+    time_spine: Optional[TimeSpine] = None
+
+    def __post_serialize__(self, dct: Dict, context: Optional[Dict] = None):
+        dct = super().__post_serialize__(dct, context)
+        if context and context.get("artifact") and "defer_relation" in dct:
+            del dct["defer_relation"]
+        return dct

dbt/artifacts/resources/v1/owner.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+from dbt_common.contracts.config.properties import AdditionalPropertiesAllowed
+
+
+@dataclass
+class Owner(AdditionalPropertiesAllowed):
+    email: Union[str, List[str], None] = None
+    name: Optional[str] = None

dbt/artifacts/resources/v1/saved_query.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from dbt.artifacts.resources.base import GraphResource
+from dbt.artifacts.resources.types import NodeType
+from dbt.artifacts.resources.v1.components import DependsOn, RefArgs
+from dbt.artifacts.resources.v1.config import list_str, metas
+from dbt.artifacts.resources.v1.semantic_layer_components import (
+    SourceFileMetadata,
+    WhereFilterIntersection,
+)
+from dbt_common.contracts.config.base import BaseConfig, CompareBehavior, MergeBehavior
+from dbt_common.contracts.config.metadata import ShowBehavior
+from dbt_common.dataclass_schema import dbtClassMixin
+from dbt_semantic_interfaces.type_enums.export_destination_type import (
+    ExportDestinationType,
+)
+
+
+@dataclass
+class ExportConfig(dbtClassMixin):
+    """Nested configuration attributes for exports."""
+
+    export_as: ExportDestinationType
+    schema_name: Optional[str] = None
+    alias: Optional[str] = None
+    database: Optional[str] = None
+
+
+@dataclass
+class Export(dbtClassMixin):
+    """Configuration for writing query results to a table."""
+
+    name: str
+    config: ExportConfig
+    unrendered_config: Dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class QueryParams(dbtClassMixin):
+    """The query parameters for the saved query"""
+
+    metrics: List[str]
+    group_by: List[str]
+    where: Optional[WhereFilterIntersection]
+    order_by: List[str] = field(default_factory=list)
+    limit: Optional[int] = None
+
+
+@dataclass
+class SavedQueryCache(dbtClassMixin):
+    enabled: bool = False
+
+
+@dataclass
+class SavedQueryConfig(BaseConfig):
+    """Where config options for SavedQueries are stored.
+
+    This class is much like many other node config classes. It's likely that
+    this class will expand in the direction of what's in the `NodeAndTestConfig`
+    class. It might make sense to clean the various *Config classes into one at
+    some point.
+    """
+
+    enabled: bool = True
+    group: Optional[str] = field(
+        default=None,
+        metadata=CompareBehavior.Exclude.meta(),
+    )
+    meta: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata=MergeBehavior.Update.meta(),
+    )
+    export_as: Optional[ExportDestinationType] = None
+    schema: Optional[str] = None
+    cache: SavedQueryCache = field(default_factory=SavedQueryCache)
+
+
+@dataclass
+class SavedQueryMandatory(GraphResource):
+    query_params: QueryParams
+    exports: List[Export]
+
+
+@dataclass
+class SavedQuery(SavedQueryMandatory):
+    resource_type: Literal[NodeType.SavedQuery]
+    description: Optional[str] = None
+    label: Optional[str] = None
+    metadata: Optional[SourceFileMetadata] = None
+    config: SavedQueryConfig = field(default_factory=SavedQueryConfig)
+    unrendered_config: Dict[str, Any] = field(default_factory=dict)
+    group: Optional[str] = None
+    depends_on: DependsOn = field(default_factory=DependsOn)
+    created_at: float = field(default_factory=lambda: time.time())
+    refs: List[RefArgs] = field(default_factory=list)
+    tags: Union[List[str], str] = field(
+        default_factory=list_str,
+        metadata=metas(ShowBehavior.Hide, MergeBehavior.Append, CompareBehavior.Exclude),
+    )
+
+    @property
+    def metrics(self) -> List[str]:
+        return self.query_params.metrics
+
+    @property
+    def depends_on_nodes(self):
+        return self.depends_on.nodes

dbt/artifacts/resources/v1/seed.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass, field
+from typing import Dict, Literal, Optional
+
+from dbt.artifacts.resources.types import NodeType
+from dbt.artifacts.resources.v1.components import (
+    DeferRelation,
+    MacroDependsOn,
+    ParsedResource,
+)
+from dbt.artifacts.resources.v1.config import NodeConfig
+from dbt_common.dataclass_schema import ValidationError
+
+
+@dataclass
+class SeedConfig(NodeConfig):
+    materialized: str = "seed"
+    delimiter: str = ","
+    quote_columns: Optional[bool] = None
+
+    @classmethod
+    def validate(cls, data):
+        super().validate(data)
+        if data.get("materialized") and data.get("materialized") != "seed":
+            raise ValidationError("A seed must have a materialized value of 'seed'")
+
+
+@dataclass
+class Seed(ParsedResource):  # No SQLDefaults!
+    resource_type: Literal[NodeType.Seed]
+    config: SeedConfig = field(default_factory=SeedConfig)
+    # seeds need the root_path because the contents are not loaded initially
+    # and we need the root_path to load the seed later
+    root_path: Optional[str] = None
+    depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)
+    defer_relation: Optional[DeferRelation] = None
+
+    def __post_serialize__(self, dct: Dict, context: Optional[Dict] = None):
+        dct = super().__post_serialize__(dct, context)
+        if context and context.get("artifact") and "defer_relation" in dct:
+            del dct["defer_relation"]
+        return dct

dbt/artifacts/resources/v1/semantic_layer_components.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+from typing import List, Optional, Sequence, Tuple
+
+from dbt_common.dataclass_schema import dbtClassMixin
+from dbt_semantic_interfaces.call_parameter_sets import JinjaCallParameterSets
+from dbt_semantic_interfaces.parsing.where_filter.jinja_object_parser import (
+    JinjaObjectParser,
+    QueryItemLocation,
+)
+from dbt_semantic_interfaces.type_enums import AggregationType
+
+
+@dataclass
+class WhereFilter(dbtClassMixin):
+    where_sql_template: str
+
+    def call_parameter_sets(
+        self, custom_granularity_names: Sequence[str]
+    ) -> JinjaCallParameterSets:
+        return JinjaObjectParser.parse_call_parameter_sets(
+            self.where_sql_template,
+            custom_granularity_names=custom_granularity_names,
+            query_item_location=QueryItemLocation.NON_ORDER_BY,
+        )
+
+
+@dataclass
+class WhereFilterIntersection(dbtClassMixin):
+    where_filters: List[WhereFilter]
+
+    def filter_expression_parameter_sets(
+        self, custom_granularity_names: Sequence[str]
+    ) -> Sequence[Tuple[str, JinjaCallParameterSets]]:
+        raise NotImplementedError
+
+
+@dataclass
+class FileSlice(dbtClassMixin):
+    """Provides file slice level context about what something was created from.
+
+    Implementation of the dbt-semantic-interfaces `FileSlice` protocol
+    """
+
+    filename: str
+    content: str
+    start_line_number: int
+    end_line_number: int
+
+
+@dataclass
+class SourceFileMetadata(dbtClassMixin):
+    """Provides file context about what something was created from.
+
+    Implementation of the dbt-semantic-interfaces `Metadata` protocol
+    """
+
+    repo_file_path: str
+    file_slice: FileSlice
+
+
+@dataclass
+class MeasureAggregationParameters(dbtClassMixin):
+    percentile: Optional[float] = None
+    use_discrete_percentile: bool = False
+    use_approximate_percentile: bool = False
+
+
+@dataclass
+class NonAdditiveDimension(dbtClassMixin):
+    name: str
+    window_choice: AggregationType
+    window_groupings: List[str]

dbt/artifacts/resources/v1/semantic_model.py

@@ -0,0 +1,314 @@
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Sequence
+
+from dbt.artifacts.resources import SourceFileMetadata
+from dbt.artifacts.resources.base import GraphResource
+from dbt.artifacts.resources.v1.components import DependsOn, RefArgs
+from dbt.artifacts.resources.v1.metric import Metric
+from dbt.artifacts.resources.v1.semantic_layer_components import (
+    MeasureAggregationParameters,
+    NonAdditiveDimension,
+)
+from dbt_common.contracts.config.base import BaseConfig, CompareBehavior, MergeBehavior
+from dbt_common.dataclass_schema import dbtClassMixin
+from dbt_semantic_interfaces.references import (
+    DimensionReference,
+    EntityReference,
+    LinkableElementReference,
+    MeasureReference,
+    SemanticModelReference,
+    TimeDimensionReference,
+)
+from dbt_semantic_interfaces.type_enums import (
+    AggregationType,
+    DimensionType,
+    EntityType,
+    MetricType,
+    TimeGranularity,
+)
+
+"""
+The classes in this file are dataclasses which are used to construct the Semantic
+Model node in dbt-core. Additionally, these classes need to at a minimum support
+what is specified in their protocol definitions in dbt-semantic-interfaces.
+Their protocol definitions can be found here:
+https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/dbt_semantic_interfaces/protocols/semantic_model.py
+"""
+
+
+@dataclass
+class SemanticLayerElementConfig(dbtClassMixin):
+    meta: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata=MergeBehavior.Update.meta(),
+    )
+
+
+@dataclass
+class Defaults(dbtClassMixin):
+    agg_time_dimension: Optional[str] = None
+
+
+@dataclass
+class NodeRelation(dbtClassMixin):
+    alias: str
+    schema_name: str  # TODO: Could this be called simply "schema" so we could reuse StateRelation?
+    database: Optional[str] = None
+    relation_name: Optional[str] = ""
+
+
+# ====================================
+# Dimension objects
+# Dimension protocols: https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/dbt_semantic_interfaces/protocols/dimension.py
+# ====================================
+
+
+@dataclass
+class DimensionValidityParams(dbtClassMixin):
+    is_start: bool = False
+    is_end: bool = False
+
+
+@dataclass
+class DimensionTypeParams(dbtClassMixin):
+    time_granularity: TimeGranularity
+    validity_params: Optional[DimensionValidityParams] = None
+
+
+@dataclass
+class Dimension(dbtClassMixin):
+    name: str
+    type: DimensionType
+    description: Optional[str] = None
+    label: Optional[str] = None
+    is_partition: bool = False
+    type_params: Optional[DimensionTypeParams] = None
+    expr: Optional[str] = None
+    metadata: Optional[SourceFileMetadata] = None
+    config: Optional[SemanticLayerElementConfig] = None
+
+    @property
+    def reference(self) -> DimensionReference:
+        return DimensionReference(element_name=self.name)
+
+    @property
+    def time_dimension_reference(self) -> Optional[TimeDimensionReference]:
+        if self.type == DimensionType.TIME:
+            return TimeDimensionReference(element_name=self.name)
+        else:
+            return None
+
+    @property
+    def validity_params(self) -> Optional[DimensionValidityParams]:
+        if self.type_params:
+            return self.type_params.validity_params
+        else:
+            return None
+
+
+# ====================================
+# Entity objects
+# Entity protocols: https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/dbt_semantic_interfaces/protocols/entity.py
+# ====================================
+
+
+@dataclass
+class Entity(dbtClassMixin):
+    name: str
+    type: EntityType
+    description: Optional[str] = None
+    label: Optional[str] = None
+    role: Optional[str] = None
+    expr: Optional[str] = None
+    config: Optional[SemanticLayerElementConfig] = None
+
+    @property
+    def reference(self) -> EntityReference:
+        return EntityReference(element_name=self.name)
+
+    @property
+    def is_linkable_entity_type(self) -> bool:
+        return self.type in (EntityType.PRIMARY, EntityType.UNIQUE, EntityType.NATURAL)
+
+
+# ====================================
+# Measure object
+# Measure protocols: https://github.com/dbt-labs/dbt-semantic-interfaces/blob/main/dbt_semantic_interfaces/protocols/measure.py
+# ====================================
+
+
+@dataclass
+class Measure(dbtClassMixin):
+    name: str
+    agg: AggregationType
+    description: Optional[str] = None
+    label: Optional[str] = None
+    create_metric: bool = False
+    expr: Optional[str] = None
+    agg_params: Optional[MeasureAggregationParameters] = None
+    non_additive_dimension: Optional[NonAdditiveDimension] = None
+    agg_time_dimension: Optional[str] = None
+    config: Optional[SemanticLayerElementConfig] = None
+
+    @property
+    def reference(self) -> MeasureReference:
+        return MeasureReference(element_name=self.name)
+
+
+# ====================================
+# SemanticModel final parts
+# ====================================
+
+
+@dataclass
+class SemanticModelConfig(BaseConfig):
+    enabled: bool = True
+    group: Optional[str] = field(
+        default=None,
+        metadata=CompareBehavior.Exclude.meta(),
+    )
+    meta: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata=MergeBehavior.Update.meta(),
+    )
+
+
+@dataclass
+class SemanticModel(GraphResource):
+    model: str
+    node_relation: Optional[NodeRelation]
+    description: Optional[str] = None
+    label: Optional[str] = None
+    defaults: Optional[Defaults] = None
+    entities: Sequence[Entity] = field(default_factory=list)
+    measures: Sequence[Measure] = field(default_factory=list)
+    dimensions: Sequence[Dimension] = field(default_factory=list)
+    metadata: Optional[SourceFileMetadata] = None
+    depends_on: DependsOn = field(default_factory=DependsOn)
+    refs: List[RefArgs] = field(default_factory=list)
+    created_at: float = field(default_factory=lambda: time.time())
+    config: SemanticModelConfig = field(default_factory=SemanticModelConfig)
+    unrendered_config: Dict[str, Any] = field(default_factory=dict)
+    primary_entity: Optional[str] = None
+    group: Optional[str] = None
+
+    @property
+    def entity_references(self) -> List[LinkableElementReference]:
+        return [entity.reference for entity in self.entities]
+
+    @property
+    def dimension_references(self) -> List[LinkableElementReference]:
+        return [dimension.reference for dimension in self.dimensions]
+
+    @property
+    def measure_references(self) -> List[MeasureReference]:
+        return [measure.reference for measure in self.measures]
+
+    @property
+    def has_validity_dimensions(self) -> bool:
+        return any([dim.validity_params is not None for dim in self.dimensions])
+
+    @property
+    def validity_start_dimension(self) -> Optional[Dimension]:
+        validity_start_dims = [
+            dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_start
+        ]
+        if not validity_start_dims:
+            return None
+        return validity_start_dims[0]
+
+    @property
+    def validity_end_dimension(self) -> Optional[Dimension]:
+        validity_end_dims = [
+            dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_end
+        ]
+        if not validity_end_dims:
+            return None
+        return validity_end_dims[0]
+
+    @property
+    def partitions(self) -> List[Dimension]:  # noqa: D
+        return [dim for dim in self.dimensions or [] if dim.is_partition]
+
+    @property
+    def partition(self) -> Optional[Dimension]:
+        partitions = self.partitions
+        if not partitions:
+            return None
+        return partitions[0]
+
+    @property
+    def reference(self) -> SemanticModelReference:
+        return SemanticModelReference(semantic_model_name=self.name)
+
+    def checked_agg_time_dimension_for_measure(
+        self, measure_reference: MeasureReference
+    ) -> TimeDimensionReference:
+        measure: Optional[Measure] = None
+        for measure in self.measures:
+            if measure.reference == measure_reference:
+                measure = measure
+
+        assert (
+            measure is not None
+        ), f"No measure with name ({measure_reference.element_name}) in semantic_model with name ({self.name})"
+
+        default_agg_time_dimension = (
+            self.defaults.agg_time_dimension if self.defaults is not None else None
+        )
+
+        agg_time_dimension_name = measure.agg_time_dimension or default_agg_time_dimension
+        assert agg_time_dimension_name is not None, (
+            f"Aggregation time dimension for measure {measure.name} on semantic model {self.name} is not set! "
+            "To fix this either specify a default `agg_time_dimension` for the semantic model or define an "
+            "`agg_time_dimension` on the measure directly."
+        )
+        return TimeDimensionReference(element_name=agg_time_dimension_name)
+
+    def checked_agg_time_dimension_for_simple_metric(
+        self, metric: Metric
+    ) -> TimeDimensionReference:
+        assert (
+            metric.type == MetricType.SIMPLE
+        ), "Only simple metrics can have an agg time dimension."
+        metric_agg_params = metric.type_params.metric_aggregation_params
+        # There are validations elsewhere to check this for metrics and provide messaging for it.
+        assert metric_agg_params, "Simple metrics must have metric_aggregation_params."
+        # This indicates a validation bug / dev error, not a user error that should appear
+        # in a user's YAML.
+        assert (
+            metric_agg_params.semantic_model == self.name
+        ), "Cannot retrieve the agg time dimension for a metric from a different model "
+        f"than the one that the metric belongs to. Metric `{metric.name}` belongs to model "
+        f"`{metric_agg_params.semantic_model}`, but we requested the agg time dimension from model `{self.name}`."
+
+        metric_time_dimension_name = None
+        if (
+            metric.type_params
+            and metric.type_params.metric_aggregation_params
+            and metric.type_params.metric_aggregation_params.agg_time_dimension
+        ):
+            metric_time_dimension_name = (
+                metric.type_params.metric_aggregation_params.agg_time_dimension
+            )
+
+        default_agg_time_dimension = (
+            self.defaults.agg_time_dimension if self.defaults is not None else None
+        )
+        agg_time_dimension_name = metric_time_dimension_name or default_agg_time_dimension
+
+        assert agg_time_dimension_name is not None, (
+            f"Aggregation time dimension for metric {metric.name} is not set! This should either be set directly on "
+            f"the metric specification in the model, or else defaulted to the time dimension in the data "
+            f"source containing the metric."
+        )
+        return TimeDimensionReference(element_name=agg_time_dimension_name)
+
+    @property
+    def primary_entity_reference(self) -> Optional[EntityReference]:
+        return (
+            EntityReference(element_name=self.primary_entity)
+            if self.primary_entity is not None
+            else None
+        )