dvt-core 0.59.0a51__py3-none-any.whl

dbt/contracts/graph/metrics.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, Iterator, List
+
+from dbt.contracts.graph.manifest import Manifest, Metric
+from dbt_semantic_interfaces.type_enums import MetricType
+
+DERIVED_METRICS = [MetricType.DERIVED, MetricType.RATIO]
+BASE_METRICS = [MetricType.SIMPLE, MetricType.CUMULATIVE, MetricType.CONVERSION]
+
+
+class MetricReference(object):
+    def __init__(self, metric_name, package_name=None) -> None:
+        self.metric_name = metric_name
+        self.package_name = package_name
+
+    def __str__(self):
+        return f"{self.metric_name}"
+
+
+class ResolvedMetricReference(MetricReference):
+    """
+    Simple proxy over a Metric which delegates property
+    lookups to the underlying node. Also adds helper functions
+    for working with metrics (ie. __str__ and templating functions)
+    """
+
+    def __init__(self, node: Metric, manifest: Manifest) -> None:
+        super().__init__(node.name, node.package_name)
+        self.node = node
+        self.manifest = manifest
+
+    def __getattr__(self, key) -> Any:
+        return getattr(self.node, key)
+
+    def __str__(self) -> str:
+        return f"{self.node.name}"
+
+    @classmethod
+    def parent_metrics(cls, metric_node: Metric, manifest: Manifest) -> Iterator[Metric]:
+        """For a given metric, yeilds all upstream metrics."""
+        yield metric_node
+
+        for parent_unique_id in metric_node.depends_on.nodes:
+            node = manifest.expect(parent_unique_id)
+            if isinstance(node, Metric):
+                yield from cls.parent_metrics(node, manifest)
+
+    @classmethod
+    def parent_metrics_names(cls, metric_node: Metric, manifest: Manifest) -> Iterator[str]:
+        """For a given metric, yeilds all upstream metric names"""
+        for metric in cls.parent_metrics(metric_node, manifest):
+            yield metric.name
+
+    @classmethod
+    def reverse_dag_parsing(
+        cls, metric_node: Metric, manifest: Manifest, metric_depth_count: int
+    ) -> Iterator[Dict[str, int]]:
+        """For the given metric, yeilds dictionaries having {<metric_name>: <depth_from_initial_metric} of upstream derived metrics.
+
+        This function is intended as a helper function for other metric helper functions.
+        """
+        if metric_node.type in DERIVED_METRICS:
+            yield {metric_node.name: metric_depth_count}
+
+            for parent_unique_id in metric_node.depends_on.nodes:
+                node = manifest.expect(parent_unique_id)
+                if isinstance(node, Metric):
+                    yield from cls.reverse_dag_parsing(node, manifest, metric_depth_count + 1)
+
+    def full_metric_dependency(self):
+        """Returns a unique list of all upstream metric names."""
+        to_return = list(set(self.parent_metrics_names(self.node, self.manifest)))
+        return to_return
+
+    def base_metric_dependency(self) -> List[str]:
+        """Returns a unique list of names for all upstream non-derived metrics."""
+        in_scope_metrics = list(self.parent_metrics(self.node, self.manifest))
+        base_metrics = {
+            metric.name for metric in in_scope_metrics if metric.type not in DERIVED_METRICS
+        }
+
+        return list(base_metrics)
+
+    def derived_metric_dependency(self) -> List[str]:
+        """Returns a unique list of names for all upstream derived metrics."""
+        in_scope_metrics = list(self.parent_metrics(self.node, self.manifest))
+        derived_metrics = {
+            metric.name for metric in in_scope_metrics if metric.type in DERIVED_METRICS
+        }
+
+        return list(derived_metrics)
+
+    def derived_metric_dependency_depth(self) -> List[Dict[str, int]]:
+        """Returns a list of {<metric_name>: <depth_from_initial_metric>} for all upstream metrics."""
+        metric_depth_count = 1
+        to_return = list(self.reverse_dag_parsing(self.node, self.manifest, metric_depth_count))
+
+        return to_return

dbt/contracts/graph/model_config.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Type
+
+from dbt.artifacts.resources import (
+    ExposureConfig,
+    FunctionConfig,
+    GroupConfig,
+    MetricConfig,
+    ModelConfig,
+    NodeConfig,
+    SavedQueryConfig,
+    SeedConfig,
+    SemanticModelConfig,
+    SnapshotConfig,
+    SourceConfig,
+    TestConfig,
+    UnitTestConfig,
+)
+from dbt.node_types import NodeType
+from dbt_common.contracts.config.base import BaseConfig
+from dbt_common.contracts.config.metadata import Metadata
+
+
+def metas(*metas: Metadata) -> Dict[str, Any]:
+    existing: Dict[str, Any] = {}
+    for m in metas:
+        existing = m.meta(existing)
+    return existing
+
+
+def insensitive_patterns(*patterns: str):
+    lowercased = []
+    for pattern in patterns:
+        lowercased.append("".join("[{}{}]".format(s.upper(), s.lower()) for s in pattern))
+    return "^({})$".format("|".join(lowercased))
+
+
+@dataclass
+class UnitTestNodeConfig(NodeConfig):
+    expected_rows: List[Dict[str, Any]] = field(default_factory=list)
+    expected_sql: Optional[str] = None
+
+
+RESOURCE_TYPES: Dict[NodeType, Type[BaseConfig]] = {
+    NodeType.Metric: MetricConfig,
+    NodeType.SemanticModel: SemanticModelConfig,
+    NodeType.SavedQuery: SavedQueryConfig,
+    NodeType.Exposure: ExposureConfig,
+    NodeType.Source: SourceConfig,
+    NodeType.Seed: SeedConfig,
+    NodeType.Test: TestConfig,
+    NodeType.Model: ModelConfig,
+    NodeType.Snapshot: SnapshotConfig,
+    NodeType.Unit: UnitTestConfig,
+    NodeType.Group: GroupConfig,
+    NodeType.Function: FunctionConfig,
+}
+
+
+# base resource types are like resource types, except nothing has mandatory
+# configs.
+BASE_RESOURCE_TYPES: Dict[NodeType, Type[BaseConfig]] = RESOURCE_TYPES.copy()
+
+
+def get_config_for(resource_type: NodeType, base=False) -> Type[BaseConfig]:
+    if base:
+        lookup = BASE_RESOURCE_TYPES
+    else:
+        lookup = RESOURCE_TYPES
+    return lookup.get(resource_type, NodeConfig)

dbt/contracts/graph/node_args.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from dbt.artifacts.resources import NodeVersion
+from dbt.node_types import AccessType, NodeType
+
+
+@dataclass
+class ModelNodeArgs:
+    name: str
+    package_name: str
+    identifier: str
+    schema: str
+    database: Optional[str] = None
+    relation_name: Optional[str] = None
+    version: Optional[NodeVersion] = None
+    latest_version: Optional[NodeVersion] = None
+    deprecation_date: Optional[datetime] = None
+    access: Optional[str] = AccessType.Protected.value
+    generated_at: datetime = field(
+        default_factory=lambda: datetime.now(timezone.utc).replace(tzinfo=None)
+    )
+    depends_on_nodes: List[str] = field(default_factory=list)
+    enabled: bool = True
+
+    @property
+    def unique_id(self) -> str:
+        unique_id = f"{NodeType.Model}.{self.package_name}.{self.name}"
+        if self.version:
+            unique_id = f"{unique_id}.v{self.version}"
+
+        return unique_id
+
+    @property
+    def fqn(self) -> List[str]:
+        fqn = [self.package_name, self.name]
+        # Test for None explicitly because version can be 0
+        if self.version is not None:
+            fqn.append(f"v{self.version}")
+
+        return fqn