dvt-core 1.11.0b4__py3-none-any.whl

dvt/artifacts/resources/v1/generic_test.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, Literal, Optional
+
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.components import CompiledResource
+from dvt.artifacts.resources.v1.config import TestConfig
+
+from dbt_common.dataclass_schema import dbtClassMixin
+
+
+@dataclass
+class TestMetadata(dbtClassMixin):
+    __test__ = False
+
+    name: str = "test"  # dummy default to allow default in GenericTestNode. Should always be set.
+    # kwargs are the args that are left in the test builder after
+    # removing configs. They are set from the test builder when
+    # the test node is created.
+    kwargs: Dict[str, Any] = field(default_factory=dict)
+    namespace: Optional[str] = None
+
+
+@dataclass
+class GenericTest(CompiledResource):
+    resource_type: Literal[NodeType.Test]
+    column_name: Optional[str] = None
+    file_key_name: Optional[str] = None
+    # Was not able to make mypy happy and keep the code working. We need to
+    # refactor the various configs.
+    config: TestConfig = field(default_factory=TestConfig)  # type: ignore
+    attached_node: Optional[str] = None
+    test_metadata: TestMetadata = field(default_factory=TestMetadata)

dvt/artifacts/resources/v1/group.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, Literal, Optional
+
+from dvt.artifacts.resources.base import BaseResource
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.owner import Owner
+
+from dbt_common.contracts.config.base import BaseConfig, MergeBehavior
+
+
+@dataclass
+class GroupConfig(BaseConfig):
+    meta: Dict[str, Any] = field(default_factory=dict, metadata=MergeBehavior.Update.meta())
+
+
+@dataclass
+class Group(BaseResource):
+    name: str
+    owner: Owner
+    resource_type: Literal[NodeType.Group]
+    description: Optional[str] = None
+    config: GroupConfig = field(default_factory=GroupConfig)

dvt/artifacts/resources/v1/hook.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.components import CompiledResource
+
+
+@dataclass
+class HookNode(CompiledResource):
+    resource_type: Literal[NodeType.Operation]
+    index: Optional[int] = None

dvt/artifacts/resources/v1/macro.py

@@ -0,0 +1,30 @@
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional
+
+from dvt.artifacts.resources.base import BaseResource, Docs
+from dvt.artifacts.resources.types import ModelLanguage, NodeType
+from dvt.artifacts.resources.v1.components import MacroDependsOn
+
+from dbt_common.dataclass_schema import dbtClassMixin
+
+
+@dataclass
+class MacroArgument(dbtClassMixin):
+    name: str
+    type: Optional[str] = None
+    description: str = ""
+
+
+@dataclass
+class Macro(BaseResource):
+    macro_sql: str
+    resource_type: Literal[NodeType.Macro]
+    depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)
+    description: str = ""
+    meta: Dict[str, Any] = field(default_factory=dict)
+    docs: Docs = field(default_factory=Docs)
+    patch_path: Optional[str] = None
+    arguments: List[MacroArgument] = field(default_factory=list)
+    created_at: float = field(default_factory=lambda: time.time())
+    supported_languages: Optional[List[ModelLanguage]] = None

dvt/artifacts/resources/v1/metric.py

@@ -0,0 +1,173 @@
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional
+
+from dvt.artifacts.resources.base import GraphResource
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.components import DependsOn, RefArgs
+from dvt.artifacts.resources.v1.semantic_layer_components import (
+    MeasureAggregationParameters,
+    NonAdditiveDimension,
+    SourceFileMetadata,
+    WhereFilterIntersection,
+)
+
+from dbt_common.contracts.config.base import BaseConfig, CompareBehavior, MergeBehavior
+from dbt_common.dataclass_schema import dbtClassMixin
+from dbt_semantic_interfaces.references import MeasureReference, MetricReference
+from dbt_semantic_interfaces.type_enums import (
+    AggregationType,
+    ConversionCalculationType,
+    MetricType,
+    PeriodAggregation,
+    TimeGranularity,
+)
+
+"""
+The following classes are dataclasses which are used to construct the Metric
+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/metric.py
+"""
+
+
+@dataclass
+class MetricInputMeasure(dbtClassMixin):
+    name: str
+    filter: Optional[WhereFilterIntersection] = None
+    alias: Optional[str] = None
+    join_to_timespine: bool = False
+    fill_nulls_with: Optional[int] = None
+
+    def measure_reference(self) -> MeasureReference:
+        return MeasureReference(element_name=self.name)
+
+    def post_aggregation_measure_reference(self) -> MeasureReference:
+        return MeasureReference(element_name=self.alias or self.name)
+
+
+@dataclass
+class MetricTimeWindow(dbtClassMixin):
+    count: int
+    granularity: str
+
+    @property
+    def window_string(self) -> str:  # noqa: D
+        return f"{self.count} {self.granularity}"
+
+    @property
+    def is_standard_granularity(self) -> bool:  # noqa: D
+        return self.granularity.casefold() in {item.value.casefold() for item in TimeGranularity}
+
+
+@dataclass
+class MetricInput(dbtClassMixin):
+    name: str
+    filter: Optional[WhereFilterIntersection] = None
+    alias: Optional[str] = None
+    offset_window: Optional[MetricTimeWindow] = None
+    offset_to_grain: Optional[str] = None
+
+    def as_reference(self) -> MetricReference:
+        return MetricReference(element_name=self.name)
+
+    def post_aggregation_reference(self) -> MetricReference:
+        return MetricReference(element_name=self.alias or self.name)
+
+
+@dataclass
+class ConstantPropertyInput(dbtClassMixin):
+    base_property: str
+    conversion_property: str
+
+
+@dataclass
+class ConversionTypeParams(dbtClassMixin):
+    base_measure: MetricInputMeasure
+    conversion_measure: MetricInputMeasure
+    entity: str
+    calculation: ConversionCalculationType = ConversionCalculationType.CONVERSION_RATE
+    window: Optional[MetricTimeWindow] = None
+    constant_properties: Optional[List[ConstantPropertyInput]] = None
+
+
+@dataclass
+class CumulativeTypeParams(dbtClassMixin):
+    window: Optional[MetricTimeWindow] = None
+    grain_to_date: Optional[str] = None
+    period_agg: PeriodAggregation = PeriodAggregation.FIRST
+    metric: Optional[MetricInput] = None
+
+
+@dataclass
+class MetricAggregationParams(dbtClassMixin):
+    semantic_model: str
+    agg: AggregationType
+    agg_params: Optional[MeasureAggregationParameters] = None
+    agg_time_dimension: Optional[str] = None
+    non_additive_dimension: Optional[NonAdditiveDimension] = None
+    expr: Optional[str] = None
+
+
+@dataclass
+class MetricTypeParams(dbtClassMixin):
+    measure: Optional[MetricInputMeasure] = None
+    input_measures: List[MetricInputMeasure] = field(default_factory=list)
+    numerator: Optional[MetricInput] = None
+    denominator: Optional[MetricInput] = None
+    expr: Optional[str] = None
+    window: Optional[MetricTimeWindow] = None
+    grain_to_date: Optional[TimeGranularity] = (
+        None  # legacy, use cumulative_type_params.grain_to_date
+    )
+    metrics: Optional[List[MetricInput]] = None
+    conversion_type_params: Optional[ConversionTypeParams] = None
+    cumulative_type_params: Optional[CumulativeTypeParams] = None
+    metric_aggregation_params: Optional[MetricAggregationParams] = None
+
+
+@dataclass
+class MetricConfig(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 Metric(GraphResource):
+    name: str
+    description: str
+    label: str
+    type: MetricType
+    type_params: MetricTypeParams
+    filter: Optional[WhereFilterIntersection] = None
+    metadata: Optional[SourceFileMetadata] = None
+    time_granularity: Optional[str] = None
+    resource_type: Literal[NodeType.Metric]
+    meta: Dict[str, Any] = field(default_factory=dict, metadata=MergeBehavior.Update.meta())
+    tags: List[str] = field(default_factory=list)
+    config: MetricConfig = field(default_factory=MetricConfig)
+    unrendered_config: Dict[str, Any] = field(default_factory=dict)
+    sources: List[List[str]] = field(default_factory=list)
+    depends_on: DependsOn = field(default_factory=DependsOn)
+    refs: List[RefArgs] = field(default_factory=list)
+    metrics: List[List[str]] = field(default_factory=list)
+    created_at: float = field(default_factory=lambda: time.time())
+    group: Optional[str] = None
+
+    @property
+    def input_measures(self) -> List[MetricInputMeasure]:
+        return self.type_params.input_measures
+
+    @property
+    def measure_references(self) -> List[MeasureReference]:
+        return [x.measure_reference() for x in self.input_measures]
+
+    @property
+    def input_metrics(self) -> List[MetricInput]:
+        return self.type_params.metrics or []

dvt/artifacts/resources/v1/model.py

@@ -0,0 +1,146 @@
+import enum
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Literal, Optional
+
+from dvt.artifacts.resources.types import AccessType, NodeType, TimePeriod
+from dvt.artifacts.resources.v1.components import (
+    CompiledResource,
+    DeferRelation,
+    NodeVersion,
+)
+from dvt.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

dvt/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

dvt/artifacts/resources/v1/saved_query.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from dvt.artifacts.resources.base import GraphResource
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.components import DependsOn, RefArgs
+from dvt.artifacts.resources.v1.config import list_str, metas
+from dvt.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

dvt/artifacts/resources/v1/seed.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import Dict, Literal, Optional
+
+from dvt.artifacts.resources.types import NodeType
+from dvt.artifacts.resources.v1.components import (
+    DeferRelation,
+    MacroDependsOn,
+    ParsedResource,
+)
+from dvt.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

dvt/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]