dvt-core 0.58.6__cp311-cp311-macosx_10_9_x86_64.whl

dbt/__init__.py

@@ -0,0 +1,7 @@
+# N.B.
+# This will add to the package’s __path__ all subdirectories of directories on sys.path named after the package which effectively combines both modules into a single namespace (dbt.adapters)
+# The matching statement is in plugins/postgres/dbt/__init__.py
+
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

dbt/_pydantic_shim.py

@@ -0,0 +1,26 @@
+# type: ignore
+
+"""Shim to allow support for both Pydantic 1 and Pydantic 2.
+
+dbt-core must support both major versions of Pydantic because dbt-core users might be using an environment with
+either version, and we can't restrict them to one or the other. Here, we essentially import all Pydantic objects
+from version 1 that we use. Throughout the repo, we import these objects from this file instead of from Pydantic
+directly, meaning that we essentially only use Pydantic 1 in dbt-core currently, but without forcing that restriction
+on dbt users. The development environment for this repo should be pinned to Pydantic 1 to ensure devs get appropriate
+type hints.
+"""
+
+from importlib.metadata import version
+
+pydantic_version = version("pydantic")
+# Pydantic uses semantic versioning, i.e. <major>.<minor>.<patch>, and we need to know the major
+pydantic_major = pydantic_version.split(".")[0]
+
+if pydantic_major == "1":
+    from pydantic import BaseSettings  # noqa: F401
+elif pydantic_major == "2":
+    from pydantic.v1 import BaseSettings  # noqa: F401
+else:
+    raise RuntimeError(
+        f"Currently only pydantic 1 and 2 are supported, found pydantic {pydantic_version}"
+    )

dbt/artifacts/exceptions/__init__.py

@@ -0,0 +1 @@
+from dbt.artifacts.exceptions.schemas import IncompatibleSchemaError

dbt/artifacts/exceptions/schemas.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from dbt_common.exceptions import DbtRuntimeError
+
+
+class IncompatibleSchemaError(DbtRuntimeError):
+    def __init__(self, expected: str, found: Optional[str] = None) -> None:
+        self.expected = expected
+        self.found = found
+        self.filename = "input file"
+
+        super().__init__(msg=self.get_message())
+
+    def add_filename(self, filename: str):
+        self.filename = filename
+        self.msg = self.get_message()
+
+    def get_message(self) -> str:
+        found_str = "nothing"
+        if self.found is not None:
+            found_str = f'"{self.found}"'
+
+        msg = (
+            f'Expected a schema version of "{self.expected}" in '
+            f"{self.filename}, but found {found_str}. Are you running with a "
+            f"different version of dbt?"
+        )
+        return msg
+
+    CODE = 10014
+    MESSAGE = "Incompatible Schema"

dbt/artifacts/resources/__init__.py

@@ -0,0 +1,116 @@
+from dbt.artifacts.resources.base import BaseResource, Docs, FileHash, GraphResource
+from dbt.artifacts.resources.v1.analysis import Analysis
+from dbt.artifacts.resources.v1.catalog import Catalog, CatalogWriteIntegrationConfig
+
+# alias to latest resource definitions
+from dbt.artifacts.resources.v1.components import (
+    ColumnConfig,
+    ColumnInfo,
+    CompiledResource,
+    Contract,
+    DeferRelation,
+    DependsOn,
+    FreshnessThreshold,
+    HasRelationMetadata,
+    InjectedCTE,
+    NodeVersion,
+    ParsedResource,
+    ParsedResourceMandatory,
+    Quoting,
+    RefArgs,
+    Time,
+)
+from dbt.artifacts.resources.v1.config import (
+    Hook,
+    NodeAndTestConfig,
+    NodeConfig,
+    TestConfig,
+    list_str,
+    metas,
+)
+from dbt.artifacts.resources.v1.documentation import Documentation
+from dbt.artifacts.resources.v1.exposure import (
+    Exposure,
+    ExposureConfig,
+    ExposureType,
+    MaturityType,
+)
+from dbt.artifacts.resources.v1.function import (
+    Function,
+    FunctionArgument,
+    FunctionConfig,
+    FunctionMandatory,
+    FunctionReturns,
+)
+from dbt.artifacts.resources.v1.generic_test import GenericTest, TestMetadata
+from dbt.artifacts.resources.v1.group import Group, GroupConfig
+from dbt.artifacts.resources.v1.hook import HookNode
+from dbt.artifacts.resources.v1.macro import Macro, MacroArgument, MacroDependsOn
+from dbt.artifacts.resources.v1.metric import (
+    ConstantPropertyInput,
+    ConversionTypeParams,
+    CumulativeTypeParams,
+    Metric,
+    MetricAggregationParams,
+    MetricConfig,
+    MetricInput,
+    MetricInputMeasure,
+    MetricTimeWindow,
+    MetricTypeParams,
+)
+from dbt.artifacts.resources.v1.model import (
+    CustomGranularity,
+    Model,
+    ModelConfig,
+    ModelFreshness,
+    TimeSpine,
+)
+from dbt.artifacts.resources.v1.owner import Owner
+from dbt.artifacts.resources.v1.saved_query import (
+    Export,
+    ExportConfig,
+    QueryParams,
+    SavedQuery,
+    SavedQueryConfig,
+    SavedQueryMandatory,
+)
+from dbt.artifacts.resources.v1.seed import Seed, SeedConfig
+from dbt.artifacts.resources.v1.semantic_layer_components import (
+    FileSlice,
+    MeasureAggregationParameters,
+    NonAdditiveDimension,
+    SourceFileMetadata,
+    WhereFilter,
+    WhereFilterIntersection,
+)
+from dbt.artifacts.resources.v1.semantic_model import (
+    Defaults,
+    Dimension,
+    DimensionTypeParams,
+    DimensionValidityParams,
+    Entity,
+    Measure,
+    NodeRelation,
+    SemanticLayerElementConfig,
+    SemanticModel,
+    SemanticModelConfig,
+)
+from dbt.artifacts.resources.v1.singular_test import SingularTest
+from dbt.artifacts.resources.v1.snapshot import Snapshot, SnapshotConfig
+from dbt.artifacts.resources.v1.source_definition import (
+    ExternalPartition,
+    ExternalTable,
+    ParsedSourceMandatory,
+    SourceConfig,
+    SourceDefinition,
+)
+from dbt.artifacts.resources.v1.sql_operation import SqlOperation
+from dbt.artifacts.resources.v1.unit_test_definition import (
+    UnitTestConfig,
+    UnitTestDefinition,
+    UnitTestFormat,
+    UnitTestInputFixture,
+    UnitTestNodeVersions,
+    UnitTestOutputFixture,
+    UnitTestOverrides,
+)

dbt/artifacts/resources/base.py

@@ -0,0 +1,67 @@
+import hashlib
+from dataclasses import dataclass
+from typing import List, Optional
+
+from dbt.artifacts.resources.types import NodeType
+from dbt_common.dataclass_schema import dbtClassMixin
+
+
+@dataclass
+class BaseResource(dbtClassMixin):
+    name: str
+    resource_type: NodeType
+    package_name: str
+    path: str
+    original_file_path: str
+    unique_id: str
+
+
+@dataclass
+class GraphResource(BaseResource):
+    fqn: List[str]
+
+
+@dataclass
+class FileHash(dbtClassMixin):
+    name: str  # the hash type name
+    checksum: str  # the hashlib.hash_type().hexdigest() of the file contents
+
+    @classmethod
+    def empty(cls):
+        return FileHash(name="none", checksum="")
+
+    @classmethod
+    def path(cls, path: str):
+        return FileHash(name="path", checksum=path)
+
+    def __eq__(self, other):
+        if not isinstance(other, FileHash):
+            return NotImplemented
+
+        if self.name == "none" or self.name != other.name:
+            return False
+
+        return self.checksum == other.checksum
+
+    def compare(self, contents: str) -> bool:
+        """Compare the file contents with the given hash"""
+        if self.name == "none":
+            return False
+
+        return self.from_contents(contents, name=self.name) == self.checksum
+
+    @classmethod
+    def from_contents(cls, contents: str, name="sha256") -> "FileHash":
+        """Create a file hash from the given file contents. The hash is always
+        the utf-8 encoding of the contents given, because dbt only reads files
+        as utf-8.
+        """
+        data = contents.encode("utf-8")
+        checksum = hashlib.new(name, data).hexdigest()
+        return cls(name=name, checksum=checksum)
+
+
+@dataclass
+class Docs(dbtClassMixin):
+    show: bool = True
+    node_color: Optional[str] = None

dbt/artifacts/resources/types.py

@@ -0,0 +1,93 @@
+from dbt_common.dataclass_schema import StrEnum
+
+
+class AccessType(StrEnum):
+    Private = "private"
+    Protected = "protected"
+    Public = "public"
+
+    @classmethod
+    def is_valid(cls, item):
+        try:
+            cls(item)
+        except ValueError:
+            return False
+        return True
+
+
+class NodeType(StrEnum):
+    Model = "model"
+    Analysis = "analysis"
+    Test = "test"  # renamed to 'data_test'; preserved as 'test' here for back-compat
+    Snapshot = "snapshot"
+    Operation = "operation"
+    Seed = "seed"
+    # TODO: rm?
+    RPCCall = "rpc"
+    SqlOperation = "sql_operation"
+    Documentation = "doc"
+    Source = "source"
+    Macro = "macro"
+    Exposure = "exposure"
+    Metric = "metric"
+    Group = "group"
+    SavedQuery = "saved_query"
+    SemanticModel = "semantic_model"
+    Unit = "unit_test"
+    Fixture = "fixture"
+    Function = "function"
+
+    def pluralize(self) -> str:
+        if self is self.Analysis:
+            return "analyses"
+        elif self is self.SavedQuery:
+            return "saved_queries"
+        elif self is self.Test:
+            return "data_tests"
+        return f"{self}s"
+
+
+class RunHookType(StrEnum):
+    Start = "on-run-start"
+    End = "on-run-end"
+
+
+class ModelLanguage(StrEnum):
+    python = "python"
+    sql = "sql"
+
+
+class ModelHookType(StrEnum):
+    PreHook = "pre-hook"
+    PostHook = "post-hook"
+
+
+class TimePeriod(StrEnum):
+    minute = "minute"
+    hour = "hour"
+    day = "day"
+
+    def plural(self) -> str:
+        return str(self) + "s"
+
+
+class BatchSize(StrEnum):
+    hour = "hour"
+    day = "day"
+    month = "month"
+    year = "year"
+
+    def plural(self) -> str:
+        return str(self) + "s"
+
+
+class FunctionType(StrEnum):
+    Scalar = "scalar"
+    Aggregate = "aggregate"
+    Table = "table"
+
+
+class FunctionVolatility(StrEnum):
+    Deterministic = "deterministic"
+    Stable = "stable"
+    NonDeterministic = "non-deterministic"

dbt/artifacts/resources/v1/analysis.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Literal
+
+from dbt.artifacts.resources.types import NodeType
+from dbt.artifacts.resources.v1.components import CompiledResource
+
+
+@dataclass
+class Analysis(CompiledResource):
+    resource_type: Literal[NodeType.Analysis]

dbt/artifacts/resources/v1/catalog.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from dbt.adapters.catalogs import CatalogIntegrationConfig
+from dbt_common.dataclass_schema import dbtClassMixin
+
+
+@dataclass
+class CatalogWriteIntegrationConfig(CatalogIntegrationConfig):
+    name: str
+    catalog_type: str
+    external_volume: Optional[str] = None
+    table_format: Optional[str] = None
+    catalog_name: Optional[str] = None
+    file_format: Optional[str] = None
+    adapter_properties: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Catalog(dbtClassMixin):
+    name: str
+    active_write_integration: Optional[str] = None
+    write_integrations: List[CatalogWriteIntegrationConfig] = field(default_factory=list)

dbt/artifacts/resources/v1/components.py

@@ -0,0 +1,274 @@
+import time
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Any, Dict, List, Optional, Union
+
+from dbt.artifacts.resources.base import Docs, FileHash, GraphResource
+from dbt.artifacts.resources.types import NodeType, TimePeriod
+from dbt.artifacts.resources.v1.config import NodeConfig
+from dbt_common.contracts.config.base import BaseConfig, MergeBehavior
+from dbt_common.contracts.config.properties import AdditionalPropertiesMixin
+from dbt_common.contracts.constraints import ColumnLevelConstraint
+from dbt_common.contracts.util import Mergeable
+from dbt_common.dataclass_schema import ExtensibleDbtClassMixin, dbtClassMixin
+from dbt_semantic_interfaces.type_enums import TimeGranularity
+
+NodeVersion = Union[str, float]
+
+
+def _backcompat_doc_blocks(doc_blocks: Any) -> List[str]:
+    """
+    Make doc_blocks backwards-compatible for scenarios where a user specifies `doc_blocks` on a model or column.
+    Mashumaro will raise a serialization error if the specified `doc_blocks` isn't a list of strings.
+    In such a scenario, this method returns an empty list to avoid a serialization error.
+    Further along, `_get_doc_blocks` in `manifest.py` populates the correct `doc_blocks` for the happy path.
+    """
+
+    if isinstance(doc_blocks, list) and all(isinstance(x, str) for x in doc_blocks):
+        return doc_blocks
+
+    return []
+
+
+@dataclass
+class MacroDependsOn(dbtClassMixin):
+    macros: List[str] = field(default_factory=list)
+
+    # 'in' on lists is O(n) so this is O(n^2) for # of macros
+    def add_macro(self, value: str):
+        if value not in self.macros:
+            self.macros.append(value)
+
+
+@dataclass
+class DependsOn(MacroDependsOn):
+    nodes: List[str] = field(default_factory=list)
+
+    def add_node(self, value: str):
+        if value not in self.nodes:
+            self.nodes.append(value)
+
+
+@dataclass
+class RefArgs(dbtClassMixin):
+    name: str
+    package: Optional[str] = None
+    version: Optional[NodeVersion] = None
+
+    @property
+    def positional_args(self) -> List[str]:
+        if self.package:
+            return [self.package, self.name]
+        else:
+            return [self.name]
+
+    @property
+    def keyword_args(self) -> Dict[str, Optional[NodeVersion]]:
+        if self.version:
+            return {"version": self.version}
+        else:
+            return {}
+
+
+@dataclass
+class ColumnConfig(BaseConfig):
+    meta: Dict[str, Any] = field(default_factory=dict, metadata=MergeBehavior.Update.meta())
+    tags: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ColumnInfo(AdditionalPropertiesMixin, ExtensibleDbtClassMixin):
+    """Used in all ManifestNodes and SourceDefinition"""
+
+    name: str
+    description: str = ""
+    meta: Dict[str, Any] = field(default_factory=dict)
+    data_type: Optional[str] = None
+    constraints: List[ColumnLevelConstraint] = field(default_factory=list)
+    quote: Optional[bool] = None
+    config: ColumnConfig = field(default_factory=ColumnConfig)
+    tags: List[str] = field(default_factory=list)
+    _extra: Dict[str, Any] = field(default_factory=dict)
+    granularity: Optional[TimeGranularity] = None
+    doc_blocks: List[str] = field(default_factory=list)
+
+    def __post_serialize__(self, dct: Dict, context: Optional[Dict] = None) -> dict:
+        dct = super().__post_serialize__(dct, context)
+        dct["doc_blocks"] = _backcompat_doc_blocks(dct["doc_blocks"])
+        return dct
+
+
+@dataclass
+class InjectedCTE(dbtClassMixin):
+    """Used in CompiledNodes as part of ephemeral model processing"""
+
+    id: str
+    sql: str
+
+
+@dataclass
+class Contract(dbtClassMixin):
+    enforced: bool = False
+    alias_types: bool = True
+    checksum: Optional[str] = None
+
+
+@dataclass
+class Quoting(dbtClassMixin, Mergeable):
+    database: Optional[bool] = None
+    schema: Optional[bool] = None
+    identifier: Optional[bool] = None
+    column: Optional[bool] = None
+
+
+@dataclass
+class Time(dbtClassMixin, Mergeable):
+    count: Optional[int] = None
+    period: Optional[TimePeriod] = None
+
+    def exceeded(self, actual_age: float) -> bool:
+        if self.period is None or self.count is None:
+            return False
+        kwargs: Dict[str, int] = {self.period.plural(): self.count}
+        difference = timedelta(**kwargs).total_seconds()
+        return actual_age > difference
+
+    def __bool__(self):
+        return self.count is not None and self.period is not None
+
+
+@dataclass
+class FreshnessThreshold(dbtClassMixin, Mergeable):
+    warn_after: Optional[Time] = field(default_factory=Time)
+    error_after: Optional[Time] = field(default_factory=Time)
+    filter: Optional[str] = None
+
+    def status(self, age: float) -> "dbt.artifacts.schemas.results.FreshnessStatus":  # type: ignore # noqa F821
+        from dbt.artifacts.schemas.results import FreshnessStatus
+
+        if self.error_after and self.error_after.exceeded(age):
+            return FreshnessStatus.Error
+        elif self.warn_after and self.warn_after.exceeded(age):
+            return FreshnessStatus.Warn
+        else:
+            return FreshnessStatus.Pass
+
+    def __bool__(self):
+        return bool(self.warn_after) or bool(self.error_after)
+
+
+@dataclass
+class HasRelationMetadata(dbtClassMixin):
+    database: Optional[str]
+    schema: str
+
+    # Can't set database to None like it ought to be
+    # because it messes up the subclasses and default parameters
+    # so hack it here
+    @classmethod
+    def __pre_deserialize__(cls, data):
+        data = super().__pre_deserialize__(data)
+        if "database" not in data:
+            data["database"] = None
+        return data
+
+    @property
+    def quoting_dict(self) -> Dict[str, bool]:
+        if hasattr(self, "quoting"):
+            return self.quoting.to_dict(omit_none=True)
+        else:
+            return {}
+
+
+@dataclass
+class DeferRelation(HasRelationMetadata):
+    alias: str
+    relation_name: Optional[str]
+    # The rest of these fields match RelationConfig protocol exactly
+    resource_type: NodeType
+    name: str
+    description: str
+    compiled_code: Optional[str]
+    meta: Dict[str, Any]
+    tags: List[str]
+    config: Optional[NodeConfig]
+
+    @property
+    def identifier(self):
+        return self.alias
+
+
+@dataclass
+class ParsedResourceMandatory(GraphResource, HasRelationMetadata):
+    alias: str
+    checksum: FileHash
+    config: NodeConfig = field(default_factory=NodeConfig)
+
+    @property
+    def identifier(self):
+        return self.alias
+
+
+@dataclass
+class ParsedResource(ParsedResourceMandatory):
+    tags: List[str] = field(default_factory=list)
+    description: str = field(default="")
+    columns: Dict[str, ColumnInfo] = field(default_factory=dict)
+    meta: Dict[str, Any] = field(default_factory=dict)
+    group: Optional[str] = None
+    docs: Docs = field(default_factory=Docs)
+    patch_path: Optional[str] = None
+    build_path: Optional[str] = None
+    unrendered_config: Dict[str, Any] = field(default_factory=dict)
+    created_at: float = field(default_factory=lambda: time.time())
+    config_call_dict: Dict[str, Any] = field(default_factory=dict)
+    unrendered_config_call_dict: Dict[str, Any] = field(default_factory=dict)
+    relation_name: Optional[str] = None
+    raw_code: str = ""
+    doc_blocks: List[str] = field(default_factory=list)
+
+    def __post_serialize__(self, dct: Dict, context: Optional[Dict] = None):
+        dct = super().__post_serialize__(dct, context)
+
+        if context and context.get("artifact") and "config_call_dict" in dct:
+            del dct["config_call_dict"]
+        if context and context.get("artifact") and "unrendered_config_call_dict" in dct:
+            del dct["unrendered_config_call_dict"]
+
+        dct["doc_blocks"] = _backcompat_doc_blocks(dct["doc_blocks"])
+
+        return dct
+
+
+@dataclass
+class CompiledResource(ParsedResource):
+    """Contains attributes necessary for SQL files and nodes with refs, sources, etc,
+    so all ManifestNodes except SeedNode."""
+
+    language: str = "sql"
+    refs: List[RefArgs] = field(default_factory=list)
+    sources: List[List[str]] = field(default_factory=list)
+    metrics: List[List[str]] = field(default_factory=list)
+    functions: List[List[str]] = field(default_factory=list)
+    depends_on: DependsOn = field(default_factory=DependsOn)
+    compiled_path: Optional[str] = None
+    compiled: bool = False
+    compiled_code: Optional[str] = None
+    extra_ctes_injected: bool = False
+    extra_ctes: List[InjectedCTE] = field(default_factory=list)
+    _pre_injected_sql: Optional[str] = None
+    contract: Contract = field(default_factory=Contract)
+
+    def __post_serialize__(self, dct: Dict, context: Optional[Dict] = None):
+        dct = super().__post_serialize__(dct, context)
+        if "_pre_injected_sql" in dct:
+            del dct["_pre_injected_sql"]
+        # Remove compiled attributes
+        if "compiled" in dct and dct["compiled"] is False:
+            del dct["compiled"]
+            del dct["extra_ctes_injected"]
+            del dct["extra_ctes"]
+            # "omit_none" means these might not be in the dictionary
+            if "compiled_code" in dct:
+                del dct["compiled_code"]
+        return dct