Dict[str, Any]:\n451 | dct = self.to_dict(omit_none=True)\n452 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n453 | for key in remove_keys:\n454 | if key in dct:\n455 | del dct[key]\n456 | \n457 | if self.freshness is None:\n458 | dct[\"freshness\"] = None\n459 | \n460 | return dct\n461 | \n462 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n463 | if self.tables is not None:\n464 | for table in self.tables:\n465 | if table.name == name:\n466 | return table\n467 | return None\n468 | \n469 | \n470 | @dataclass\n471 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n472 | package_name: str\n473 | path: str\n474 | original_file_path: str\n475 | \n476 | @property\n477 | def file_id(self):\n478 | return f\"{self.package_name}://{self.original_file_path}\"\n479 | \n480 | @property\n481 | def resource_type(self):\n482 | return NodeType.Documentation\n483 | \n484 | \n485 | @dataclass\n486 | class UnparsedDocumentationFile(UnparsedDocumentation):\n487 | file_contents: str\n488 | \n489 | \n490 | # can't use total_ordering decorator here, as str provides an ordering already\n491 | # and it's not the one we want.\n492 | class Maturity(StrEnum):\n493 | low = \"low\"\n494 | medium = \"medium\"\n495 | high = \"high\"\n496 | \n497 | def __lt__(self, other):\n498 | if not isinstance(other, Maturity):\n499 | return NotImplemented\n500 | order = (Maturity.low, Maturity.medium, Maturity.high)\n501 | return order.index(self) < order.index(other)\n502 | \n503 | def __gt__(self, other):\n504 | if not isinstance(other, Maturity):\n505 | return NotImplemented\n506 | return self != other and not (self < other)\n507 | \n508 | def __ge__(self, other):\n509 | if not isinstance(other, Maturity):\n510 | return NotImplemented\n511 | return self == other or not (self < other)\n512 | \n513 | def __le__(self, other):\n514 | if not isinstance(other, Maturity):\n515 | return NotImplemented\n516 | return self == other or self < other\n517 | \n518 | \n519 | class ExposureType(StrEnum):\n520 | Dashboard = \"dashboard\"\n521 | Notebook = \"notebook\"\n522 | Analysis = \"analysis\"\n523 | ML = \"ml\"\n524 | Application = \"application\"\n525 | \n526 | \n527 | class MaturityType(StrEnum):\n528 | Low = \"low\"\n529 | Medium = \"medium\"\n530 | High = \"high\"\n531 | \n532 | \n533 | @dataclass\n534 | class Owner(AdditionalPropertiesAllowed, Replaceable):\n535 | email: Optional[str] = None\n536 | name: Optional[str] = None\n537 | \n538 | \n539 | @dataclass\n540 | class UnparsedExposure(dbtClassMixin, Replaceable):\n541 | name: str\n542 | type: ExposureType\n543 | owner: Owner\n544 | description: str = \"\"\n545 | label: Optional[str] = None\n546 | maturity: Optional[MaturityType] = None\n547 | meta: Dict[str, Any] = field(default_factory=dict)\n548 | tags: List[str] = field(default_factory=list)\n549 | url: Optional[str] = None\n550 | depends_on: List[str] = field(default_factory=list)\n551 | config: Dict[str, Any] = field(default_factory=dict)\n552 | \n553 | @classmethod\n554 | def validate(cls, data):\n555 | super(UnparsedExposure, cls).validate(data)\n556 | if \"name\" in data:\n557 | # name can only contain alphanumeric chars and underscores\n558 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n559 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n560 | \n561 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n562 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n563 | \n564 | \n565 | @dataclass\n566 | class MetricFilter(dbtClassMixin, Replaceable):\n567 | field: str\n568 | operator: str\n569 | # TODO : Can we make this Any?\n570 | value: str\n571 | \n572 | \n573 | class MetricTimePeriod(StrEnum):\n574 | day = \"day\"\n575 | week = \"week\"\n576 | month = \"month\"\n577 | year = \"year\"\n578 | \n579 | def plural(self) -> str:\n580 | return str(self) + \"s\"\n581 | \n582 | \n583 | @dataclass\n584 | class MetricTime(dbtClassMixin, Mergeable):\n585 | count: Optional[int] = None\n586 | period: Optional[MetricTimePeriod] = None\n587 | \n588 | def __bool__(self):\n589 | return self.count is not None and self.period is not None\n590 | \n591 | \n592 | @dataclass\n593 | class UnparsedMetricInputMeasure(dbtClassMixin):\n594 | name: str\n595 | filter: Optional[Union[str, List[str]]] = None\n596 | alias: Optional[str] = None\n597 | join_to_timespine: bool = False\n598 | fill_nulls_with: Optional[int] = None\n599 | \n600 | \n601 | @dataclass\n602 | class UnparsedMetricInput(dbtClassMixin):\n603 | name: str\n604 | filter: Optional[Union[str, List[str]]] = None\n605 | alias: Optional[str] = None\n606 | offset_window: Optional[str] = None\n607 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n608 | \n609 | \n610 | @dataclass\n611 | class ConstantPropertyInput(dbtClassMixin):\n612 | base_property: str\n613 | conversion_property: str\n614 | \n615 | \n616 | @dataclass\n617 | class UnparsedConversionTypeParams(dbtClassMixin):\n618 | base_measure: Union[UnparsedMetricInputMeasure, str]\n619 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n620 | entity: str\n621 | calculation: str = (\n622 | ConversionCalculationType.CONVERSION_RATE.value\n623 | ) # ConversionCalculationType Enum\n624 | window: Optional[str] = None\n625 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n626 | \n627 | \n628 | @dataclass\n629 | class UnparsedMetricTypeParams(dbtClassMixin):\n630 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n631 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n632 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n633 | expr: Optional[Union[str, bool]] = None\n634 | window: Optional[str] = None\n635 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n636 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n637 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n638 | \n639 | \n640 | @dataclass\n641 | class UnparsedMetric(dbtClassMixin):\n642 | name: str\n643 | label: str\n644 | type: str\n645 | type_params: UnparsedMetricTypeParams\n646 | description: str = \"\"\n647 | filter: Optional[Union[str, List[str]]] = None\n648 | # metadata: Optional[Unparsedetadata] = None # TODO\n649 | meta: Dict[str, Any] = field(default_factory=dict)\n650 | tags: List[str] = field(default_factory=list)\n651 | config: Dict[str, Any] = field(default_factory=dict)\n652 | \n653 | @classmethod\n654 | def validate(cls, data):\n655 | super(UnparsedMetric, cls).validate(data)\n656 | if \"name\" in data:\n657 | errors = []\n658 | if \" \" in data[\"name\"]:\n659 | errors.append(\"cannot contain spaces\")\n660 | # This handles failing queries due to too long metric names.\n661 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n662 | if len(data[\"name\"]) > 250:\n663 | errors.append(\"cannot contain more than 250 characters\")\n664 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n665 | errors.append(\"must begin with a letter\")\n666 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n667 | errors.append(\"must contain only letters, numbers and underscores\")\n668 | \n669 | if errors:\n670 | raise ParsingError(\n671 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n672 | )\n673 | \n674 | \n675 | @dataclass\n676 | class UnparsedGroup(dbtClassMixin, Replaceable):\n677 | name: str\n678 | owner: Owner\n679 | \n680 | @classmethod\n681 | def validate(cls, data):\n682 | super(UnparsedGroup, cls).validate(data)\n683 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n684 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n685 | \n686 | \n687 | #\n688 | # semantic interfaces unparsed objects\n689 | #\n690 | \n691 | \n692 | @dataclass\n693 | class UnparsedEntity(dbtClassMixin):\n694 | name: str\n695 | type: str # EntityType enum\n696 | description: Optional[str] = None\n697 | label: Optional[str] = None\n698 | role: Optional[str] = None\n699 | expr: Optional[str] = None\n700 | \n701 | \n702 | @dataclass\n703 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n704 | name: str\n705 | window_choice: str # AggregationType enum\n706 | window_groupings: List[str] = field(default_factory=list)\n707 | \n708 | \n709 | @dataclass\n710 | class UnparsedMeasure(dbtClassMixin):\n711 | name: str\n712 | agg: str # actually an enum\n713 | description: Optional[str] = None\n714 | label: Optional[str] = None\n715 | expr: Optional[Union[str, bool, int]] = None\n716 | agg_params: Optional[MeasureAggregationParameters] = None\n717 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n718 | agg_time_dimension: Optional[str] = None\n719 | create_metric: bool = False\n720 | \n721 | \n722 | @dataclass\n723 | class UnparsedDimensionTypeParams(dbtClassMixin):\n724 | time_granularity: str # TimeGranularity enum\n725 | validity_params: Optional[DimensionValidityParams] = None\n726 | \n727 | \n728 | @dataclass\n729 | class UnparsedDimension(dbtClassMixin):\n730 | name: str\n731 | type: str # actually an enum\n732 | description: Optional[str] = None\n733 | label: Optional[str] = None\n734 | is_partition: bool = False\n735 | type_params: Optional[UnparsedDimensionTypeParams] = None\n736 | expr: Optional[str] = None\n737 | \n738 | \n739 | @dataclass\n740 | class UnparsedSemanticModel(dbtClassMixin):\n741 | name: str\n742 | model: str # looks like \"ref(...)\"\n743 | config: Dict[str, Any] = field(default_factory=dict)\n744 | description: Optional[str] = None\n745 | label: Optional[str] = None\n746 | defaults: Optional[Defaults] = None\n747 | entities: List[UnparsedEntity] = field(default_factory=list)\n748 | measures: List[UnparsedMeasure] = field(default_factory=list)\n749 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n750 | primary_entity: Optional[str] = None\n751 | \n752 | \n753 | @dataclass\n754 | class UnparsedQueryParams(dbtClassMixin):\n755 | metrics: List[str] = field(default_factory=list)\n756 | group_by: List[str] = field(default_factory=list)\n757 | where: Optional[Union[str, List[str]]] = None\n758 | \n759 | \n760 | @dataclass\n761 | class UnparsedExport(dbtClassMixin):\n762 | \"\"\"Configuration for writing query results to a table.\"\"\"\n763 | \n764 | name: str\n765 | config: Dict[str, Any] = field(default_factory=dict)\n766 | \n767 | \n768 | @dataclass\n769 | class UnparsedSavedQuery(dbtClassMixin):\n770 | name: str\n771 | query_params: UnparsedQueryParams\n772 | description: Optional[str] = None\n773 | label: Optional[str] = None\n774 | exports: List[UnparsedExport] = field(default_factory=list)\n775 | config: Dict[str, Any] = field(default_factory=dict)\n776 | \n777 | \n778 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n779 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n780 | if d is None:\n781 | return None\n782 | \n783 | # convert date to datetime\n784 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n785 | \n786 | if not dt.tzinfo:\n787 | # date is naive, re-interpret as system time zone\n788 | dt = dt.astimezone()\n789 | \n790 | return dt\n791 | \n792 | \n793 | class UnitTestFormat(StrEnum):\n794 | CSV = \"csv\"\n795 | Dict = \"dict\"\n796 | \n797 | \n798 | @dataclass\n799 | class UnitTestInputFixture(dbtClassMixin):\n800 | input: str\n801 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n802 | format: UnitTestFormat = UnitTestFormat.Dict\n803 | fixture: Optional[str] = None\n804 | \n805 | \n806 | @dataclass\n807 | class UnitTestOutputFixture(dbtClassMixin):\n808 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n809 | format: UnitTestFormat = UnitTestFormat.Dict\n810 | fixture: Optional[str] = None\n811 | \n812 | \n813 | @dataclass\n814 | class UnitTestOverrides(dbtClassMixin):\n815 | macros: Dict[str, Any] = field(default_factory=dict)\n816 | vars: Dict[str, Any] = field(default_factory=dict)\n817 | env_vars: Dict[str, Any] = field(default_factory=dict)\n818 | \n819 | \n820 | @dataclass\n821 | class UnparsedUnitTest(dbtClassMixin):\n822 | name: str\n823 | model: str # name of the model being unit tested\n824 | given: Sequence[UnitTestInputFixture]\n825 | expect: UnitTestOutputFixture\n826 | description: str = \"\"\n827 | overrides: Optional[UnitTestOverrides] = None\n828 | config: Dict[str, Any] = field(default_factory=dict)\n```\n\n### File: core/dbt/parser/schemas.py\n\n```python\n 1 | import datetime\n 2 | import time\n 3 | \n 4 | from abc import ABCMeta, abstractmethod\n 5 | from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Type, TypeVar\n 6 | from dataclasses import dataclass, field\n 7 | \n 8 | from dbt import deprecations\n 9 | from dbt_common.contracts.constraints import ConstraintType, ModelLevelConstraint\n 10 | from dbt_common.dataclass_schema import ValidationError, dbtClassMixin\n 11 | \n 12 | from dbt.clients.yaml_helper import load_yaml_text\n 13 | from dbt.parser.schema_renderer import SchemaYamlRenderer\n 14 | from dbt.parser.schema_generic_tests import SchemaGenericTestParser\n 15 | from dbt.context.context_config import ContextConfig\n 16 | from dbt.context.configured import generate_schema_yml_context, SchemaYamlVars\n 17 | from dbt.contracts.files import SchemaSourceFile\n 18 | from dbt.contracts.graph.nodes import (\n 19 | ParsedNodePatch,\n 20 | ParsedMacroPatch,\n 21 | UnpatchedSourceDefinition,\n 22 | ModelNode,\n 23 | )\n 24 | from dbt.contracts.graph.unparsed import (\n 25 | HasColumnDocs,\n 26 | HasColumnTests,\n 27 | SourcePatch,\n 28 | UnparsedAnalysisUpdate,\n 29 | UnparsedMacroUpdate,\n 30 | UnparsedNodeUpdate,\n 31 | UnparsedModelUpdate,\n 32 | UnparsedSourceDefinition,\n 33 | )\n 34 | from dbt.exceptions import (\n 35 | DuplicateMacroPatchNameError,\n 36 | DuplicatePatchPathError,\n 37 | DuplicateSourcePatchNameError,\n 38 | JSONValidationError,\n 39 | DbtInternalError,\n 40 | ParsingError,\n 41 | YamlLoadError,\n 42 | YamlParseDictError,\n 43 | YamlParseListError,\n 44 | InvalidAccessTypeError,\n 45 | )\n 46 | from dbt_common.exceptions import DbtValidationError\n 47 | from dbt_common.events.functions import warn_or_error\n 48 | from dbt.events.types import (\n 49 | MacroNotFoundForPatch,\n 50 | NoNodeForYamlKey,\n 51 | ValidationWarning,\n 52 | UnsupportedConstraintMaterialization,\n 53 | WrongResourceSchemaFile,\n 54 | )\n 55 | from dbt.node_types import NodeType, AccessType\n 56 | from dbt.parser.base import SimpleParser\n 57 | from dbt.parser.search import FileBlock\n 58 | from dbt.parser.common import (\n 59 | YamlBlock,\n 60 | TargetBlock,\n 61 | TestBlock,\n 62 | VersionedTestBlock,\n 63 | ParserRef,\n 64 | trimmed,\n 65 | )\n 66 | from dbt.utils import coerce_dict_str\n 67 | from dbt_common.utils import deep_merge\n 68 | \n 69 | \n 70 | schema_file_keys = (\n 71 | \"models\",\n 72 | \"seeds\",\n 73 | \"snapshots\",\n 74 | \"sources\",\n 75 | \"macros\",\n 76 | \"analyses\",\n 77 | \"exposures\",\n 78 | \"metrics\",\n 79 | \"semantic_models\",\n 80 | \"saved_queries\",\n 81 | )\n 82 | \n 83 | \n 84 | # ===============================================================================\n 85 | # Schema Parser classes\n 86 | #\n 87 | # The SchemaParser is a subclass of the SimpleParser from base.py, as is\n 88 | # the SchemaGenericTestParser. The schema sub-parsers are all subclasses of\n 89 | # the YamlReader parsing class. Most of the action in creating SourceDefinition\n 90 | # nodes actually happens in the SourcePatcher class, in sources.py, which is\n 91 | # called as a late-stage parsing step in manifest.py.\n 92 | #\n 93 | # The \"patch\" parsers read yaml config and properties and apply them to\n 94 | # nodes that were already created from sql files.\n 95 | #\n 96 | # The SchemaParser and SourcePatcher both use the SchemaGenericTestParser\n 97 | # (in schema_generic_tests.py) to create generic test nodes.\n 98 | #\n 99 | # YamlReader\n100 | # MetricParser (metrics) [schema_yaml_readers.py]\n101 | # ExposureParser (exposures) [schema_yaml_readers.py]\n102 | # GroupParser (groups) [schema_yaml_readers.py]\n103 | # SourceParser (sources)\n104 | # PatchParser\n105 | # MacroPatchParser (macros)\n106 | # NodePatchParser\n107 | # ModelPatchParser (models)\n108 | # AnalysisPatchParser (analyses)\n109 | # TestablePatchParser (seeds, snapshots)\n110 | #\n111 | # ===============================================================================\n112 | \n113 | \n114 | def yaml_from_file(source_file: SchemaSourceFile) -> Dict[str, Any]:\n115 | \"\"\"If loading the yaml fails, raise an exception.\"\"\"\n116 | try:\n117 | # source_file.contents can sometimes be None\n118 | return load_yaml_text(source_file.contents or \"\", source_file.path)\n119 | except DbtValidationError as e:\n120 | raise YamlLoadError(\n121 | project_name=source_file.project_name, path=source_file.path.relative_path, exc=e\n122 | )\n123 | \n124 | \n125 | # This is the main schema file parser, but almost everything happens in the\n126 | # the schema sub-parsers.\n127 | class SchemaParser(SimpleParser[YamlBlock, ModelNode]):\n128 | def __init__(\n129 | self,\n130 | project,\n131 | manifest,\n132 | root_project,\n133 | ) -> None:\n134 | super().__init__(project, manifest, root_project)\n135 | \n136 | self.generic_test_parser = SchemaGenericTestParser(project, manifest, root_project)\n137 | \n138 | self.schema_yaml_vars = SchemaYamlVars()\n139 | self.render_ctx = generate_schema_yml_context(\n140 | self.root_project, self.project.project_name, self.schema_yaml_vars\n141 | )\n142 | \n143 | # This is unnecessary, but mypy was requiring it. Clean up parser code so\n144 | # we don't have to do this.\n145 | def parse_from_dict(self, dct):\n146 | pass\n147 | \n148 | @classmethod\n149 | def get_compiled_path(cls, block: FileBlock) -> str:\n150 | # should this raise an error?\n151 | return block.path.relative_path\n152 | \n153 | @property\n154 | def resource_type(self) -> NodeType:\n155 | return NodeType.Test\n156 | \n157 | def parse_file(self, block: FileBlock, dct: Optional[Dict] = None) -> None:\n158 | assert isinstance(block.file, SchemaSourceFile)\n159 | \n160 | # If partially parsing, dct should be from pp_dict, otherwise\n161 | # dict_from_yaml\n162 | if dct:\n163 | # contains the FileBlock and the data (dictionary)\n164 | yaml_block = YamlBlock.from_file_block(block, dct)\n165 | \n166 | parser: YamlReader\n167 | \n168 | # There are 9 different yaml lists which are parsed by different parsers:\n169 | # Model, Seed, Snapshot, Source, Macro, Analysis, Exposure, Metric, Group\n170 | \n171 | # ModelPatchParser.parse()\n172 | if \"models\" in dct:\n173 | # the models are already in the manifest as nodes when we reach this code,\n174 | # even if they are disabled in the schema file\n175 | model_parse_result = ModelPatchParser(self, yaml_block, \"models\").parse()\n176 | for versioned_test_block in model_parse_result.versioned_test_blocks:\n177 | self.generic_test_parser.parse_versioned_tests(versioned_test_block)\n178 | \n179 | # PatchParser.parse()\n180 | if \"seeds\" in dct:\n181 | seed_parse_result = TestablePatchParser(self, yaml_block, \"seeds\").parse()\n182 | for test_block in seed_parse_result.test_blocks:\n183 | self.generic_test_parser.parse_tests(test_block)\n184 | \n185 | # PatchParser.parse()\n186 | if \"snapshots\" in dct:\n187 | snapshot_parse_result = TestablePatchParser(self, yaml_block, \"snapshots\").parse()\n188 | for test_block in snapshot_parse_result.test_blocks:\n189 | self.generic_test_parser.parse_tests(test_block)\n190 | \n191 | # This parser uses SourceParser.parse() which doesn't return\n192 | # any test blocks. Source tests are handled at a later point\n193 | # in the process.\n194 | if \"sources\" in dct:\n195 | parser = SourceParser(self, yaml_block, \"sources\")\n196 | parser.parse()\n197 | \n198 | # PatchParser.parse() (but never test_blocks)\n199 | if \"macros\" in dct:\n200 | parser = MacroPatchParser(self, yaml_block, \"macros\")\n201 | parser.parse()\n202 | \n203 | # PatchParser.parse() (but never test_blocks)\n204 | if \"analyses\" in dct:\n205 | parser = AnalysisPatchParser(self, yaml_block, \"analyses\")\n206 | parser.parse()\n207 | \n208 | # ExposureParser.parse()\n209 | if \"exposures\" in dct:\n210 | from dbt.parser.schema_yaml_readers import ExposureParser\n211 | \n212 | exp_parser = ExposureParser(self, yaml_block)\n213 | exp_parser.parse()\n214 | \n215 | # MetricParser.parse()\n216 | if \"metrics\" in dct:\n217 | from dbt.parser.schema_yaml_readers import MetricParser\n218 | \n219 | metric_parser = MetricParser(self, yaml_block)\n220 | metric_parser.parse()\n221 | \n222 | # GroupParser.parse()\n223 | if \"groups\" in dct:\n224 | from dbt.parser.schema_yaml_readers import GroupParser\n225 | \n226 | group_parser = GroupParser(self, yaml_block)\n227 | group_parser.parse()\n228 | \n229 | if \"semantic_models\" in dct:\n230 | from dbt.parser.schema_yaml_readers import SemanticModelParser\n231 | \n232 | semantic_model_parser = SemanticModelParser(self, yaml_block)\n233 | semantic_model_parser.parse()\n234 | \n235 | if \"unit_tests\" in dct:\n236 | from dbt.parser.unit_tests import UnitTestParser\n237 | \n238 | unit_test_parser = UnitTestParser(self, yaml_block)\n239 | unit_test_parser.parse()\n240 | \n241 | if \"saved_queries\" in dct:\n242 | from dbt.parser.schema_yaml_readers import SavedQueryParser\n243 | \n244 | saved_query_parser = SavedQueryParser(self, yaml_block)\n245 | saved_query_parser.parse()\n246 | \n247 | \n248 | Parsed = TypeVar(\"Parsed\", UnpatchedSourceDefinition, ParsedNodePatch, ParsedMacroPatch)\n249 | NodeTarget = TypeVar(\"NodeTarget\", UnparsedNodeUpdate, UnparsedAnalysisUpdate, UnparsedModelUpdate)\n250 | NonSourceTarget = TypeVar(\n251 | \"NonSourceTarget\",\n252 | UnparsedNodeUpdate,\n253 | UnparsedAnalysisUpdate,\n254 | UnparsedMacroUpdate,\n255 | UnparsedModelUpdate,\n256 | )\n257 | \n258 | \n259 | @dataclass\n260 | class ParseResult:\n261 | test_blocks: List[TestBlock] = field(default_factory=list)\n262 | versioned_test_blocks: List[VersionedTestBlock] = field(default_factory=list)\n263 | \n264 | \n265 | # abstract base class (ABCMeta)\n266 | # Many subclasses: MetricParser, ExposureParser, GroupParser, SourceParser,\n267 | # PatchParser, SemanticModelParser, SavedQueryParser, UnitTestParser\n268 | class YamlReader(metaclass=ABCMeta):\n269 | def __init__(self, schema_parser: SchemaParser, yaml: YamlBlock, key: str) -> None:\n270 | self.schema_parser = schema_parser\n271 | # key: models, seeds, snapshots, sources, macros,\n272 | # analyses, exposures, unit_tests\n273 | self.key = key\n274 | self.yaml = yaml\n275 | self.schema_yaml_vars = SchemaYamlVars()\n276 | self.render_ctx = generate_schema_yml_context(\n277 | self.schema_parser.root_project,\n278 | self.schema_parser.project.project_name,\n279 | self.schema_yaml_vars,\n280 | )\n281 | self.renderer = SchemaYamlRenderer(self.render_ctx, self.key)\n282 | \n283 | @property\n284 | def manifest(self):\n285 | return self.schema_parser.manifest\n286 | \n287 | @property\n288 | def project(self):\n289 | return self.schema_parser.project\n290 | \n291 | @property\n292 | def default_database(self):\n293 | return self.schema_parser.default_database\n294 | \n295 | @property\n296 | def root_project(self):\n297 | return self.schema_parser.root_project\n298 | \n299 | # for the different schema subparsers ('models', 'source', etc)\n300 | # get the list of dicts pointed to by the key in the yaml config,\n301 | # ensure that the dicts have string keys\n302 | def get_key_dicts(self) -> Iterable[Dict[str, Any]]:\n303 | data = self.yaml.data.get(self.key, [])\n304 | if not isinstance(data, list):\n305 | raise ParsingError(\n306 | \"{} must be a list, got {} instead: ({})\".format(\n307 | self.key, type(data), trimmed(str(data))\n308 | )\n309 | )\n310 | path = self.yaml.path.original_file_path\n311 | \n312 | # for each dict in the data (which is a list of dicts)\n313 | for entry in data:\n314 | \n315 | # check that entry is a dict and that all dict values\n316 | # are strings\n317 | if coerce_dict_str(entry) is None:\n318 | raise YamlParseListError(path, self.key, data, \"expected a dict with string keys\")\n319 | \n320 | if \"name\" not in entry and \"model\" not in entry:\n321 | raise ParsingError(\"Entry did not contain a name\")\n322 | \n323 | # Render the data (except for tests, data_tests and descriptions).\n324 | # See the SchemaYamlRenderer\n325 | entry = self.render_entry(entry)\n326 | if self.schema_yaml_vars.env_vars:\n327 | self.schema_parser.manifest.env_vars.update(self.schema_yaml_vars.env_vars)\n328 | schema_file = self.yaml.file\n329 | assert isinstance(schema_file, SchemaSourceFile)\n330 | for var in self.schema_yaml_vars.env_vars.keys():\n331 | schema_file.add_env_var(var, self.key, entry[\"name\"])\n332 | self.schema_yaml_vars.env_vars = {}\n333 | \n334 | yield entry\n335 | \n336 | def render_entry(self, dct):\n337 | try:\n338 | # This does a deep_map which will fail if there are circular references\n339 | dct = self.renderer.render_data(dct)\n340 | except ParsingError as exc:\n341 | raise ParsingError(\n342 | f\"Failed to render {self.yaml.file.path.original_file_path} from \"\n343 | f\"project {self.project.project_name}: {exc}\"\n344 | ) from exc\n345 | return dct\n346 | \n347 | @abstractmethod\n348 | def parse(self) -> ParseResult:\n349 | raise NotImplementedError(\"parse is abstract\")\n350 | \n351 | \n352 | T = TypeVar(\"T\", bound=dbtClassMixin)\n353 | \n354 | \n355 | # This parses the 'sources' keys in yaml files.\n356 | class SourceParser(YamlReader):\n357 | def _target_from_dict(self, cls: Type[T], data: Dict[str, Any]) -> T:\n358 | path = self.yaml.path.original_file_path\n359 | try:\n360 | cls.validate(data)\n361 | return cls.from_dict(data)\n362 | except (ValidationError, JSONValidationError) as exc:\n363 | raise YamlParseDictError(path, self.key, data, exc)\n364 | \n365 | # This parse method takes the yaml dictionaries in 'sources' keys and uses them\n366 | # to create UnparsedSourceDefinition objects. They are then turned\n367 | # into UnpatchedSourceDefinition objects in 'add_source_definitions'\n368 | # or SourcePatch objects in 'add_source_patch'\n369 | def parse(self) -> ParseResult:\n370 | # get a verified list of dicts for the key handled by this parser\n371 | for data in self.get_key_dicts():\n372 | data = self.project.credentials.translate_aliases(data, recurse=True)\n373 | \n374 | is_override = \"overrides\" in data\n375 | if is_override:\n376 | data[\"path\"] = self.yaml.path.original_file_path\n377 | patch = self._target_from_dict(SourcePatch, data)\n378 | assert isinstance(self.yaml.file, SchemaSourceFile)\n379 | source_file = self.yaml.file\n380 | # source patches must be unique\n381 | key = (patch.overrides, patch.name)\n382 | if key in self.manifest.source_patches:\n383 | raise DuplicateSourcePatchNameError(patch, self.manifest.source_patches[key])\n384 | self.manifest.source_patches[key] = patch\n385 | source_file.source_patches.append(key)\n386 | else:\n387 | source = self._target_from_dict(UnparsedSourceDefinition, data)\n388 | self.add_source_definitions(source)\n389 | return ParseResult()\n390 | \n391 | def add_source_definitions(self, source: UnparsedSourceDefinition) -> None:\n392 | package_name = self.project.project_name\n393 | original_file_path = self.yaml.path.original_file_path\n394 | fqn_path = self.yaml.path.relative_path\n395 | for table in source.tables:\n396 | unique_id = \".\".join([NodeType.Source, package_name, source.name, table.name])\n397 | \n398 | # the FQN is project name / path elements /source_name /table_name\n399 | fqn = self.schema_parser.get_fqn_prefix(fqn_path)\n400 | fqn.extend([source.name, table.name])\n401 | \n402 | source_def = UnpatchedSourceDefinition(\n403 | source=source,\n404 | table=table,\n405 | path=original_file_path,\n406 | original_file_path=original_file_path,\n407 | package_name=package_name,\n408 | unique_id=unique_id,\n409 | resource_type=NodeType.Source,\n410 | fqn=fqn,\n411 | name=f\"{source.name}_{table.name}\",\n412 | )\n413 | self.manifest.add_source(self.yaml.file, source_def)\n414 | \n415 | \n416 | # This class has two subclasses: NodePatchParser and MacroPatchParser\n417 | class PatchParser(YamlReader, Generic[NonSourceTarget, Parsed]):\n418 | @abstractmethod\n419 | def _target_type(self) -> Type[NonSourceTarget]:\n420 | raise NotImplementedError(\"_target_type not implemented\")\n421 | \n422 | @abstractmethod\n423 | def get_block(self, node: NonSourceTarget) -> TargetBlock:\n424 | raise NotImplementedError(\"get_block is abstract\")\n425 | \n426 | @abstractmethod\n427 | def parse_patch(self, block: TargetBlock[NonSourceTarget], refs: ParserRef) -> None:\n428 | raise NotImplementedError(\"parse_patch is abstract\")\n429 | \n430 | def parse(self) -> ParseResult:\n431 | node: NonSourceTarget\n432 | # This will always be empty if the node a macro or analysis\n433 | test_blocks: List[TestBlock] = []\n434 | # This will always be empty if the node is _not_ a model\n435 | versioned_test_blocks: List[VersionedTestBlock] = []\n436 | \n437 | # get list of 'node' objects\n438 | # UnparsedNodeUpdate (TestablePatchParser, models, seeds, snapshots)\n439 | # = HasColumnTests, HasTests\n440 | # UnparsedAnalysisUpdate (UnparsedAnalysisParser, analyses)\n441 | # = HasColumnDocs, HasDocs\n442 | # UnparsedMacroUpdate (MacroPatchParser, 'macros')\n443 | # = HasDocs\n444 | # correspond to this parser's 'key'\n445 | for node in self.get_unparsed_target():\n446 | # node_block is a TargetBlock (Macro or Analysis)\n447 | # or a TestBlock (all of the others)\n448 | node_block = self.get_block(node)\n449 | if isinstance(node_block, TestBlock):\n450 | # TestablePatchParser = seeds, snapshots\n451 | test_blocks.append(node_block)\n452 | if isinstance(node_block, VersionedTestBlock):\n453 | # models\n454 | versioned_test_blocks.append(node_block)\n455 | if isinstance(node, (HasColumnDocs, HasColumnTests)):\n456 | # UnparsedNodeUpdate and UnparsedAnalysisUpdate\n457 | refs: ParserRef = ParserRef.from_target(node)\n458 | else:\n459 | refs = ParserRef()\n460 | \n461 | # There's no unique_id on the node yet so cannot add to disabled dict\n462 | self.parse_patch(node_block, refs)\n463 | \n464 | return ParseResult(test_blocks, versioned_test_blocks)\n465 | \n466 | def get_unparsed_target(self) -> Iterable[NonSourceTarget]:\n467 | path = self.yaml.path.original_file_path\n468 | \n469 | # get verified list of dicts for the 'key' that this\n470 | # parser handles\n471 | key_dicts = self.get_key_dicts()\n472 | for data in key_dicts:\n473 | # add extra data to each dict. This updates the dicts\n474 | # in the parser yaml\n475 | data.update(\n476 | {\n477 | \"original_file_path\": path,\n478 | \"yaml_key\": self.key,\n479 | \"package_name\": self.project.project_name,\n480 | }\n481 | )\n482 | try:\n483 | # target_type: UnparsedNodeUpdate, UnparsedAnalysisUpdate,\n484 | # or UnparsedMacroUpdate\n485 | self._target_type().validate(data)\n486 | if self.key != \"macros\":\n487 | # macros don't have the 'config' key support yet\n488 | self.normalize_meta_attribute(data, path)\n489 | self.normalize_docs_attribute(data, path)\n490 | self.normalize_group_attribute(data, path)\n491 | self.normalize_contract_attribute(data, path)\n492 | self.normalize_access_attribute(data, path)\n493 | # `tests` has been deprecated, convert to `data_tests` here if present\n494 | self.validate_data_tests(data)\n495 | node = self._target_type().from_dict(data)\n496 | except (ValidationError, JSONValidationError) as exc:\n497 | raise YamlParseDictError(path, self.key, data, exc)\n498 | else:\n499 | yield node\n500 | \n501 | # We want to raise an error if some attributes are in two places, and move them\n502 | # from toplevel to config if necessary\n503 | def normalize_attribute(self, data, path, attribute):\n504 | if attribute in data:\n505 | if \"config\" in data and attribute in data[\"config\"]:\n506 | raise ParsingError(\n507 | f\"\"\"\n508 | In {path}: found {attribute} dictionary in 'config' dictionary and as top-level key.\n509 | Remove the top-level key and define it under 'config' dictionary only.\n510 | \"\"\".strip()\n511 | )\n512 | else:\n513 | if \"config\" not in data:\n514 | data[\"config\"] = {}\n515 | data[\"config\"][attribute] = data.pop(attribute)\n516 | \n517 | def normalize_meta_attribute(self, data, path):\n518 | return self.normalize_attribute(data, path, \"meta\")\n519 | \n520 | def normalize_docs_attribute(self, data, path):\n521 | return self.normalize_attribute(data, path, \"docs\")\n522 | \n523 | def normalize_group_attribute(self, data, path):\n524 | return self.normalize_attribute(data, path, \"group\")\n525 | \n526 | def normalize_contract_attribute(self, data, path):\n527 | return self.normalize_attribute(data, path, \"contract\")\n528 | \n529 | def normalize_access_attribute(self, data, path):\n530 | return self.normalize_attribute(data, path, \"access\")\n531 | \n532 | def validate_data_tests(self, data):\n533 | if data.get(\"columns\"):\n534 | for column in data[\"columns\"]:\n535 | if \"tests\" in column and \"data_tests\" in column:\n536 | raise ValidationError(\n537 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n538 | )\n539 | if \"tests\" in column:\n540 | deprecations.warn(\n541 | \"project-test-config\",\n542 | deprecated_path=\"tests\",\n543 | exp_path=\"data_tests\",\n544 | )\n545 | column[\"data_tests\"] = column.pop(\"tests\")\n546 | \n547 | def patch_node_config(self, node, patch):\n548 | # Get the ContextConfig that's used in calculating the config\n549 | # This must match the model resource_type that's being patched\n550 | config = ContextConfig(\n551 | self.schema_parser.root_project,\n552 | node.fqn,\n553 | node.resource_type,\n554 | self.schema_parser.project.project_name,\n555 | )\n556 | # We need to re-apply the config_call_dict after the patch config\n557 | config._config_call_dict = node.config_call_dict\n558 | self.schema_parser.update_parsed_node_config(node, config, patch_config_dict=patch.config)\n559 | \n560 | \n561 | # Subclasses of NodePatchParser: TestablePatchParser, ModelPatchParser, AnalysisPatchParser,\n562 | # so models, seeds, snapshots, analyses\n563 | class NodePatchParser(PatchParser[NodeTarget, ParsedNodePatch], Generic[NodeTarget]):\n564 | def parse_patch(self, block: TargetBlock[NodeTarget], refs: ParserRef) -> None:\n565 | # We're not passing the ParsedNodePatch around anymore, so we\n566 | # could possibly skip creating one. Leaving here for now for\n567 | # code consistency.\n568 | deprecation_date: Optional[datetime.datetime] = None\n569 | if isinstance(block.target, UnparsedModelUpdate):\n570 | deprecation_date = block.target.deprecation_date\n571 | \n572 | patch = ParsedNodePatch(\n573 | name=block.target.name,\n574 | original_file_path=block.target.original_file_path,\n575 | yaml_key=block.target.yaml_key,\n576 | package_name=block.target.package_name,\n577 | description=block.target.description,\n578 | columns=refs.column_info,\n579 | meta=block.target.meta,\n580 | docs=block.target.docs,\n581 | config=block.target.config,\n582 | access=block.target.access,\n583 | version=None,\n584 | latest_version=None,\n585 | constraints=block.target.constraints,\n586 | deprecation_date=deprecation_date,\n587 | )\n588 | assert isinstance(self.yaml.file, SchemaSourceFile)\n589 | source_file: SchemaSourceFile = self.yaml.file\n590 | if patch.yaml_key in [\"models\", \"seeds\", \"snapshots\"]:\n591 | unique_id = self.manifest.ref_lookup.get_unique_id(\n592 | patch.name, self.project.project_name, None\n593 | ) or self.manifest.ref_lookup.get_unique_id(patch.name, None, None)\n594 | \n595 | if unique_id:\n596 | resource_type = NodeType(unique_id.split(\".\")[0])\n597 | if resource_type.pluralize() != patch.yaml_key:\n598 | warn_or_error(\n599 | WrongResourceSchemaFile(\n600 | patch_name=patch.name,\n601 | resource_type=resource_type,\n602 | plural_resource_type=resource_type.pluralize(),\n603 | yaml_key=patch.yaml_key,\n604 | file_path=patch.original_file_path,\n605 | )\n606 | )\n607 | return\n608 | \n609 | elif patch.yaml_key == \"analyses\":\n610 | unique_id = self.manifest.analysis_lookup.get_unique_id(patch.name, None, None)\n611 | else:\n612 | raise DbtInternalError(\n613 | f\"Unexpected yaml_key {patch.yaml_key} for patch in \"\n614 | f\"file {source_file.path.original_file_path}\"\n615 | )\n616 | # handle disabled nodes\n617 | if unique_id is None:\n618 | # Node might be disabled. Following call returns list of matching disabled nodes\n619 | found_nodes = self.manifest.disabled_lookup.find(patch.name, patch.package_name)\n620 | if found_nodes:\n621 | if len(found_nodes) > 1 and patch.config.get(\"enabled\"):\n622 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n623 | # We have no way to know which one to enable.\n624 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n625 | msg = (\n626 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n627 | f\"{resource_type} '{patch.name}'. Multiple nodes for the same \"\n628 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n629 | \"in `dbt_project.yml` or in the sql files.\"\n630 | )\n631 | raise ParsingError(msg)\n632 | \n633 | # all nodes in the disabled dict have the same unique_id so just grab the first one\n634 | # to append with the unique id\n635 | source_file.append_patch(patch.yaml_key, found_nodes[0].unique_id)\n636 | for node in found_nodes:\n637 | node.patch_path = source_file.file_id\n638 | # re-calculate the node config with the patch config. Always do this\n639 | # for the case when no config is set to ensure the default of true gets captured\n640 | if patch.config:\n641 | self.patch_node_config(node, patch)\n642 | \n643 | self.patch_node_properties(node, patch)\n644 | else:\n645 | warn_or_error(\n646 | NoNodeForYamlKey(\n647 | patch_name=patch.name,\n648 | yaml_key=patch.yaml_key,\n649 | file_path=source_file.path.original_file_path,\n650 | )\n651 | )\n652 | return\n653 | \n654 | # patches can't be overwritten\n655 | node = self.manifest.nodes.get(unique_id)\n656 | if node:\n657 | if node.patch_path:\n658 | package_name, existing_file_path = node.patch_path.split(\"://\")\n659 | raise DuplicatePatchPathError(patch, existing_file_path)\n660 | \n661 | source_file.append_patch(patch.yaml_key, node.unique_id)\n662 | # re-calculate the node config with the patch config. Always do this\n663 | # for the case when no config is set to ensure the default of true gets captured\n664 | if patch.config:\n665 | self.patch_node_config(node, patch)\n666 | \n667 | self.patch_node_properties(node, patch)\n668 | \n669 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n670 | \"\"\"Given a ParsedNodePatch, add the new information to the node.\"\"\"\n671 | # explicitly pick out the parts to update so we don't inadvertently\n672 | # step on the model name or anything\n673 | # Note: config should already be updated\n674 | node.patch_path = patch.file_id\n675 | # update created_at so process_docs will run in partial parsing\n676 | node.created_at = time.time()\n677 | node.description = patch.description\n678 | node.columns = patch.columns\n679 | node.name = patch.name\n680 | \n681 | if not isinstance(node, ModelNode):\n682 | for attr in [\"latest_version\", \"access\", \"version\", \"constraints\"]:\n683 | if getattr(patch, attr):\n684 | warn_or_error(\n685 | ValidationWarning(\n686 | field_name=attr,\n687 | resource_type=node.resource_type.value,\n688 | node_name=patch.name,\n689 | )\n690 | )\n691 | \n692 | \n693 | # TestablePatchParser = seeds, snapshots\n694 | class TestablePatchParser(NodePatchParser[UnparsedNodeUpdate]):\n695 | __test__ = False\n696 | \n697 | def get_block(self, node: UnparsedNodeUpdate) -> TestBlock:\n698 | return TestBlock.from_yaml_block(self.yaml, node)\n699 | \n700 | def _target_type(self) -> Type[UnparsedNodeUpdate]:\n701 | return UnparsedNodeUpdate\n702 | \n703 | \n704 | class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n705 | def get_block(self, node: UnparsedModelUpdate) -> VersionedTestBlock:\n706 | return VersionedTestBlock.from_yaml_block(self.yaml, node)\n707 | \n708 | def parse_patch(self, block: TargetBlock[UnparsedModelUpdate], refs: ParserRef) -> None:\n709 | target = block.target\n710 | if NodeType.Model.pluralize() != target.yaml_key:\n711 | warn_or_error(\n712 | WrongResourceSchemaFile(\n713 | patch_name=target.name,\n714 | resource_type=NodeType.Model,\n715 | plural_resource_type=NodeType.Model.pluralize(),\n716 | yaml_key=target.yaml_key,\n717 | file_path=target.original_file_path,\n718 | )\n719 | )\n720 | return\n721 | \n722 | versions = target.versions\n723 | if not versions:\n724 | super().parse_patch(block, refs)\n725 | else:\n726 | assert isinstance(self.yaml.file, SchemaSourceFile)\n727 | source_file: SchemaSourceFile = self.yaml.file\n728 | latest_version = (\n729 | target.latest_version if target.latest_version is not None else max(versions).v\n730 | )\n731 | for unparsed_version in versions:\n732 | versioned_model_name = (\n733 | unparsed_version.defined_in or f\"{block.name}_{unparsed_version.formatted_v}\"\n734 | )\n735 | # ref lookup without version - version is not set yet\n736 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n737 | versioned_model_name, target.package_name, None\n738 | )\n739 | \n740 | versioned_model_node = None\n741 | add_node_nofile_fn: Callable\n742 | \n743 | # If this is the latest version, it's allowed to define itself in a model file name that doesn't have a suffix\n744 | if versioned_model_unique_id is None and unparsed_version.v == latest_version:\n745 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n746 | block.name, target.package_name, None\n747 | )\n748 | \n749 | if versioned_model_unique_id is None:\n750 | # Node might be disabled. Following call returns list of matching disabled nodes\n751 | found_nodes = self.manifest.disabled_lookup.find(versioned_model_name, None)\n752 | if found_nodes:\n753 | if len(found_nodes) > 1 and target.config.get(\"enabled\"):\n754 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n755 | # We have no way to know which one to enable.\n756 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n757 | msg = (\n758 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n759 | f\"{resource_type} '{target.name}'. Multiple nodes for the same \"\n760 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n761 | \"in `dbt_project.yml` or in the sql files.\"\n762 | )\n763 | raise ParsingError(msg)\n764 | versioned_model_node = self.manifest.disabled.pop(\n765 | found_nodes[0].unique_id\n766 | )[0]\n767 | add_node_nofile_fn = self.manifest.add_disabled_nofile\n768 | else:\n769 | versioned_model_node = self.manifest.nodes.pop(versioned_model_unique_id)\n770 | add_node_nofile_fn = self.manifest.add_node_nofile\n771 | \n772 | if versioned_model_node is None:\n773 | warn_or_error(\n774 | NoNodeForYamlKey(\n775 | patch_name=versioned_model_name,\n776 | yaml_key=target.yaml_key,\n777 | file_path=source_file.path.original_file_path,\n778 | )\n779 | )\n780 | continue\n781 | \n782 | # update versioned node unique_id\n783 | versioned_model_node_unique_id_old = versioned_model_node.unique_id\n784 | versioned_model_node.unique_id = (\n785 | f\"model.{target.package_name}.{target.name}.{unparsed_version.formatted_v}\"\n786 | )\n787 | # update source file.nodes with new unique_id\n788 | self.manifest.files[versioned_model_node.file_id].nodes.remove(\n789 | versioned_model_node_unique_id_old\n790 | )\n791 | self.manifest.files[versioned_model_node.file_id].nodes.append(\n792 | versioned_model_node.unique_id\n793 | )\n794 | \n795 | # update versioned node fqn\n796 | versioned_model_node.fqn[-1] = target.name\n797 | versioned_model_node.fqn.append(unparsed_version.formatted_v)\n798 | \n799 | # add versioned node back to nodes/disabled\n800 | add_node_nofile_fn(versioned_model_node)\n801 | \n802 | # flatten columns based on include/exclude\n803 | version_refs: ParserRef = ParserRef.from_versioned_target(\n804 | block.target, unparsed_version.v\n805 | )\n806 | \n807 | versioned_model_patch = ParsedNodePatch(\n808 | name=target.name,\n809 | original_file_path=target.original_file_path,\n810 | yaml_key=target.yaml_key,\n811 | package_name=target.package_name,\n812 | description=unparsed_version.description or target.description,\n813 | columns=version_refs.column_info,\n814 | meta=target.meta,\n815 | docs=unparsed_version.docs or target.docs,\n816 | config=deep_merge(target.config, unparsed_version.config),\n817 | access=unparsed_version.access or target.access,\n818 | version=unparsed_version.v,\n819 | latest_version=latest_version,\n820 | constraints=unparsed_version.constraints or target.constraints,\n821 | deprecation_date=unparsed_version.deprecation_date,\n822 | )\n823 | # Node patched before config because config patching depends on model name,\n824 | # which may have been updated in the version patch\n825 | # versioned_model_node.patch(versioned_model_patch)\n826 | self.patch_node_properties(versioned_model_node, versioned_model_patch)\n827 | \n828 | # Includes alias recomputation\n829 | self.patch_node_config(versioned_model_node, versioned_model_patch)\n830 | \n831 | # Need to reapply this here, in the case that 'contract: {enforced: true}' was during config-setting\n832 | versioned_model_node.build_contract_checksum()\n833 | source_file.append_patch(\n834 | versioned_model_patch.yaml_key, versioned_model_node.unique_id\n835 | )\n836 | self.manifest.rebuild_ref_lookup()\n837 | self.manifest.rebuild_disabled_lookup()\n838 | \n839 | def _target_type(self) -> Type[UnparsedModelUpdate]:\n840 | return UnparsedModelUpdate\n841 | \n842 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n843 | super().patch_node_properties(node, patch)\n844 | node.version = patch.version\n845 | node.latest_version = patch.latest_version\n846 | node.deprecation_date = patch.deprecation_date\n847 | if patch.access:\n848 | if AccessType.is_valid(patch.access):\n849 | node.access = AccessType(patch.access)\n850 | else:\n851 | raise InvalidAccessTypeError(\n852 | unique_id=node.unique_id,\n853 | field_value=patch.access,\n854 | )\n855 | self.patch_constraints(node, patch.constraints)\n856 | node.build_contract_checksum()\n857 | \n858 | def patch_constraints(self, node, constraints):\n859 | contract_config = node.config.get(\"contract\")\n860 | if contract_config.enforced is True:\n861 | self._validate_constraint_prerequisites(node)\n862 | \n863 | if any(\n864 | c for c in constraints if \"type\" not in c or not ConstraintType.is_valid(c[\"type\"])\n865 | ):\n866 | raise ParsingError(\n867 | f\"Invalid constraint type on model {node.name}: \"\n868 | f\"Type must be one of {[ct.value for ct in ConstraintType]}\"\n869 | )\n870 | \n871 | node.constraints = [ModelLevelConstraint.from_dict(c) for c in constraints]\n872 | \n873 | def _validate_constraint_prerequisites(self, model_node: ModelNode):\n874 | \n875 | column_warn_unsupported = [\n876 | constraint.warn_unsupported\n877 | for column in model_node.columns.values()\n878 | for constraint in column.constraints\n879 | ]\n880 | model_warn_unsupported = [\n881 | constraint.warn_unsupported for constraint in model_node.constraints\n882 | ]\n883 | warn_unsupported = column_warn_unsupported + model_warn_unsupported\n884 | \n885 | # if any constraint has `warn_unsupported` as True then send the warning\n886 | if any(warn_unsupported) and not model_node.materialization_enforces_constraints:\n887 | warn_or_error(\n888 | UnsupportedConstraintMaterialization(materialized=model_node.config.materialized),\n889 | node=model_node,\n890 | )\n891 | \n892 | errors = []\n893 | if not model_node.columns:\n894 | errors.append(\n895 | \"Constraints must be defined in a `yml` schema configuration file like `schema.yml`.\"\n896 | )\n897 | \n898 | if str(model_node.language) != \"sql\":\n899 | errors.append(f\"Language Error: Expected 'sql' but found '{model_node.language}'\")\n900 | \n901 | if errors:\n902 | raise ParsingError(\n903 | f\"Contract enforcement failed for: ({model_node.original_file_path})\\n\"\n904 | + \"\\n\".join(errors)\n905 | )\n906 | \n907 | \n908 | class AnalysisPatchParser(NodePatchParser[UnparsedAnalysisUpdate]):\n909 | def get_block(self, node: UnparsedAnalysisUpdate) -> TargetBlock:\n910 | return TargetBlock.from_yaml_block(self.yaml, node)\n911 | \n912 | def _target_type(self) -> Type[UnparsedAnalysisUpdate]:\n913 | return UnparsedAnalysisUpdate\n914 | \n915 | \n916 | class MacroPatchParser(PatchParser[UnparsedMacroUpdate, ParsedMacroPatch]):\n917 | def get_block(self, node: UnparsedMacroUpdate) -> TargetBlock:\n918 | return TargetBlock.from_yaml_block(self.yaml, node)\n919 | \n920 | def _target_type(self) -> Type[UnparsedMacroUpdate]:\n921 | return UnparsedMacroUpdate\n922 | \n923 | def parse_patch(self, block: TargetBlock[UnparsedMacroUpdate], refs: ParserRef) -> None:\n924 | patch = ParsedMacroPatch(\n925 | name=block.target.name,\n926 | original_file_path=block.target.original_file_path,\n927 | yaml_key=block.target.yaml_key,\n928 | package_name=block.target.package_name,\n929 | arguments=block.target.arguments,\n930 | description=block.target.description,\n931 | meta=block.target.meta,\n932 | docs=block.target.docs,\n933 | config=block.target.config,\n934 | )\n935 | assert isinstance(self.yaml.file, SchemaSourceFile)\n936 | source_file = self.yaml.file\n937 | # macros are fully namespaced\n938 | unique_id = f\"macro.{patch.package_name}.{patch.name}\"\n939 | macro = self.manifest.macros.get(unique_id)\n940 | if not macro:\n941 | warn_or_error(MacroNotFoundForPatch(patch_name=patch.name))\n942 | return\n943 | if macro.patch_path:\n944 | package_name, existing_file_path = macro.patch_path.split(\"://\")\n945 | raise DuplicateMacroPatchNameError(patch, existing_file_path)\n946 | source_file.macro_patches[patch.name] = unique_id\n947 | \n948 | # former macro.patch code\n949 | macro.patch_path = patch.file_id\n950 | macro.description = patch.description\n951 | macro.created_at = time.time()\n952 | macro.meta = patch.meta\n953 | macro.docs = patch.docs\n954 | macro.arguments = patch.arguments\n```\n\n## Files after the fix\n\n### File: core/dbt/contracts/graph/nodes.py\n\n```python\n 1 | import os\n 2 | from datetime import datetime\n 3 | import time\n 4 | from dataclasses import dataclass, field\n 5 | import hashlib\n 6 | \n 7 | from mashumaro.types import SerializableType\n 8 | from typing import Optional, Union, List, Dict, Any, Sequence, Tuple, Iterator, Literal\n 9 | \n 10 | from dbt import deprecations\n 11 | from dbt_common.contracts.constraints import (\n 12 | ColumnLevelConstraint,\n 13 | ConstraintType,\n 14 | ModelLevelConstraint,\n 15 | )\n 16 | from dbt_common.dataclass_schema import dbtClassMixin, ExtensibleDbtClassMixin\n 17 | \n 18 | from dbt_common.clients.system import write_file\n 19 | from dbt.contracts.files import FileHash\n 20 | from dbt.contracts.graph.saved_queries import Export, QueryParams\n 21 | from dbt.contracts.graph.semantic_models import (\n 22 | Defaults,\n 23 | Dimension,\n 24 | Entity,\n 25 | Measure,\n 26 | SourceFileMetadata,\n 27 | )\n 28 | from dbt.contracts.graph.unparsed import (\n 29 | ConstantPropertyInput,\n 30 | Docs,\n 31 | ExposureType,\n 32 | ExternalTable,\n 33 | FreshnessThreshold,\n 34 | HasYamlMetadata,\n 35 | MacroArgument,\n 36 | MaturityType,\n 37 | Owner,\n 38 | Quoting,\n 39 | TestDef,\n 40 | NodeVersion,\n 41 | UnparsedSourceDefinition,\n 42 | UnparsedSourceTableDefinition,\n 43 | UnparsedColumn,\n 44 | UnitTestOverrides,\n 45 | UnitTestInputFixture,\n 46 | UnitTestOutputFixture,\n 47 | )\n 48 | from dbt.contracts.graph.node_args import ModelNodeArgs\n 49 | from dbt.contracts.graph.semantic_layer_common import WhereFilterIntersection\n 50 | from dbt.contracts.util import Replaceable\n 51 | from dbt_common.contracts.config.properties import AdditionalPropertiesMixin\n 52 | from dbt_common.events.functions import warn_or_error\n 53 | from dbt.exceptions import ParsingError, ContractBreakingChangeError, ValidationError\n 54 | from dbt.events.types import (\n 55 | SeedIncreased,\n 56 | SeedExceedsLimitSamePath,\n 57 | SeedExceedsLimitAndPathChanged,\n 58 | SeedExceedsLimitChecksumChanged,\n 59 | UnversionedBreakingChange,\n 60 | )\n 61 | from dbt_common.events.contextvars import set_log_contextvars\n 62 | from dbt.flags import get_flags\n 63 | from dbt.node_types import ModelLanguage, NodeType, AccessType\n 64 | from dbt_semantic_interfaces.references import (\n 65 | EntityReference,\n 66 | MeasureReference,\n 67 | LinkableElementReference,\n 68 | SemanticModelReference,\n 69 | TimeDimensionReference,\n 70 | )\n 71 | from dbt_semantic_interfaces.references import MetricReference as DSIMetricReference\n 72 | from dbt_semantic_interfaces.type_enums import (\n 73 | ConversionCalculationType,\n 74 | MetricType,\n 75 | TimeGranularity,\n 76 | )\n 77 | \n 78 | from .model_config import (\n 79 | NodeConfig,\n 80 | ModelConfig,\n 81 | SeedConfig,\n 82 | TestConfig,\n 83 | SourceConfig,\n 84 | MetricConfig,\n 85 | ExposureConfig,\n 86 | EmptySnapshotConfig,\n 87 | SnapshotConfig,\n 88 | SemanticModelConfig,\n 89 | UnitTestConfig,\n 90 | UnitTestNodeConfig,\n 91 | SavedQueryConfig,\n 92 | )\n 93 | \n 94 | \n 95 | # =====================================================================\n 96 | # This contains the classes for all of the nodes and node-like objects\n 97 | # in the manifest. In the \"nodes\" dictionary of the manifest we find\n 98 | # all of the objects in the ManifestNode union below. In addition the\n 99 | # manifest contains \"macros\", \"sources\", \"metrics\", \"exposures\", \"docs\",\n 100 | # and \"disabled\" dictionaries.\n 101 | #\n 102 | # The SeedNode is a ManifestNode, but can't be compiled because it has\n 103 | # no SQL.\n 104 | #\n 105 | # All objects defined in this file should have BaseNode as a parent\n 106 | # class.\n 107 | #\n 108 | # The two objects which do not show up in the DAG are Macro and\n 109 | # Documentation.\n 110 | # =====================================================================\n 111 | \n 112 | \n 113 | # ==================================================\n 114 | # Various parent classes and node attribute classes\n 115 | # ==================================================\n 116 | \n 117 | \n 118 | @dataclass\n 119 | class BaseNode(dbtClassMixin, Replaceable):\n 120 | \"\"\"All nodes or node-like objects in this file should have this as a base class\"\"\"\n 121 | \n 122 | name: str\n 123 | resource_type: NodeType\n 124 | package_name: str\n 125 | path: str\n 126 | original_file_path: str\n 127 | unique_id: str\n 128 | \n 129 | @property\n 130 | def search_name(self):\n 131 | return self.name\n 132 | \n 133 | @property\n 134 | def file_id(self):\n 135 | return f\"{self.package_name}://{self.original_file_path}\"\n 136 | \n 137 | @property\n 138 | def is_refable(self):\n 139 | return self.resource_type in NodeType.refable()\n 140 | \n 141 | @property\n 142 | def should_store_failures(self):\n 143 | return False\n 144 | \n 145 | # will this node map to an object in the database?\n 146 | @property\n 147 | def is_relational(self):\n 148 | return self.resource_type in NodeType.refable()\n 149 | \n 150 | @property\n 151 | def is_versioned(self):\n 152 | return self.resource_type in NodeType.versioned() and self.version is not None\n 153 | \n 154 | @property\n 155 | def is_ephemeral(self):\n 156 | return self.config.materialized == \"ephemeral\"\n 157 | \n 158 | @property\n 159 | def is_ephemeral_model(self):\n 160 | return self.is_refable and self.is_ephemeral\n 161 | \n 162 | def get_materialization(self):\n 163 | return self.config.materialized\n 164 | \n 165 | \n 166 | @dataclass\n 167 | class GraphNode(BaseNode):\n 168 | \"\"\"Nodes in the DAG. Macro and Documentation don't have fqn.\"\"\"\n 169 | \n 170 | fqn: List[str]\n 171 | \n 172 | def same_fqn(self, other) -> bool:\n 173 | return self.fqn == other.fqn\n 174 | \n 175 | \n 176 | @dataclass\n 177 | class RefArgs(dbtClassMixin):\n 178 | name: str\n 179 | package: Optional[str] = None\n 180 | version: Optional[NodeVersion] = None\n 181 | \n 182 | @property\n 183 | def positional_args(self) -> List[str]:\n 184 | if self.package:\n 185 | return [self.package, self.name]\n 186 | else:\n 187 | return [self.name]\n 188 | \n 189 | @property\n 190 | def keyword_args(self) -> Dict[str, Optional[NodeVersion]]:\n 191 | if self.version:\n 192 | return {\"version\": self.version}\n 193 | else:\n 194 | return {}\n 195 | \n 196 | \n 197 | @dataclass\n 198 | class ColumnInfo(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 199 | \"\"\"Used in all ManifestNodes and SourceDefinition\"\"\"\n 200 | \n 201 | name: str\n 202 | description: str = \"\"\n 203 | meta: Dict[str, Any] = field(default_factory=dict)\n 204 | data_type: Optional[str] = None\n 205 | constraints: List[ColumnLevelConstraint] = field(default_factory=list)\n 206 | quote: Optional[bool] = None\n 207 | tags: List[str] = field(default_factory=list)\n 208 | _extra: Dict[str, Any] = field(default_factory=dict)\n 209 | \n 210 | \n 211 | @dataclass\n 212 | class Contract(dbtClassMixin, Replaceable):\n 213 | enforced: bool = False\n 214 | alias_types: bool = True\n 215 | checksum: Optional[str] = None\n 216 | \n 217 | \n 218 | # Metrics, exposures,\n 219 | @dataclass\n 220 | class HasRelationMetadata(dbtClassMixin, Replaceable):\n 221 | database: Optional[str]\n 222 | schema: str\n 223 | \n 224 | # Can't set database to None like it ought to be\n 225 | # because it messes up the subclasses and default parameters\n 226 | # so hack it here\n 227 | @classmethod\n 228 | def __pre_deserialize__(cls, data):\n 229 | data = super().__pre_deserialize__(data)\n 230 | if \"database\" not in data:\n 231 | data[\"database\"] = None\n 232 | return data\n 233 | \n 234 | @property\n 235 | def quoting_dict(self) -> Dict[str, bool]:\n 236 | if hasattr(self, \"quoting\"):\n 237 | return self.quoting.to_dict(omit_none=True)\n 238 | else:\n 239 | return {}\n 240 | \n 241 | \n 242 | @dataclass\n 243 | class MacroDependsOn(dbtClassMixin, Replaceable):\n 244 | \"\"\"Used only in the Macro class\"\"\"\n 245 | \n 246 | macros: List[str] = field(default_factory=list)\n 247 | \n 248 | # 'in' on lists is O(n) so this is O(n^2) for # of macros\n 249 | def add_macro(self, value: str):\n 250 | if value not in self.macros:\n 251 | self.macros.append(value)\n 252 | \n 253 | \n 254 | @dataclass\n 255 | class DeferRelation(HasRelationMetadata):\n 256 | alias: str\n 257 | relation_name: Optional[str]\n 258 | \n 259 | @property\n 260 | def identifier(self):\n 261 | return self.alias\n 262 | \n 263 | \n 264 | @dataclass\n 265 | class DependsOn(MacroDependsOn):\n 266 | nodes: List[str] = field(default_factory=list)\n 267 | \n 268 | def add_node(self, value: str):\n 269 | if value not in self.nodes:\n 270 | self.nodes.append(value)\n 271 | \n 272 | \n 273 | @dataclass\n 274 | class ParsedNodeMandatory(GraphNode, HasRelationMetadata, Replaceable):\n 275 | alias: str\n 276 | checksum: FileHash\n 277 | config: NodeConfig = field(default_factory=NodeConfig)\n 278 | \n 279 | @property\n 280 | def identifier(self):\n 281 | return self.alias\n 282 | \n 283 | \n 284 | # This needs to be in all ManifestNodes and also in SourceDefinition,\n 285 | # because of \"source freshness\"\n 286 | @dataclass\n 287 | class NodeInfoMixin:\n 288 | _event_status: Dict[str, Any] = field(default_factory=dict)\n 289 | \n 290 | @property\n 291 | def node_info(self):\n 292 | node_info = {\n 293 | \"node_path\": getattr(self, \"path\", None),\n 294 | \"node_name\": getattr(self, \"name\", None),\n 295 | \"unique_id\": getattr(self, \"unique_id\", None),\n 296 | \"resource_type\": str(getattr(self, \"resource_type\", \"\")),\n 297 | \"materialized\": self.config.get(\"materialized\"),\n 298 | \"node_status\": str(self._event_status.get(\"node_status\")),\n 299 | \"node_started_at\": self._event_status.get(\"started_at\"),\n 300 | \"node_finished_at\": self._event_status.get(\"finished_at\"),\n 301 | \"meta\": getattr(self, \"meta\", {}),\n 302 | \"node_relation\": {\n 303 | \"database\": getattr(self, \"database\", None),\n 304 | \"schema\": getattr(self, \"schema\", None),\n 305 | \"alias\": getattr(self, \"alias\", None),\n 306 | \"relation_name\": getattr(self, \"relation_name\", None),\n 307 | },\n 308 | }\n 309 | return node_info\n 310 | \n 311 | def update_event_status(self, **kwargs):\n 312 | for k, v in kwargs.items():\n 313 | self._event_status[k] = v\n 314 | set_log_contextvars(node_info=self.node_info)\n 315 | \n 316 | def clear_event_status(self):\n 317 | self._event_status = dict()\n 318 | \n 319 | \n 320 | @dataclass\n 321 | class ParsedNode(NodeInfoMixin, ParsedNodeMandatory, SerializableType):\n 322 | tags: List[str] = field(default_factory=list)\n 323 | description: str = field(default=\"\")\n 324 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n 325 | meta: Dict[str, Any] = field(default_factory=dict)\n 326 | group: Optional[str] = None\n 327 | docs: Docs = field(default_factory=Docs)\n 328 | patch_path: Optional[str] = None\n 329 | build_path: Optional[str] = None\n 330 | deferred: bool = False\n 331 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n 332 | created_at: float = field(default_factory=lambda: time.time())\n 333 | config_call_dict: Dict[str, Any] = field(default_factory=dict)\n 334 | relation_name: Optional[str] = None\n 335 | raw_code: str = \"\"\n 336 | \n 337 | def get_target_write_path(self, target_path: str, subdirectory: str):\n 338 | # This is called for both the \"compiled\" subdirectory of \"target\" and the \"run\" subdirectory\n 339 | if os.path.basename(self.path) == os.path.basename(self.original_file_path):\n 340 | # One-to-one relationship of nodes to files.\n 341 | path = self.original_file_path\n 342 | else:\n 343 | # Many-to-one relationship of nodes to files.\n 344 | path = os.path.join(self.original_file_path, self.path)\n 345 | target_write_path = os.path.join(target_path, subdirectory, self.package_name, path)\n 346 | return target_write_path\n 347 | \n 348 | def write_node(self, project_root: str, compiled_path, compiled_code: str):\n 349 | if os.path.isabs(compiled_path):\n 350 | full_path = compiled_path\n 351 | else:\n 352 | full_path = os.path.join(project_root, compiled_path)\n 353 | write_file(full_path, compiled_code)\n 354 | \n 355 | def _serialize(self):\n 356 | return self.to_dict()\n 357 | \n 358 | def __post_serialize__(self, dct):\n 359 | dct = super().__post_serialize__(dct)\n 360 | if \"_event_status\" in dct:\n 361 | del dct[\"_event_status\"]\n 362 | return dct\n 363 | \n 364 | @classmethod\n 365 | def _deserialize(cls, dct: Dict[str, int]):\n 366 | # The serialized ParsedNodes do not differ from each other\n 367 | # in fields that would allow 'from_dict' to distinguis\n 368 | # between them.\n 369 | resource_type = dct[\"resource_type\"]\n 370 | if resource_type == \"model\":\n 371 | return ModelNode.from_dict(dct)\n 372 | elif resource_type == \"analysis\":\n 373 | return AnalysisNode.from_dict(dct)\n 374 | elif resource_type == \"seed\":\n 375 | return SeedNode.from_dict(dct)\n 376 | elif resource_type == \"rpc\":\n 377 | return RPCNode.from_dict(dct)\n 378 | elif resource_type == \"sql\":\n 379 | return SqlNode.from_dict(dct)\n 380 | elif resource_type == \"test\":\n 381 | if \"test_metadata\" in dct:\n 382 | return GenericTestNode.from_dict(dct)\n 383 | else:\n 384 | return SingularTestNode.from_dict(dct)\n 385 | elif resource_type == \"operation\":\n 386 | return HookNode.from_dict(dct)\n 387 | elif resource_type == \"seed\":\n 388 | return SeedNode.from_dict(dct)\n 389 | elif resource_type == \"snapshot\":\n 390 | return SnapshotNode.from_dict(dct)\n 391 | else:\n 392 | return cls.from_dict(dct)\n 393 | \n 394 | def _persist_column_docs(self) -> bool:\n 395 | if hasattr(self.config, \"persist_docs\"):\n 396 | assert isinstance(self.config, NodeConfig)\n 397 | return bool(self.config.persist_docs.get(\"columns\"))\n 398 | return False\n 399 | \n 400 | def _persist_relation_docs(self) -> bool:\n 401 | if hasattr(self.config, \"persist_docs\"):\n 402 | assert isinstance(self.config, NodeConfig)\n 403 | return bool(self.config.persist_docs.get(\"relation\"))\n 404 | return False\n 405 | \n 406 | def same_persisted_description(self, other) -> bool:\n 407 | # the check on configs will handle the case where we have different\n 408 | # persist settings, so we only have to care about the cases where they\n 409 | # are the same..\n 410 | if self._persist_relation_docs():\n 411 | if self.description != other.description:\n 412 | return False\n 413 | \n 414 | if self._persist_column_docs():\n 415 | # assert other._persist_column_docs()\n 416 | column_descriptions = {k: v.description for k, v in self.columns.items()}\n 417 | other_column_descriptions = {k: v.description for k, v in other.columns.items()}\n 418 | if column_descriptions != other_column_descriptions:\n 419 | return False\n 420 | \n 421 | return True\n 422 | \n 423 | def same_body(self, other) -> bool:\n 424 | return self.raw_code == other.raw_code\n 425 | \n 426 | def same_database_representation(self, other) -> bool:\n 427 | # compare the config representation, not the node's config value. This\n 428 | # compares the configured value, rather than the ultimate value (so\n 429 | # generate_*_name and unset values derived from the target are\n 430 | # ignored)\n 431 | keys = (\"database\", \"schema\", \"alias\")\n 432 | for key in keys:\n 433 | mine = self.unrendered_config.get(key)\n 434 | others = other.unrendered_config.get(key)\n 435 | if mine != others:\n 436 | return False\n 437 | return True\n 438 | \n 439 | def same_config(self, old) -> bool:\n 440 | return self.config.same_contents(\n 441 | self.unrendered_config,\n 442 | old.unrendered_config,\n 443 | )\n 444 | \n 445 | def build_contract_checksum(self):\n 446 | pass\n 447 | \n 448 | def same_contract(self, old, adapter_type=None) -> bool:\n 449 | # This would only apply to seeds\n 450 | return True\n 451 | \n 452 | def same_contents(self, old, adapter_type) -> bool:\n 453 | if old is None:\n 454 | return False\n 455 | \n 456 | # Need to ensure that same_contract is called because it\n 457 | # could throw an error\n 458 | same_contract = self.same_contract(old, adapter_type)\n 459 | return (\n 460 | self.same_body(old)\n 461 | and self.same_config(old)\n 462 | and self.same_persisted_description(old)\n 463 | and self.same_fqn(old)\n 464 | and self.same_database_representation(old)\n 465 | and same_contract\n 466 | and True\n 467 | )\n 468 | \n 469 | @property\n 470 | def is_external_node(self):\n 471 | return False\n 472 | \n 473 | \n 474 | @dataclass\n 475 | class InjectedCTE(dbtClassMixin, Replaceable):\n 476 | \"\"\"Used in CompiledNodes as part of ephemeral model processing\"\"\"\n 477 | \n 478 | id: str\n 479 | sql: str\n 480 | \n 481 | \n 482 | @dataclass\n 483 | class CompiledNode(ParsedNode):\n 484 | \"\"\"Contains attributes necessary for SQL files and nodes with refs, sources, etc,\n 485 | so all ManifestNodes except SeedNode.\"\"\"\n 486 | \n 487 | language: str = \"sql\"\n 488 | refs: List[RefArgs] = field(default_factory=list)\n 489 | sources: List[List[str]] = field(default_factory=list)\n 490 | metrics: List[List[str]] = field(default_factory=list)\n 491 | depends_on: DependsOn = field(default_factory=DependsOn)\n 492 | compiled_path: Optional[str] = None\n 493 | compiled: bool = False\n 494 | compiled_code: Optional[str] = None\n 495 | extra_ctes_injected: bool = False\n 496 | extra_ctes: List[InjectedCTE] = field(default_factory=list)\n 497 | _pre_injected_sql: Optional[str] = None\n 498 | contract: Contract = field(default_factory=Contract)\n 499 | \n 500 | @property\n 501 | def empty(self):\n 502 | return not self.raw_code.strip()\n 503 | \n 504 | def set_cte(self, cte_id: str, sql: str):\n 505 | \"\"\"This is the equivalent of what self.extra_ctes[cte_id] = sql would\n 506 | do if extra_ctes were an OrderedDict\n 507 | \"\"\"\n 508 | for cte in self.extra_ctes:\n 509 | # Because it's possible that multiple threads are compiling the\n 510 | # node at the same time, we don't want to overwrite already compiled\n 511 | # sql in the extra_ctes with empty sql.\n 512 | if cte.id == cte_id:\n 513 | break\n 514 | else:\n 515 | self.extra_ctes.append(InjectedCTE(id=cte_id, sql=sql))\n 516 | \n 517 | def __post_serialize__(self, dct):\n 518 | dct = super().__post_serialize__(dct)\n 519 | if \"_pre_injected_sql\" in dct:\n 520 | del dct[\"_pre_injected_sql\"]\n 521 | # Remove compiled attributes\n 522 | if \"compiled\" in dct and dct[\"compiled\"] is False:\n 523 | del dct[\"compiled\"]\n 524 | del dct[\"extra_ctes_injected\"]\n 525 | del dct[\"extra_ctes\"]\n 526 | # \"omit_none\" means these might not be in the dictionary\n 527 | if \"compiled_code\" in dct:\n 528 | del dct[\"compiled_code\"]\n 529 | return dct\n 530 | \n 531 | @property\n 532 | def depends_on_nodes(self):\n 533 | return self.depends_on.nodes\n 534 | \n 535 | @property\n 536 | def depends_on_macros(self):\n 537 | return self.depends_on.macros\n 538 | \n 539 | \n 540 | # ====================================\n 541 | # CompiledNode subclasses\n 542 | # ====================================\n 543 | \n 544 | \n 545 | @dataclass\n 546 | class AnalysisNode(CompiledNode):\n 547 | resource_type: Literal[NodeType.Analysis]\n 548 | \n 549 | \n 550 | @dataclass\n 551 | class HookNode(CompiledNode):\n 552 | resource_type: Literal[NodeType.Operation]\n 553 | index: Optional[int] = None\n 554 | \n 555 | \n 556 | @dataclass\n 557 | class ModelNode(CompiledNode):\n 558 | resource_type: Literal[NodeType.Model]\n 559 | access: AccessType = AccessType.Protected\n 560 | config: ModelConfig = field(default_factory=ModelConfig)\n 561 | constraints: List[ModelLevelConstraint] = field(default_factory=list)\n 562 | version: Optional[NodeVersion] = None\n 563 | latest_version: Optional[NodeVersion] = None\n 564 | deprecation_date: Optional[datetime] = None\n 565 | defer_relation: Optional[DeferRelation] = None\n 566 | \n 567 | @classmethod\n 568 | def from_args(cls, args: ModelNodeArgs) -> \"ModelNode\":\n 569 | unique_id = args.unique_id\n 570 | \n 571 | # build unrendered config -- for usage in ParsedNode.same_contents\n 572 | unrendered_config = {}\n 573 | unrendered_config[\"alias\"] = args.identifier\n 574 | unrendered_config[\"schema\"] = args.schema\n 575 | if args.database:\n 576 | unrendered_config[\"database\"] = args.database\n 577 | \n 578 | return cls(\n 579 | resource_type=NodeType.Model,\n 580 | name=args.name,\n 581 | package_name=args.package_name,\n 582 | unique_id=unique_id,\n 583 | fqn=args.fqn,\n 584 | version=args.version,\n 585 | latest_version=args.latest_version,\n 586 | relation_name=args.relation_name,\n 587 | database=args.database,\n 588 | schema=args.schema,\n 589 | alias=args.identifier,\n 590 | deprecation_date=args.deprecation_date,\n 591 | checksum=FileHash.from_contents(f\"{unique_id},{args.generated_at}\"),\n 592 | access=AccessType(args.access),\n 593 | original_file_path=\"\",\n 594 | path=\"\",\n 595 | unrendered_config=unrendered_config,\n 596 | depends_on=DependsOn(nodes=args.depends_on_nodes),\n 597 | config=ModelConfig(enabled=args.enabled),\n 598 | )\n 599 | \n 600 | @property\n 601 | def is_external_node(self) -> bool:\n 602 | return not self.original_file_path and not self.path\n 603 | \n 604 | @property\n 605 | def is_latest_version(self) -> bool:\n 606 | return self.version is not None and self.version == self.latest_version\n 607 | \n 608 | @property\n 609 | def search_name(self):\n 610 | if self.version is None:\n 611 | return self.name\n 612 | else:\n 613 | return f\"{self.name}.v{self.version}\"\n 614 | \n 615 | @property\n 616 | def materialization_enforces_constraints(self) -> bool:\n 617 | return self.config.materialized in [\"table\", \"incremental\"]\n 618 | \n 619 | def same_contents(self, old, adapter_type) -> bool:\n 620 | return super().same_contents(old, adapter_type) and self.same_ref_representation(old)\n 621 | \n 622 | def same_ref_representation(self, old) -> bool:\n 623 | return (\n 624 | # Changing the latest_version may break downstream unpinned refs\n 625 | self.latest_version == old.latest_version\n 626 | # Changes to access or deprecation_date may lead to ref-related parsing errors\n 627 | and self.access == old.access\n 628 | and self.deprecation_date == old.deprecation_date\n 629 | )\n 630 | \n 631 | def build_contract_checksum(self):\n 632 | # We don't need to construct the checksum if the model does not\n 633 | # have contract enforced, because it won't be used.\n 634 | # This needs to be executed after contract config is set\n 635 | \n 636 | # Avoid rebuilding the checksum if it has already been set.\n 637 | if self.contract.checksum is not None:\n 638 | return\n 639 | \n 640 | if self.contract.enforced is True:\n 641 | contract_state = \"\"\n 642 | # We need to sort the columns so that order doesn't matter\n 643 | # columns is a str: ColumnInfo dictionary\n 644 | sorted_columns = sorted(self.columns.values(), key=lambda col: col.name)\n 645 | for column in sorted_columns:\n 646 | contract_state += f\"|{column.name}\"\n 647 | contract_state += str(column.data_type)\n 648 | contract_state += str(column.constraints)\n 649 | if self.materialization_enforces_constraints:\n 650 | contract_state += self.config.materialized\n 651 | contract_state += str(self.constraints)\n 652 | data = contract_state.encode(\"utf-8\")\n 653 | self.contract.checksum = hashlib.new(\"sha256\", data).hexdigest()\n 654 | \n 655 | def same_contract(self, old, adapter_type=None) -> bool:\n 656 | # If the contract wasn't previously enforced:\n 657 | if old.contract.enforced is False and self.contract.enforced is False:\n 658 | # No change -- same_contract: True\n 659 | return True\n 660 | if old.contract.enforced is False and self.contract.enforced is True:\n 661 | # Now it's enforced. This is a change, but not a breaking change -- same_contract: False\n 662 | return False\n 663 | \n 664 | # Otherwise: The contract was previously enforced, and we need to check for changes.\n 665 | # Happy path: The contract is still being enforced, and the checksums are identical.\n 666 | if self.contract.enforced is True and self.contract.checksum == old.contract.checksum:\n 667 | # No change -- same_contract: True\n 668 | return True\n 669 | \n 670 | # Otherwise: There has been a change.\n 671 | # We need to determine if it is a **breaking** change.\n 672 | # These are the categories of breaking changes:\n 673 | contract_enforced_disabled: bool = False\n 674 | columns_removed: List[str] = []\n 675 | column_type_changes: List[Dict[str, str]] = []\n 676 | enforced_column_constraint_removed: List[\n 677 | Dict[str, str]\n 678 | ] = [] # column_name, constraint_type\n 679 | enforced_model_constraint_removed: List[Dict[str, Any]] = [] # constraint_type, columns\n 680 | materialization_changed: List[str] = []\n 681 | \n 682 | if old.contract.enforced is True and self.contract.enforced is False:\n 683 | # Breaking change: the contract was previously enforced, and it no longer is\n 684 | contract_enforced_disabled = True\n 685 | \n 686 | # TODO: this avoid the circular imports but isn't ideal\n 687 | from dbt.adapters.factory import get_adapter_constraint_support\n 688 | from dbt.adapters.base import ConstraintSupport\n 689 | \n 690 | constraint_support = get_adapter_constraint_support(adapter_type)\n 691 | column_constraints_exist = False\n 692 | \n 693 | # Next, compare each column from the previous contract (old.columns)\n 694 | for old_key, old_value in sorted(old.columns.items()):\n 695 | # Has this column been removed?\n 696 | if old_key not in self.columns.keys():\n 697 | columns_removed.append(old_value.name)\n 698 | # Has this column's data type changed?\n 699 | elif old_value.data_type != self.columns[old_key].data_type:\n 700 | column_type_changes.append(\n 701 | {\n 702 | \"column_name\": str(old_value.name),\n 703 | \"previous_column_type\": str(old_value.data_type),\n 704 | \"current_column_type\": str(self.columns[old_key].data_type),\n 705 | }\n 706 | )\n 707 | \n 708 | # track if there are any column level constraints for the materialization check late\n 709 | if old_value.constraints:\n 710 | column_constraints_exist = True\n 711 | \n 712 | # Have enforced columns level constraints changed?\n 713 | # Constraints are only enforced for table and incremental materializations.\n 714 | # We only really care if the old node was one of those materializations for breaking changes\n 715 | if (\n 716 | old_key in self.columns.keys()\n 717 | and old_value.constraints != self.columns[old_key].constraints\n 718 | and old.materialization_enforces_constraints\n 719 | ):\n 720 | for old_constraint in old_value.constraints:\n 721 | if (\n 722 | old_constraint not in self.columns[old_key].constraints\n 723 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 724 | ):\n 725 | enforced_column_constraint_removed.append(\n 726 | {\n 727 | \"column_name\": old_key,\n 728 | \"constraint_name\": old_constraint.name,\n 729 | \"constraint_type\": ConstraintType(old_constraint.type),\n 730 | }\n 731 | )\n 732 | \n 733 | # Now compare the model level constraints\n 734 | if old.constraints != self.constraints and old.materialization_enforces_constraints:\n 735 | for old_constraint in old.constraints:\n 736 | if (\n 737 | old_constraint not in self.constraints\n 738 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 739 | ):\n 740 | enforced_model_constraint_removed.append(\n 741 | {\n 742 | \"constraint_name\": old_constraint.name,\n 743 | \"constraint_type\": ConstraintType(old_constraint.type),\n 744 | \"columns\": old_constraint.columns,\n 745 | }\n 746 | )\n 747 | \n 748 | # Check for relevant materialization changes.\n 749 | if (\n 750 | old.materialization_enforces_constraints\n 751 | and not self.materialization_enforces_constraints\n 752 | and (old.constraints or column_constraints_exist)\n 753 | ):\n 754 | materialization_changed = [old.config.materialized, self.config.materialized]\n 755 | \n 756 | # If a column has been added, it will be missing in the old.columns, and present in self.columns\n 757 | # That's a change (caught by the different checksums), but not a breaking change\n 758 | \n 759 | # Did we find any changes that we consider breaking? If there's an enforced contract, that's\n 760 | # a warning unless the model is versioned, then it's an error.\n 761 | if (\n 762 | contract_enforced_disabled\n 763 | or columns_removed\n 764 | or column_type_changes\n 765 | or enforced_model_constraint_removed\n 766 | or enforced_column_constraint_removed\n 767 | or materialization_changed\n 768 | ):\n 769 | \n 770 | breaking_changes = []\n 771 | if contract_enforced_disabled:\n 772 | breaking_changes.append(\n 773 | \"Contract enforcement was removed: Previously, this model had an enforced contract. It is no longer configured to enforce its contract, and this is a breaking change.\"\n 774 | )\n 775 | if columns_removed:\n 776 | columns_removed_str = \"\\n - \".join(columns_removed)\n 777 | breaking_changes.append(f\"Columns were removed: \\n - {columns_removed_str}\")\n 778 | if column_type_changes:\n 779 | column_type_changes_str = \"\\n - \".join(\n 780 | [\n 781 | f\"{c['column_name']} ({c['previous_column_type']} -> {c['current_column_type']})\"\n 782 | for c in column_type_changes\n 783 | ]\n 784 | )\n 785 | breaking_changes.append(\n 786 | f\"Columns with data_type changes: \\n - {column_type_changes_str}\"\n 787 | )\n 788 | if enforced_column_constraint_removed:\n 789 | column_constraint_changes_str = \"\\n - \".join(\n 790 | [\n 791 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on column {c['column_name']}\"\n 792 | for c in enforced_column_constraint_removed\n 793 | ]\n 794 | )\n 795 | breaking_changes.append(\n 796 | f\"Enforced column level constraints were removed: \\n - {column_constraint_changes_str}\"\n 797 | )\n 798 | if enforced_model_constraint_removed:\n 799 | model_constraint_changes_str = \"\\n - \".join(\n 800 | [\n 801 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on columns {c['columns']}\"\n 802 | for c in enforced_model_constraint_removed\n 803 | ]\n 804 | )\n 805 | breaking_changes.append(\n 806 | f\"Enforced model level constraints were removed: \\n - {model_constraint_changes_str}\"\n 807 | )\n 808 | if materialization_changed:\n 809 | materialization_changes_str = (\n 810 | f\"{materialization_changed[0]} -> {materialization_changed[1]}\"\n 811 | )\n 812 | \n 813 | breaking_changes.append(\n 814 | f\"Materialization changed with enforced constraints: \\n - {materialization_changes_str}\"\n 815 | )\n 816 | \n 817 | if self.version is None:\n 818 | warn_or_error(\n 819 | UnversionedBreakingChange(\n 820 | contract_enforced_disabled=contract_enforced_disabled,\n 821 | columns_removed=columns_removed,\n 822 | column_type_changes=column_type_changes,\n 823 | enforced_column_constraint_removed=enforced_column_constraint_removed,\n 824 | enforced_model_constraint_removed=enforced_model_constraint_removed,\n 825 | breaking_changes=breaking_changes,\n 826 | model_name=self.name,\n 827 | model_file_path=self.original_file_path,\n 828 | ),\n 829 | node=self,\n 830 | )\n 831 | else:\n 832 | raise (\n 833 | ContractBreakingChangeError(\n 834 | breaking_changes=breaking_changes,\n 835 | node=self,\n 836 | )\n 837 | )\n 838 | \n 839 | # Otherwise, the contract has changed -- same_contract: False\n 840 | return False\n 841 | \n 842 | \n 843 | # TODO: rm?\n 844 | @dataclass\n 845 | class RPCNode(CompiledNode):\n 846 | resource_type: Literal[NodeType.RPCCall]\n 847 | \n 848 | \n 849 | @dataclass\n 850 | class SqlNode(CompiledNode):\n 851 | resource_type: Literal[NodeType.SqlOperation]\n 852 | \n 853 | \n 854 | # ====================================\n 855 | # Seed node\n 856 | # ====================================\n 857 | \n 858 | \n 859 | @dataclass\n 860 | class SeedNode(ParsedNode): # No SQLDefaults!\n 861 | resource_type: Literal[NodeType.Seed]\n 862 | config: SeedConfig = field(default_factory=SeedConfig)\n 863 | # seeds need the root_path because the contents are not loaded initially\n 864 | # and we need the root_path to load the seed later\n 865 | root_path: Optional[str] = None\n 866 | depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)\n 867 | defer_relation: Optional[DeferRelation] = None\n 868 | \n 869 | def same_seeds(self, other: \"SeedNode\") -> bool:\n 870 | # for seeds, we check the hashes. If the hashes are different types,\n 871 | # no match. If the hashes are both the same 'path', log a warning and\n 872 | # assume they are the same\n 873 | # if the current checksum is a path, we want to log a warning.\n 874 | result = self.checksum == other.checksum\n 875 | \n 876 | if self.checksum.name == \"path\":\n 877 | msg: str\n 878 | if other.checksum.name != \"path\":\n 879 | warn_or_error(\n 880 | SeedIncreased(package_name=self.package_name, name=self.name), node=self\n 881 | )\n 882 | elif result:\n 883 | warn_or_error(\n 884 | SeedExceedsLimitSamePath(package_name=self.package_name, name=self.name),\n 885 | node=self,\n 886 | )\n 887 | elif not result:\n 888 | warn_or_error(\n 889 | SeedExceedsLimitAndPathChanged(package_name=self.package_name, name=self.name),\n 890 | node=self,\n 891 | )\n 892 | else:\n 893 | warn_or_error(\n 894 | SeedExceedsLimitChecksumChanged(\n 895 | package_name=self.package_name,\n 896 | name=self.name,\n 897 | checksum_name=other.checksum.name,\n 898 | ),\n 899 | node=self,\n 900 | )\n 901 | \n 902 | return result\n 903 | \n 904 | @property\n 905 | def empty(self):\n 906 | \"\"\"Seeds are never empty\"\"\"\n 907 | return False\n 908 | \n 909 | def _disallow_implicit_dependencies(self):\n 910 | \"\"\"Disallow seeds to take implicit upstream dependencies via pre/post hooks\"\"\"\n 911 | # Seeds are root nodes in the DAG. They cannot depend on other nodes.\n 912 | # However, it's possible to define pre- and post-hooks on seeds, and for those\n 913 | # hooks to include {{ ref(...) }}. This worked in previous versions, but it\n 914 | # was never officially documented or supported behavior. Let's raise an explicit error,\n 915 | # which will surface during parsing if the user has written code such that we attempt\n 916 | # to capture & record a ref/source/metric call on the SeedNode.\n 917 | # For more details: https://github.com/dbt-labs/dbt-core/issues/6806\n 918 | hooks = [f'- pre_hook: \"{hook.sql}\"' for hook in self.config.pre_hook] + [\n 919 | f'- post_hook: \"{hook.sql}\"' for hook in self.config.post_hook\n 920 | ]\n 921 | hook_list = \"\\n\".join(hooks)\n 922 | message = f\"\"\"\n 923 | Seeds cannot depend on other nodes. dbt detected a seed with a pre- or post-hook\n 924 | that calls 'ref', 'source', or 'metric', either directly or indirectly via other macros.\n 925 | \n 926 | Error raised for '{self.unique_id}', which has these hooks defined: \\n{hook_list}\n 927 | \"\"\"\n 928 | raise ParsingError(message)\n 929 | \n 930 | @property\n 931 | def refs(self):\n 932 | self._disallow_implicit_dependencies()\n 933 | \n 934 | @property\n 935 | def sources(self):\n 936 | self._disallow_implicit_dependencies()\n 937 | \n 938 | @property\n 939 | def metrics(self):\n 940 | self._disallow_implicit_dependencies()\n 941 | \n 942 | def same_body(self, other) -> bool:\n 943 | return self.same_seeds(other)\n 944 | \n 945 | @property\n 946 | def depends_on_nodes(self):\n 947 | return []\n 948 | \n 949 | @property\n 950 | def depends_on_macros(self) -> List[str]:\n 951 | return self.depends_on.macros\n 952 | \n 953 | @property\n 954 | def extra_ctes(self):\n 955 | return []\n 956 | \n 957 | @property\n 958 | def extra_ctes_injected(self):\n 959 | return False\n 960 | \n 961 | @property\n 962 | def language(self):\n 963 | return \"sql\"\n 964 | \n 965 | \n 966 | # ====================================\n 967 | # Singular Test node\n 968 | # ====================================\n 969 | \n 970 | \n 971 | class TestShouldStoreFailures:\n 972 | @property\n 973 | def should_store_failures(self):\n 974 | if self.config.store_failures:\n 975 | return self.config.store_failures\n 976 | return get_flags().STORE_FAILURES\n 977 | \n 978 | @property\n 979 | def is_relational(self):\n 980 | if self.should_store_failures:\n 981 | return True\n 982 | return False\n 983 | \n 984 | \n 985 | @dataclass\n 986 | class SingularTestNode(TestShouldStoreFailures, CompiledNode):\n 987 | resource_type: Literal[NodeType.Test]\n 988 | # Was not able to make mypy happy and keep the code working. We need to\n 989 | # refactor the various configs.\n 990 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n 991 | \n 992 | @property\n 993 | def test_node_type(self):\n 994 | return \"singular\"\n 995 | \n 996 | \n 997 | # ====================================\n 998 | # Generic Test node\n 999 | # ====================================\n1000 | \n1001 | \n1002 | @dataclass\n1003 | class TestMetadata(dbtClassMixin, Replaceable):\n1004 | __test__ = False\n1005 | \n1006 | name: str\n1007 | # kwargs are the args that are left in the test builder after\n1008 | # removing configs. They are set from the test builder when\n1009 | # the test node is created.\n1010 | kwargs: Dict[str, Any] = field(default_factory=dict)\n1011 | namespace: Optional[str] = None\n1012 | \n1013 | \n1014 | # This has to be separated out because it has no default and so\n1015 | # has to be included as a superclass, not an attribute\n1016 | @dataclass\n1017 | class HasTestMetadata(dbtClassMixin):\n1018 | test_metadata: TestMetadata\n1019 | \n1020 | \n1021 | @dataclass\n1022 | class GenericTestNode(TestShouldStoreFailures, CompiledNode, HasTestMetadata):\n1023 | resource_type: Literal[NodeType.Test]\n1024 | column_name: Optional[str] = None\n1025 | file_key_name: Optional[str] = None\n1026 | # Was not able to make mypy happy and keep the code working. We need to\n1027 | # refactor the various configs.\n1028 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n1029 | attached_node: Optional[str] = None\n1030 | \n1031 | def same_contents(self, other, adapter_type: Optional[str]) -> bool:\n1032 | if other is None:\n1033 | return False\n1034 | \n1035 | return self.same_config(other) and self.same_fqn(other) and True\n1036 | \n1037 | @property\n1038 | def test_node_type(self):\n1039 | return \"generic\"\n1040 | \n1041 | \n1042 | @dataclass\n1043 | class UnitTestSourceDefinition(ModelNode):\n1044 | source_name: str = \"undefined\"\n1045 | quoting: Quoting = field(default_factory=Quoting)\n1046 | \n1047 | @property\n1048 | def search_name(self):\n1049 | return f\"{self.source_name}.{self.name}\"\n1050 | \n1051 | \n1052 | @dataclass\n1053 | class UnitTestNode(CompiledNode):\n1054 | resource_type: Literal[NodeType.Unit]\n1055 | tested_node_unique_id: Optional[str] = None\n1056 | this_input_node_unique_id: Optional[str] = None\n1057 | overrides: Optional[UnitTestOverrides] = None\n1058 | config: UnitTestNodeConfig = field(default_factory=UnitTestNodeConfig)\n1059 | \n1060 | \n1061 | @dataclass\n1062 | class UnitTestDefinitionMandatory:\n1063 | model: str\n1064 | given: Sequence[UnitTestInputFixture]\n1065 | expect: UnitTestOutputFixture\n1066 | \n1067 | \n1068 | @dataclass\n1069 | class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):\n1070 | description: str = \"\"\n1071 | overrides: Optional[UnitTestOverrides] = None\n1072 | depends_on: DependsOn = field(default_factory=DependsOn)\n1073 | config: UnitTestConfig = field(default_factory=UnitTestConfig)\n1074 | checksum: Optional[str] = None\n1075 | schema: Optional[str] = None\n1076 | \n1077 | @property\n1078 | def build_path(self):\n1079 | # TODO: is this actually necessary?\n1080 | return self.original_file_path\n1081 | \n1082 | @property\n1083 | def compiled_path(self):\n1084 | # TODO: is this actually necessary?\n1085 | return self.original_file_path\n1086 | \n1087 | @property\n1088 | def depends_on_nodes(self):\n1089 | return self.depends_on.nodes\n1090 | \n1091 | @property\n1092 | def tags(self) -> List[str]:\n1093 | tags = self.config.tags\n1094 | return [tags] if isinstance(tags, str) else tags\n1095 | \n1096 | def build_unit_test_checksum(self):\n1097 | # everything except 'description'\n1098 | data = f\"{self.model}-{self.given}-{self.expect}-{self.overrides}\"\n1099 | \n1100 | # include underlying fixture data\n1101 | for input in self.given:\n1102 | if input.fixture:\n1103 | data += f\"-{input.rows}\"\n1104 | \n1105 | self.checksum = hashlib.new(\"sha256\", data.encode(\"utf-8\")).hexdigest()\n1106 | \n1107 | def same_contents(self, other: Optional[\"UnitTestDefinition\"]) -> bool:\n1108 | if other is None:\n1109 | return False\n1110 | \n1111 | return self.checksum == other.checksum\n1112 | \n1113 | \n1114 | @dataclass\n1115 | class UnitTestFileFixture(BaseNode):\n1116 | resource_type: Literal[NodeType.Fixture]\n1117 | rows: Optional[List[Dict[str, Any]]] = None\n1118 | \n1119 | \n1120 | # ====================================\n1121 | # Snapshot node\n1122 | # ====================================\n1123 | \n1124 | \n1125 | @dataclass\n1126 | class IntermediateSnapshotNode(CompiledNode):\n1127 | # at an intermediate stage in parsing, where we've built something better\n1128 | # than an unparsed node for rendering in parse mode, it's pretty possible\n1129 | # that we won't have critical snapshot-related information that is only\n1130 | # defined in config blocks. To fix that, we have an intermediate type that\n1131 | # uses a regular node config, which the snapshot parser will then convert\n1132 | # into a full ParsedSnapshotNode after rendering. Note: it currently does\n1133 | # not work to set snapshot config in schema files because of the validation.\n1134 | resource_type: Literal[NodeType.Snapshot]\n1135 | config: EmptySnapshotConfig = field(default_factory=EmptySnapshotConfig)\n1136 | \n1137 | \n1138 | @dataclass\n1139 | class SnapshotNode(CompiledNode):\n1140 | resource_type: Literal[NodeType.Snapshot]\n1141 | config: SnapshotConfig\n1142 | defer_relation: Optional[DeferRelation] = None\n1143 | \n1144 | \n1145 | # ====================================\n1146 | # Macro\n1147 | # ====================================\n1148 | \n1149 | \n1150 | @dataclass\n1151 | class Macro(BaseNode):\n1152 | macro_sql: str\n1153 | resource_type: Literal[NodeType.Macro]\n1154 | depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)\n1155 | description: str = \"\"\n1156 | meta: Dict[str, Any] = field(default_factory=dict)\n1157 | docs: Docs = field(default_factory=Docs)\n1158 | patch_path: Optional[str] = None\n1159 | arguments: List[MacroArgument] = field(default_factory=list)\n1160 | created_at: float = field(default_factory=lambda: time.time())\n1161 | supported_languages: Optional[List[ModelLanguage]] = None\n1162 | \n1163 | def same_contents(self, other: Optional[\"Macro\"]) -> bool:\n1164 | if other is None:\n1165 | return False\n1166 | # the only thing that makes one macro different from another with the\n1167 | # same name/package is its content\n1168 | return self.macro_sql == other.macro_sql\n1169 | \n1170 | @property\n1171 | def depends_on_macros(self):\n1172 | return self.depends_on.macros\n1173 | \n1174 | \n1175 | # ====================================\n1176 | # Documentation node\n1177 | # ====================================\n1178 | \n1179 | \n1180 | @dataclass\n1181 | class Documentation(BaseNode):\n1182 | block_contents: str\n1183 | resource_type: Literal[NodeType.Documentation]\n1184 | \n1185 | @property\n1186 | def search_name(self):\n1187 | return self.name\n1188 | \n1189 | def same_contents(self, other: Optional[\"Documentation\"]) -> bool:\n1190 | if other is None:\n1191 | return False\n1192 | # the only thing that makes one doc different from another with the\n1193 | # same name/package is its content\n1194 | return self.block_contents == other.block_contents\n1195 | \n1196 | \n1197 | # ====================================\n1198 | # Source node\n1199 | # ====================================\n1200 | \n1201 | \n1202 | def normalize_test(testdef: TestDef) -> Dict[str, Any]:\n1203 | if isinstance(testdef, str):\n1204 | return {testdef: {}}\n1205 | else:\n1206 | return testdef\n1207 | \n1208 | \n1209 | @dataclass\n1210 | class UnpatchedSourceDefinition(BaseNode):\n1211 | source: UnparsedSourceDefinition\n1212 | table: UnparsedSourceTableDefinition\n1213 | fqn: List[str]\n1214 | resource_type: Literal[NodeType.Source]\n1215 | patch_path: Optional[str] = None\n1216 | \n1217 | def get_full_source_name(self):\n1218 | return f\"{self.source.name}_{self.table.name}\"\n1219 | \n1220 | def get_source_representation(self):\n1221 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1222 | \n1223 | def validate_data_tests(self):\n1224 | \"\"\"\n1225 | sources parse tests differently than models, so we need to do some validation\n1226 | here where it's done in the PatchParser for other nodes\n1227 | \"\"\"\n1228 | # source table-level tests\n1229 | if self.tests and self.data_tests:\n1230 | raise ValidationError(\n1231 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1232 | )\n1233 | if self.tests:\n1234 | deprecations.warn(\n1235 | \"project-test-config\",\n1236 | deprecated_path=\"tests\",\n1237 | exp_path=\"data_tests\",\n1238 | )\n1239 | self.data_tests.extend(self.tests)\n1240 | self.tests.clear()\n1241 | \n1242 | # column-level tests\n1243 | for column in self.columns:\n1244 | if column.tests and column.data_tests:\n1245 | raise ValidationError(\n1246 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1247 | )\n1248 | if column.tests:\n1249 | deprecations.warn(\n1250 | \"project-test-config\",\n1251 | deprecated_path=\"tests\",\n1252 | exp_path=\"data_tests\",\n1253 | )\n1254 | column.data_tests.extend(column.tests)\n1255 | column.tests.clear()\n1256 | \n1257 | @property\n1258 | def quote_columns(self) -> Optional[bool]:\n1259 | result = None\n1260 | if self.source.quoting.column is not None:\n1261 | result = self.source.quoting.column\n1262 | if self.table.quoting.column is not None:\n1263 | result = self.table.quoting.column\n1264 | return result\n1265 | \n1266 | @property\n1267 | def columns(self) -> Sequence[UnparsedColumn]:\n1268 | return [] if self.table.columns is None else self.table.columns\n1269 | \n1270 | def get_tests(self) -> Iterator[Tuple[Dict[str, Any], Optional[UnparsedColumn]]]:\n1271 | self.validate_data_tests()\n1272 | for data_test in self.data_tests:\n1273 | yield normalize_test(data_test), None\n1274 | \n1275 | for column in self.columns:\n1276 | if column.data_tests is not None:\n1277 | for data_test in column.data_tests:\n1278 | yield normalize_test(data_test), column\n1279 | \n1280 | @property\n1281 | def data_tests(self) -> List[TestDef]:\n1282 | if self.table.data_tests is None:\n1283 | return []\n1284 | else:\n1285 | return self.table.data_tests\n1286 | \n1287 | # deprecated\n1288 | @property\n1289 | def tests(self) -> List[TestDef]:\n1290 | if self.table.tests is None:\n1291 | return []\n1292 | else:\n1293 | return self.table.tests\n1294 | \n1295 | \n1296 | @dataclass\n1297 | class ParsedSourceMandatory(GraphNode, HasRelationMetadata):\n1298 | source_name: str\n1299 | source_description: str\n1300 | loader: str\n1301 | identifier: str\n1302 | resource_type: Literal[NodeType.Source]\n1303 | \n1304 | \n1305 | @dataclass\n1306 | class SourceDefinition(NodeInfoMixin, ParsedSourceMandatory):\n1307 | quoting: Quoting = field(default_factory=Quoting)\n1308 | loaded_at_field: Optional[str] = None\n1309 | freshness: Optional[FreshnessThreshold] = None\n1310 | external: Optional[ExternalTable] = None\n1311 | description: str = \"\"\n1312 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n1313 | meta: Dict[str, Any] = field(default_factory=dict)\n1314 | source_meta: Dict[str, Any] = field(default_factory=dict)\n1315 | tags: List[str] = field(default_factory=list)\n1316 | config: SourceConfig = field(default_factory=SourceConfig)\n1317 | patch_path: Optional[str] = None\n1318 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1319 | relation_name: Optional[str] = None\n1320 | created_at: float = field(default_factory=lambda: time.time())\n1321 | \n1322 | def __post_serialize__(self, dct):\n1323 | if \"_event_status\" in dct:\n1324 | del dct[\"_event_status\"]\n1325 | return dct\n1326 | \n1327 | def same_database_representation(self, other: \"SourceDefinition\") -> bool:\n1328 | return (\n1329 | self.database == other.database\n1330 | and self.schema == other.schema\n1331 | and self.identifier == other.identifier\n1332 | and True\n1333 | )\n1334 | \n1335 | def same_quoting(self, other: \"SourceDefinition\") -> bool:\n1336 | return self.quoting == other.quoting\n1337 | \n1338 | def same_freshness(self, other: \"SourceDefinition\") -> bool:\n1339 | return (\n1340 | self.freshness == other.freshness\n1341 | and self.loaded_at_field == other.loaded_at_field\n1342 | and True\n1343 | )\n1344 | \n1345 | def same_external(self, other: \"SourceDefinition\") -> bool:\n1346 | return self.external == other.external\n1347 | \n1348 | def same_config(self, old: \"SourceDefinition\") -> bool:\n1349 | return self.config.same_contents(\n1350 | self.unrendered_config,\n1351 | old.unrendered_config,\n1352 | )\n1353 | \n1354 | def same_contents(self, old: Optional[\"SourceDefinition\"]) -> bool:\n1355 | # existing when it didn't before is a change!\n1356 | if old is None:\n1357 | return True\n1358 | \n1359 | # config changes are changes (because the only config is \"enforced\", and\n1360 | # enabling a source is a change!)\n1361 | # changing the database/schema/identifier is a change\n1362 | # messing around with external stuff is a change (uh, right?)\n1363 | # quoting changes are changes\n1364 | # freshness changes are changes, I guess\n1365 | # metadata/tags changes are not \"changes\"\n1366 | # patching/description changes are not \"changes\"\n1367 | return (\n1368 | self.same_database_representation(old)\n1369 | and self.same_fqn(old)\n1370 | and self.same_config(old)\n1371 | and self.same_quoting(old)\n1372 | and self.same_freshness(old)\n1373 | and self.same_external(old)\n1374 | and True\n1375 | )\n1376 | \n1377 | def get_full_source_name(self):\n1378 | return f\"{self.source_name}_{self.name}\"\n1379 | \n1380 | def get_source_representation(self):\n1381 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1382 | \n1383 | @property\n1384 | def is_refable(self):\n1385 | return False\n1386 | \n1387 | @property\n1388 | def is_ephemeral(self):\n1389 | return False\n1390 | \n1391 | @property\n1392 | def is_ephemeral_model(self):\n1393 | return False\n1394 | \n1395 | @property\n1396 | def depends_on_nodes(self):\n1397 | return []\n1398 | \n1399 | @property\n1400 | def depends_on(self):\n1401 | return DependsOn(macros=[], nodes=[])\n1402 | \n1403 | @property\n1404 | def refs(self):\n1405 | return []\n1406 | \n1407 | @property\n1408 | def sources(self):\n1409 | return []\n1410 | \n1411 | @property\n1412 | def has_freshness(self) -> bool:\n1413 | return bool(self.freshness)\n1414 | \n1415 | @property\n1416 | def search_name(self):\n1417 | return f\"{self.source_name}.{self.name}\"\n1418 | \n1419 | @property\n1420 | def group(self):\n1421 | return None\n1422 | \n1423 | \n1424 | # ====================================\n1425 | # Exposure node\n1426 | # ====================================\n1427 | \n1428 | \n1429 | @dataclass\n1430 | class Exposure(GraphNode):\n1431 | type: ExposureType\n1432 | owner: Owner\n1433 | resource_type: Literal[NodeType.Exposure]\n1434 | description: str = \"\"\n1435 | label: Optional[str] = None\n1436 | maturity: Optional[MaturityType] = None\n1437 | meta: Dict[str, Any] = field(default_factory=dict)\n1438 | tags: List[str] = field(default_factory=list)\n1439 | config: ExposureConfig = field(default_factory=ExposureConfig)\n1440 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1441 | url: Optional[str] = None\n1442 | depends_on: DependsOn = field(default_factory=DependsOn)\n1443 | refs: List[RefArgs] = field(default_factory=list)\n1444 | sources: List[List[str]] = field(default_factory=list)\n1445 | metrics: List[List[str]] = field(default_factory=list)\n1446 | created_at: float = field(default_factory=lambda: time.time())\n1447 | \n1448 | @property\n1449 | def depends_on_nodes(self):\n1450 | return self.depends_on.nodes\n1451 | \n1452 | @property\n1453 | def search_name(self):\n1454 | return self.name\n1455 | \n1456 | def same_depends_on(self, old: \"Exposure\") -> bool:\n1457 | return set(self.depends_on.nodes) == set(old.depends_on.nodes)\n1458 | \n1459 | def same_description(self, old: \"Exposure\") -> bool:\n1460 | return self.description == old.description\n1461 | \n1462 | def same_label(self, old: \"Exposure\") -> bool:\n1463 | return self.label == old.label\n1464 | \n1465 | def same_maturity(self, old: \"Exposure\") -> bool:\n1466 | return self.maturity == old.maturity\n1467 | \n1468 | def same_owner(self, old: \"Exposure\") -> bool:\n1469 | return self.owner == old.owner\n1470 | \n1471 | def same_exposure_type(self, old: \"Exposure\") -> bool:\n1472 | return self.type == old.type\n1473 | \n1474 | def same_url(self, old: \"Exposure\") -> bool:\n1475 | return self.url == old.url\n1476 | \n1477 | def same_config(self, old: \"Exposure\") -> bool:\n1478 | return self.config.same_contents(\n1479 | self.unrendered_config,\n1480 | old.unrendered_config,\n1481 | )\n1482 | \n1483 | def same_contents(self, old: Optional[\"Exposure\"]) -> bool:\n1484 | # existing when it didn't before is a change!\n1485 | # metadata/tags changes are not \"changes\"\n1486 | if old is None:\n1487 | return True\n1488 | \n1489 | return (\n1490 | self.same_fqn(old)\n1491 | and self.same_exposure_type(old)\n1492 | and self.same_owner(old)\n1493 | and self.same_maturity(old)\n1494 | and self.same_url(old)\n1495 | and self.same_description(old)\n1496 | and self.same_label(old)\n1497 | and self.same_depends_on(old)\n1498 | and self.same_config(old)\n1499 | and True\n1500 | )\n1501 | \n1502 | @property\n1503 | def group(self):\n1504 | return None\n1505 | \n1506 | \n1507 | # ====================================\n1508 | # Metric node\n1509 | # ====================================\n1510 | \n1511 | \n1512 | @dataclass\n1513 | class MetricInputMeasure(dbtClassMixin):\n1514 | name: str\n1515 | filter: Optional[WhereFilterIntersection] = None\n1516 | alias: Optional[str] = None\n1517 | join_to_timespine: bool = False\n1518 | fill_nulls_with: Optional[int] = None\n1519 | \n1520 | def measure_reference(self) -> MeasureReference:\n1521 | return MeasureReference(element_name=self.name)\n1522 | \n1523 | def post_aggregation_measure_reference(self) -> MeasureReference:\n1524 | return MeasureReference(element_name=self.alias or self.name)\n1525 | \n1526 | \n1527 | @dataclass\n1528 | class MetricTimeWindow(dbtClassMixin):\n1529 | count: int\n1530 | granularity: TimeGranularity\n1531 | \n1532 | \n1533 | @dataclass\n1534 | class MetricInput(dbtClassMixin):\n1535 | name: str\n1536 | filter: Optional[WhereFilterIntersection] = None\n1537 | alias: Optional[str] = None\n1538 | offset_window: Optional[MetricTimeWindow] = None\n1539 | offset_to_grain: Optional[TimeGranularity] = None\n1540 | \n1541 | def as_reference(self) -> DSIMetricReference:\n1542 | return DSIMetricReference(element_name=self.name)\n1543 | \n1544 | def post_aggregation_reference(self) -> DSIMetricReference:\n1545 | return DSIMetricReference(element_name=self.alias or self.name)\n1546 | \n1547 | \n1548 | @dataclass\n1549 | class ConversionTypeParams(dbtClassMixin):\n1550 | base_measure: MetricInputMeasure\n1551 | conversion_measure: MetricInputMeasure\n1552 | entity: str\n1553 | calculation: ConversionCalculationType = ConversionCalculationType.CONVERSION_RATE\n1554 | window: Optional[MetricTimeWindow] = None\n1555 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n1556 | \n1557 | \n1558 | @dataclass\n1559 | class MetricTypeParams(dbtClassMixin):\n1560 | measure: Optional[MetricInputMeasure] = None\n1561 | input_measures: List[MetricInputMeasure] = field(default_factory=list)\n1562 | numerator: Optional[MetricInput] = None\n1563 | denominator: Optional[MetricInput] = None\n1564 | expr: Optional[str] = None\n1565 | window: Optional[MetricTimeWindow] = None\n1566 | grain_to_date: Optional[TimeGranularity] = None\n1567 | metrics: Optional[List[MetricInput]] = None\n1568 | conversion_type_params: Optional[ConversionTypeParams] = None\n1569 | \n1570 | \n1571 | @dataclass\n1572 | class MetricReference(dbtClassMixin, Replaceable):\n1573 | sql: Optional[Union[str, int]] = None\n1574 | unique_id: Optional[str] = None\n1575 | \n1576 | \n1577 | @dataclass\n1578 | class Metric(GraphNode):\n1579 | name: str\n1580 | description: str\n1581 | label: str\n1582 | type: MetricType\n1583 | type_params: MetricTypeParams\n1584 | filter: Optional[WhereFilterIntersection] = None\n1585 | metadata: Optional[SourceFileMetadata] = None\n1586 | resource_type: Literal[NodeType.Metric]\n1587 | meta: Dict[str, Any] = field(default_factory=dict)\n1588 | tags: List[str] = field(default_factory=list)\n1589 | config: MetricConfig = field(default_factory=MetricConfig)\n1590 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1591 | sources: List[List[str]] = field(default_factory=list)\n1592 | depends_on: DependsOn = field(default_factory=DependsOn)\n1593 | refs: List[RefArgs] = field(default_factory=list)\n1594 | metrics: List[List[str]] = field(default_factory=list)\n1595 | created_at: float = field(default_factory=lambda: time.time())\n1596 | group: Optional[str] = None\n1597 | \n1598 | @property\n1599 | def depends_on_nodes(self):\n1600 | return self.depends_on.nodes\n1601 | \n1602 | @property\n1603 | def search_name(self):\n1604 | return self.name\n1605 | \n1606 | @property\n1607 | def input_measures(self) -> List[MetricInputMeasure]:\n1608 | return self.type_params.input_measures\n1609 | \n1610 | @property\n1611 | def measure_references(self) -> List[MeasureReference]:\n1612 | return [x.measure_reference() for x in self.input_measures]\n1613 | \n1614 | @property\n1615 | def input_metrics(self) -> List[MetricInput]:\n1616 | return self.type_params.metrics or []\n1617 | \n1618 | def same_description(self, old: \"Metric\") -> bool:\n1619 | return self.description == old.description\n1620 | \n1621 | def same_label(self, old: \"Metric\") -> bool:\n1622 | return self.label == old.label\n1623 | \n1624 | def same_config(self, old: \"Metric\") -> bool:\n1625 | return self.config.same_contents(\n1626 | self.unrendered_config,\n1627 | old.unrendered_config,\n1628 | )\n1629 | \n1630 | def same_filter(self, old: \"Metric\") -> bool:\n1631 | return True # TODO\n1632 | \n1633 | def same_metadata(self, old: \"Metric\") -> bool:\n1634 | return True # TODO\n1635 | \n1636 | def same_type(self, old: \"Metric\") -> bool:\n1637 | return self.type == old.type\n1638 | \n1639 | def same_type_params(self, old: \"Metric\") -> bool:\n1640 | return True # TODO\n1641 | \n1642 | def same_contents(self, old: Optional[\"Metric\"]) -> bool:\n1643 | # existing when it didn't before is a change!\n1644 | # metadata/tags changes are not \"changes\"\n1645 | if old is None:\n1646 | return True\n1647 | \n1648 | return (\n1649 | self.same_filter(old)\n1650 | and self.same_metadata(old)\n1651 | and self.same_type(old)\n1652 | and self.same_type_params(old)\n1653 | and self.same_description(old)\n1654 | and self.same_label(old)\n1655 | and self.same_config(old)\n1656 | and True\n1657 | )\n1658 | \n1659 | \n1660 | # ====================================\n1661 | # Group node\n1662 | # ====================================\n1663 | \n1664 | \n1665 | @dataclass\n1666 | class Group(BaseNode):\n1667 | name: str\n1668 | owner: Owner\n1669 | resource_type: Literal[NodeType.Group]\n1670 | \n1671 | \n1672 | # ====================================\n1673 | # SemanticModel and related classes\n1674 | # ====================================\n1675 | \n1676 | \n1677 | @dataclass\n1678 | class NodeRelation(dbtClassMixin):\n1679 | alias: str\n1680 | schema_name: str # TODO: Could this be called simply \"schema\" so we could reuse StateRelation?\n1681 | database: Optional[str] = None\n1682 | relation_name: Optional[str] = None\n1683 | \n1684 | \n1685 | @dataclass\n1686 | class SemanticModel(GraphNode):\n1687 | model: str\n1688 | node_relation: Optional[NodeRelation]\n1689 | description: Optional[str] = None\n1690 | label: Optional[str] = None\n1691 | defaults: Optional[Defaults] = None\n1692 | entities: Sequence[Entity] = field(default_factory=list)\n1693 | measures: Sequence[Measure] = field(default_factory=list)\n1694 | dimensions: Sequence[Dimension] = field(default_factory=list)\n1695 | metadata: Optional[SourceFileMetadata] = None\n1696 | depends_on: DependsOn = field(default_factory=DependsOn)\n1697 | refs: List[RefArgs] = field(default_factory=list)\n1698 | created_at: float = field(default_factory=lambda: time.time())\n1699 | config: SemanticModelConfig = field(default_factory=SemanticModelConfig)\n1700 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1701 | primary_entity: Optional[str] = None\n1702 | group: Optional[str] = None\n1703 | \n1704 | @property\n1705 | def entity_references(self) -> List[LinkableElementReference]:\n1706 | return [entity.reference for entity in self.entities]\n1707 | \n1708 | @property\n1709 | def dimension_references(self) -> List[LinkableElementReference]:\n1710 | return [dimension.reference for dimension in self.dimensions]\n1711 | \n1712 | @property\n1713 | def measure_references(self) -> List[MeasureReference]:\n1714 | return [measure.reference for measure in self.measures]\n1715 | \n1716 | @property\n1717 | def has_validity_dimensions(self) -> bool:\n1718 | return any([dim.validity_params is not None for dim in self.dimensions])\n1719 | \n1720 | @property\n1721 | def validity_start_dimension(self) -> Optional[Dimension]:\n1722 | validity_start_dims = [\n1723 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_start\n1724 | ]\n1725 | if not validity_start_dims:\n1726 | return None\n1727 | return validity_start_dims[0]\n1728 | \n1729 | @property\n1730 | def validity_end_dimension(self) -> Optional[Dimension]:\n1731 | validity_end_dims = [\n1732 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_end\n1733 | ]\n1734 | if not validity_end_dims:\n1735 | return None\n1736 | return validity_end_dims[0]\n1737 | \n1738 | @property\n1739 | def partitions(self) -> List[Dimension]: # noqa: D\n1740 | return [dim for dim in self.dimensions or [] if dim.is_partition]\n1741 | \n1742 | @property\n1743 | def partition(self) -> Optional[Dimension]:\n1744 | partitions = self.partitions\n1745 | if not partitions:\n1746 | return None\n1747 | return partitions[0]\n1748 | \n1749 | @property\n1750 | def reference(self) -> SemanticModelReference:\n1751 | return SemanticModelReference(semantic_model_name=self.name)\n1752 | \n1753 | @property\n1754 | def depends_on_nodes(self):\n1755 | return self.depends_on.nodes\n1756 | \n1757 | @property\n1758 | def depends_on_macros(self):\n1759 | return self.depends_on.macros\n1760 | \n1761 | def checked_agg_time_dimension_for_measure(\n1762 | self, measure_reference: MeasureReference\n1763 | ) -> TimeDimensionReference:\n1764 | measure: Optional[Measure] = None\n1765 | for measure in self.measures:\n1766 | if measure.reference == measure_reference:\n1767 | measure = measure\n1768 | \n1769 | assert (\n1770 | measure is not None\n1771 | ), f\"No measure with name ({measure_reference.element_name}) in semantic_model with name ({self.name})\"\n1772 | \n1773 | default_agg_time_dimension = (\n1774 | self.defaults.agg_time_dimension if self.defaults is not None else None\n1775 | )\n1776 | \n1777 | agg_time_dimension_name = measure.agg_time_dimension or default_agg_time_dimension\n1778 | assert agg_time_dimension_name is not None, (\n1779 | f\"Aggregation time dimension for measure {measure.name} on semantic model {self.name} is not set! \"\n1780 | \"To fix this either specify a default `agg_time_dimension` for the semantic model or define an \"\n1781 | \"`agg_time_dimension` on the measure directly.\"\n1782 | )\n1783 | return TimeDimensionReference(element_name=agg_time_dimension_name)\n1784 | \n1785 | @property\n1786 | def primary_entity_reference(self) -> Optional[EntityReference]:\n1787 | return (\n1788 | EntityReference(element_name=self.primary_entity)\n1789 | if self.primary_entity is not None\n1790 | else None\n1791 | )\n1792 | \n1793 | def same_model(self, old: \"SemanticModel\") -> bool:\n1794 | return self.model == old.same_model\n1795 | \n1796 | def same_node_relation(self, old: \"SemanticModel\") -> bool:\n1797 | return self.node_relation == old.node_relation\n1798 | \n1799 | def same_description(self, old: \"SemanticModel\") -> bool:\n1800 | return self.description == old.description\n1801 | \n1802 | def same_defaults(self, old: \"SemanticModel\") -> bool:\n1803 | return self.defaults == old.defaults\n1804 | \n1805 | def same_entities(self, old: \"SemanticModel\") -> bool:\n1806 | return self.entities == old.entities\n1807 | \n1808 | def same_dimensions(self, old: \"SemanticModel\") -> bool:\n1809 | return self.dimensions == old.dimensions\n1810 | \n1811 | def same_measures(self, old: \"SemanticModel\") -> bool:\n1812 | return self.measures == old.measures\n1813 | \n1814 | def same_config(self, old: \"SemanticModel\") -> bool:\n1815 | return self.config == old.config\n1816 | \n1817 | def same_primary_entity(self, old: \"SemanticModel\") -> bool:\n1818 | return self.primary_entity == old.primary_entity\n1819 | \n1820 | def same_group(self, old: \"SemanticModel\") -> bool:\n1821 | return self.group == old.group\n1822 | \n1823 | def same_contents(self, old: Optional[\"SemanticModel\"]) -> bool:\n1824 | # existing when it didn't before is a change!\n1825 | # metadata/tags changes are not \"changes\"\n1826 | if old is None:\n1827 | return True\n1828 | \n1829 | return (\n1830 | self.same_model(old)\n1831 | and self.same_node_relation(old)\n1832 | and self.same_description(old)\n1833 | and self.same_defaults(old)\n1834 | and self.same_entities(old)\n1835 | and self.same_dimensions(old)\n1836 | and self.same_measures(old)\n1837 | and self.same_config(old)\n1838 | and self.same_primary_entity(old)\n1839 | and self.same_group(old)\n1840 | and True\n1841 | )\n1842 | \n1843 | \n1844 | # ====================================\n1845 | # SavedQuery and related classes\n1846 | # ====================================\n1847 | \n1848 | \n1849 | @dataclass\n1850 | class SavedQueryMandatory(GraphNode):\n1851 | query_params: QueryParams\n1852 | exports: List[Export]\n1853 | \n1854 | \n1855 | @dataclass\n1856 | class SavedQuery(NodeInfoMixin, SavedQueryMandatory):\n1857 | description: Optional[str] = None\n1858 | label: Optional[str] = None\n1859 | metadata: Optional[SourceFileMetadata] = None\n1860 | config: SavedQueryConfig = field(default_factory=SavedQueryConfig)\n1861 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1862 | group: Optional[str] = None\n1863 | depends_on: DependsOn = field(default_factory=DependsOn)\n1864 | created_at: float = field(default_factory=lambda: time.time())\n1865 | refs: List[RefArgs] = field(default_factory=list)\n1866 | \n1867 | @property\n1868 | def metrics(self) -> List[str]:\n1869 | return self.query_params.metrics\n1870 | \n1871 | @property\n1872 | def depends_on_nodes(self):\n1873 | return self.depends_on.nodes\n1874 | \n1875 | def same_metrics(self, old: \"SavedQuery\") -> bool:\n1876 | return self.query_params.metrics == old.query_params.metrics\n1877 | \n1878 | def same_group_by(self, old: \"SavedQuery\") -> bool:\n1879 | return self.query_params.group_by == old.query_params.group_by\n1880 | \n1881 | def same_description(self, old: \"SavedQuery\") -> bool:\n1882 | return self.description == old.description\n1883 | \n1884 | def same_where(self, old: \"SavedQuery\") -> bool:\n1885 | return self.query_params.where == old.query_params.where\n1886 | \n1887 | def same_label(self, old: \"SavedQuery\") -> bool:\n1888 | return self.label == old.label\n1889 | \n1890 | def same_config(self, old: \"SavedQuery\") -> bool:\n1891 | return self.config == old.config\n1892 | \n1893 | def same_group(self, old: \"SavedQuery\") -> bool:\n1894 | return self.group == old.group\n1895 | \n1896 | def same_exports(self, old: \"SavedQuery\") -> bool:\n1897 | if len(self.exports) != len(old.exports):\n1898 | return False\n1899 | \n1900 | # exports should be in the same order, so we zip them for easy iteration\n1901 | for (old_export, new_export) in zip(old.exports, self.exports):\n1902 | if not new_export.same_contents(old_export):\n1903 | return False\n1904 | \n1905 | return True\n1906 | \n1907 | def same_contents(self, old: Optional[\"SavedQuery\"]) -> bool:\n1908 | # existing when it didn't before is a change!\n1909 | # metadata/tags changes are not \"changes\"\n1910 | if old is None:\n1911 | return True\n1912 | \n1913 | return (\n1914 | self.same_metrics(old)\n1915 | and self.same_group_by(old)\n1916 | and self.same_description(old)\n1917 | and self.same_where(old)\n1918 | and self.same_label(old)\n1919 | and self.same_config(old)\n1920 | and self.same_group(old)\n1921 | and True\n1922 | )\n1923 | \n1924 | \n1925 | # ====================================\n1926 | # Patches\n1927 | # ====================================\n1928 | \n1929 | \n1930 | @dataclass\n1931 | class ParsedPatch(HasYamlMetadata, Replaceable):\n1932 | name: str\n1933 | description: str\n1934 | meta: Dict[str, Any]\n1935 | docs: Docs\n1936 | config: Dict[str, Any]\n1937 | \n1938 | \n1939 | # The parsed node update is only the 'patch', not the test. The test became a\n1940 | # regular parsed node. Note that description and columns must be present, but\n1941 | # may be empty.\n1942 | @dataclass\n1943 | class ParsedNodePatch(ParsedPatch):\n1944 | columns: Dict[str, ColumnInfo]\n1945 | access: Optional[str]\n1946 | version: Optional[NodeVersion]\n1947 | latest_version: Optional[NodeVersion]\n1948 | constraints: List[Dict[str, Any]]\n1949 | deprecation_date: Optional[datetime]\n1950 | \n1951 | \n1952 | @dataclass\n1953 | class ParsedMacroPatch(ParsedPatch):\n1954 | arguments: List[MacroArgument] = field(default_factory=list)\n1955 | \n1956 | \n1957 | # ====================================\n1958 | # Node unions/categories\n1959 | # ====================================\n1960 | \n1961 | \n1962 | # ManifestNode without SeedNode, which doesn't have the\n1963 | # SQL related attributes\n1964 | ManifestSQLNode = Union[\n1965 | AnalysisNode,\n1966 | SingularTestNode,\n1967 | HookNode,\n1968 | ModelNode,\n1969 | RPCNode,\n1970 | SqlNode,\n1971 | GenericTestNode,\n1972 | SnapshotNode,\n1973 | UnitTestNode,\n1974 | ]\n1975 | \n1976 | # All SQL nodes plus SeedNode (csv files)\n1977 | ManifestNode = Union[\n1978 | ManifestSQLNode,\n1979 | SeedNode,\n1980 | ]\n1981 | \n1982 | ResultNode = Union[\n1983 | ManifestNode,\n1984 | SourceDefinition,\n1985 | ]\n1986 | \n1987 | # All nodes that can be in the DAG\n1988 | GraphMemberNode = Union[\n1989 | ResultNode,\n1990 | Exposure,\n1991 | Metric,\n1992 | SavedQuery,\n1993 | SemanticModel,\n1994 | UnitTestDefinition,\n1995 | ]\n1996 | \n1997 | # All \"nodes\" (or node-like objects) in this file\n1998 | Resource = Union[\n1999 | GraphMemberNode,\n2000 | Documentation,\n2001 | Macro,\n2002 | Group,\n2003 | ]\n2004 | \n2005 | TestNode = Union[SingularTestNode, GenericTestNode]\n```\n\n### File: core/dbt/contracts/graph/unparsed.py\n\n```python\n 1 | import datetime\n 2 | import re\n 3 | \n 4 | from dbt import deprecations\n 5 | from dbt_common.contracts.config.properties import (\n 6 | AdditionalPropertiesAllowed,\n 7 | AdditionalPropertiesMixin,\n 8 | )\n 9 | from dbt_common.exceptions import DbtInternalError, CompilationError\n 10 | from dbt_common.dataclass_schema import (\n 11 | dbtClassMixin,\n 12 | StrEnum,\n 13 | ExtensibleDbtClassMixin,\n 14 | ValidationError,\n 15 | )\n 16 | from dbt.node_types import NodeType\n 17 | from dbt.contracts.graph.semantic_models import (\n 18 | Defaults,\n 19 | DimensionValidityParams,\n 20 | MeasureAggregationParameters,\n 21 | )\n 22 | from dbt.contracts.util import (\n 23 | Mergeable,\n 24 | Replaceable,\n 25 | )\n 26 | \n 27 | # trigger the PathEncoder\n 28 | import dbt_common.helper_types # noqa:F401\n 29 | from dbt.exceptions import ParsingError\n 30 | \n 31 | from dbt_semantic_interfaces.type_enums import ConversionCalculationType\n 32 | \n 33 | from dataclasses import dataclass, field\n 34 | from datetime import timedelta\n 35 | from pathlib import Path\n 36 | from typing import Optional, List, Union, Dict, Any, Sequence, Literal\n 37 | \n 38 | \n 39 | @dataclass\n 40 | class UnparsedBaseNode(dbtClassMixin, Replaceable):\n 41 | package_name: str\n 42 | path: str\n 43 | original_file_path: str\n 44 | \n 45 | @property\n 46 | def file_id(self):\n 47 | return f\"{self.package_name}://{self.original_file_path}\"\n 48 | \n 49 | \n 50 | @dataclass\n 51 | class HasCode(dbtClassMixin):\n 52 | raw_code: str\n 53 | language: str\n 54 | \n 55 | @property\n 56 | def empty(self):\n 57 | return not self.raw_code.strip()\n 58 | \n 59 | \n 60 | @dataclass\n 61 | class UnparsedMacro(UnparsedBaseNode, HasCode):\n 62 | resource_type: Literal[NodeType.Macro]\n 63 | \n 64 | \n 65 | @dataclass\n 66 | class UnparsedGenericTest(UnparsedBaseNode, HasCode):\n 67 | resource_type: Literal[NodeType.Macro]\n 68 | \n 69 | \n 70 | @dataclass\n 71 | class UnparsedNode(UnparsedBaseNode, HasCode):\n 72 | name: str\n 73 | resource_type: NodeType\n 74 | \n 75 | @property\n 76 | def search_name(self):\n 77 | return self.name\n 78 | \n 79 | \n 80 | @dataclass\n 81 | class UnparsedRunHook(UnparsedNode):\n 82 | resource_type: Literal[NodeType.Operation]\n 83 | index: Optional[int] = None\n 84 | \n 85 | \n 86 | @dataclass\n 87 | class Docs(dbtClassMixin, Replaceable):\n 88 | show: bool = True\n 89 | node_color: Optional[str] = None\n 90 | \n 91 | \n 92 | @dataclass\n 93 | class HasColumnProps(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 94 | name: str\n 95 | description: str = \"\"\n 96 | meta: Dict[str, Any] = field(default_factory=dict)\n 97 | data_type: Optional[str] = None\n 98 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n 99 | docs: Docs = field(default_factory=Docs)\n100 | _extra: Dict[str, Any] = field(default_factory=dict)\n101 | \n102 | \n103 | TestDef = Union[Dict[str, Any], str]\n104 | \n105 | \n106 | @dataclass\n107 | class HasColumnAndTestProps(HasColumnProps):\n108 | data_tests: List[TestDef] = field(default_factory=list)\n109 | tests: List[TestDef] = field(\n110 | default_factory=list\n111 | ) # back compat for previous name of 'data_tests'\n112 | \n113 | \n114 | @dataclass\n115 | class UnparsedColumn(HasColumnAndTestProps):\n116 | quote: Optional[bool] = None\n117 | tags: List[str] = field(default_factory=list)\n118 | \n119 | \n120 | @dataclass\n121 | class HasColumnDocs(dbtClassMixin, Replaceable):\n122 | columns: Sequence[HasColumnProps] = field(default_factory=list)\n123 | \n124 | \n125 | @dataclass\n126 | class HasColumnTests(dbtClassMixin, Replaceable):\n127 | columns: Sequence[UnparsedColumn] = field(default_factory=list)\n128 | \n129 | \n130 | @dataclass\n131 | class HasYamlMetadata(dbtClassMixin):\n132 | original_file_path: str\n133 | yaml_key: str\n134 | package_name: str\n135 | \n136 | @property\n137 | def file_id(self):\n138 | return f\"{self.package_name}://{self.original_file_path}\"\n139 | \n140 | \n141 | @dataclass\n142 | class HasConfig:\n143 | config: Dict[str, Any] = field(default_factory=dict)\n144 | \n145 | \n146 | NodeVersion = Union[str, float]\n147 | \n148 | \n149 | @dataclass\n150 | class UnparsedVersion(dbtClassMixin):\n151 | v: NodeVersion\n152 | defined_in: Optional[str] = None\n153 | description: str = \"\"\n154 | access: Optional[str] = None\n155 | config: Dict[str, Any] = field(default_factory=dict)\n156 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n157 | docs: Docs = field(default_factory=Docs)\n158 | data_tests: Optional[List[TestDef]] = None\n159 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n160 | columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n161 | default_factory=list\n162 | )\n163 | deprecation_date: Optional[datetime.datetime] = None\n164 | \n165 | def __lt__(self, other):\n166 | try:\n167 | return float(self.v) < float(other.v)\n168 | except ValueError:\n169 | return str(self.v) < str(other.v)\n170 | \n171 | @property\n172 | def include_exclude(self) -> dbt_common.helper_types.IncludeExclude:\n173 | return self._include_exclude\n174 | \n175 | @property\n176 | def unparsed_columns(self) -> List:\n177 | return self._unparsed_columns\n178 | \n179 | @property\n180 | def formatted_v(self) -> str:\n181 | return f\"v{self.v}\"\n182 | \n183 | def __post_init__(self):\n184 | has_include_exclude = False\n185 | self._include_exclude = dbt_common.helper_types.IncludeExclude(include=\"*\")\n186 | self._unparsed_columns = []\n187 | for column in self.columns:\n188 | if isinstance(column, dbt_common.helper_types.IncludeExclude):\n189 | if not has_include_exclude:\n190 | self._include_exclude = column\n191 | has_include_exclude = True\n192 | else:\n193 | raise ParsingError(\"version can have at most one include/exclude element\")\n194 | else:\n195 | self._unparsed_columns.append(column)\n196 | \n197 | self.deprecation_date = normalize_date(self.deprecation_date)\n198 | \n199 | \n200 | @dataclass\n201 | class UnparsedAnalysisUpdate(HasConfig, HasColumnDocs, HasColumnProps, HasYamlMetadata):\n202 | access: Optional[str] = None\n203 | \n204 | \n205 | @dataclass\n206 | class UnparsedNodeUpdate(HasConfig, HasColumnTests, HasColumnAndTestProps, HasYamlMetadata):\n207 | quote_columns: Optional[bool] = None\n208 | access: Optional[str] = None\n209 | \n210 | \n211 | @dataclass\n212 | class UnparsedModelUpdate(UnparsedNodeUpdate):\n213 | quote_columns: Optional[bool] = None\n214 | access: Optional[str] = None\n215 | latest_version: Optional[NodeVersion] = None\n216 | versions: Sequence[UnparsedVersion] = field(default_factory=list)\n217 | deprecation_date: Optional[datetime.datetime] = None\n218 | \n219 | def __post_init__(self) -> None:\n220 | if self.latest_version:\n221 | version_values = [version.v for version in self.versions]\n222 | if self.latest_version not in version_values:\n223 | raise ParsingError(\n224 | f\"latest_version: {self.latest_version} is not one of model '{self.name}' versions: {version_values} \"\n225 | )\n226 | \n227 | seen_versions = set()\n228 | for version in self.versions:\n229 | if str(version.v) in seen_versions:\n230 | raise ParsingError(\n231 | f\"Found duplicate version: '{version.v}' in versions list of model '{self.name}'\"\n232 | )\n233 | seen_versions.add(str(version.v))\n234 | \n235 | self._version_map = {version.v: version for version in self.versions}\n236 | \n237 | self.deprecation_date = normalize_date(self.deprecation_date)\n238 | \n239 | def get_columns_for_version(self, version: NodeVersion) -> List[UnparsedColumn]:\n240 | if version not in self._version_map:\n241 | raise DbtInternalError(\n242 | f\"get_columns_for_version called for version '{version}' not in version map\"\n243 | )\n244 | \n245 | version_columns = []\n246 | unparsed_version = self._version_map[version]\n247 | for base_column in self.columns:\n248 | if unparsed_version.include_exclude.includes(base_column.name):\n249 | version_columns.append(base_column)\n250 | \n251 | for column in unparsed_version.unparsed_columns:\n252 | version_columns.append(column)\n253 | \n254 | return version_columns\n255 | \n256 | def get_tests_for_version(self, version: NodeVersion) -> List[TestDef]:\n257 | if version not in self._version_map:\n258 | raise DbtInternalError(\n259 | f\"get_tests_for_version called for version '{version}' not in version map\"\n260 | )\n261 | unparsed_version = self._version_map[version]\n262 | return (\n263 | unparsed_version.data_tests\n264 | if unparsed_version.data_tests is not None\n265 | else self.data_tests\n266 | )\n267 | \n268 | \n269 | @dataclass\n270 | class MacroArgument(dbtClassMixin):\n271 | name: str\n272 | type: Optional[str] = None\n273 | description: str = \"\"\n274 | \n275 | \n276 | @dataclass\n277 | class UnparsedMacroUpdate(HasConfig, HasColumnProps, HasYamlMetadata):\n278 | arguments: List[MacroArgument] = field(default_factory=list)\n279 | \n280 | \n281 | class TimePeriod(StrEnum):\n282 | minute = \"minute\"\n283 | hour = \"hour\"\n284 | day = \"day\"\n285 | \n286 | def plural(self) -> str:\n287 | return str(self) + \"s\"\n288 | \n289 | \n290 | @dataclass\n291 | class Time(dbtClassMixin, Mergeable):\n292 | count: Optional[int] = None\n293 | period: Optional[TimePeriod] = None\n294 | \n295 | def exceeded(self, actual_age: float) -> bool:\n296 | if self.period is None or self.count is None:\n297 | return False\n298 | kwargs: Dict[str, int] = {self.period.plural(): self.count}\n299 | difference = timedelta(**kwargs).total_seconds()\n300 | return actual_age > difference\n301 | \n302 | def __bool__(self):\n303 | return self.count is not None and self.period is not None\n304 | \n305 | \n306 | @dataclass\n307 | class FreshnessThreshold(dbtClassMixin, Mergeable):\n308 | warn_after: Optional[Time] = field(default_factory=Time)\n309 | error_after: Optional[Time] = field(default_factory=Time)\n310 | filter: Optional[str] = None\n311 | \n312 | def status(self, age: float) -> \"dbt.artifacts.results.FreshnessStatus\": # type: ignore # noqa F821\n313 | from dbt.artifacts.results import FreshnessStatus\n314 | \n315 | if self.error_after and self.error_after.exceeded(age):\n316 | return FreshnessStatus.Error\n317 | elif self.warn_after and self.warn_after.exceeded(age):\n318 | return FreshnessStatus.Warn\n319 | else:\n320 | return FreshnessStatus.Pass\n321 | \n322 | def __bool__(self):\n323 | return bool(self.warn_after) or bool(self.error_after)\n324 | \n325 | \n326 | @dataclass\n327 | class ExternalPartition(AdditionalPropertiesAllowed, Replaceable):\n328 | name: str = \"\"\n329 | description: str = \"\"\n330 | data_type: str = \"\"\n331 | meta: Dict[str, Any] = field(default_factory=dict)\n332 | \n333 | def __post_init__(self):\n334 | if self.name == \"\" or self.data_type == \"\":\n335 | raise CompilationError(\"External partition columns must have names and data types\")\n336 | \n337 | \n338 | @dataclass\n339 | class ExternalTable(AdditionalPropertiesAllowed, Mergeable):\n340 | location: Optional[str] = None\n341 | file_format: Optional[str] = None\n342 | row_format: Optional[str] = None\n343 | tbl_properties: Optional[str] = None\n344 | partitions: Optional[Union[List[str], List[ExternalPartition]]] = None\n345 | \n346 | def __bool__(self):\n347 | return self.location is not None\n348 | \n349 | \n350 | @dataclass\n351 | class Quoting(dbtClassMixin, Mergeable):\n352 | database: Optional[bool] = None\n353 | schema: Optional[bool] = None\n354 | identifier: Optional[bool] = None\n355 | column: Optional[bool] = None\n356 | \n357 | \n358 | @dataclass\n359 | class UnparsedSourceTableDefinition(HasColumnTests, HasColumnAndTestProps):\n360 | config: Dict[str, Any] = field(default_factory=dict)\n361 | loaded_at_field: Optional[str] = None\n362 | identifier: Optional[str] = None\n363 | quoting: Quoting = field(default_factory=Quoting)\n364 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n365 | external: Optional[ExternalTable] = None\n366 | tags: List[str] = field(default_factory=list)\n367 | \n368 | def __post_serialize__(self, dct):\n369 | dct = super().__post_serialize__(dct)\n370 | if \"freshness\" not in dct and self.freshness is None:\n371 | dct[\"freshness\"] = None\n372 | return dct\n373 | \n374 | \n375 | @dataclass\n376 | class UnparsedSourceDefinition(dbtClassMixin, Replaceable):\n377 | name: str\n378 | description: str = \"\"\n379 | meta: Dict[str, Any] = field(default_factory=dict)\n380 | database: Optional[str] = None\n381 | schema: Optional[str] = None\n382 | loader: str = \"\"\n383 | quoting: Quoting = field(default_factory=Quoting)\n384 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n385 | loaded_at_field: Optional[str] = None\n386 | tables: List[UnparsedSourceTableDefinition] = field(default_factory=list)\n387 | tags: List[str] = field(default_factory=list)\n388 | config: Dict[str, Any] = field(default_factory=dict)\n389 | \n390 | @property\n391 | def yaml_key(self) -> \"str\":\n392 | return \"sources\"\n393 | \n394 | def __post_serialize__(self, dct):\n395 | dct = super().__post_serialize__(dct)\n396 | if \"freshness\" not in dct and self.freshness is None:\n397 | dct[\"freshness\"] = None\n398 | return dct\n399 | \n400 | \n401 | @dataclass\n402 | class SourceTablePatch(dbtClassMixin):\n403 | name: str\n404 | description: Optional[str] = None\n405 | meta: Optional[Dict[str, Any]] = None\n406 | data_type: Optional[str] = None\n407 | docs: Optional[Docs] = None\n408 | loaded_at_field: Optional[str] = None\n409 | identifier: Optional[str] = None\n410 | quoting: Quoting = field(default_factory=Quoting)\n411 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n412 | external: Optional[ExternalTable] = None\n413 | tags: Optional[List[str]] = None\n414 | data_tests: Optional[List[TestDef]] = None\n415 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n416 | columns: Optional[Sequence[UnparsedColumn]] = None\n417 | \n418 | def to_patch_dict(self) -> Dict[str, Any]:\n419 | dct = self.to_dict(omit_none=True)\n420 | remove_keys = \"name\"\n421 | for key in remove_keys:\n422 | if key in dct:\n423 | del dct[key]\n424 | \n425 | if self.freshness is None:\n426 | dct[\"freshness\"] = None\n427 | \n428 | return dct\n429 | \n430 | \n431 | @dataclass\n432 | class SourcePatch(dbtClassMixin, Replaceable):\n433 | name: str = field(\n434 | metadata=dict(description=\"The name of the source to override\"),\n435 | )\n436 | overrides: str = field(\n437 | metadata=dict(description=\"The package of the source to override\"),\n438 | )\n439 | path: Path = field(\n440 | metadata=dict(description=\"The path to the patch-defining yml file\"),\n441 | )\n442 | config: Dict[str, Any] = field(default_factory=dict)\n443 | description: Optional[str] = None\n444 | meta: Optional[Dict[str, Any]] = None\n445 | database: Optional[str] = None\n446 | schema: Optional[str] = None\n447 | loader: Optional[str] = None\n448 | quoting: Optional[Quoting] = None\n449 | freshness: Optional[Optional[FreshnessThreshold]] = field(default_factory=FreshnessThreshold)\n450 | loaded_at_field: Optional[str] = None\n451 | tables: Optional[List[SourceTablePatch]] = None\n452 | tags: Optional[List[str]] = None\n453 | \n454 | def to_patch_dict(self) -> Dict[str, Any]:\n455 | dct = self.to_dict(omit_none=True)\n456 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n457 | for key in remove_keys:\n458 | if key in dct:\n459 | del dct[key]\n460 | \n461 | if self.freshness is None:\n462 | dct[\"freshness\"] = None\n463 | \n464 | return dct\n465 | \n466 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n467 | if self.tables is not None:\n468 | for table in self.tables:\n469 | if table.name == name:\n470 | return table\n471 | return None\n472 | \n473 | \n474 | @dataclass\n475 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n476 | package_name: str\n477 | path: str\n478 | original_file_path: str\n479 | \n480 | @property\n481 | def file_id(self):\n482 | return f\"{self.package_name}://{self.original_file_path}\"\n483 | \n484 | @property\n485 | def resource_type(self):\n486 | return NodeType.Documentation\n487 | \n488 | \n489 | @dataclass\n490 | class UnparsedDocumentationFile(UnparsedDocumentation):\n491 | file_contents: str\n492 | \n493 | \n494 | # can't use total_ordering decorator here, as str provides an ordering already\n495 | # and it's not the one we want.\n496 | class Maturity(StrEnum):\n497 | low = \"low\"\n498 | medium = \"medium\"\n499 | high = \"high\"\n500 | \n501 | def __lt__(self, other):\n502 | if not isinstance(other, Maturity):\n503 | return NotImplemented\n504 | order = (Maturity.low, Maturity.medium, Maturity.high)\n505 | return order.index(self) < order.index(other)\n506 | \n507 | def __gt__(self, other):\n508 | if not isinstance(other, Maturity):\n509 | return NotImplemented\n510 | return self != other and not (self < other)\n511 | \n512 | def __ge__(self, other):\n513 | if not isinstance(other, Maturity):\n514 | return NotImplemented\n515 | return self == other or not (self < other)\n516 | \n517 | def __le__(self, other):\n518 | if not isinstance(other, Maturity):\n519 | return NotImplemented\n520 | return self == other or self < other\n521 | \n522 | \n523 | class ExposureType(StrEnum):\n524 | Dashboard = \"dashboard\"\n525 | Notebook = \"notebook\"\n526 | Analysis = \"analysis\"\n527 | ML = \"ml\"\n528 | Application = \"application\"\n529 | \n530 | \n531 | class MaturityType(StrEnum):\n532 | Low = \"low\"\n533 | Medium = \"medium\"\n534 | High = \"high\"\n535 | \n536 | \n537 | @dataclass\n538 | class Owner(AdditionalPropertiesAllowed, Replaceable):\n539 | email: Optional[str] = None\n540 | name: Optional[str] = None\n541 | \n542 | \n543 | @dataclass\n544 | class UnparsedExposure(dbtClassMixin, Replaceable):\n545 | name: str\n546 | type: ExposureType\n547 | owner: Owner\n548 | description: str = \"\"\n549 | label: Optional[str] = None\n550 | maturity: Optional[MaturityType] = None\n551 | meta: Dict[str, Any] = field(default_factory=dict)\n552 | tags: List[str] = field(default_factory=list)\n553 | url: Optional[str] = None\n554 | depends_on: List[str] = field(default_factory=list)\n555 | config: Dict[str, Any] = field(default_factory=dict)\n556 | \n557 | @classmethod\n558 | def validate(cls, data):\n559 | super(UnparsedExposure, cls).validate(data)\n560 | if \"name\" in data:\n561 | # name can only contain alphanumeric chars and underscores\n562 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n563 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n564 | \n565 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n566 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n567 | \n568 | \n569 | @dataclass\n570 | class MetricFilter(dbtClassMixin, Replaceable):\n571 | field: str\n572 | operator: str\n573 | # TODO : Can we make this Any?\n574 | value: str\n575 | \n576 | \n577 | class MetricTimePeriod(StrEnum):\n578 | day = \"day\"\n579 | week = \"week\"\n580 | month = \"month\"\n581 | year = \"year\"\n582 | \n583 | def plural(self) -> str:\n584 | return str(self) + \"s\"\n585 | \n586 | \n587 | @dataclass\n588 | class MetricTime(dbtClassMixin, Mergeable):\n589 | count: Optional[int] = None\n590 | period: Optional[MetricTimePeriod] = None\n591 | \n592 | def __bool__(self):\n593 | return self.count is not None and self.period is not None\n594 | \n595 | \n596 | @dataclass\n597 | class UnparsedMetricInputMeasure(dbtClassMixin):\n598 | name: str\n599 | filter: Optional[Union[str, List[str]]] = None\n600 | alias: Optional[str] = None\n601 | join_to_timespine: bool = False\n602 | fill_nulls_with: Optional[int] = None\n603 | \n604 | \n605 | @dataclass\n606 | class UnparsedMetricInput(dbtClassMixin):\n607 | name: str\n608 | filter: Optional[Union[str, List[str]]] = None\n609 | alias: Optional[str] = None\n610 | offset_window: Optional[str] = None\n611 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n612 | \n613 | \n614 | @dataclass\n615 | class ConstantPropertyInput(dbtClassMixin):\n616 | base_property: str\n617 | conversion_property: str\n618 | \n619 | \n620 | @dataclass\n621 | class UnparsedConversionTypeParams(dbtClassMixin):\n622 | base_measure: Union[UnparsedMetricInputMeasure, str]\n623 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n624 | entity: str\n625 | calculation: str = (\n626 | ConversionCalculationType.CONVERSION_RATE.value\n627 | ) # ConversionCalculationType Enum\n628 | window: Optional[str] = None\n629 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n630 | \n631 | \n632 | @dataclass\n633 | class UnparsedMetricTypeParams(dbtClassMixin):\n634 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n635 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n636 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n637 | expr: Optional[Union[str, bool]] = None\n638 | window: Optional[str] = None\n639 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n640 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n641 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n642 | \n643 | \n644 | @dataclass\n645 | class UnparsedMetric(dbtClassMixin):\n646 | name: str\n647 | label: str\n648 | type: str\n649 | type_params: UnparsedMetricTypeParams\n650 | description: str = \"\"\n651 | filter: Optional[Union[str, List[str]]] = None\n652 | # metadata: Optional[Unparsedetadata] = None # TODO\n653 | meta: Dict[str, Any] = field(default_factory=dict)\n654 | tags: List[str] = field(default_factory=list)\n655 | config: Dict[str, Any] = field(default_factory=dict)\n656 | \n657 | @classmethod\n658 | def validate(cls, data):\n659 | super(UnparsedMetric, cls).validate(data)\n660 | if \"name\" in data:\n661 | errors = []\n662 | if \" \" in data[\"name\"]:\n663 | errors.append(\"cannot contain spaces\")\n664 | # This handles failing queries due to too long metric names.\n665 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n666 | if len(data[\"name\"]) > 250:\n667 | errors.append(\"cannot contain more than 250 characters\")\n668 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n669 | errors.append(\"must begin with a letter\")\n670 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n671 | errors.append(\"must contain only letters, numbers and underscores\")\n672 | \n673 | if errors:\n674 | raise ParsingError(\n675 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n676 | )\n677 | \n678 | \n679 | @dataclass\n680 | class UnparsedGroup(dbtClassMixin, Replaceable):\n681 | name: str\n682 | owner: Owner\n683 | \n684 | @classmethod\n685 | def validate(cls, data):\n686 | super(UnparsedGroup, cls).validate(data)\n687 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n688 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n689 | \n690 | \n691 | #\n692 | # semantic interfaces unparsed objects\n693 | #\n694 | \n695 | \n696 | @dataclass\n697 | class UnparsedEntity(dbtClassMixin):\n698 | name: str\n699 | type: str # EntityType enum\n700 | description: Optional[str] = None\n701 | label: Optional[str] = None\n702 | role: Optional[str] = None\n703 | expr: Optional[str] = None\n704 | \n705 | \n706 | @dataclass\n707 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n708 | name: str\n709 | window_choice: str # AggregationType enum\n710 | window_groupings: List[str] = field(default_factory=list)\n711 | \n712 | \n713 | @dataclass\n714 | class UnparsedMeasure(dbtClassMixin):\n715 | name: str\n716 | agg: str # actually an enum\n717 | description: Optional[str] = None\n718 | label: Optional[str] = None\n719 | expr: Optional[Union[str, bool, int]] = None\n720 | agg_params: Optional[MeasureAggregationParameters] = None\n721 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n722 | agg_time_dimension: Optional[str] = None\n723 | create_metric: bool = False\n724 | \n725 | \n726 | @dataclass\n727 | class UnparsedDimensionTypeParams(dbtClassMixin):\n728 | time_granularity: str # TimeGranularity enum\n729 | validity_params: Optional[DimensionValidityParams] = None\n730 | \n731 | \n732 | @dataclass\n733 | class UnparsedDimension(dbtClassMixin):\n734 | name: str\n735 | type: str # actually an enum\n736 | description: Optional[str] = None\n737 | label: Optional[str] = None\n738 | is_partition: bool = False\n739 | type_params: Optional[UnparsedDimensionTypeParams] = None\n740 | expr: Optional[str] = None\n741 | \n742 | \n743 | @dataclass\n744 | class UnparsedSemanticModel(dbtClassMixin):\n745 | name: str\n746 | model: str # looks like \"ref(...)\"\n747 | config: Dict[str, Any] = field(default_factory=dict)\n748 | description: Optional[str] = None\n749 | label: Optional[str] = None\n750 | defaults: Optional[Defaults] = None\n751 | entities: List[UnparsedEntity] = field(default_factory=list)\n752 | measures: List[UnparsedMeasure] = field(default_factory=list)\n753 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n754 | primary_entity: Optional[str] = None\n755 | \n756 | \n757 | @dataclass\n758 | class UnparsedQueryParams(dbtClassMixin):\n759 | metrics: List[str] = field(default_factory=list)\n760 | group_by: List[str] = field(default_factory=list)\n761 | where: Optional[Union[str, List[str]]] = None\n762 | \n763 | \n764 | @dataclass\n765 | class UnparsedExport(dbtClassMixin):\n766 | \"\"\"Configuration for writing query results to a table.\"\"\"\n767 | \n768 | name: str\n769 | config: Dict[str, Any] = field(default_factory=dict)\n770 | \n771 | \n772 | @dataclass\n773 | class UnparsedSavedQuery(dbtClassMixin):\n774 | name: str\n775 | query_params: UnparsedQueryParams\n776 | description: Optional[str] = None\n777 | label: Optional[str] = None\n778 | exports: List[UnparsedExport] = field(default_factory=list)\n779 | config: Dict[str, Any] = field(default_factory=dict)\n780 | \n781 | \n782 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n783 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n784 | if d is None:\n785 | return None\n786 | \n787 | # convert date to datetime\n788 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n789 | \n790 | if not dt.tzinfo:\n791 | # date is naive, re-interpret as system time zone\n792 | dt = dt.astimezone()\n793 | \n794 | return dt\n795 | \n796 | \n797 | class UnitTestFormat(StrEnum):\n798 | CSV = \"csv\"\n799 | Dict = \"dict\"\n800 | \n801 | \n802 | @dataclass\n803 | class UnitTestInputFixture(dbtClassMixin):\n804 | input: str\n805 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n806 | format: UnitTestFormat = UnitTestFormat.Dict\n807 | fixture: Optional[str] = None\n808 | \n809 | \n810 | @dataclass\n811 | class UnitTestOutputFixture(dbtClassMixin):\n812 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n813 | format: UnitTestFormat = UnitTestFormat.Dict\n814 | fixture: Optional[str] = None\n815 | \n816 | \n817 | @dataclass\n818 | class UnitTestOverrides(dbtClassMixin):\n819 | macros: Dict[str, Any] = field(default_factory=dict)\n820 | vars: Dict[str, Any] = field(default_factory=dict)\n821 | env_vars: Dict[str, Any] = field(default_factory=dict)\n822 | \n823 | \n824 | @dataclass\n825 | class UnparsedUnitTest(dbtClassMixin):\n826 | name: str\n827 | model: str # name of the model being unit tested\n828 | given: Sequence[UnitTestInputFixture]\n829 | expect: UnitTestOutputFixture\n830 | description: str = \"\"\n831 | overrides: Optional[UnitTestOverrides] = None\n832 | config: Dict[str, Any] = field(default_factory=dict)\n```\n\n### File: core/dbt/parser/schemas.py\n\n```python\n 1 | import datetime\n 2 | import time\n 3 | \n 4 | from abc import ABCMeta, abstractmethod\n 5 | from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Type, TypeVar\n 6 | from dataclasses import dataclass, field\n 7 | \n 8 | from dbt import deprecations\n 9 | from dbt_common.contracts.constraints import ConstraintType, ModelLevelConstraint\n 10 | from dbt_common.dataclass_schema import ValidationError, dbtClassMixin\n 11 | \n 12 | from dbt.clients.yaml_helper import load_yaml_text\n 13 | from dbt.parser.schema_renderer import SchemaYamlRenderer\n 14 | from dbt.parser.schema_generic_tests import SchemaGenericTestParser\n 15 | from dbt.context.context_config import ContextConfig\n 16 | from dbt.context.configured import generate_schema_yml_context, SchemaYamlVars\n 17 | from dbt.contracts.files import SchemaSourceFile\n 18 | from dbt.contracts.graph.nodes import (\n 19 | ParsedNodePatch,\n 20 | ParsedMacroPatch,\n 21 | UnpatchedSourceDefinition,\n 22 | ModelNode,\n 23 | )\n 24 | from dbt.contracts.graph.unparsed import (\n 25 | HasColumnDocs,\n 26 | HasColumnTests,\n 27 | SourcePatch,\n 28 | UnparsedAnalysisUpdate,\n 29 | UnparsedMacroUpdate,\n 30 | UnparsedNodeUpdate,\n 31 | UnparsedModelUpdate,\n 32 | UnparsedSourceDefinition,\n 33 | )\n 34 | from dbt.exceptions import (\n 35 | DuplicateMacroPatchNameError,\n 36 | DuplicatePatchPathError,\n 37 | DuplicateSourcePatchNameError,\n 38 | JSONValidationError,\n 39 | DbtInternalError,\n 40 | ParsingError,\n 41 | YamlLoadError,\n 42 | YamlParseDictError,\n 43 | YamlParseListError,\n 44 | InvalidAccessTypeError,\n 45 | )\n 46 | from dbt_common.exceptions import DbtValidationError\n 47 | from dbt_common.events.functions import warn_or_error\n 48 | from dbt.events.types import (\n 49 | MacroNotFoundForPatch,\n 50 | NoNodeForYamlKey,\n 51 | ValidationWarning,\n 52 | UnsupportedConstraintMaterialization,\n 53 | WrongResourceSchemaFile,\n 54 | )\n 55 | from dbt.node_types import NodeType, AccessType\n 56 | from dbt.parser.base import SimpleParser\n 57 | from dbt.parser.search import FileBlock\n 58 | from dbt.parser.common import (\n 59 | YamlBlock,\n 60 | TargetBlock,\n 61 | TestBlock,\n 62 | VersionedTestBlock,\n 63 | ParserRef,\n 64 | trimmed,\n 65 | )\n 66 | from dbt.utils import coerce_dict_str\n 67 | from dbt_common.utils import deep_merge\n 68 | \n 69 | \n 70 | schema_file_keys = (\n 71 | \"models\",\n 72 | \"seeds\",\n 73 | \"snapshots\",\n 74 | \"sources\",\n 75 | \"macros\",\n 76 | \"analyses\",\n 77 | \"exposures\",\n 78 | \"metrics\",\n 79 | \"semantic_models\",\n 80 | \"saved_queries\",\n 81 | )\n 82 | \n 83 | \n 84 | # ===============================================================================\n 85 | # Schema Parser classes\n 86 | #\n 87 | # The SchemaParser is a subclass of the SimpleParser from base.py, as is\n 88 | # the SchemaGenericTestParser. The schema sub-parsers are all subclasses of\n 89 | # the YamlReader parsing class. Most of the action in creating SourceDefinition\n 90 | # nodes actually happens in the SourcePatcher class, in sources.py, which is\n 91 | # called as a late-stage parsing step in manifest.py.\n 92 | #\n 93 | # The \"patch\" parsers read yaml config and properties and apply them to\n 94 | # nodes that were already created from sql files.\n 95 | #\n 96 | # The SchemaParser and SourcePatcher both use the SchemaGenericTestParser\n 97 | # (in schema_generic_tests.py) to create generic test nodes.\n 98 | #\n 99 | # YamlReader\n100 | # MetricParser (metrics) [schema_yaml_readers.py]\n101 | # ExposureParser (exposures) [schema_yaml_readers.py]\n102 | # GroupParser (groups) [schema_yaml_readers.py]\n103 | # SourceParser (sources)\n104 | # PatchParser\n105 | # MacroPatchParser (macros)\n106 | # NodePatchParser\n107 | # ModelPatchParser (models)\n108 | # AnalysisPatchParser (analyses)\n109 | # TestablePatchParser (seeds, snapshots)\n110 | #\n111 | # ===============================================================================\n112 | \n113 | \n114 | def yaml_from_file(source_file: SchemaSourceFile) -> Dict[str, Any]:\n115 | \"\"\"If loading the yaml fails, raise an exception.\"\"\"\n116 | try:\n117 | # source_file.contents can sometimes be None\n118 | return load_yaml_text(source_file.contents or \"\", source_file.path)\n119 | except DbtValidationError as e:\n120 | raise YamlLoadError(\n121 | project_name=source_file.project_name, path=source_file.path.relative_path, exc=e\n122 | )\n123 | \n124 | \n125 | # This is the main schema file parser, but almost everything happens in the\n126 | # the schema sub-parsers.\n127 | class SchemaParser(SimpleParser[YamlBlock, ModelNode]):\n128 | def __init__(\n129 | self,\n130 | project,\n131 | manifest,\n132 | root_project,\n133 | ) -> None:\n134 | super().__init__(project, manifest, root_project)\n135 | \n136 | self.generic_test_parser = SchemaGenericTestParser(project, manifest, root_project)\n137 | \n138 | self.schema_yaml_vars = SchemaYamlVars()\n139 | self.render_ctx = generate_schema_yml_context(\n140 | self.root_project, self.project.project_name, self.schema_yaml_vars\n141 | )\n142 | \n143 | # This is unnecessary, but mypy was requiring it. Clean up parser code so\n144 | # we don't have to do this.\n145 | def parse_from_dict(self, dct):\n146 | pass\n147 | \n148 | @classmethod\n149 | def get_compiled_path(cls, block: FileBlock) -> str:\n150 | # should this raise an error?\n151 | return block.path.relative_path\n152 | \n153 | @property\n154 | def resource_type(self) -> NodeType:\n155 | return NodeType.Test\n156 | \n157 | def parse_file(self, block: FileBlock, dct: Optional[Dict] = None) -> None:\n158 | assert isinstance(block.file, SchemaSourceFile)\n159 | \n160 | # If partially parsing, dct should be from pp_dict, otherwise\n161 | # dict_from_yaml\n162 | if dct:\n163 | # contains the FileBlock and the data (dictionary)\n164 | yaml_block = YamlBlock.from_file_block(block, dct)\n165 | \n166 | parser: YamlReader\n167 | \n168 | # There are 9 different yaml lists which are parsed by different parsers:\n169 | # Model, Seed, Snapshot, Source, Macro, Analysis, Exposure, Metric, Group\n170 | \n171 | # ModelPatchParser.parse()\n172 | if \"models\" in dct:\n173 | # the models are already in the manifest as nodes when we reach this code,\n174 | # even if they are disabled in the schema file\n175 | model_parse_result = ModelPatchParser(self, yaml_block, \"models\").parse()\n176 | for versioned_test_block in model_parse_result.versioned_test_blocks:\n177 | self.generic_test_parser.parse_versioned_tests(versioned_test_block)\n178 | \n179 | # PatchParser.parse()\n180 | if \"seeds\" in dct:\n181 | seed_parse_result = TestablePatchParser(self, yaml_block, \"seeds\").parse()\n182 | for test_block in seed_parse_result.test_blocks:\n183 | self.generic_test_parser.parse_tests(test_block)\n184 | \n185 | # PatchParser.parse()\n186 | if \"snapshots\" in dct:\n187 | snapshot_parse_result = TestablePatchParser(self, yaml_block, \"snapshots\").parse()\n188 | for test_block in snapshot_parse_result.test_blocks:\n189 | self.generic_test_parser.parse_tests(test_block)\n190 | \n191 | # This parser uses SourceParser.parse() which doesn't return\n192 | # any test blocks. Source tests are handled at a later point\n193 | # in the process.\n194 | if \"sources\" in dct:\n195 | parser = SourceParser(self, yaml_block, \"sources\")\n196 | parser.parse()\n197 | \n198 | # PatchParser.parse() (but never test_blocks)\n199 | if \"macros\" in dct:\n200 | parser = MacroPatchParser(self, yaml_block, \"macros\")\n201 | parser.parse()\n202 | \n203 | # PatchParser.parse() (but never test_blocks)\n204 | if \"analyses\" in dct:\n205 | parser = AnalysisPatchParser(self, yaml_block, \"analyses\")\n206 | parser.parse()\n207 | \n208 | # ExposureParser.parse()\n209 | if \"exposures\" in dct:\n210 | from dbt.parser.schema_yaml_readers import ExposureParser\n211 | \n212 | exp_parser = ExposureParser(self, yaml_block)\n213 | exp_parser.parse()\n214 | \n215 | # MetricParser.parse()\n216 | if \"metrics\" in dct:\n217 | from dbt.parser.schema_yaml_readers import MetricParser\n218 | \n219 | metric_parser = MetricParser(self, yaml_block)\n220 | metric_parser.parse()\n221 | \n222 | # GroupParser.parse()\n223 | if \"groups\" in dct:\n224 | from dbt.parser.schema_yaml_readers import GroupParser\n225 | \n226 | group_parser = GroupParser(self, yaml_block)\n227 | group_parser.parse()\n228 | \n229 | if \"semantic_models\" in dct:\n230 | from dbt.parser.schema_yaml_readers import SemanticModelParser\n231 | \n232 | semantic_model_parser = SemanticModelParser(self, yaml_block)\n233 | semantic_model_parser.parse()\n234 | \n235 | if \"unit_tests\" in dct:\n236 | from dbt.parser.unit_tests import UnitTestParser\n237 | \n238 | unit_test_parser = UnitTestParser(self, yaml_block)\n239 | unit_test_parser.parse()\n240 | \n241 | if \"saved_queries\" in dct:\n242 | from dbt.parser.schema_yaml_readers import SavedQueryParser\n243 | \n244 | saved_query_parser = SavedQueryParser(self, yaml_block)\n245 | saved_query_parser.parse()\n246 | \n247 | \n248 | Parsed = TypeVar(\"Parsed\", UnpatchedSourceDefinition, ParsedNodePatch, ParsedMacroPatch)\n249 | NodeTarget = TypeVar(\"NodeTarget\", UnparsedNodeUpdate, UnparsedAnalysisUpdate, UnparsedModelUpdate)\n250 | NonSourceTarget = TypeVar(\n251 | \"NonSourceTarget\",\n252 | UnparsedNodeUpdate,\n253 | UnparsedAnalysisUpdate,\n254 | UnparsedMacroUpdate,\n255 | UnparsedModelUpdate,\n256 | )\n257 | \n258 | \n259 | @dataclass\n260 | class ParseResult:\n261 | test_blocks: List[TestBlock] = field(default_factory=list)\n262 | versioned_test_blocks: List[VersionedTestBlock] = field(default_factory=list)\n263 | \n264 | \n265 | # abstract base class (ABCMeta)\n266 | # Many subclasses: MetricParser, ExposureParser, GroupParser, SourceParser,\n267 | # PatchParser, SemanticModelParser, SavedQueryParser, UnitTestParser\n268 | class YamlReader(metaclass=ABCMeta):\n269 | def __init__(self, schema_parser: SchemaParser, yaml: YamlBlock, key: str) -> None:\n270 | self.schema_parser = schema_parser\n271 | # key: models, seeds, snapshots, sources, macros,\n272 | # analyses, exposures, unit_tests\n273 | self.key = key\n274 | self.yaml = yaml\n275 | self.schema_yaml_vars = SchemaYamlVars()\n276 | self.render_ctx = generate_schema_yml_context(\n277 | self.schema_parser.root_project,\n278 | self.schema_parser.project.project_name,\n279 | self.schema_yaml_vars,\n280 | )\n281 | self.renderer = SchemaYamlRenderer(self.render_ctx, self.key)\n282 | \n283 | @property\n284 | def manifest(self):\n285 | return self.schema_parser.manifest\n286 | \n287 | @property\n288 | def project(self):\n289 | return self.schema_parser.project\n290 | \n291 | @property\n292 | def default_database(self):\n293 | return self.schema_parser.default_database\n294 | \n295 | @property\n296 | def root_project(self):\n297 | return self.schema_parser.root_project\n298 | \n299 | # for the different schema subparsers ('models', 'source', etc)\n300 | # get the list of dicts pointed to by the key in the yaml config,\n301 | # ensure that the dicts have string keys\n302 | def get_key_dicts(self) -> Iterable[Dict[str, Any]]:\n303 | data = self.yaml.data.get(self.key, [])\n304 | if not isinstance(data, list):\n305 | raise ParsingError(\n306 | \"{} must be a list, got {} instead: ({})\".format(\n307 | self.key, type(data), trimmed(str(data))\n308 | )\n309 | )\n310 | path = self.yaml.path.original_file_path\n311 | \n312 | # for each dict in the data (which is a list of dicts)\n313 | for entry in data:\n314 | \n315 | # check that entry is a dict and that all dict values\n316 | # are strings\n317 | if coerce_dict_str(entry) is None:\n318 | raise YamlParseListError(path, self.key, data, \"expected a dict with string keys\")\n319 | \n320 | if \"name\" not in entry and \"model\" not in entry:\n321 | raise ParsingError(\"Entry did not contain a name\")\n322 | \n323 | # Render the data (except for tests, data_tests and descriptions).\n324 | # See the SchemaYamlRenderer\n325 | entry = self.render_entry(entry)\n326 | if self.schema_yaml_vars.env_vars:\n327 | self.schema_parser.manifest.env_vars.update(self.schema_yaml_vars.env_vars)\n328 | schema_file = self.yaml.file\n329 | assert isinstance(schema_file, SchemaSourceFile)\n330 | for var in self.schema_yaml_vars.env_vars.keys():\n331 | schema_file.add_env_var(var, self.key, entry[\"name\"])\n332 | self.schema_yaml_vars.env_vars = {}\n333 | \n334 | yield entry\n335 | \n336 | def render_entry(self, dct):\n337 | try:\n338 | # This does a deep_map which will fail if there are circular references\n339 | dct = self.renderer.render_data(dct)\n340 | except ParsingError as exc:\n341 | raise ParsingError(\n342 | f\"Failed to render {self.yaml.file.path.original_file_path} from \"\n343 | f\"project {self.project.project_name}: {exc}\"\n344 | ) from exc\n345 | return dct\n346 | \n347 | @abstractmethod\n348 | def parse(self) -> ParseResult:\n349 | raise NotImplementedError(\"parse is abstract\")\n350 | \n351 | \n352 | T = TypeVar(\"T\", bound=dbtClassMixin)\n353 | \n354 | \n355 | # This parses the 'sources' keys in yaml files.\n356 | class SourceParser(YamlReader):\n357 | def _target_from_dict(self, cls: Type[T], data: Dict[str, Any]) -> T:\n358 | path = self.yaml.path.original_file_path\n359 | try:\n360 | cls.validate(data)\n361 | return cls.from_dict(data)\n362 | except (ValidationError, JSONValidationError) as exc:\n363 | raise YamlParseDictError(path, self.key, data, exc)\n364 | \n365 | # This parse method takes the yaml dictionaries in 'sources' keys and uses them\n366 | # to create UnparsedSourceDefinition objects. They are then turned\n367 | # into UnpatchedSourceDefinition objects in 'add_source_definitions'\n368 | # or SourcePatch objects in 'add_source_patch'\n369 | def parse(self) -> ParseResult:\n370 | # get a verified list of dicts for the key handled by this parser\n371 | for data in self.get_key_dicts():\n372 | data = self.project.credentials.translate_aliases(data, recurse=True)\n373 | \n374 | is_override = \"overrides\" in data\n375 | if is_override:\n376 | data[\"path\"] = self.yaml.path.original_file_path\n377 | patch = self._target_from_dict(SourcePatch, data)\n378 | assert isinstance(self.yaml.file, SchemaSourceFile)\n379 | source_file = self.yaml.file\n380 | # source patches must be unique\n381 | key = (patch.overrides, patch.name)\n382 | if key in self.manifest.source_patches:\n383 | raise DuplicateSourcePatchNameError(patch, self.manifest.source_patches[key])\n384 | self.manifest.source_patches[key] = patch\n385 | source_file.source_patches.append(key)\n386 | else:\n387 | source = self._target_from_dict(UnparsedSourceDefinition, data)\n388 | self.add_source_definitions(source)\n389 | return ParseResult()\n390 | \n391 | def add_source_definitions(self, source: UnparsedSourceDefinition) -> None:\n392 | package_name = self.project.project_name\n393 | original_file_path = self.yaml.path.original_file_path\n394 | fqn_path = self.yaml.path.relative_path\n395 | for table in source.tables:\n396 | unique_id = \".\".join([NodeType.Source, package_name, source.name, table.name])\n397 | \n398 | # the FQN is project name / path elements /source_name /table_name\n399 | fqn = self.schema_parser.get_fqn_prefix(fqn_path)\n400 | fqn.extend([source.name, table.name])\n401 | \n402 | source_def = UnpatchedSourceDefinition(\n403 | source=source,\n404 | table=table,\n405 | path=original_file_path,\n406 | original_file_path=original_file_path,\n407 | package_name=package_name,\n408 | unique_id=unique_id,\n409 | resource_type=NodeType.Source,\n410 | fqn=fqn,\n411 | name=f\"{source.name}_{table.name}\",\n412 | )\n413 | self.manifest.add_source(self.yaml.file, source_def)\n414 | \n415 | \n416 | # This class has two subclasses: NodePatchParser and MacroPatchParser\n417 | class PatchParser(YamlReader, Generic[NonSourceTarget, Parsed]):\n418 | @abstractmethod\n419 | def _target_type(self) -> Type[NonSourceTarget]:\n420 | raise NotImplementedError(\"_target_type not implemented\")\n421 | \n422 | @abstractmethod\n423 | def get_block(self, node: NonSourceTarget) -> TargetBlock:\n424 | raise NotImplementedError(\"get_block is abstract\")\n425 | \n426 | @abstractmethod\n427 | def parse_patch(self, block: TargetBlock[NonSourceTarget], refs: ParserRef) -> None:\n428 | raise NotImplementedError(\"parse_patch is abstract\")\n429 | \n430 | def parse(self) -> ParseResult:\n431 | node: NonSourceTarget\n432 | # This will always be empty if the node a macro or analysis\n433 | test_blocks: List[TestBlock] = []\n434 | # This will always be empty if the node is _not_ a model\n435 | versioned_test_blocks: List[VersionedTestBlock] = []\n436 | \n437 | # get list of 'node' objects\n438 | # UnparsedNodeUpdate (TestablePatchParser, models, seeds, snapshots)\n439 | # = HasColumnTests, HasTests\n440 | # UnparsedAnalysisUpdate (UnparsedAnalysisParser, analyses)\n441 | # = HasColumnDocs, HasDocs\n442 | # UnparsedMacroUpdate (MacroPatchParser, 'macros')\n443 | # = HasDocs\n444 | # correspond to this parser's 'key'\n445 | for node in self.get_unparsed_target():\n446 | # node_block is a TargetBlock (Macro or Analysis)\n447 | # or a TestBlock (all of the others)\n448 | node_block = self.get_block(node)\n449 | if isinstance(node_block, TestBlock):\n450 | # TestablePatchParser = seeds, snapshots\n451 | test_blocks.append(node_block)\n452 | if isinstance(node_block, VersionedTestBlock):\n453 | # models\n454 | versioned_test_blocks.append(node_block)\n455 | if isinstance(node, (HasColumnDocs, HasColumnTests)):\n456 | # UnparsedNodeUpdate and UnparsedAnalysisUpdate\n457 | refs: ParserRef = ParserRef.from_target(node)\n458 | else:\n459 | refs = ParserRef()\n460 | \n461 | # There's no unique_id on the node yet so cannot add to disabled dict\n462 | self.parse_patch(node_block, refs)\n463 | \n464 | return ParseResult(test_blocks, versioned_test_blocks)\n465 | \n466 | def get_unparsed_target(self) -> Iterable[NonSourceTarget]:\n467 | path = self.yaml.path.original_file_path\n468 | \n469 | # get verified list of dicts for the 'key' that this\n470 | # parser handles\n471 | key_dicts = self.get_key_dicts()\n472 | for data in key_dicts:\n473 | # add extra data to each dict. This updates the dicts\n474 | # in the parser yaml\n475 | data.update(\n476 | {\n477 | \"original_file_path\": path,\n478 | \"yaml_key\": self.key,\n479 | \"package_name\": self.project.project_name,\n480 | }\n481 | )\n482 | try:\n483 | # target_type: UnparsedNodeUpdate, UnparsedAnalysisUpdate,\n484 | # or UnparsedMacroUpdate\n485 | self._target_type().validate(data)\n486 | if self.key != \"macros\":\n487 | # macros don't have the 'config' key support yet\n488 | self.normalize_meta_attribute(data, path)\n489 | self.normalize_docs_attribute(data, path)\n490 | self.normalize_group_attribute(data, path)\n491 | self.normalize_contract_attribute(data, path)\n492 | self.normalize_access_attribute(data, path)\n493 | # `tests` has been deprecated, convert to `data_tests` here if present\n494 | self.validate_data_tests(data)\n495 | node = self._target_type().from_dict(data)\n496 | except (ValidationError, JSONValidationError) as exc:\n497 | raise YamlParseDictError(path, self.key, data, exc)\n498 | else:\n499 | yield node\n500 | \n501 | # We want to raise an error if some attributes are in two places, and move them\n502 | # from toplevel to config if necessary\n503 | def normalize_attribute(self, data, path, attribute):\n504 | if attribute in data:\n505 | if \"config\" in data and attribute in data[\"config\"]:\n506 | raise ParsingError(\n507 | f\"\"\"\n508 | In {path}: found {attribute} dictionary in 'config' dictionary and as top-level key.\n509 | Remove the top-level key and define it under 'config' dictionary only.\n510 | \"\"\".strip()\n511 | )\n512 | else:\n513 | if \"config\" not in data:\n514 | data[\"config\"] = {}\n515 | data[\"config\"][attribute] = data.pop(attribute)\n516 | \n517 | def normalize_meta_attribute(self, data, path):\n518 | return self.normalize_attribute(data, path, \"meta\")\n519 | \n520 | def normalize_docs_attribute(self, data, path):\n521 | return self.normalize_attribute(data, path, \"docs\")\n522 | \n523 | def normalize_group_attribute(self, data, path):\n524 | return self.normalize_attribute(data, path, \"group\")\n525 | \n526 | def normalize_contract_attribute(self, data, path):\n527 | return self.normalize_attribute(data, path, \"contract\")\n528 | \n529 | def normalize_access_attribute(self, data, path):\n530 | return self.normalize_attribute(data, path, \"access\")\n531 | \n532 | def validate_data_tests(self, data):\n533 | # Rename 'tests' -> 'data_tests' at both model-level and column-level\n534 | # Raise a validation error if the user has defined both names\n535 | def validate_and_rename(data):\n536 | if data.get(\"tests\"):\n537 | if \"tests\" in data and \"data_tests\" in data:\n538 | raise ValidationError(\n539 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n540 | )\n541 | deprecations.warn(\n542 | \"project-test-config\",\n543 | deprecated_path=\"tests\",\n544 | exp_path=\"data_tests\",\n545 | )\n546 | data[\"data_tests\"] = data.pop(\"tests\")\n547 | \n548 | # model-level tests\n549 | validate_and_rename(data)\n550 | \n551 | # column-level tests\n552 | if data.get(\"columns\"):\n553 | for column in data[\"columns\"]:\n554 | validate_and_rename(column)\n555 | \n556 | # versioned models\n557 | if data.get(\"versions\"):\n558 | for version in data[\"versions\"]:\n559 | validate_and_rename(version)\n560 | if version.get(\"columns\"):\n561 | for column in version[\"columns\"]:\n562 | validate_and_rename(column)\n563 | \n564 | def patch_node_config(self, node, patch):\n565 | # Get the ContextConfig that's used in calculating the config\n566 | # This must match the model resource_type that's being patched\n567 | config = ContextConfig(\n568 | self.schema_parser.root_project,\n569 | node.fqn,\n570 | node.resource_type,\n571 | self.schema_parser.project.project_name,\n572 | )\n573 | # We need to re-apply the config_call_dict after the patch config\n574 | config._config_call_dict = node.config_call_dict\n575 | self.schema_parser.update_parsed_node_config(node, config, patch_config_dict=patch.config)\n576 | \n577 | \n578 | # Subclasses of NodePatchParser: TestablePatchParser, ModelPatchParser, AnalysisPatchParser,\n579 | # so models, seeds, snapshots, analyses\n580 | class NodePatchParser(PatchParser[NodeTarget, ParsedNodePatch], Generic[NodeTarget]):\n581 | def parse_patch(self, block: TargetBlock[NodeTarget], refs: ParserRef) -> None:\n582 | # We're not passing the ParsedNodePatch around anymore, so we\n583 | # could possibly skip creating one. Leaving here for now for\n584 | # code consistency.\n585 | deprecation_date: Optional[datetime.datetime] = None\n586 | if isinstance(block.target, UnparsedModelUpdate):\n587 | deprecation_date = block.target.deprecation_date\n588 | \n589 | patch = ParsedNodePatch(\n590 | name=block.target.name,\n591 | original_file_path=block.target.original_file_path,\n592 | yaml_key=block.target.yaml_key,\n593 | package_name=block.target.package_name,\n594 | description=block.target.description,\n595 | columns=refs.column_info,\n596 | meta=block.target.meta,\n597 | docs=block.target.docs,\n598 | config=block.target.config,\n599 | access=block.target.access,\n600 | version=None,\n601 | latest_version=None,\n602 | constraints=block.target.constraints,\n603 | deprecation_date=deprecation_date,\n604 | )\n605 | assert isinstance(self.yaml.file, SchemaSourceFile)\n606 | source_file: SchemaSourceFile = self.yaml.file\n607 | if patch.yaml_key in [\"models\", \"seeds\", \"snapshots\"]:\n608 | unique_id = self.manifest.ref_lookup.get_unique_id(\n609 | patch.name, self.project.project_name, None\n610 | ) or self.manifest.ref_lookup.get_unique_id(patch.name, None, None)\n611 | \n612 | if unique_id:\n613 | resource_type = NodeType(unique_id.split(\".\")[0])\n614 | if resource_type.pluralize() != patch.yaml_key:\n615 | warn_or_error(\n616 | WrongResourceSchemaFile(\n617 | patch_name=patch.name,\n618 | resource_type=resource_type,\n619 | plural_resource_type=resource_type.pluralize(),\n620 | yaml_key=patch.yaml_key,\n621 | file_path=patch.original_file_path,\n622 | )\n623 | )\n624 | return\n625 | \n626 | elif patch.yaml_key == \"analyses\":\n627 | unique_id = self.manifest.analysis_lookup.get_unique_id(patch.name, None, None)\n628 | else:\n629 | raise DbtInternalError(\n630 | f\"Unexpected yaml_key {patch.yaml_key} for patch in \"\n631 | f\"file {source_file.path.original_file_path}\"\n632 | )\n633 | # handle disabled nodes\n634 | if unique_id is None:\n635 | # Node might be disabled. Following call returns list of matching disabled nodes\n636 | found_nodes = self.manifest.disabled_lookup.find(patch.name, patch.package_name)\n637 | if found_nodes:\n638 | if len(found_nodes) > 1 and patch.config.get(\"enabled\"):\n639 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n640 | # We have no way to know which one to enable.\n641 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n642 | msg = (\n643 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n644 | f\"{resource_type} '{patch.name}'. Multiple nodes for the same \"\n645 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n646 | \"in `dbt_project.yml` or in the sql files.\"\n647 | )\n648 | raise ParsingError(msg)\n649 | \n650 | # all nodes in the disabled dict have the same unique_id so just grab the first one\n651 | # to append with the unique id\n652 | source_file.append_patch(patch.yaml_key, found_nodes[0].unique_id)\n653 | for node in found_nodes:\n654 | node.patch_path = source_file.file_id\n655 | # re-calculate the node config with the patch config. Always do this\n656 | # for the case when no config is set to ensure the default of true gets captured\n657 | if patch.config:\n658 | self.patch_node_config(node, patch)\n659 | \n660 | self.patch_node_properties(node, patch)\n661 | else:\n662 | warn_or_error(\n663 | NoNodeForYamlKey(\n664 | patch_name=patch.name,\n665 | yaml_key=patch.yaml_key,\n666 | file_path=source_file.path.original_file_path,\n667 | )\n668 | )\n669 | return\n670 | \n671 | # patches can't be overwritten\n672 | node = self.manifest.nodes.get(unique_id)\n673 | if node:\n674 | if node.patch_path:\n675 | package_name, existing_file_path = node.patch_path.split(\"://\")\n676 | raise DuplicatePatchPathError(patch, existing_file_path)\n677 | \n678 | source_file.append_patch(patch.yaml_key, node.unique_id)\n679 | # re-calculate the node config with the patch config. Always do this\n680 | # for the case when no config is set to ensure the default of true gets captured\n681 | if patch.config:\n682 | self.patch_node_config(node, patch)\n683 | \n684 | self.patch_node_properties(node, patch)\n685 | \n686 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n687 | \"\"\"Given a ParsedNodePatch, add the new information to the node.\"\"\"\n688 | # explicitly pick out the parts to update so we don't inadvertently\n689 | # step on the model name or anything\n690 | # Note: config should already be updated\n691 | node.patch_path = patch.file_id\n692 | # update created_at so process_docs will run in partial parsing\n693 | node.created_at = time.time()\n694 | node.description = patch.description\n695 | node.columns = patch.columns\n696 | node.name = patch.name\n697 | \n698 | if not isinstance(node, ModelNode):\n699 | for attr in [\"latest_version\", \"access\", \"version\", \"constraints\"]:\n700 | if getattr(patch, attr):\n701 | warn_or_error(\n702 | ValidationWarning(\n703 | field_name=attr,\n704 | resource_type=node.resource_type.value,\n705 | node_name=patch.name,\n706 | )\n707 | )\n708 | \n709 | \n710 | # TestablePatchParser = seeds, snapshots\n711 | class TestablePatchParser(NodePatchParser[UnparsedNodeUpdate]):\n712 | __test__ = False\n713 | \n714 | def get_block(self, node: UnparsedNodeUpdate) -> TestBlock:\n715 | return TestBlock.from_yaml_block(self.yaml, node)\n716 | \n717 | def _target_type(self) -> Type[UnparsedNodeUpdate]:\n718 | return UnparsedNodeUpdate\n719 | \n720 | \n721 | class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n722 | def get_block(self, node: UnparsedModelUpdate) -> VersionedTestBlock:\n723 | return VersionedTestBlock.from_yaml_block(self.yaml, node)\n724 | \n725 | def parse_patch(self, block: TargetBlock[UnparsedModelUpdate], refs: ParserRef) -> None:\n726 | target = block.target\n727 | if NodeType.Model.pluralize() != target.yaml_key:\n728 | warn_or_error(\n729 | WrongResourceSchemaFile(\n730 | patch_name=target.name,\n731 | resource_type=NodeType.Model,\n732 | plural_resource_type=NodeType.Model.pluralize(),\n733 | yaml_key=target.yaml_key,\n734 | file_path=target.original_file_path,\n735 | )\n736 | )\n737 | return\n738 | \n739 | versions = target.versions\n740 | if not versions:\n741 | super().parse_patch(block, refs)\n742 | else:\n743 | assert isinstance(self.yaml.file, SchemaSourceFile)\n744 | source_file: SchemaSourceFile = self.yaml.file\n745 | latest_version = (\n746 | target.latest_version if target.latest_version is not None else max(versions).v\n747 | )\n748 | for unparsed_version in versions:\n749 | versioned_model_name = (\n750 | unparsed_version.defined_in or f\"{block.name}_{unparsed_version.formatted_v}\"\n751 | )\n752 | # ref lookup without version - version is not set yet\n753 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n754 | versioned_model_name, target.package_name, None\n755 | )\n756 | \n757 | versioned_model_node = None\n758 | add_node_nofile_fn: Callable\n759 | \n760 | # If this is the latest version, it's allowed to define itself in a model file name that doesn't have a suffix\n761 | if versioned_model_unique_id is None and unparsed_version.v == latest_version:\n762 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n763 | block.name, target.package_name, None\n764 | )\n765 | \n766 | if versioned_model_unique_id is None:\n767 | # Node might be disabled. Following call returns list of matching disabled nodes\n768 | found_nodes = self.manifest.disabled_lookup.find(versioned_model_name, None)\n769 | if found_nodes:\n770 | if len(found_nodes) > 1 and target.config.get(\"enabled\"):\n771 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n772 | # We have no way to know which one to enable.\n773 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n774 | msg = (\n775 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n776 | f\"{resource_type} '{target.name}'. Multiple nodes for the same \"\n777 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n778 | \"in `dbt_project.yml` or in the sql files.\"\n779 | )\n780 | raise ParsingError(msg)\n781 | versioned_model_node = self.manifest.disabled.pop(\n782 | found_nodes[0].unique_id\n783 | )[0]\n784 | add_node_nofile_fn = self.manifest.add_disabled_nofile\n785 | else:\n786 | versioned_model_node = self.manifest.nodes.pop(versioned_model_unique_id)\n787 | add_node_nofile_fn = self.manifest.add_node_nofile\n788 | \n789 | if versioned_model_node is None:\n790 | warn_or_error(\n791 | NoNodeForYamlKey(\n792 | patch_name=versioned_model_name,\n793 | yaml_key=target.yaml_key,\n794 | file_path=source_file.path.original_file_path,\n795 | )\n796 | )\n797 | continue\n798 | \n799 | # update versioned node unique_id\n800 | versioned_model_node_unique_id_old = versioned_model_node.unique_id\n801 | versioned_model_node.unique_id = (\n802 | f\"model.{target.package_name}.{target.name}.{unparsed_version.formatted_v}\"\n803 | )\n804 | # update source file.nodes with new unique_id\n805 | self.manifest.files[versioned_model_node.file_id].nodes.remove(\n806 | versioned_model_node_unique_id_old\n807 | )\n808 | self.manifest.files[versioned_model_node.file_id].nodes.append(\n809 | versioned_model_node.unique_id\n810 | )\n811 | \n812 | # update versioned node fqn\n813 | versioned_model_node.fqn[-1] = target.name\n814 | versioned_model_node.fqn.append(unparsed_version.formatted_v)\n815 | \n816 | # add versioned node back to nodes/disabled\n817 | add_node_nofile_fn(versioned_model_node)\n818 | \n819 | # flatten columns based on include/exclude\n820 | version_refs: ParserRef = ParserRef.from_versioned_target(\n821 | block.target, unparsed_version.v\n822 | )\n823 | \n824 | versioned_model_patch = ParsedNodePatch(\n825 | name=target.name,\n826 | original_file_path=target.original_file_path,\n827 | yaml_key=target.yaml_key,\n828 | package_name=target.package_name,\n829 | description=unparsed_version.description or target.description,\n830 | columns=version_refs.column_info,\n831 | meta=target.meta,\n832 | docs=unparsed_version.docs or target.docs,\n833 | config=deep_merge(target.config, unparsed_version.config),\n834 | access=unparsed_version.access or target.access,\n835 | version=unparsed_version.v,\n836 | latest_version=latest_version,\n837 | constraints=unparsed_version.constraints or target.constraints,\n838 | deprecation_date=unparsed_version.deprecation_date,\n839 | )\n840 | # Node patched before config because config patching depends on model name,\n841 | # which may have been updated in the version patch\n842 | # versioned_model_node.patch(versioned_model_patch)\n843 | self.patch_node_properties(versioned_model_node, versioned_model_patch)\n844 | \n845 | # Includes alias recomputation\n846 | self.patch_node_config(versioned_model_node, versioned_model_patch)\n847 | \n848 | # Need to reapply this here, in the case that 'contract: {enforced: true}' was during config-setting\n849 | versioned_model_node.build_contract_checksum()\n850 | source_file.append_patch(\n851 | versioned_model_patch.yaml_key, versioned_model_node.unique_id\n852 | )\n853 | self.manifest.rebuild_ref_lookup()\n854 | self.manifest.rebuild_disabled_lookup()\n855 | \n856 | def _target_type(self) -> Type[UnparsedModelUpdate]:\n857 | return UnparsedModelUpdate\n858 | \n859 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n860 | super().patch_node_properties(node, patch)\n861 | node.version = patch.version\n862 | node.latest_version = patch.latest_version\n863 | node.deprecation_date = patch.deprecation_date\n864 | if patch.access:\n865 | if AccessType.is_valid(patch.access):\n866 | node.access = AccessType(patch.access)\n867 | else:\n868 | raise InvalidAccessTypeError(\n869 | unique_id=node.unique_id,\n870 | field_value=patch.access,\n871 | )\n872 | self.patch_constraints(node, patch.constraints)\n873 | node.build_contract_checksum()\n874 | \n875 | def patch_constraints(self, node, constraints):\n876 | contract_config = node.config.get(\"contract\")\n877 | if contract_config.enforced is True:\n878 | self._validate_constraint_prerequisites(node)\n879 | \n880 | if any(\n881 | c for c in constraints if \"type\" not in c or not ConstraintType.is_valid(c[\"type\"])\n882 | ):\n883 | raise ParsingError(\n884 | f\"Invalid constraint type on model {node.name}: \"\n885 | f\"Type must be one of {[ct.value for ct in ConstraintType]}\"\n886 | )\n887 | \n888 | node.constraints = [ModelLevelConstraint.from_dict(c) for c in constraints]\n889 | \n890 | def _validate_constraint_prerequisites(self, model_node: ModelNode):\n891 | \n892 | column_warn_unsupported = [\n893 | constraint.warn_unsupported\n894 | for column in model_node.columns.values()\n895 | for constraint in column.constraints\n896 | ]\n897 | model_warn_unsupported = [\n898 | constraint.warn_unsupported for constraint in model_node.constraints\n899 | ]\n900 | warn_unsupported = column_warn_unsupported + model_warn_unsupported\n901 | \n902 | # if any constraint has `warn_unsupported` as True then send the warning\n903 | if any(warn_unsupported) and not model_node.materialization_enforces_constraints:\n904 | warn_or_error(\n905 | UnsupportedConstraintMaterialization(materialized=model_node.config.materialized),\n906 | node=model_node,\n907 | )\n908 | \n909 | errors = []\n910 | if not model_node.columns:\n911 | errors.append(\n912 | \"Constraints must be defined in a `yml` schema configuration file like `schema.yml`.\"\n913 | )\n914 | \n915 | if str(model_node.language) != \"sql\":\n916 | errors.append(f\"Language Error: Expected 'sql' but found '{model_node.language}'\")\n917 | \n918 | if errors:\n919 | raise ParsingError(\n920 | f\"Contract enforcement failed for: ({model_node.original_file_path})\\n\"\n921 | + \"\\n\".join(errors)\n922 | )\n923 | \n924 | \n925 | class AnalysisPatchParser(NodePatchParser[UnparsedAnalysisUpdate]):\n926 | def get_block(self, node: UnparsedAnalysisUpdate) -> TargetBlock:\n927 | return TargetBlock.from_yaml_block(self.yaml, node)\n928 | \n929 | def _target_type(self) -> Type[UnparsedAnalysisUpdate]:\n930 | return UnparsedAnalysisUpdate\n931 | \n932 | \n933 | class MacroPatchParser(PatchParser[UnparsedMacroUpdate, ParsedMacroPatch]):\n934 | def get_block(self, node: UnparsedMacroUpdate) -> TargetBlock:\n935 | return TargetBlock.from_yaml_block(self.yaml, node)\n936 | \n937 | def _target_type(self) -> Type[UnparsedMacroUpdate]:\n938 | return UnparsedMacroUpdate\n939 | \n940 | def parse_patch(self, block: TargetBlock[UnparsedMacroUpdate], refs: ParserRef) -> None:\n941 | patch = ParsedMacroPatch(\n942 | name=block.target.name,\n943 | original_file_path=block.target.original_file_path,\n944 | yaml_key=block.target.yaml_key,\n945 | package_name=block.target.package_name,\n946 | arguments=block.target.arguments,\n947 | description=block.target.description,\n948 | meta=block.target.meta,\n949 | docs=block.target.docs,\n950 | config=block.target.config,\n951 | )\n952 | assert isinstance(self.yaml.file, SchemaSourceFile)\n953 | source_file = self.yaml.file\n954 | # macros are fully namespaced\n955 | unique_id = f\"macro.{patch.package_name}.{patch.name}\"\n956 | macro = self.manifest.macros.get(unique_id)\n957 | if not macro:\n958 | warn_or_error(MacroNotFoundForPatch(patch_name=patch.name))\n959 | return\n960 | if macro.patch_path:\n961 | package_name, existing_file_path = macro.patch_path.split(\"://\")\n962 | raise DuplicateMacroPatchNameError(patch, existing_file_path)\n963 | source_file.macro_patches[patch.name] = unique_id\n964 | \n965 | # former macro.patch code\n966 | macro.patch_path = patch.file_id\n967 | macro.description = patch.description\n968 | macro.created_at = time.time()\n969 | macro.meta = patch.meta\n970 | macro.docs = patch.docs\n971 | macro.arguments = patch.arguments\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/nodes.py\n+++ b/core/dbt/contracts/graph/nodes.py\n@@ -1225,6 +1225,21 @@ class UnpatchedSourceDefinition(BaseNode):\n sources parse tests differently than models, so we need to do some validation\n here where it's done in the PatchParser for other nodes\n \"\"\"\n+ # source table-level tests\n+ if self.tests and self.data_tests:\n+ raise ValidationError(\n+ \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n+ )\n+ if self.tests:\n+ deprecations.warn(\n+ \"project-test-config\",\n+ deprecated_path=\"tests\",\n+ exp_path=\"data_tests\",\n+ )\n+ self.data_tests.extend(self.tests)\n+ self.tests.clear()\n+\n+ # column-level tests\n for column in self.columns:\n if column.tests and column.data_tests:\n raise ValidationError(\n@@ -1236,7 +1251,8 @@ class UnpatchedSourceDefinition(BaseNode):\n deprecated_path=\"tests\",\n exp_path=\"data_tests\",\n )\n- column.data_tests = column.tests\n+ column.data_tests.extend(column.tests)\n+ column.tests.clear()\n \n @property\n def quote_columns(self) -> Optional[bool]:\ndiff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/unparsed.py\n+++ b/core/dbt/contracts/graph/unparsed.py\n@@ -106,7 +106,9 @@ TestDef = Union[Dict[str, Any], str]\n @dataclass\n class HasColumnAndTestProps(HasColumnProps):\n data_tests: List[TestDef] = field(default_factory=list)\n- tests: List[TestDef] = field(default_factory=list)\n+ tests: List[TestDef] = field(\n+ default_factory=list\n+ ) # back compat for previous name of 'data_tests'\n \n \n @dataclass\n@@ -154,6 +156,7 @@ class UnparsedVersion(dbtClassMixin):\n constraints: List[Dict[str, Any]] = field(default_factory=list)\n docs: Docs = field(default_factory=Docs)\n data_tests: Optional[List[TestDef]] = None\n+ tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n default_factory=list\n )\n@@ -409,6 +412,7 @@ class SourceTablePatch(dbtClassMixin):\n external: Optional[ExternalTable] = None\n tags: Optional[List[str]] = None\n data_tests: Optional[List[TestDef]] = None\n+ tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n columns: Optional[Sequence[UnparsedColumn]] = None\n \n def to_patch_dict(self) -> Dict[str, Any]:\ndiff --git a/core/dbt/parser/schemas.py b/core/dbt/parser/schemas.py\nindex 0000000..0000000 100644\n--- a/core/dbt/parser/schemas.py\n+++ b/core/dbt/parser/schemas.py\n@@ -530,19 +530,36 @@ class PatchParser(YamlReader, Generic[NonSourceTarget, Parsed]):\n return self.normalize_attribute(data, path, \"access\")\n \n def validate_data_tests(self, data):\n- if data.get(\"columns\"):\n- for column in data[\"columns\"]:\n- if \"tests\" in column and \"data_tests\" in column:\n+ # Rename 'tests' -> 'data_tests' at both model-level and column-level\n+ # Raise a validation error if the user has defined both names\n+ def validate_and_rename(data):\n+ if data.get(\"tests\"):\n+ if \"tests\" in data and \"data_tests\" in data:\n raise ValidationError(\n \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n )\n- if \"tests\" in column:\n- deprecations.warn(\n- \"project-test-config\",\n- deprecated_path=\"tests\",\n- exp_path=\"data_tests\",\n- )\n- column[\"data_tests\"] = column.pop(\"tests\")\n+ deprecations.warn(\n+ \"project-test-config\",\n+ deprecated_path=\"tests\",\n+ exp_path=\"data_tests\",\n+ )\n+ data[\"data_tests\"] = data.pop(\"tests\")\n+\n+ # model-level tests\n+ validate_and_rename(data)\n+\n+ # column-level tests\n+ if data.get(\"columns\"):\n+ for column in data[\"columns\"]:\n+ validate_and_rename(column)\n+\n+ # versioned models\n+ if data.get(\"versions\"):\n+ for version in data[\"versions\"]:\n+ validate_and_rename(version)\n+ if version.get(\"columns\"):\n+ for column in version[\"columns\"]:\n+ validate_and_rename(column)\n \n def patch_node_config(self, node, patch):\n # Get the ContextConfig that's used in calculating the config"},"prompt_input_token_count":{"kind":"number","value":92220,"string":"92,220"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9412\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"0da5dfecbb45632d52ecdb07ad2c5b4726c246ca\",\n \"pull_number\": 9412,\n \"issue_numbers\": [\n \"9411\"\n ],\n \"changed_files\": [\n \"core/dbt/contracts/graph/nodes.py\",\n \"core/dbt/contracts/graph/unparsed.py\",\n \"core/dbt/parser/schemas.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32287,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9423"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: c547aace361ea12c3de90a811e612481fefe766b\nChanged files:\n- core/dbt/context/macros.py\n- core/dbt/context/manifest.py\n- core/dbt/contracts/graph/manifest.py\n\n## Problem statement\n\nMacro Context Cleanup\n### Housekeeping\r\n\r\n- [X] I am a maintainer of dbt-core\r\n\r\n### Short description\r\n\r\nReorganize jinja macro contexts so that upcoming maintenance is easier.\r\n\r\n### Acceptance criteria\r\n\r\n\r\n### Suggested Tests\r\n\r\n\r\n### Impact to Other Teams\r\n\r\nNone\r\n\r\n### Will backports be required?\r\n\r\nNo\r\n\r\n### Context\r\n\r\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/context/macros.py\n\n```python\n 1 | from typing import Any, Dict, Iterable, Union, Optional, List, Iterator, Mapping, Set\n 2 | \n 3 | from dbt.clients.jinja import MacroGenerator, MacroStack\n 4 | from dbt.contracts.graph.nodes import Macro\n 5 | from dbt.adapters.include.global_project import PROJECT_NAME as GLOBAL_PROJECT_NAME\n 6 | from dbt.exceptions import DuplicateMacroNameError, PackageNotFoundForMacroError\n 7 | \n 8 | \n 9 | FlatNamespace = Dict[str, MacroGenerator]\n 10 | NamespaceMember = Union[FlatNamespace, MacroGenerator]\n 11 | FullNamespace = Dict[str, NamespaceMember]\n 12 | \n 13 | \n 14 | # The point of this class is to collect the various macros\n 15 | # and provide the ability to flatten them into the ManifestContexts\n 16 | # that are created for jinja, so that macro calls can be resolved.\n 17 | # Creates special iterators and _keys methods to flatten the lists.\n 18 | # When this class is created it has a static 'local_namespace' which\n 19 | # depends on the package of the node, so it only works for one\n 20 | # particular local package at a time for \"flattening\" into a context.\n 21 | # 'get_by_package' should work for any macro.\n 22 | class MacroNamespace(Mapping):\n 23 | def __init__(\n 24 | self,\n 25 | global_namespace: FlatNamespace, # root package macros\n 26 | local_namespace: FlatNamespace, # packages for *this* node\n 27 | global_project_namespace: FlatNamespace, # internal packages\n 28 | packages: Dict[str, FlatNamespace], # non-internal packages\n 29 | ):\n 30 | self.global_namespace: FlatNamespace = global_namespace\n 31 | self.local_namespace: FlatNamespace = local_namespace\n 32 | self.packages: Dict[str, FlatNamespace] = packages\n 33 | self.global_project_namespace: FlatNamespace = global_project_namespace\n 34 | \n 35 | def _search_order(self) -> Iterable[Union[FullNamespace, FlatNamespace]]:\n 36 | yield self.local_namespace # local package\n 37 | yield self.global_namespace # root package\n 38 | # TODO CT-211\n 39 | yield self.packages # type: ignore[misc] # non-internal packages\n 40 | yield {\n 41 | # TODO CT-211\n 42 | GLOBAL_PROJECT_NAME: self.global_project_namespace, # type: ignore[misc] # dbt\n 43 | }\n 44 | yield self.global_project_namespace # other internal project besides dbt\n 45 | \n 46 | # provides special keys method for MacroNamespace iterator\n 47 | # returns keys from local_namespace, global_namespace, packages,\n 48 | # global_project_namespace\n 49 | def _keys(self) -> Set[str]:\n 50 | keys: Set[str] = set()\n 51 | for search in self._search_order():\n 52 | keys.update(search)\n 53 | return keys\n 54 | \n 55 | # special iterator using special keys\n 56 | def __iter__(self) -> Iterator[str]:\n 57 | for key in self._keys():\n 58 | yield key\n 59 | \n 60 | def __len__(self):\n 61 | return len(self._keys())\n 62 | \n 63 | def __getitem__(self, key: str) -> NamespaceMember:\n 64 | for dct in self._search_order():\n 65 | if key in dct:\n 66 | return dct[key]\n 67 | raise KeyError(key)\n 68 | \n 69 | def get_from_package(self, package_name: Optional[str], name: str) -> Optional[MacroGenerator]:\n 70 | pkg: FlatNamespace\n 71 | if package_name is None:\n 72 | return self.get(name)\n 73 | elif package_name == GLOBAL_PROJECT_NAME:\n 74 | return self.global_project_namespace.get(name)\n 75 | elif package_name in self.packages:\n 76 | return self.packages[package_name].get(name)\n 77 | else:\n 78 | raise PackageNotFoundForMacroError(package_name)\n 79 | \n 80 | \n 81 | # This class builds the MacroNamespace by adding macros to\n 82 | # internal_packages or packages, and locals/globals.\n 83 | # Call 'build_namespace' to return a MacroNamespace.\n 84 | # This is used by ManifestContext (and subclasses)\n 85 | class MacroNamespaceBuilder:\n 86 | def __init__(\n 87 | self,\n 88 | root_package: str,\n 89 | search_package: str,\n 90 | thread_ctx: MacroStack,\n 91 | internal_packages: List[str],\n 92 | node: Optional[Any] = None,\n 93 | ) -> None:\n 94 | self.root_package = root_package\n 95 | self.search_package = search_package\n 96 | # internal packages comes from get_adapter_package_names\n 97 | self.internal_package_names = set(internal_packages)\n 98 | self.internal_package_names_order = internal_packages\n 99 | # macro_func is added here if in root package, since\n100 | # the root package acts as a \"global\" namespace, overriding\n101 | # everything else except local external package macro calls\n102 | self.globals: FlatNamespace = {}\n103 | # macro_func is added here if it's the package for this node\n104 | self.locals: FlatNamespace = {}\n105 | # Create a dictionary of [package name][macro name] =\n106 | # MacroGenerator object which acts like a function\n107 | self.internal_packages: Dict[str, FlatNamespace] = {}\n108 | self.packages: Dict[str, FlatNamespace] = {}\n109 | self.thread_ctx = thread_ctx\n110 | self.node = node\n111 | \n112 | def _add_macro_to(\n113 | self,\n114 | hierarchy: Dict[str, FlatNamespace],\n115 | macro: Macro,\n116 | macro_func: MacroGenerator,\n117 | ):\n118 | if macro.package_name in hierarchy:\n119 | namespace = hierarchy[macro.package_name]\n120 | else:\n121 | namespace = {}\n122 | hierarchy[macro.package_name] = namespace\n123 | \n124 | if macro.name in namespace:\n125 | raise DuplicateMacroNameError(macro_func.macro, macro, macro.package_name)\n126 | hierarchy[macro.package_name][macro.name] = macro_func\n127 | \n128 | def add_macro(self, macro: Macro, ctx: Dict[str, Any]):\n129 | macro_name: str = macro.name\n130 | \n131 | # MacroGenerator is in clients/jinja.py\n132 | # a MacroGenerator object is a callable object that will\n133 | # execute the MacroGenerator.__call__ function\n134 | macro_func: MacroGenerator = MacroGenerator(macro, ctx, self.node, self.thread_ctx)\n135 | \n136 | # internal macros (from plugins) will be processed separately from\n137 | # project macros, so store them in a different place\n138 | if macro.package_name in self.internal_package_names:\n139 | self._add_macro_to(self.internal_packages, macro, macro_func)\n140 | else:\n141 | # if it's not an internal package\n142 | self._add_macro_to(self.packages, macro, macro_func)\n143 | # add to locals if it's the package this node is in\n144 | if macro.package_name == self.search_package:\n145 | self.locals[macro_name] = macro_func\n146 | # add to globals if it's in the root package\n147 | elif macro.package_name == self.root_package:\n148 | self.globals[macro_name] = macro_func\n149 | \n150 | def add_macros(self, macros: Iterable[Macro], ctx: Dict[str, Any]):\n151 | for macro in macros:\n152 | self.add_macro(macro, ctx)\n153 | \n154 | def build_namespace(self, macros: Iterable[Macro], ctx: Dict[str, Any]) -> MacroNamespace:\n155 | self.add_macros(macros, ctx)\n156 | \n157 | # Iterate in reverse-order and overwrite: the packages that are first\n158 | # in the list are the ones we want to \"win\".\n159 | global_project_namespace: FlatNamespace = {}\n160 | for pkg in reversed(self.internal_package_names_order):\n161 | if pkg in self.internal_packages:\n162 | # add the macros pointed to by this package name\n163 | global_project_namespace.update(self.internal_packages[pkg])\n164 | \n165 | return MacroNamespace(\n166 | global_namespace=self.globals, # root package macros\n167 | local_namespace=self.locals, # packages for *this* node\n168 | global_project_namespace=global_project_namespace, # internal packages\n169 | packages=self.packages, # non internal_packages\n170 | )\n```\n\n### File: core/dbt/context/manifest.py\n\n```python\n 1 | from typing import List\n 2 | \n 3 | from dbt.clients.jinja import MacroStack\n 4 | from dbt.adapters.contracts.connection import AdapterRequiredConfig\n 5 | from dbt.contracts.graph.manifest import Manifest\n 6 | from dbt.context.macro_resolver import TestMacroNamespace\n 7 | from .base import contextproperty\n 8 | \n 9 | \n10 | from .configured import ConfiguredContext\n11 | from .macros import MacroNamespaceBuilder\n12 | \n13 | \n14 | class ManifestContext(ConfiguredContext):\n15 | \"\"\"The Macro context has everything in the target context, plus the macros\n16 | in the manifest.\n17 | \n18 | The given macros can override any previous context values, which will be\n19 | available as if they were accessed relative to the package name.\n20 | \"\"\"\n21 | \n22 | # subclasses are QueryHeaderContext and ProviderContext\n23 | def __init__(\n24 | self,\n25 | config: AdapterRequiredConfig,\n26 | manifest: Manifest,\n27 | search_package: str,\n28 | ) -> None:\n29 | super().__init__(config)\n30 | self.manifest = manifest\n31 | # this is the package of the node for which this context was built\n32 | self.search_package = search_package\n33 | self.macro_stack = MacroStack()\n34 | # This namespace is used by the BaseDatabaseWrapper in jinja rendering.\n35 | # The namespace is passed to it when it's constructed. It expects\n36 | # to be able to do: namespace.get_from_package(..)\n37 | self.namespace = self._build_namespace()\n38 | \n39 | def _build_namespace(self):\n40 | # this takes all the macros in the manifest and adds them\n41 | # to the MacroNamespaceBuilder stored in self.namespace\n42 | builder = self._get_namespace_builder()\n43 | return builder.build_namespace(self.manifest.macros.values(), self._ctx)\n44 | \n45 | def _get_namespace_builder(self) -> MacroNamespaceBuilder:\n46 | # avoid an import loop\n47 | from dbt.adapters.factory import get_adapter_package_names\n48 | \n49 | internal_packages: List[str] = get_adapter_package_names(self.config.credentials.type)\n50 | return MacroNamespaceBuilder(\n51 | self.config.project_name,\n52 | self.search_package,\n53 | self.macro_stack,\n54 | internal_packages,\n55 | None,\n56 | )\n57 | \n58 | # This does not use the Mashumaro code\n59 | def to_dict(self):\n60 | dct = super().to_dict()\n61 | # This moves all of the macros in the 'namespace' into top level\n62 | # keys in the manifest dictionary\n63 | if isinstance(self.namespace, TestMacroNamespace):\n64 | dct.update(self.namespace.local_namespace)\n65 | dct.update(self.namespace.project_namespace)\n66 | else:\n67 | dct.update(self.namespace)\n68 | return dct\n69 | \n70 | @contextproperty()\n71 | def context_macro_stack(self):\n72 | return self.macro_stack\n73 | \n74 | \n75 | class QueryHeaderContext(ManifestContext):\n76 | def __init__(self, config: AdapterRequiredConfig, manifest: Manifest) -> None:\n77 | super().__init__(config, manifest, config.project_name)\n78 | \n79 | \n80 | def generate_query_header_context(config: AdapterRequiredConfig, manifest: Manifest):\n81 | ctx = QueryHeaderContext(config, manifest)\n82 | return ctx.to_dict()\n```\n\n### File: core/dbt/contracts/graph/manifest.py\n\n```python\n 1 | import enum\n 2 | from collections import defaultdict\n 3 | from dataclasses import dataclass, field\n 4 | from itertools import chain, islice\n 5 | from mashumaro.mixins.msgpack import DataClassMessagePackMixin\n 6 | from multiprocessing.synchronize import Lock\n 7 | from typing import (\n 8 | DefaultDict,\n 9 | Dict,\n 10 | List,\n 11 | Optional,\n 12 | Union,\n 13 | Mapping,\n 14 | MutableMapping,\n 15 | Any,\n 16 | Set,\n 17 | Tuple,\n 18 | TypeVar,\n 19 | Callable,\n 20 | Generic,\n 21 | AbstractSet,\n 22 | ClassVar,\n 23 | Iterable,\n 24 | )\n 25 | from typing_extensions import Protocol\n 26 | from uuid import UUID\n 27 | \n 28 | from dbt.contracts.graph.nodes import (\n 29 | BaseNode,\n 30 | Documentation,\n 31 | Exposure,\n 32 | GenericTestNode,\n 33 | GraphMemberNode,\n 34 | Group,\n 35 | Macro,\n 36 | ManifestNode,\n 37 | Metric,\n 38 | ModelNode,\n 39 | DeferRelation,\n 40 | ResultNode,\n 41 | SavedQuery,\n 42 | SemanticModel,\n 43 | SourceDefinition,\n 44 | UnpatchedSourceDefinition,\n 45 | UnitTestDefinition,\n 46 | UnitTestFileFixture,\n 47 | )\n 48 | from dbt.contracts.graph.unparsed import SourcePatch, NodeVersion, UnparsedVersion\n 49 | from dbt.contracts.graph.manifest_upgrade import upgrade_manifest_json\n 50 | from dbt.contracts.files import (\n 51 | SourceFile,\n 52 | SchemaSourceFile,\n 53 | FileHash,\n 54 | AnySourceFile,\n 55 | FixtureSourceFile,\n 56 | )\n 57 | from dbt.artifacts.base import (\n 58 | BaseArtifactMetadata,\n 59 | ArtifactMixin,\n 60 | schema_version,\n 61 | get_artifact_schema_version,\n 62 | )\n 63 | from dbt.contracts.util import SourceKey\n 64 | from dbt_common.dataclass_schema import dbtClassMixin\n 65 | \n 66 | from dbt.exceptions import (\n 67 | CompilationError,\n 68 | DuplicateResourceNameError,\n 69 | AmbiguousResourceNameRefError,\n 70 | )\n 71 | from dbt.adapters.exceptions import DuplicateMacroInPackageError, DuplicateMaterializationNameError\n 72 | from dbt_common.helper_types import PathSet\n 73 | from dbt_common.events.functions import fire_event\n 74 | from dbt_common.events.contextvars import get_node_info\n 75 | from dbt.events.types import MergedFromState, UnpinnedRefNewVersionAvailable\n 76 | from dbt.node_types import NodeType, AccessType\n 77 | from dbt.flags import get_flags\n 78 | from dbt.mp_context import get_mp_context\n 79 | from dbt import tracking\n 80 | import dbt_common.utils\n 81 | import dbt_common.exceptions\n 82 | \n 83 | \n 84 | NodeEdgeMap = Dict[str, List[str]]\n 85 | PackageName = str\n 86 | DocName = str\n 87 | RefName = str\n 88 | UniqueID = str\n 89 | \n 90 | \n 91 | def find_unique_id_for_package(storage, key, package: Optional[PackageName]):\n 92 | if key not in storage:\n 93 | return None\n 94 | \n 95 | pkg_dct: Mapping[PackageName, UniqueID] = storage[key]\n 96 | \n 97 | if package is None:\n 98 | if not pkg_dct:\n 99 | return None\n 100 | else:\n 101 | return next(iter(pkg_dct.values()))\n 102 | elif package in pkg_dct:\n 103 | return pkg_dct[package]\n 104 | else:\n 105 | return None\n 106 | \n 107 | \n 108 | class DocLookup(dbtClassMixin):\n 109 | def __init__(self, manifest: \"Manifest\") -> None:\n 110 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 111 | self.populate(manifest)\n 112 | \n 113 | def get_unique_id(self, key, package: Optional[PackageName]):\n 114 | return find_unique_id_for_package(self.storage, key, package)\n 115 | \n 116 | def find(self, key, package: Optional[PackageName], manifest: \"Manifest\"):\n 117 | unique_id = self.get_unique_id(key, package)\n 118 | if unique_id is not None:\n 119 | return self.perform_lookup(unique_id, manifest)\n 120 | return None\n 121 | \n 122 | def add_doc(self, doc: Documentation):\n 123 | if doc.name not in self.storage:\n 124 | self.storage[doc.name] = {}\n 125 | self.storage[doc.name][doc.package_name] = doc.unique_id\n 126 | \n 127 | def populate(self, manifest):\n 128 | for doc in manifest.docs.values():\n 129 | self.add_doc(doc)\n 130 | \n 131 | def perform_lookup(self, unique_id: UniqueID, manifest) -> Documentation:\n 132 | if unique_id not in manifest.docs:\n 133 | raise dbt_common.exceptions.DbtInternalError(\n 134 | f\"Doc {unique_id} found in cache but not found in manifest\"\n 135 | )\n 136 | return manifest.docs[unique_id]\n 137 | \n 138 | \n 139 | class SourceLookup(dbtClassMixin):\n 140 | def __init__(self, manifest: \"Manifest\") -> None:\n 141 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 142 | self.populate(manifest)\n 143 | \n 144 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 145 | return find_unique_id_for_package(self.storage, search_name, package)\n 146 | \n 147 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 148 | unique_id = self.get_unique_id(search_name, package)\n 149 | if unique_id is not None:\n 150 | return self.perform_lookup(unique_id, manifest)\n 151 | return None\n 152 | \n 153 | def add_source(self, source: SourceDefinition):\n 154 | if source.search_name not in self.storage:\n 155 | self.storage[source.search_name] = {}\n 156 | \n 157 | self.storage[source.search_name][source.package_name] = source.unique_id\n 158 | \n 159 | def populate(self, manifest):\n 160 | for source in manifest.sources.values():\n 161 | if hasattr(source, \"source_name\"):\n 162 | self.add_source(source)\n 163 | \n 164 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SourceDefinition:\n 165 | if unique_id not in manifest.sources:\n 166 | raise dbt_common.exceptions.DbtInternalError(\n 167 | f\"Source {unique_id} found in cache but not found in manifest\"\n 168 | )\n 169 | return manifest.sources[unique_id]\n 170 | \n 171 | \n 172 | class RefableLookup(dbtClassMixin):\n 173 | # model, seed, snapshot\n 174 | _lookup_types: ClassVar[set] = set(NodeType.refable())\n 175 | _versioned_types: ClassVar[set] = set(NodeType.versioned())\n 176 | \n 177 | def __init__(self, manifest: \"Manifest\") -> None:\n 178 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 179 | self.populate(manifest)\n 180 | \n 181 | def get_unique_id(\n 182 | self,\n 183 | key: str,\n 184 | package: Optional[PackageName],\n 185 | version: Optional[NodeVersion],\n 186 | node: Optional[GraphMemberNode] = None,\n 187 | ):\n 188 | if version:\n 189 | key = f\"{key}.v{version}\"\n 190 | \n 191 | unique_ids = self._find_unique_ids_for_package(key, package)\n 192 | if len(unique_ids) > 1:\n 193 | raise AmbiguousResourceNameRefError(key, unique_ids, node)\n 194 | else:\n 195 | return unique_ids[0] if unique_ids else None\n 196 | \n 197 | def find(\n 198 | self,\n 199 | key: str,\n 200 | package: Optional[PackageName],\n 201 | version: Optional[NodeVersion],\n 202 | manifest: \"Manifest\",\n 203 | source_node: Optional[GraphMemberNode] = None,\n 204 | ):\n 205 | unique_id = self.get_unique_id(key, package, version, source_node)\n 206 | if unique_id is not None:\n 207 | node = self.perform_lookup(unique_id, manifest)\n 208 | # If this is an unpinned ref (no 'version' arg was passed),\n 209 | # AND this is a versioned node,\n 210 | # AND this ref is being resolved at runtime -- get_node_info != {}\n 211 | # Only ModelNodes can be versioned.\n 212 | if (\n 213 | isinstance(node, ModelNode)\n 214 | and version is None\n 215 | and node.is_versioned\n 216 | and get_node_info()\n 217 | ):\n 218 | # Check to see if newer versions are available, and log an \"FYI\" if so\n 219 | max_version: UnparsedVersion = max(\n 220 | [\n 221 | UnparsedVersion(v.version)\n 222 | for v in manifest.nodes.values()\n 223 | if isinstance(v, ModelNode)\n 224 | and v.name == node.name\n 225 | and v.version is not None\n 226 | ]\n 227 | )\n 228 | assert node.latest_version is not None # for mypy, whenever i may find it\n 229 | if max_version > UnparsedVersion(node.latest_version):\n 230 | fire_event(\n 231 | UnpinnedRefNewVersionAvailable(\n 232 | node_info=get_node_info(),\n 233 | ref_node_name=node.name,\n 234 | ref_node_package=node.package_name,\n 235 | ref_node_version=str(node.version),\n 236 | ref_max_version=str(max_version.v),\n 237 | )\n 238 | )\n 239 | \n 240 | return node\n 241 | return None\n 242 | \n 243 | def add_node(self, node: ManifestNode):\n 244 | if node.resource_type in self._lookup_types:\n 245 | if node.name not in self.storage:\n 246 | self.storage[node.name] = {}\n 247 | \n 248 | if node.is_versioned:\n 249 | if node.search_name not in self.storage:\n 250 | self.storage[node.search_name] = {}\n 251 | self.storage[node.search_name][node.package_name] = node.unique_id\n 252 | if node.is_latest_version: # type: ignore\n 253 | self.storage[node.name][node.package_name] = node.unique_id\n 254 | else:\n 255 | self.storage[node.name][node.package_name] = node.unique_id\n 256 | \n 257 | def populate(self, manifest):\n 258 | for node in manifest.nodes.values():\n 259 | self.add_node(node)\n 260 | \n 261 | def perform_lookup(self, unique_id: UniqueID, manifest) -> ManifestNode:\n 262 | if unique_id in manifest.nodes:\n 263 | node = manifest.nodes[unique_id]\n 264 | else:\n 265 | raise dbt_common.exceptions.DbtInternalError(\n 266 | f\"Node {unique_id} found in cache but not found in manifest\"\n 267 | )\n 268 | return node\n 269 | \n 270 | def _find_unique_ids_for_package(self, key, package: Optional[PackageName]) -> List[str]:\n 271 | if key not in self.storage:\n 272 | return []\n 273 | \n 274 | pkg_dct: Mapping[PackageName, UniqueID] = self.storage[key]\n 275 | \n 276 | if package is None:\n 277 | if not pkg_dct:\n 278 | return []\n 279 | else:\n 280 | return list(pkg_dct.values())\n 281 | elif package in pkg_dct:\n 282 | return [pkg_dct[package]]\n 283 | else:\n 284 | return []\n 285 | \n 286 | \n 287 | class MetricLookup(dbtClassMixin):\n 288 | def __init__(self, manifest: \"Manifest\") -> None:\n 289 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 290 | self.populate(manifest)\n 291 | \n 292 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 293 | return find_unique_id_for_package(self.storage, search_name, package)\n 294 | \n 295 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 296 | unique_id = self.get_unique_id(search_name, package)\n 297 | if unique_id is not None:\n 298 | return self.perform_lookup(unique_id, manifest)\n 299 | return None\n 300 | \n 301 | def add_metric(self, metric: Metric):\n 302 | if metric.search_name not in self.storage:\n 303 | self.storage[metric.search_name] = {}\n 304 | \n 305 | self.storage[metric.search_name][metric.package_name] = metric.unique_id\n 306 | \n 307 | def populate(self, manifest):\n 308 | for metric in manifest.metrics.values():\n 309 | if hasattr(metric, \"name\"):\n 310 | self.add_metric(metric)\n 311 | \n 312 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> Metric:\n 313 | if unique_id not in manifest.metrics:\n 314 | raise dbt_common.exceptions.DbtInternalError(\n 315 | f\"Metric {unique_id} found in cache but not found in manifest\"\n 316 | )\n 317 | return manifest.metrics[unique_id]\n 318 | \n 319 | \n 320 | class SavedQueryLookup(dbtClassMixin):\n 321 | \"\"\"Lookup utility for finding SavedQuery nodes\"\"\"\n 322 | \n 323 | def __init__(self, manifest: \"Manifest\") -> None:\n 324 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 325 | self.populate(manifest)\n 326 | \n 327 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 328 | return find_unique_id_for_package(self.storage, search_name, package)\n 329 | \n 330 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 331 | unique_id = self.get_unique_id(search_name, package)\n 332 | if unique_id is not None:\n 333 | return self.perform_lookup(unique_id, manifest)\n 334 | return None\n 335 | \n 336 | def add_saved_query(self, saved_query: SavedQuery):\n 337 | if saved_query.search_name not in self.storage:\n 338 | self.storage[saved_query.search_name] = {}\n 339 | \n 340 | self.storage[saved_query.search_name][saved_query.package_name] = saved_query.unique_id\n 341 | \n 342 | def populate(self, manifest):\n 343 | for saved_query in manifest.saved_queries.values():\n 344 | if hasattr(saved_query, \"name\"):\n 345 | self.add_saved_query(saved_query)\n 346 | \n 347 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SavedQuery:\n 348 | if unique_id not in manifest.saved_queries:\n 349 | raise dbt_common.exceptions.DbtInternalError(\n 350 | f\"SavedQUery {unique_id} found in cache but not found in manifest\"\n 351 | )\n 352 | return manifest.saved_queries[unique_id]\n 353 | \n 354 | \n 355 | class SemanticModelByMeasureLookup(dbtClassMixin):\n 356 | \"\"\"Lookup utility for finding SemanticModel by measure\n 357 | \n 358 | This is possible because measure names are supposed to be unique across\n 359 | the semantic models in a manifest.\n 360 | \"\"\"\n 361 | \n 362 | def __init__(self, manifest: \"Manifest\") -> None:\n 363 | self.storage: DefaultDict[str, Dict[PackageName, UniqueID]] = defaultdict(dict)\n 364 | self.populate(manifest)\n 365 | \n 366 | def get_unique_id(self, search_name: str, package: Optional[PackageName]):\n 367 | return find_unique_id_for_package(self.storage, search_name, package)\n 368 | \n 369 | def find(\n 370 | self, search_name: str, package: Optional[PackageName], manifest: \"Manifest\"\n 371 | ) -> Optional[SemanticModel]:\n 372 | \"\"\"Tries to find a SemanticModel based on a measure name\"\"\"\n 373 | unique_id = self.get_unique_id(search_name, package)\n 374 | if unique_id is not None:\n 375 | return self.perform_lookup(unique_id, manifest)\n 376 | return None\n 377 | \n 378 | def add(self, semantic_model: SemanticModel):\n 379 | \"\"\"Sets all measures for a SemanticModel as paths to the SemanticModel's `unique_id`\"\"\"\n 380 | for measure in semantic_model.measures:\n 381 | self.storage[measure.name][semantic_model.package_name] = semantic_model.unique_id\n 382 | \n 383 | def populate(self, manifest: \"Manifest\"):\n 384 | \"\"\"Populate storage with all the measure + package paths to the Manifest's SemanticModels\"\"\"\n 385 | for semantic_model in manifest.semantic_models.values():\n 386 | self.add(semantic_model=semantic_model)\n 387 | for disabled in manifest.disabled.values():\n 388 | for node in disabled:\n 389 | if isinstance(node, SemanticModel):\n 390 | self.add(semantic_model=node)\n 391 | \n 392 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SemanticModel:\n 393 | \"\"\"Tries to get a SemanticModel from the Manifest\"\"\"\n 394 | enabled_semantic_model: Optional[SemanticModel] = manifest.semantic_models.get(unique_id)\n 395 | disabled_semantic_model: Optional[List] = manifest.disabled.get(unique_id)\n 396 | \n 397 | if isinstance(enabled_semantic_model, SemanticModel):\n 398 | return enabled_semantic_model\n 399 | elif disabled_semantic_model is not None and isinstance(\n 400 | disabled_semantic_model[0], SemanticModel\n 401 | ):\n 402 | return disabled_semantic_model[0]\n 403 | else:\n 404 | raise dbt_common.exceptions.DbtInternalError(\n 405 | f\"Semantic model `{unique_id}` found in cache but not found in manifest\"\n 406 | )\n 407 | \n 408 | \n 409 | # This handles both models/seeds/snapshots and sources/metrics/exposures/semantic_models\n 410 | class DisabledLookup(dbtClassMixin):\n 411 | def __init__(self, manifest: \"Manifest\") -> None:\n 412 | self.storage: Dict[str, Dict[PackageName, List[Any]]] = {}\n 413 | self.populate(manifest)\n 414 | \n 415 | def populate(self, manifest):\n 416 | for node in list(chain.from_iterable(manifest.disabled.values())):\n 417 | self.add_node(node)\n 418 | \n 419 | def add_node(self, node):\n 420 | if node.search_name not in self.storage:\n 421 | self.storage[node.search_name] = {}\n 422 | if node.package_name not in self.storage[node.search_name]:\n 423 | self.storage[node.search_name][node.package_name] = []\n 424 | self.storage[node.search_name][node.package_name].append(node)\n 425 | \n 426 | # This should return a list of disabled nodes. It's different from\n 427 | # the other Lookup functions in that it returns full nodes, not just unique_ids\n 428 | def find(\n 429 | self, search_name, package: Optional[PackageName], version: Optional[NodeVersion] = None\n 430 | ):\n 431 | if version:\n 432 | search_name = f\"{search_name}.v{version}\"\n 433 | \n 434 | if search_name not in self.storage:\n 435 | return None\n 436 | \n 437 | pkg_dct: Mapping[PackageName, List[Any]] = self.storage[search_name]\n 438 | \n 439 | if package is None:\n 440 | if not pkg_dct:\n 441 | return None\n 442 | else:\n 443 | return next(iter(pkg_dct.values()))\n 444 | elif package in pkg_dct:\n 445 | return pkg_dct[package]\n 446 | else:\n 447 | return None\n 448 | \n 449 | \n 450 | class AnalysisLookup(RefableLookup):\n 451 | _lookup_types: ClassVar[set] = set([NodeType.Analysis])\n 452 | _versioned_types: ClassVar[set] = set()\n 453 | \n 454 | \n 455 | def _packages_to_search(\n 456 | current_project: str,\n 457 | node_package: str,\n 458 | target_package: Optional[str] = None,\n 459 | ) -> List[Optional[str]]:\n 460 | if target_package is not None:\n 461 | return [target_package]\n 462 | elif current_project == node_package:\n 463 | return [current_project, None]\n 464 | else:\n 465 | return [current_project, node_package, None]\n 466 | \n 467 | \n 468 | @dataclass\n 469 | class ManifestMetadata(BaseArtifactMetadata):\n 470 | \"\"\"Metadata for the manifest.\"\"\"\n 471 | \n 472 | dbt_schema_version: str = field(\n 473 | default_factory=lambda: str(WritableManifest.dbt_schema_version)\n 474 | )\n 475 | project_name: Optional[str] = field(\n 476 | default=None,\n 477 | metadata={\n 478 | \"description\": \"Name of the root project\",\n 479 | },\n 480 | )\n 481 | project_id: Optional[str] = field(\n 482 | default=None,\n 483 | metadata={\n 484 | \"description\": \"A unique identifier for the project, hashed from the project name\",\n 485 | },\n 486 | )\n 487 | user_id: Optional[UUID] = field(\n 488 | default=None,\n 489 | metadata={\n 490 | \"description\": \"A unique identifier for the user\",\n 491 | },\n 492 | )\n 493 | send_anonymous_usage_stats: Optional[bool] = field(\n 494 | default=None,\n 495 | metadata=dict(\n 496 | description=(\"Whether dbt is configured to send anonymous usage statistics\")\n 497 | ),\n 498 | )\n 499 | adapter_type: Optional[str] = field(\n 500 | default=None,\n 501 | metadata=dict(description=\"The type name of the adapter\"),\n 502 | )\n 503 | \n 504 | def __post_init__(self):\n 505 | if tracking.active_user is None:\n 506 | return\n 507 | \n 508 | if self.user_id is None:\n 509 | self.user_id = tracking.active_user.id\n 510 | \n 511 | if self.send_anonymous_usage_stats is None:\n 512 | self.send_anonymous_usage_stats = get_flags().SEND_ANONYMOUS_USAGE_STATS\n 513 | \n 514 | @classmethod\n 515 | def default(cls):\n 516 | return cls(\n 517 | dbt_schema_version=str(WritableManifest.dbt_schema_version),\n 518 | )\n 519 | \n 520 | \n 521 | def _sort_values(dct):\n 522 | \"\"\"Given a dictionary, sort each value. This makes output deterministic,\n 523 | which helps for tests.\n 524 | \"\"\"\n 525 | return {k: sorted(v) for k, v in dct.items()}\n 526 | \n 527 | \n 528 | def build_node_edges(nodes: List[ManifestNode]):\n 529 | \"\"\"Build the forward and backward edges on the given list of ManifestNodes\n 530 | and return them as two separate dictionaries, each mapping unique IDs to\n 531 | lists of edges.\n 532 | \"\"\"\n 533 | backward_edges: Dict[str, List[str]] = {}\n 534 | # pre-populate the forward edge dict for simplicity\n 535 | forward_edges: Dict[str, List[str]] = {n.unique_id: [] for n in nodes}\n 536 | for node in nodes:\n 537 | backward_edges[node.unique_id] = node.depends_on_nodes[:]\n 538 | for unique_id in backward_edges[node.unique_id]:\n 539 | if unique_id in forward_edges.keys():\n 540 | forward_edges[unique_id].append(node.unique_id)\n 541 | return _sort_values(forward_edges), _sort_values(backward_edges)\n 542 | \n 543 | \n 544 | # Build a map of children of macros and generic tests\n 545 | def build_macro_edges(nodes: List[Any]):\n 546 | forward_edges: Dict[str, List[str]] = {\n 547 | n.unique_id: [] for n in nodes if n.unique_id.startswith(\"macro\") or n.depends_on_macros\n 548 | }\n 549 | for node in nodes:\n 550 | for unique_id in node.depends_on_macros:\n 551 | if unique_id in forward_edges.keys():\n 552 | forward_edges[unique_id].append(node.unique_id)\n 553 | return _sort_values(forward_edges)\n 554 | \n 555 | \n 556 | def _deepcopy(value):\n 557 | return value.from_dict(value.to_dict(omit_none=True))\n 558 | \n 559 | \n 560 | class Locality(enum.IntEnum):\n 561 | Core = 1\n 562 | Imported = 2\n 563 | Root = 3\n 564 | \n 565 | \n 566 | @dataclass\n 567 | class MacroCandidate:\n 568 | locality: Locality\n 569 | macro: Macro\n 570 | \n 571 | def __eq__(self, other: object) -> bool:\n 572 | if not isinstance(other, MacroCandidate):\n 573 | return NotImplemented\n 574 | return self.locality == other.locality\n 575 | \n 576 | def __lt__(self, other: object) -> bool:\n 577 | if not isinstance(other, MacroCandidate):\n 578 | return NotImplemented\n 579 | if self.locality < other.locality:\n 580 | return True\n 581 | if self.locality > other.locality:\n 582 | return False\n 583 | return False\n 584 | \n 585 | \n 586 | @dataclass\n 587 | class MaterializationCandidate(MacroCandidate):\n 588 | # specificity describes where in the inheritance chain this materialization candidate is\n 589 | # a specificity of 0 means a materialization defined by the current adapter\n 590 | # the highest the specificity describes a default materialization. the value itself depends on\n 591 | # how many adapters there are in the inheritance chain\n 592 | specificity: int\n 593 | \n 594 | @classmethod\n 595 | def from_macro(cls, candidate: MacroCandidate, specificity: int) -> \"MaterializationCandidate\":\n 596 | return cls(\n 597 | locality=candidate.locality,\n 598 | macro=candidate.macro,\n 599 | specificity=specificity,\n 600 | )\n 601 | \n 602 | def __eq__(self, other: object) -> bool:\n 603 | if not isinstance(other, MaterializationCandidate):\n 604 | return NotImplemented\n 605 | equal = self.specificity == other.specificity and self.locality == other.locality\n 606 | if equal:\n 607 | raise DuplicateMaterializationNameError(self.macro, other)\n 608 | \n 609 | return equal\n 610 | \n 611 | def __lt__(self, other: object) -> bool:\n 612 | if not isinstance(other, MaterializationCandidate):\n 613 | return NotImplemented\n 614 | if self.specificity > other.specificity:\n 615 | return True\n 616 | if self.specificity < other.specificity:\n 617 | return False\n 618 | if self.locality < other.locality:\n 619 | return True\n 620 | if self.locality > other.locality:\n 621 | return False\n 622 | return False\n 623 | \n 624 | \n 625 | M = TypeVar(\"M\", bound=MacroCandidate)\n 626 | \n 627 | \n 628 | class CandidateList(List[M]):\n 629 | def last(self) -> Optional[Macro]:\n 630 | if not self:\n 631 | return None\n 632 | self.sort()\n 633 | return self[-1].macro\n 634 | \n 635 | \n 636 | def _get_locality(macro: Macro, root_project_name: str, internal_packages: Set[str]) -> Locality:\n 637 | if macro.package_name == root_project_name:\n 638 | return Locality.Root\n 639 | elif macro.package_name in internal_packages:\n 640 | return Locality.Core\n 641 | else:\n 642 | return Locality.Imported\n 643 | \n 644 | \n 645 | class Searchable(Protocol):\n 646 | resource_type: NodeType\n 647 | package_name: str\n 648 | \n 649 | @property\n 650 | def search_name(self) -> str:\n 651 | raise NotImplementedError(\"search_name not implemented\")\n 652 | \n 653 | \n 654 | D = TypeVar(\"D\")\n 655 | \n 656 | \n 657 | @dataclass\n 658 | class Disabled(Generic[D]):\n 659 | target: D\n 660 | \n 661 | \n 662 | MaybeMetricNode = Optional[Union[Metric, Disabled[Metric]]]\n 663 | \n 664 | \n 665 | MaybeSavedQueryNode = Optional[Union[SavedQuery, Disabled[SavedQuery]]]\n 666 | \n 667 | \n 668 | MaybeDocumentation = Optional[Documentation]\n 669 | \n 670 | \n 671 | MaybeParsedSource = Optional[\n 672 | Union[\n 673 | SourceDefinition,\n 674 | Disabled[SourceDefinition],\n 675 | ]\n 676 | ]\n 677 | \n 678 | \n 679 | MaybeNonSource = Optional[Union[ManifestNode, Disabled[ManifestNode]]]\n 680 | \n 681 | \n 682 | T = TypeVar(\"T\", bound=GraphMemberNode)\n 683 | \n 684 | \n 685 | # This contains macro methods that are in both the Manifest\n 686 | # and the MacroManifest\n 687 | class MacroMethods:\n 688 | # Just to make mypy happy. There must be a better way.\n 689 | def __init__(self):\n 690 | self.macros = []\n 691 | self.metadata = {}\n 692 | \n 693 | def find_macro_by_name(\n 694 | self, name: str, root_project_name: str, package: Optional[str]\n 695 | ) -> Optional[Macro]:\n 696 | \"\"\"Find a macro in the graph by its name and package name, or None for\n 697 | any package. The root project name is used to determine priority:\n 698 | - locally defined macros come first\n 699 | - then imported macros\n 700 | - then macros defined in the root project\n 701 | \"\"\"\n 702 | filter: Optional[Callable[[MacroCandidate], bool]] = None\n 703 | if package is not None:\n 704 | \n 705 | def filter(candidate: MacroCandidate) -> bool:\n 706 | return package == candidate.macro.package_name\n 707 | \n 708 | candidates: CandidateList = self._find_macros_by_name(\n 709 | name=name,\n 710 | root_project_name=root_project_name,\n 711 | filter=filter,\n 712 | )\n 713 | \n 714 | return candidates.last()\n 715 | \n 716 | def find_generate_macro_by_name(\n 717 | self, component: str, root_project_name: str, imported_package: Optional[str] = None\n 718 | ) -> Optional[Macro]:\n 719 | \"\"\"\n 720 | The default `generate_X_name` macros are similar to regular ones, but only\n 721 | includes imported packages when searching for a package.\n 722 | - if package is not provided:\n 723 | - if there is a `generate_{component}_name` macro in the root\n 724 | project, return it\n 725 | - return the `generate_{component}_name` macro from the 'dbt'\n 726 | internal project\n 727 | - if package is provided\n 728 | - return the `generate_{component}_name` macro from the imported\n 729 | package, if one exists\n 730 | \"\"\"\n 731 | \n 732 | def filter(candidate: MacroCandidate) -> bool:\n 733 | if imported_package:\n 734 | return (\n 735 | candidate.locality == Locality.Imported\n 736 | and imported_package == candidate.macro.package_name\n 737 | )\n 738 | else:\n 739 | return candidate.locality != Locality.Imported\n 740 | \n 741 | candidates: CandidateList = self._find_macros_by_name(\n 742 | name=f\"generate_{component}_name\",\n 743 | root_project_name=root_project_name,\n 744 | filter=filter,\n 745 | )\n 746 | \n 747 | return candidates.last()\n 748 | \n 749 | def _find_macros_by_name(\n 750 | self,\n 751 | name: str,\n 752 | root_project_name: str,\n 753 | filter: Optional[Callable[[MacroCandidate], bool]] = None,\n 754 | ) -> CandidateList:\n 755 | \"\"\"Find macros by their name.\"\"\"\n 756 | # avoid an import cycle\n 757 | from dbt.adapters.factory import get_adapter_package_names\n 758 | \n 759 | candidates: CandidateList = CandidateList()\n 760 | packages = set(get_adapter_package_names(self.metadata.adapter_type))\n 761 | for unique_id, macro in self.macros.items():\n 762 | if macro.name != name:\n 763 | continue\n 764 | candidate = MacroCandidate(\n 765 | locality=_get_locality(macro, root_project_name, packages),\n 766 | macro=macro,\n 767 | )\n 768 | if filter is None or filter(candidate):\n 769 | candidates.append(candidate)\n 770 | \n 771 | return candidates\n 772 | \n 773 | \n 774 | @dataclass\n 775 | class ParsingInfo:\n 776 | static_analysis_parsed_path_count: int = 0\n 777 | static_analysis_path_count: int = 0\n 778 | \n 779 | \n 780 | @dataclass\n 781 | class ManifestStateCheck(dbtClassMixin):\n 782 | vars_hash: FileHash = field(default_factory=FileHash.empty)\n 783 | project_env_vars_hash: FileHash = field(default_factory=FileHash.empty)\n 784 | profile_env_vars_hash: FileHash = field(default_factory=FileHash.empty)\n 785 | profile_hash: FileHash = field(default_factory=FileHash.empty)\n 786 | project_hashes: MutableMapping[str, FileHash] = field(default_factory=dict)\n 787 | \n 788 | \n 789 | @dataclass\n 790 | class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):\n 791 | \"\"\"The manifest for the full graph, after parsing and during compilation.\"\"\"\n 792 | \n 793 | # These attributes are both positional and by keyword. If an attribute\n 794 | # is added it must all be added in the __reduce_ex__ method in the\n 795 | # args tuple in the right position.\n 796 | nodes: MutableMapping[str, ManifestNode] = field(default_factory=dict)\n 797 | sources: MutableMapping[str, SourceDefinition] = field(default_factory=dict)\n 798 | macros: MutableMapping[str, Macro] = field(default_factory=dict)\n 799 | docs: MutableMapping[str, Documentation] = field(default_factory=dict)\n 800 | exposures: MutableMapping[str, Exposure] = field(default_factory=dict)\n 801 | metrics: MutableMapping[str, Metric] = field(default_factory=dict)\n 802 | groups: MutableMapping[str, Group] = field(default_factory=dict)\n 803 | selectors: MutableMapping[str, Any] = field(default_factory=dict)\n 804 | files: MutableMapping[str, AnySourceFile] = field(default_factory=dict)\n 805 | metadata: ManifestMetadata = field(default_factory=ManifestMetadata)\n 806 | flat_graph: Dict[str, Any] = field(default_factory=dict)\n 807 | state_check: ManifestStateCheck = field(default_factory=ManifestStateCheck)\n 808 | source_patches: MutableMapping[SourceKey, SourcePatch] = field(default_factory=dict)\n 809 | disabled: MutableMapping[str, List[GraphMemberNode]] = field(default_factory=dict)\n 810 | env_vars: MutableMapping[str, str] = field(default_factory=dict)\n 811 | semantic_models: MutableMapping[str, SemanticModel] = field(default_factory=dict)\n 812 | unit_tests: MutableMapping[str, UnitTestDefinition] = field(default_factory=dict)\n 813 | saved_queries: MutableMapping[str, SavedQuery] = field(default_factory=dict)\n 814 | fixtures: MutableMapping[str, UnitTestFileFixture] = field(default_factory=dict)\n 815 | \n 816 | _doc_lookup: Optional[DocLookup] = field(\n 817 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 818 | )\n 819 | _source_lookup: Optional[SourceLookup] = field(\n 820 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 821 | )\n 822 | _ref_lookup: Optional[RefableLookup] = field(\n 823 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 824 | )\n 825 | _metric_lookup: Optional[MetricLookup] = field(\n 826 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 827 | )\n 828 | _saved_query_lookup: Optional[SavedQueryLookup] = field(\n 829 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 830 | )\n 831 | _semantic_model_by_measure_lookup: Optional[SemanticModelByMeasureLookup] = field(\n 832 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 833 | )\n 834 | _disabled_lookup: Optional[DisabledLookup] = field(\n 835 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 836 | )\n 837 | _analysis_lookup: Optional[AnalysisLookup] = field(\n 838 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 839 | )\n 840 | _parsing_info: ParsingInfo = field(\n 841 | default_factory=ParsingInfo,\n 842 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 843 | )\n 844 | _lock: Lock = field(\n 845 | default_factory=get_mp_context().Lock,\n 846 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 847 | )\n 848 | \n 849 | def __pre_serialize__(self):\n 850 | # serialization won't work with anything except an empty source_patches because\n 851 | # tuple keys are not supported, so ensure it's empty\n 852 | self.source_patches = {}\n 853 | return self\n 854 | \n 855 | @classmethod\n 856 | def __post_deserialize__(cls, obj):\n 857 | obj._lock = get_mp_context().Lock()\n 858 | return obj\n 859 | \n 860 | def build_flat_graph(self):\n 861 | \"\"\"This attribute is used in context.common by each node, so we want to\n 862 | only build it once and avoid any concurrency issues around it.\n 863 | Make sure you don't call this until you're done with building your\n 864 | manifest!\n 865 | \"\"\"\n 866 | self.flat_graph = {\n 867 | \"exposures\": {k: v.to_dict(omit_none=False) for k, v in self.exposures.items()},\n 868 | \"groups\": {k: v.to_dict(omit_none=False) for k, v in self.groups.items()},\n 869 | \"metrics\": {k: v.to_dict(omit_none=False) for k, v in self.metrics.items()},\n 870 | \"nodes\": {k: v.to_dict(omit_none=False) for k, v in self.nodes.items()},\n 871 | \"sources\": {k: v.to_dict(omit_none=False) for k, v in self.sources.items()},\n 872 | \"semantic_models\": {\n 873 | k: v.to_dict(omit_none=False) for k, v in self.semantic_models.items()\n 874 | },\n 875 | \"saved_queries\": {\n 876 | k: v.to_dict(omit_none=False) for k, v in self.saved_queries.items()\n 877 | },\n 878 | }\n 879 | \n 880 | def build_disabled_by_file_id(self):\n 881 | disabled_by_file_id = {}\n 882 | for node_list in self.disabled.values():\n 883 | for node in node_list:\n 884 | disabled_by_file_id[node.file_id] = node\n 885 | return disabled_by_file_id\n 886 | \n 887 | def _get_parent_adapter_types(self, adapter_type: str) -> List[str]:\n 888 | # This is duplicated logic from core/dbt/context/providers.py\n 889 | # Ideally this would instead be incorporating actual dispatch logic\n 890 | from dbt.adapters.factory import get_adapter_type_names\n 891 | \n 892 | # order matters for dispatch:\n 893 | # 1. current adapter\n 894 | # 2. any parent adapters (dependencies)\n 895 | # 3. 'default'\n 896 | return get_adapter_type_names(adapter_type) + [\"default\"]\n 897 | \n 898 | def _materialization_candidates_for(\n 899 | self,\n 900 | project_name: str,\n 901 | materialization_name: str,\n 902 | adapter_type: str,\n 903 | specificity: int,\n 904 | ) -> CandidateList:\n 905 | full_name = dbt_common.utils.get_materialization_macro_name(\n 906 | materialization_name=materialization_name,\n 907 | adapter_type=adapter_type,\n 908 | with_prefix=False,\n 909 | )\n 910 | return CandidateList(\n 911 | MaterializationCandidate.from_macro(m, specificity)\n 912 | for m in self._find_macros_by_name(full_name, project_name)\n 913 | )\n 914 | \n 915 | def find_materialization_macro_by_name(\n 916 | self, project_name: str, materialization_name: str, adapter_type: str\n 917 | ) -> Optional[Macro]:\n 918 | candidates: CandidateList = CandidateList(\n 919 | chain.from_iterable(\n 920 | self._materialization_candidates_for(\n 921 | project_name=project_name,\n 922 | materialization_name=materialization_name,\n 923 | adapter_type=atype,\n 924 | specificity=specificity, # where in the inheritance chain this candidate is\n 925 | )\n 926 | for specificity, atype in enumerate(self._get_parent_adapter_types(adapter_type))\n 927 | )\n 928 | )\n 929 | return candidates.last()\n 930 | \n 931 | def get_resource_fqns(self) -> Mapping[str, PathSet]:\n 932 | resource_fqns: Dict[str, Set[Tuple[str, ...]]] = {}\n 933 | all_resources = chain(\n 934 | self.exposures.values(),\n 935 | self.nodes.values(),\n 936 | self.sources.values(),\n 937 | self.metrics.values(),\n 938 | self.semantic_models.values(),\n 939 | self.saved_queries.values(),\n 940 | )\n 941 | for resource in all_resources:\n 942 | resource_type_plural = resource.resource_type.pluralize()\n 943 | if resource_type_plural not in resource_fqns:\n 944 | resource_fqns[resource_type_plural] = set()\n 945 | resource_fqns[resource_type_plural].add(tuple(resource.fqn))\n 946 | return resource_fqns\n 947 | \n 948 | def get_used_schemas(self, resource_types=None):\n 949 | return frozenset(\n 950 | {\n 951 | (node.database, node.schema)\n 952 | for node in chain(self.nodes.values(), self.sources.values())\n 953 | if not resource_types or node.resource_type in resource_types\n 954 | }\n 955 | )\n 956 | \n 957 | def get_used_databases(self):\n 958 | return frozenset(x.database for x in chain(self.nodes.values(), self.sources.values()))\n 959 | \n 960 | def deepcopy(self):\n 961 | copy = Manifest(\n 962 | nodes={k: _deepcopy(v) for k, v in self.nodes.items()},\n 963 | sources={k: _deepcopy(v) for k, v in self.sources.items()},\n 964 | macros={k: _deepcopy(v) for k, v in self.macros.items()},\n 965 | docs={k: _deepcopy(v) for k, v in self.docs.items()},\n 966 | exposures={k: _deepcopy(v) for k, v in self.exposures.items()},\n 967 | metrics={k: _deepcopy(v) for k, v in self.metrics.items()},\n 968 | groups={k: _deepcopy(v) for k, v in self.groups.items()},\n 969 | selectors={k: _deepcopy(v) for k, v in self.selectors.items()},\n 970 | metadata=self.metadata,\n 971 | disabled={k: _deepcopy(v) for k, v in self.disabled.items()},\n 972 | files={k: _deepcopy(v) for k, v in self.files.items()},\n 973 | state_check=_deepcopy(self.state_check),\n 974 | semantic_models={k: _deepcopy(v) for k, v in self.semantic_models.items()},\n 975 | unit_tests={k: _deepcopy(v) for k, v in self.unit_tests.items()},\n 976 | saved_queries={k: _deepcopy(v) for k, v in self.saved_queries.items()},\n 977 | )\n 978 | copy.build_flat_graph()\n 979 | return copy\n 980 | \n 981 | def build_parent_and_child_maps(self):\n 982 | edge_members = list(\n 983 | chain(\n 984 | self.nodes.values(),\n 985 | self.sources.values(),\n 986 | self.exposures.values(),\n 987 | self.metrics.values(),\n 988 | self.semantic_models.values(),\n 989 | self.saved_queries.values(),\n 990 | )\n 991 | )\n 992 | forward_edges, backward_edges = build_node_edges(edge_members)\n 993 | self.child_map = forward_edges\n 994 | self.parent_map = backward_edges\n 995 | \n 996 | def build_macro_child_map(self):\n 997 | edge_members = list(\n 998 | chain(\n 999 | self.nodes.values(),\n1000 | self.macros.values(),\n1001 | )\n1002 | )\n1003 | forward_edges = build_macro_edges(edge_members)\n1004 | return forward_edges\n1005 | \n1006 | def build_group_map(self):\n1007 | groupable_nodes = list(\n1008 | chain(\n1009 | self.nodes.values(),\n1010 | self.saved_queries.values(),\n1011 | self.semantic_models.values(),\n1012 | self.metrics.values(),\n1013 | )\n1014 | )\n1015 | group_map = {group.name: [] for group in self.groups.values()}\n1016 | for node in groupable_nodes:\n1017 | if node.group is not None:\n1018 | # group updates are not included with state:modified and\n1019 | # by ignoring the groups that aren't in the group map we\n1020 | # can avoid hitting errors for groups that are not getting\n1021 | # updated. This is a hack but any groups that are not\n1022 | # valid will be caught in\n1023 | # parser.manifest.ManifestLoader.check_valid_group_config_node\n1024 | if node.group in group_map:\n1025 | group_map[node.group].append(node.unique_id)\n1026 | self.group_map = group_map\n1027 | \n1028 | def writable_manifest(self) -> \"WritableManifest\":\n1029 | self.build_parent_and_child_maps()\n1030 | self.build_group_map()\n1031 | return WritableManifest(\n1032 | nodes=self.nodes,\n1033 | sources=self.sources,\n1034 | macros=self.macros,\n1035 | docs=self.docs,\n1036 | exposures=self.exposures,\n1037 | metrics=self.metrics,\n1038 | groups=self.groups,\n1039 | selectors=self.selectors,\n1040 | metadata=self.metadata,\n1041 | disabled=self.disabled,\n1042 | child_map=self.child_map,\n1043 | parent_map=self.parent_map,\n1044 | group_map=self.group_map,\n1045 | semantic_models=self.semantic_models,\n1046 | unit_tests=self.unit_tests,\n1047 | saved_queries=self.saved_queries,\n1048 | )\n1049 | \n1050 | def write(self, path):\n1051 | self.writable_manifest().write(path)\n1052 | \n1053 | # Called in dbt.compilation.Linker.write_graph and\n1054 | # dbt.graph.queue.get and ._include_in_cost\n1055 | def expect(self, unique_id: str) -> GraphMemberNode:\n1056 | if unique_id in self.nodes:\n1057 | return self.nodes[unique_id]\n1058 | elif unique_id in self.sources:\n1059 | return self.sources[unique_id]\n1060 | elif unique_id in self.exposures:\n1061 | return self.exposures[unique_id]\n1062 | elif unique_id in self.metrics:\n1063 | return self.metrics[unique_id]\n1064 | elif unique_id in self.semantic_models:\n1065 | return self.semantic_models[unique_id]\n1066 | elif unique_id in self.unit_tests:\n1067 | return self.unit_tests[unique_id]\n1068 | elif unique_id in self.saved_queries:\n1069 | return self.saved_queries[unique_id]\n1070 | else:\n1071 | # something terrible has happened\n1072 | raise dbt_common.exceptions.DbtInternalError(\n1073 | \"Expected node {} not found in manifest\".format(unique_id)\n1074 | )\n1075 | \n1076 | @property\n1077 | def doc_lookup(self) -> DocLookup:\n1078 | if self._doc_lookup is None:\n1079 | self._doc_lookup = DocLookup(self)\n1080 | return self._doc_lookup\n1081 | \n1082 | def rebuild_doc_lookup(self):\n1083 | self._doc_lookup = DocLookup(self)\n1084 | \n1085 | @property\n1086 | def source_lookup(self) -> SourceLookup:\n1087 | if self._source_lookup is None:\n1088 | self._source_lookup = SourceLookup(self)\n1089 | return self._source_lookup\n1090 | \n1091 | def rebuild_source_lookup(self):\n1092 | self._source_lookup = SourceLookup(self)\n1093 | \n1094 | @property\n1095 | def ref_lookup(self) -> RefableLookup:\n1096 | if self._ref_lookup is None:\n1097 | self._ref_lookup = RefableLookup(self)\n1098 | return self._ref_lookup\n1099 | \n1100 | @property\n1101 | def metric_lookup(self) -> MetricLookup:\n1102 | if self._metric_lookup is None:\n1103 | self._metric_lookup = MetricLookup(self)\n1104 | return self._metric_lookup\n1105 | \n1106 | @property\n1107 | def saved_query_lookup(self) -> SavedQueryLookup:\n1108 | \"\"\"Retuns a SavedQueryLookup, instantiating it first if necessary.\"\"\"\n1109 | if self._saved_query_lookup is None:\n1110 | self._saved_query_lookup = SavedQueryLookup(self)\n1111 | return self._saved_query_lookup\n1112 | \n1113 | @property\n1114 | def semantic_model_by_measure_lookup(self) -> SemanticModelByMeasureLookup:\n1115 | \"\"\"Gets (and creates if necessary) the lookup utility for getting SemanticModels by measures\"\"\"\n1116 | if self._semantic_model_by_measure_lookup is None:\n1117 | self._semantic_model_by_measure_lookup = SemanticModelByMeasureLookup(self)\n1118 | return self._semantic_model_by_measure_lookup\n1119 | \n1120 | def rebuild_ref_lookup(self):\n1121 | self._ref_lookup = RefableLookup(self)\n1122 | \n1123 | @property\n1124 | def disabled_lookup(self) -> DisabledLookup:\n1125 | if self._disabled_lookup is None:\n1126 | self._disabled_lookup = DisabledLookup(self)\n1127 | return self._disabled_lookup\n1128 | \n1129 | def rebuild_disabled_lookup(self):\n1130 | self._disabled_lookup = DisabledLookup(self)\n1131 | \n1132 | @property\n1133 | def analysis_lookup(self) -> AnalysisLookup:\n1134 | if self._analysis_lookup is None:\n1135 | self._analysis_lookup = AnalysisLookup(self)\n1136 | return self._analysis_lookup\n1137 | \n1138 | @property\n1139 | def external_node_unique_ids(self):\n1140 | return [node.unique_id for node in self.nodes.values() if node.is_external_node]\n1141 | \n1142 | def resolve_refs(\n1143 | self,\n1144 | source_node: ModelNode,\n1145 | current_project: str, # TODO: ModelNode is overly restrictive typing\n1146 | ) -> List[MaybeNonSource]:\n1147 | resolved_refs: List[MaybeNonSource] = []\n1148 | for ref in source_node.refs:\n1149 | resolved = self.resolve_ref(\n1150 | source_node,\n1151 | ref.name,\n1152 | ref.package,\n1153 | ref.version,\n1154 | current_project,\n1155 | source_node.package_name,\n1156 | )\n1157 | resolved_refs.append(resolved)\n1158 | \n1159 | return resolved_refs\n1160 | \n1161 | # Called by dbt.parser.manifest._process_refs & ManifestLoader.check_for_model_deprecations\n1162 | def resolve_ref(\n1163 | self,\n1164 | source_node: GraphMemberNode,\n1165 | target_model_name: str,\n1166 | target_model_package: Optional[str],\n1167 | target_model_version: Optional[NodeVersion],\n1168 | current_project: str,\n1169 | node_package: str,\n1170 | ) -> MaybeNonSource:\n1171 | \n1172 | node: Optional[ManifestNode] = None\n1173 | disabled: Optional[List[ManifestNode]] = None\n1174 | \n1175 | candidates = _packages_to_search(current_project, node_package, target_model_package)\n1176 | for pkg in candidates:\n1177 | node = self.ref_lookup.find(\n1178 | target_model_name, pkg, target_model_version, self, source_node\n1179 | )\n1180 | \n1181 | if node is not None and hasattr(node, \"config\") and node.config.enabled:\n1182 | return node\n1183 | \n1184 | # it's possible that the node is disabled\n1185 | if disabled is None:\n1186 | disabled = self.disabled_lookup.find(target_model_name, pkg, target_model_version)\n1187 | \n1188 | if disabled:\n1189 | return Disabled(disabled[0])\n1190 | return None\n1191 | \n1192 | # Called by dbt.parser.manifest._resolve_sources_for_exposure\n1193 | # and dbt.parser.manifest._process_source_for_node\n1194 | def resolve_source(\n1195 | self,\n1196 | target_source_name: str,\n1197 | target_table_name: str,\n1198 | current_project: str,\n1199 | node_package: str,\n1200 | ) -> MaybeParsedSource:\n1201 | search_name = f\"{target_source_name}.{target_table_name}\"\n1202 | candidates = _packages_to_search(current_project, node_package)\n1203 | \n1204 | source: Optional[SourceDefinition] = None\n1205 | disabled: Optional[List[SourceDefinition]] = None\n1206 | \n1207 | for pkg in candidates:\n1208 | source = self.source_lookup.find(search_name, pkg, self)\n1209 | if source is not None and source.config.enabled:\n1210 | return source\n1211 | \n1212 | if disabled is None:\n1213 | disabled = self.disabled_lookup.find(\n1214 | f\"{target_source_name}.{target_table_name}\", pkg\n1215 | )\n1216 | \n1217 | if disabled:\n1218 | return Disabled(disabled[0])\n1219 | return None\n1220 | \n1221 | def resolve_metric(\n1222 | self,\n1223 | target_metric_name: str,\n1224 | target_metric_package: Optional[str],\n1225 | current_project: str,\n1226 | node_package: str,\n1227 | ) -> MaybeMetricNode:\n1228 | \n1229 | metric: Optional[Metric] = None\n1230 | disabled: Optional[List[Metric]] = None\n1231 | \n1232 | candidates = _packages_to_search(current_project, node_package, target_metric_package)\n1233 | for pkg in candidates:\n1234 | metric = self.metric_lookup.find(target_metric_name, pkg, self)\n1235 | \n1236 | if metric is not None and metric.config.enabled:\n1237 | return metric\n1238 | \n1239 | # it's possible that the node is disabled\n1240 | if disabled is None:\n1241 | disabled = self.disabled_lookup.find(f\"{target_metric_name}\", pkg)\n1242 | if disabled:\n1243 | return Disabled(disabled[0])\n1244 | return None\n1245 | \n1246 | def resolve_saved_query(\n1247 | self,\n1248 | target_saved_query_name: str,\n1249 | target_saved_query_package: Optional[str],\n1250 | current_project: str,\n1251 | node_package: str,\n1252 | ) -> MaybeSavedQueryNode:\n1253 | \"\"\"Tries to find the SavedQuery by name within the available project and packages.\n1254 | \n1255 | Will return the first enabled SavedQuery matching the name found while iterating over\n1256 | the scoped packages. If no enabled SavedQuery node match is found, returns the last\n1257 | disabled SavedQuery node. Otherwise it returns None.\n1258 | \"\"\"\n1259 | disabled: Optional[List[SavedQuery]] = None\n1260 | candidates = _packages_to_search(current_project, node_package, target_saved_query_package)\n1261 | for pkg in candidates:\n1262 | saved_query = self.saved_query_lookup.find(target_saved_query_name, pkg, self)\n1263 | \n1264 | if saved_query is not None and saved_query.config.enabled:\n1265 | return saved_query\n1266 | \n1267 | # it's possible that the node is disabled\n1268 | if disabled is None:\n1269 | disabled = self.disabled_lookup.find(f\"{target_saved_query_name}\", pkg)\n1270 | if disabled:\n1271 | return Disabled(disabled[0])\n1272 | \n1273 | return None\n1274 | \n1275 | def resolve_semantic_model_for_measure(\n1276 | self,\n1277 | target_measure_name: str,\n1278 | current_project: str,\n1279 | node_package: str,\n1280 | target_package: Optional[str] = None,\n1281 | ) -> Optional[SemanticModel]:\n1282 | \"\"\"Tries to find the SemanticModel that a measure belongs to\"\"\"\n1283 | candidates = _packages_to_search(current_project, node_package, target_package)\n1284 | \n1285 | for pkg in candidates:\n1286 | semantic_model = self.semantic_model_by_measure_lookup.find(\n1287 | target_measure_name, pkg, self\n1288 | )\n1289 | # need to return it even if it's disabled so know it's not fully missing\n1290 | if semantic_model is not None:\n1291 | return semantic_model\n1292 | \n1293 | return None\n1294 | \n1295 | # Called by DocsRuntimeContext.doc\n1296 | def resolve_doc(\n1297 | self,\n1298 | name: str,\n1299 | package: Optional[str],\n1300 | current_project: str,\n1301 | node_package: str,\n1302 | ) -> Optional[Documentation]:\n1303 | \"\"\"Resolve the given documentation. This follows the same algorithm as\n1304 | resolve_ref except the is_enabled checks are unnecessary as docs are\n1305 | always enabled.\n1306 | \"\"\"\n1307 | candidates = _packages_to_search(current_project, node_package, package)\n1308 | \n1309 | for pkg in candidates:\n1310 | result = self.doc_lookup.find(name, pkg, self)\n1311 | if result is not None:\n1312 | return result\n1313 | return None\n1314 | \n1315 | def is_invalid_private_ref(\n1316 | self, node: GraphMemberNode, target_model: MaybeNonSource, dependencies: Optional[Mapping]\n1317 | ) -> bool:\n1318 | dependencies = dependencies or {}\n1319 | if not isinstance(target_model, ModelNode):\n1320 | return False\n1321 | \n1322 | is_private_ref = (\n1323 | target_model.access == AccessType.Private\n1324 | # don't raise this reference error for ad hoc 'preview' queries\n1325 | and node.resource_type != NodeType.SqlOperation\n1326 | and node.resource_type != NodeType.RPCCall # TODO: rm\n1327 | )\n1328 | target_dependency = dependencies.get(target_model.package_name)\n1329 | restrict_package_access = target_dependency.restrict_access if target_dependency else False\n1330 | \n1331 | # TODO: SemanticModel and SourceDefinition do not have group, and so should not be able to make _any_ private ref.\n1332 | return is_private_ref and (\n1333 | not hasattr(node, \"group\")\n1334 | or not node.group\n1335 | or node.group != target_model.group\n1336 | or restrict_package_access\n1337 | )\n1338 | \n1339 | def is_invalid_protected_ref(\n1340 | self, node: GraphMemberNode, target_model: MaybeNonSource, dependencies: Optional[Mapping]\n1341 | ) -> bool:\n1342 | dependencies = dependencies or {}\n1343 | if not isinstance(target_model, ModelNode):\n1344 | return False\n1345 | \n1346 | is_protected_ref = (\n1347 | target_model.access == AccessType.Protected\n1348 | # don't raise this reference error for ad hoc 'preview' queries\n1349 | and node.resource_type != NodeType.SqlOperation\n1350 | and node.resource_type != NodeType.RPCCall # TODO: rm\n1351 | )\n1352 | target_dependency = dependencies.get(target_model.package_name)\n1353 | restrict_package_access = target_dependency.restrict_access if target_dependency else False\n1354 | \n1355 | return is_protected_ref and (\n1356 | node.package_name != target_model.package_name and restrict_package_access\n1357 | )\n1358 | \n1359 | # Called by GraphRunnableTask.defer_to_manifest\n1360 | def merge_from_artifact(\n1361 | self,\n1362 | adapter,\n1363 | other: \"WritableManifest\",\n1364 | selected: AbstractSet[UniqueID],\n1365 | favor_state: bool = False,\n1366 | ) -> None:\n1367 | \"\"\"Given the selected unique IDs and a writable manifest, update this\n1368 | manifest by replacing any unselected nodes with their counterpart.\n1369 | \n1370 | Only non-ephemeral refable nodes are examined.\n1371 | \"\"\"\n1372 | refables = set(NodeType.refable())\n1373 | merged = set()\n1374 | for unique_id, node in other.nodes.items():\n1375 | current = self.nodes.get(unique_id)\n1376 | if current and (\n1377 | node.resource_type in refables\n1378 | and not node.is_ephemeral\n1379 | and unique_id not in selected\n1380 | and (\n1381 | not adapter.get_relation(current.database, current.schema, current.identifier)\n1382 | or favor_state\n1383 | )\n1384 | ):\n1385 | merged.add(unique_id)\n1386 | self.nodes[unique_id] = node.replace(deferred=True)\n1387 | \n1388 | # for all other nodes, add 'defer_relation'\n1389 | elif current and node.resource_type in refables and not node.is_ephemeral:\n1390 | defer_relation = DeferRelation(\n1391 | node.database, node.schema, node.alias, node.relation_name\n1392 | )\n1393 | self.nodes[unique_id] = current.replace(defer_relation=defer_relation)\n1394 | \n1395 | # Rebuild the flat_graph, which powers the 'graph' context variable,\n1396 | # now that we've deferred some nodes\n1397 | self.build_flat_graph()\n1398 | \n1399 | # log up to 5 items\n1400 | sample = list(islice(merged, 5))\n1401 | fire_event(MergedFromState(num_merged=len(merged), sample=sample))\n1402 | \n1403 | # Methods that were formerly in ParseResult\n1404 | \n1405 | def add_macro(self, source_file: SourceFile, macro: Macro):\n1406 | if macro.unique_id in self.macros:\n1407 | # detect that the macro exists and emit an error\n1408 | raise DuplicateMacroInPackageError(macro=macro, macro_mapping=self.macros)\n1409 | \n1410 | self.macros[macro.unique_id] = macro\n1411 | source_file.macros.append(macro.unique_id)\n1412 | \n1413 | def has_file(self, source_file: SourceFile) -> bool:\n1414 | key = source_file.file_id\n1415 | if key is None:\n1416 | return False\n1417 | if key not in self.files:\n1418 | return False\n1419 | my_checksum = self.files[key].checksum\n1420 | return my_checksum == source_file.checksum\n1421 | \n1422 | def add_source(self, source_file: SchemaSourceFile, source: UnpatchedSourceDefinition):\n1423 | # sources can't be overwritten!\n1424 | _check_duplicates(source, self.sources)\n1425 | self.sources[source.unique_id] = source # type: ignore\n1426 | source_file.sources.append(source.unique_id)\n1427 | \n1428 | def add_node_nofile(self, node: ManifestNode):\n1429 | # nodes can't be overwritten!\n1430 | _check_duplicates(node, self.nodes)\n1431 | self.nodes[node.unique_id] = node\n1432 | \n1433 | def add_node(self, source_file: AnySourceFile, node: ManifestNode, test_from=None):\n1434 | self.add_node_nofile(node)\n1435 | if isinstance(source_file, SchemaSourceFile):\n1436 | if isinstance(node, GenericTestNode):\n1437 | assert test_from\n1438 | source_file.add_test(node.unique_id, test_from)\n1439 | if isinstance(node, Metric):\n1440 | source_file.metrics.append(node.unique_id)\n1441 | if isinstance(node, Exposure):\n1442 | source_file.exposures.append(node.unique_id)\n1443 | if isinstance(node, Group):\n1444 | source_file.groups.append(node.unique_id)\n1445 | elif isinstance(source_file, FixtureSourceFile):\n1446 | pass\n1447 | else:\n1448 | source_file.nodes.append(node.unique_id)\n1449 | \n1450 | def add_exposure(self, source_file: SchemaSourceFile, exposure: Exposure):\n1451 | _check_duplicates(exposure, self.exposures)\n1452 | self.exposures[exposure.unique_id] = exposure\n1453 | source_file.exposures.append(exposure.unique_id)\n1454 | \n1455 | def add_metric(self, source_file: SchemaSourceFile, metric: Metric, generated: bool = False):\n1456 | _check_duplicates(metric, self.metrics)\n1457 | self.metrics[metric.unique_id] = metric\n1458 | if not generated:\n1459 | source_file.metrics.append(metric.unique_id)\n1460 | else:\n1461 | source_file.generated_metrics.append(metric.unique_id)\n1462 | \n1463 | def add_group(self, source_file: SchemaSourceFile, group: Group):\n1464 | _check_duplicates(group, self.groups)\n1465 | self.groups[group.unique_id] = group\n1466 | source_file.groups.append(group.unique_id)\n1467 | \n1468 | def add_disabled_nofile(self, node: GraphMemberNode):\n1469 | # There can be multiple disabled nodes for the same unique_id\n1470 | if node.unique_id in self.disabled:\n1471 | self.disabled[node.unique_id].append(node)\n1472 | else:\n1473 | self.disabled[node.unique_id] = [node]\n1474 | \n1475 | def add_disabled(self, source_file: AnySourceFile, node: ResultNode, test_from=None):\n1476 | self.add_disabled_nofile(node)\n1477 | if isinstance(source_file, SchemaSourceFile):\n1478 | if isinstance(node, GenericTestNode):\n1479 | assert test_from\n1480 | source_file.add_test(node.unique_id, test_from)\n1481 | if isinstance(node, Metric):\n1482 | source_file.metrics.append(node.unique_id)\n1483 | if isinstance(node, SavedQuery):\n1484 | source_file.saved_queries.append(node.unique_id)\n1485 | if isinstance(node, SemanticModel):\n1486 | source_file.semantic_models.append(node.unique_id)\n1487 | if isinstance(node, Exposure):\n1488 | source_file.exposures.append(node.unique_id)\n1489 | elif isinstance(source_file, FixtureSourceFile):\n1490 | pass\n1491 | else:\n1492 | source_file.nodes.append(node.unique_id)\n1493 | \n1494 | def add_doc(self, source_file: SourceFile, doc: Documentation):\n1495 | _check_duplicates(doc, self.docs)\n1496 | self.docs[doc.unique_id] = doc\n1497 | source_file.docs.append(doc.unique_id)\n1498 | \n1499 | def add_semantic_model(self, source_file: SchemaSourceFile, semantic_model: SemanticModel):\n1500 | _check_duplicates(semantic_model, self.semantic_models)\n1501 | self.semantic_models[semantic_model.unique_id] = semantic_model\n1502 | source_file.semantic_models.append(semantic_model.unique_id)\n1503 | \n1504 | def add_unit_test(self, source_file: SchemaSourceFile, unit_test: UnitTestDefinition):\n1505 | if unit_test.unique_id in self.unit_tests:\n1506 | raise DuplicateResourceNameError(unit_test, self.unit_tests[unit_test.unique_id])\n1507 | self.unit_tests[unit_test.unique_id] = unit_test\n1508 | source_file.unit_tests.append(unit_test.unique_id)\n1509 | \n1510 | def add_fixture(self, source_file: FixtureSourceFile, fixture: UnitTestFileFixture):\n1511 | if fixture.unique_id in self.fixtures:\n1512 | raise DuplicateResourceNameError(fixture, self.fixtures[fixture.unique_id])\n1513 | self.fixtures[fixture.unique_id] = fixture\n1514 | source_file.fixture = fixture.unique_id\n1515 | \n1516 | def add_saved_query(self, source_file: SchemaSourceFile, saved_query: SavedQuery) -> None:\n1517 | _check_duplicates(saved_query, self.saved_queries)\n1518 | self.saved_queries[saved_query.unique_id] = saved_query\n1519 | source_file.saved_queries.append(saved_query.unique_id)\n1520 | \n1521 | # end of methods formerly in ParseResult\n1522 | \n1523 | # Provide support for copy.deepcopy() - we just need to avoid the lock!\n1524 | # pickle and deepcopy use this. It returns a callable object used to\n1525 | # create the initial version of the object and a tuple of arguments\n1526 | # for the object, i.e. the Manifest.\n1527 | # The order of the arguments must match the order of the attributes\n1528 | # in the Manifest class declaration, because they are used as\n1529 | # positional arguments to construct a Manifest.\n1530 | def __reduce_ex__(self, protocol):\n1531 | args = (\n1532 | self.nodes,\n1533 | self.sources,\n1534 | self.macros,\n1535 | self.docs,\n1536 | self.exposures,\n1537 | self.metrics,\n1538 | self.groups,\n1539 | self.selectors,\n1540 | self.files,\n1541 | self.metadata,\n1542 | self.flat_graph,\n1543 | self.state_check,\n1544 | self.source_patches,\n1545 | self.disabled,\n1546 | self.env_vars,\n1547 | self.semantic_models,\n1548 | self.unit_tests,\n1549 | self.saved_queries,\n1550 | self._doc_lookup,\n1551 | self._source_lookup,\n1552 | self._ref_lookup,\n1553 | self._metric_lookup,\n1554 | self._semantic_model_by_measure_lookup,\n1555 | self._disabled_lookup,\n1556 | self._analysis_lookup,\n1557 | )\n1558 | return self.__class__, args\n1559 | \n1560 | \n1561 | class MacroManifest(MacroMethods):\n1562 | def __init__(self, macros) -> None:\n1563 | self.macros = macros\n1564 | self.metadata = ManifestMetadata()\n1565 | # This is returned by the 'graph' context property\n1566 | # in the ProviderContext class.\n1567 | self.flat_graph: Dict[str, Any] = {}\n1568 | \n1569 | \n1570 | AnyManifest = Union[Manifest, MacroManifest]\n1571 | \n1572 | \n1573 | @dataclass\n1574 | @schema_version(\"manifest\", 12)\n1575 | class WritableManifest(ArtifactMixin):\n1576 | nodes: Mapping[UniqueID, ManifestNode] = field(\n1577 | metadata=dict(description=(\"The nodes defined in the dbt project and its dependencies\"))\n1578 | )\n1579 | sources: Mapping[UniqueID, SourceDefinition] = field(\n1580 | metadata=dict(description=(\"The sources defined in the dbt project and its dependencies\"))\n1581 | )\n1582 | macros: Mapping[UniqueID, Macro] = field(\n1583 | metadata=dict(description=(\"The macros defined in the dbt project and its dependencies\"))\n1584 | )\n1585 | docs: Mapping[UniqueID, Documentation] = field(\n1586 | metadata=dict(description=(\"The docs defined in the dbt project and its dependencies\"))\n1587 | )\n1588 | exposures: Mapping[UniqueID, Exposure] = field(\n1589 | metadata=dict(\n1590 | description=(\"The exposures defined in the dbt project and its dependencies\")\n1591 | )\n1592 | )\n1593 | metrics: Mapping[UniqueID, Metric] = field(\n1594 | metadata=dict(description=(\"The metrics defined in the dbt project and its dependencies\"))\n1595 | )\n1596 | groups: Mapping[UniqueID, Group] = field(\n1597 | metadata=dict(description=(\"The groups defined in the dbt project\"))\n1598 | )\n1599 | selectors: Mapping[UniqueID, Any] = field(\n1600 | metadata=dict(description=(\"The selectors defined in selectors.yml\"))\n1601 | )\n1602 | disabled: Optional[Mapping[UniqueID, List[GraphMemberNode]]] = field(\n1603 | metadata=dict(description=\"A mapping of the disabled nodes in the target\")\n1604 | )\n1605 | parent_map: Optional[NodeEdgeMap] = field(\n1606 | metadata=dict(\n1607 | description=\"A mapping from child nodes to their dependencies\",\n1608 | )\n1609 | )\n1610 | child_map: Optional[NodeEdgeMap] = field(\n1611 | metadata=dict(\n1612 | description=\"A mapping from parent nodes to their dependents\",\n1613 | )\n1614 | )\n1615 | group_map: Optional[NodeEdgeMap] = field(\n1616 | metadata=dict(\n1617 | description=\"A mapping from group names to their nodes\",\n1618 | )\n1619 | )\n1620 | saved_queries: Mapping[UniqueID, SavedQuery] = field(\n1621 | metadata=dict(description=(\"The saved queries defined in the dbt project\"))\n1622 | )\n1623 | semantic_models: Mapping[UniqueID, SemanticModel] = field(\n1624 | metadata=dict(description=(\"The semantic models defined in the dbt project\"))\n1625 | )\n1626 | metadata: ManifestMetadata = field(\n1627 | metadata=dict(\n1628 | description=\"Metadata about the manifest\",\n1629 | )\n1630 | )\n1631 | unit_tests: Mapping[UniqueID, UnitTestDefinition] = field(\n1632 | metadata=dict(\n1633 | description=\"The unit tests defined in the project\",\n1634 | )\n1635 | )\n1636 | \n1637 | @classmethod\n1638 | def compatible_previous_versions(cls) -> Iterable[Tuple[str, int]]:\n1639 | return [\n1640 | (\"manifest\", 4),\n1641 | (\"manifest\", 5),\n1642 | (\"manifest\", 6),\n1643 | (\"manifest\", 7),\n1644 | (\"manifest\", 8),\n1645 | (\"manifest\", 9),\n1646 | (\"manifest\", 10),\n1647 | (\"manifest\", 11),\n1648 | ]\n1649 | \n1650 | @classmethod\n1651 | def upgrade_schema_version(cls, data):\n1652 | \"\"\"This overrides the \"upgrade_schema_version\" call in VersionedSchema (via\n1653 | ArtifactMixin) to modify the dictionary passed in from earlier versions of the manifest.\"\"\"\n1654 | manifest_schema_version = get_artifact_schema_version(data)\n1655 | if manifest_schema_version <= 10:\n1656 | data = upgrade_manifest_json(data, manifest_schema_version)\n1657 | return cls.from_dict(data)\n1658 | \n1659 | def __post_serialize__(self, dct):\n1660 | for unique_id, node in dct[\"nodes\"].items():\n1661 | if \"config_call_dict\" in node:\n1662 | del node[\"config_call_dict\"]\n1663 | if \"defer_relation\" in node:\n1664 | del node[\"defer_relation\"]\n1665 | return dct\n1666 | \n1667 | \n1668 | def _check_duplicates(value: BaseNode, src: Mapping[str, BaseNode]):\n1669 | if value.unique_id in src:\n1670 | raise DuplicateResourceNameError(value, src[value.unique_id])\n1671 | \n1672 | \n1673 | K_T = TypeVar(\"K_T\")\n1674 | V_T = TypeVar(\"V_T\")\n1675 | \n1676 | \n1677 | def _expect_value(key: K_T, src: Mapping[K_T, V_T], old_file: SourceFile, name: str) -> V_T:\n1678 | if key not in src:\n1679 | raise CompilationError(\n1680 | 'Expected to find \"{}\" in cached \"result.{}\" based '\n1681 | \"on cached file information: {}!\".format(key, name, old_file)\n1682 | )\n1683 | return src[key]\n```\n\n## Files after the fix\n\n### File: core/dbt/context/macros.py\n\n```python\n 1 | from typing import Any, Dict, Iterable, Union, Optional, List, Iterator, Mapping, Set\n 2 | \n 3 | from dbt.clients.jinja import MacroGenerator, MacroStack\n 4 | from dbt.contracts.graph.nodes import Macro\n 5 | from dbt.adapters.include.global_project import PROJECT_NAME as GLOBAL_PROJECT_NAME\n 6 | from dbt.exceptions import DuplicateMacroNameError, PackageNotFoundForMacroError\n 7 | \n 8 | \n 9 | FlatNamespace = Dict[str, MacroGenerator]\n 10 | NamespaceMember = Union[FlatNamespace, MacroGenerator]\n 11 | FullNamespace = Dict[str, NamespaceMember]\n 12 | \n 13 | \n 14 | # The point of this class is to collect the various macros\n 15 | # and provide the ability to flatten them into the ManifestContexts\n 16 | # that are created for jinja, so that macro calls can be resolved.\n 17 | # Creates special iterators and _keys methods to flatten the lists.\n 18 | # When this class is created it has a static 'local_namespace' which\n 19 | # depends on the package of the node, so it only works for one\n 20 | # particular local package at a time for \"flattening\" into a context.\n 21 | # 'get_by_package' should work for any macro.\n 22 | class MacroNamespace(Mapping):\n 23 | def __init__(\n 24 | self,\n 25 | global_namespace: FlatNamespace, # root package macros\n 26 | local_namespace: FlatNamespace, # packages for *this* node\n 27 | global_project_namespace: FlatNamespace, # internal packages\n 28 | packages: Dict[str, FlatNamespace], # non-internal packages\n 29 | ):\n 30 | self.global_namespace: FlatNamespace = global_namespace\n 31 | self.local_namespace: FlatNamespace = local_namespace\n 32 | self.packages: Dict[str, FlatNamespace] = packages\n 33 | self.global_project_namespace: FlatNamespace = global_project_namespace\n 34 | \n 35 | def _search_order(self) -> Iterable[Union[FullNamespace, FlatNamespace]]:\n 36 | yield self.local_namespace # local package\n 37 | yield self.global_namespace # root package\n 38 | # TODO CT-211\n 39 | yield self.packages # type: ignore[misc] # non-internal packages\n 40 | yield {\n 41 | # TODO CT-211\n 42 | GLOBAL_PROJECT_NAME: self.global_project_namespace, # type: ignore[misc] # dbt\n 43 | }\n 44 | yield self.global_project_namespace # other internal project besides dbt\n 45 | \n 46 | # provides special keys method for MacroNamespace iterator\n 47 | # returns keys from local_namespace, global_namespace, packages,\n 48 | # global_project_namespace\n 49 | def _keys(self) -> Set[str]:\n 50 | keys: Set[str] = set()\n 51 | for search in self._search_order():\n 52 | keys.update(search)\n 53 | return keys\n 54 | \n 55 | # special iterator using special keys\n 56 | def __iter__(self) -> Iterator[str]:\n 57 | for key in self._keys():\n 58 | yield key\n 59 | \n 60 | def __len__(self):\n 61 | return len(self._keys())\n 62 | \n 63 | def __getitem__(self, key: str) -> NamespaceMember:\n 64 | for dct in self._search_order():\n 65 | if key in dct:\n 66 | return dct[key]\n 67 | raise KeyError(key)\n 68 | \n 69 | def get_from_package(self, package_name: Optional[str], name: str) -> Optional[MacroGenerator]:\n 70 | if package_name is None:\n 71 | return self.get(name)\n 72 | elif package_name == GLOBAL_PROJECT_NAME:\n 73 | return self.global_project_namespace.get(name)\n 74 | elif package_name in self.packages:\n 75 | return self.packages[package_name].get(name)\n 76 | else:\n 77 | raise PackageNotFoundForMacroError(package_name)\n 78 | \n 79 | \n 80 | # This class builds the MacroNamespace by adding macros to\n 81 | # internal_packages or packages, and locals/globals.\n 82 | # Call 'build_namespace' to return a MacroNamespace.\n 83 | # This is used by ManifestContext (and subclasses)\n 84 | class MacroNamespaceBuilder:\n 85 | def __init__(\n 86 | self,\n 87 | root_package: str,\n 88 | search_package: str,\n 89 | thread_ctx: MacroStack,\n 90 | internal_packages: List[str],\n 91 | node: Optional[Any] = None,\n 92 | ) -> None:\n 93 | self.root_package = root_package\n 94 | self.search_package = search_package\n 95 | # internal packages comes from get_adapter_package_names\n 96 | self.internal_package_names = set(internal_packages)\n 97 | self.internal_package_names_order = internal_packages\n 98 | # macro_func is added here if in root package, since\n 99 | # the root package acts as a \"global\" namespace, overriding\n100 | # everything else except local external package macro calls\n101 | self.globals: FlatNamespace = {}\n102 | # macro_func is added here if it's the package for this node\n103 | self.locals: FlatNamespace = {}\n104 | # Create a dictionary of [package name][macro name] =\n105 | # MacroGenerator object which acts like a function\n106 | self.internal_packages: Dict[str, FlatNamespace] = {}\n107 | self.packages: Dict[str, FlatNamespace] = {}\n108 | self.thread_ctx = thread_ctx\n109 | self.node = node\n110 | \n111 | def _add_macro_to(\n112 | self,\n113 | hierarchy: Dict[str, FlatNamespace],\n114 | macro: Macro,\n115 | macro_func: MacroGenerator,\n116 | ):\n117 | if macro.package_name in hierarchy:\n118 | namespace = hierarchy[macro.package_name]\n119 | else:\n120 | namespace = {}\n121 | hierarchy[macro.package_name] = namespace\n122 | \n123 | if macro.name in namespace:\n124 | raise DuplicateMacroNameError(macro_func.macro, macro, macro.package_name)\n125 | hierarchy[macro.package_name][macro.name] = macro_func\n126 | \n127 | def add_macro(self, macro: Macro, ctx: Dict[str, Any]) -> None:\n128 | macro_name: str = macro.name\n129 | \n130 | # MacroGenerator is in clients/jinja.py\n131 | # a MacroGenerator object is a callable object that will\n132 | # execute the MacroGenerator.__call__ function\n133 | macro_func: MacroGenerator = MacroGenerator(macro, ctx, self.node, self.thread_ctx)\n134 | \n135 | # internal macros (from plugins) will be processed separately from\n136 | # project macros, so store them in a different place\n137 | if macro.package_name in self.internal_package_names:\n138 | self._add_macro_to(self.internal_packages, macro, macro_func)\n139 | else:\n140 | # if it's not an internal package\n141 | self._add_macro_to(self.packages, macro, macro_func)\n142 | # add to locals if it's the package this node is in\n143 | if macro.package_name == self.search_package:\n144 | self.locals[macro_name] = macro_func\n145 | # add to globals if it's in the root package\n146 | elif macro.package_name == self.root_package:\n147 | self.globals[macro_name] = macro_func\n148 | \n149 | def add_macros(self, macros: Iterable[Macro], ctx: Dict[str, Any]) -> None:\n150 | for macro in macros:\n151 | self.add_macro(macro, ctx)\n152 | \n153 | def build_namespace(\n154 | self, macros_by_package: Dict[str, Dict[str, Macro]], ctx: Dict[str, Any]\n155 | ) -> MacroNamespace:\n156 | for package in macros_by_package.values():\n157 | self.add_macros(package.values(), ctx)\n158 | \n159 | # Iterate in reverse-order and overwrite: the packages that are first\n160 | # in the list are the ones we want to \"win\".\n161 | global_project_namespace: FlatNamespace = {}\n162 | for pkg in reversed(self.internal_package_names_order):\n163 | if pkg in self.internal_packages:\n164 | # add the macros pointed to by this package name\n165 | global_project_namespace.update(self.internal_packages[pkg])\n166 | \n167 | return MacroNamespace(\n168 | global_namespace=self.globals, # root package macros\n169 | local_namespace=self.locals, # packages for *this* node\n170 | global_project_namespace=global_project_namespace, # internal packages\n171 | packages=self.packages, # non internal_packages\n172 | )\n```\n\n### File: core/dbt/context/manifest.py\n\n```python\n 1 | from typing import List\n 2 | \n 3 | from dbt.clients.jinja import MacroStack\n 4 | from dbt.adapters.contracts.connection import AdapterRequiredConfig\n 5 | from dbt.contracts.graph.manifest import Manifest\n 6 | from dbt.context.macro_resolver import TestMacroNamespace\n 7 | from .base import contextproperty\n 8 | \n 9 | \n10 | from .configured import ConfiguredContext\n11 | from .macros import MacroNamespace, MacroNamespaceBuilder\n12 | \n13 | \n14 | class ManifestContext(ConfiguredContext):\n15 | \"\"\"The Macro context has everything in the target context, plus the macros\n16 | in the manifest.\n17 | \n18 | The given macros can override any previous context values, which will be\n19 | available as if they were accessed relative to the package name.\n20 | \"\"\"\n21 | \n22 | # subclasses are QueryHeaderContext and ProviderContext\n23 | def __init__(\n24 | self,\n25 | config: AdapterRequiredConfig,\n26 | manifest: Manifest,\n27 | search_package: str,\n28 | ) -> None:\n29 | super().__init__(config)\n30 | self.manifest = manifest\n31 | # this is the package of the node for which this context was built\n32 | self.search_package = search_package\n33 | self.macro_stack = MacroStack()\n34 | # This namespace is used by the BaseDatabaseWrapper in jinja rendering.\n35 | # The namespace is passed to it when it's constructed. It expects\n36 | # to be able to do: namespace.get_from_package(..)\n37 | self.namespace = self._build_namespace()\n38 | \n39 | def _build_namespace(self) -> MacroNamespace:\n40 | # this takes all the macros in the manifest and adds them\n41 | # to the MacroNamespaceBuilder stored in self.namespace\n42 | builder = self._get_namespace_builder()\n43 | return builder.build_namespace(self.manifest.get_macros_by_package(), self._ctx)\n44 | \n45 | def _get_namespace_builder(self) -> MacroNamespaceBuilder:\n46 | # avoid an import loop\n47 | from dbt.adapters.factory import get_adapter_package_names\n48 | \n49 | internal_packages: List[str] = get_adapter_package_names(self.config.credentials.type)\n50 | return MacroNamespaceBuilder(\n51 | self.config.project_name,\n52 | self.search_package,\n53 | self.macro_stack,\n54 | internal_packages,\n55 | None,\n56 | )\n57 | \n58 | # This does not use the Mashumaro code\n59 | def to_dict(self):\n60 | dct = super().to_dict()\n61 | # This moves all of the macros in the 'namespace' into top level\n62 | # keys in the manifest dictionary\n63 | if isinstance(self.namespace, TestMacroNamespace):\n64 | dct.update(self.namespace.local_namespace)\n65 | dct.update(self.namespace.project_namespace)\n66 | else:\n67 | dct.update(self.namespace)\n68 | \n69 | return dct\n70 | \n71 | @contextproperty()\n72 | def context_macro_stack(self):\n73 | return self.macro_stack\n74 | \n75 | \n76 | class QueryHeaderContext(ManifestContext):\n77 | def __init__(self, config: AdapterRequiredConfig, manifest: Manifest) -> None:\n78 | super().__init__(config, manifest, config.project_name)\n79 | \n80 | \n81 | def generate_query_header_context(config: AdapterRequiredConfig, manifest: Manifest):\n82 | ctx = QueryHeaderContext(config, manifest)\n83 | return ctx.to_dict()\n```\n\n### File: core/dbt/contracts/graph/manifest.py\n\n```python\n 1 | import enum\n 2 | from collections import defaultdict\n 3 | from dataclasses import dataclass, field\n 4 | from itertools import chain, islice\n 5 | from mashumaro.mixins.msgpack import DataClassMessagePackMixin\n 6 | from multiprocessing.synchronize import Lock\n 7 | from typing import (\n 8 | DefaultDict,\n 9 | Dict,\n 10 | List,\n 11 | Optional,\n 12 | Union,\n 13 | Mapping,\n 14 | MutableMapping,\n 15 | Any,\n 16 | Set,\n 17 | Tuple,\n 18 | TypeVar,\n 19 | Callable,\n 20 | Generic,\n 21 | AbstractSet,\n 22 | ClassVar,\n 23 | Iterable,\n 24 | )\n 25 | from typing_extensions import Protocol\n 26 | from uuid import UUID\n 27 | \n 28 | from dbt.contracts.graph.nodes import (\n 29 | BaseNode,\n 30 | Documentation,\n 31 | Exposure,\n 32 | GenericTestNode,\n 33 | GraphMemberNode,\n 34 | Group,\n 35 | Macro,\n 36 | ManifestNode,\n 37 | Metric,\n 38 | ModelNode,\n 39 | DeferRelation,\n 40 | ResultNode,\n 41 | SavedQuery,\n 42 | SemanticModel,\n 43 | SourceDefinition,\n 44 | UnpatchedSourceDefinition,\n 45 | UnitTestDefinition,\n 46 | UnitTestFileFixture,\n 47 | )\n 48 | from dbt.contracts.graph.unparsed import SourcePatch, NodeVersion, UnparsedVersion\n 49 | from dbt.contracts.graph.manifest_upgrade import upgrade_manifest_json\n 50 | from dbt.contracts.files import (\n 51 | SourceFile,\n 52 | SchemaSourceFile,\n 53 | FileHash,\n 54 | AnySourceFile,\n 55 | FixtureSourceFile,\n 56 | )\n 57 | from dbt.artifacts.base import (\n 58 | BaseArtifactMetadata,\n 59 | ArtifactMixin,\n 60 | schema_version,\n 61 | get_artifact_schema_version,\n 62 | )\n 63 | from dbt.contracts.util import SourceKey\n 64 | from dbt_common.dataclass_schema import dbtClassMixin\n 65 | \n 66 | from dbt.exceptions import (\n 67 | CompilationError,\n 68 | DuplicateResourceNameError,\n 69 | AmbiguousResourceNameRefError,\n 70 | )\n 71 | from dbt.adapters.exceptions import DuplicateMacroInPackageError, DuplicateMaterializationNameError\n 72 | from dbt_common.helper_types import PathSet\n 73 | from dbt_common.events.functions import fire_event\n 74 | from dbt_common.events.contextvars import get_node_info\n 75 | from dbt.events.types import MergedFromState, UnpinnedRefNewVersionAvailable\n 76 | from dbt.node_types import NodeType, AccessType\n 77 | from dbt.flags import get_flags\n 78 | from dbt.mp_context import get_mp_context\n 79 | from dbt import tracking\n 80 | import dbt_common.utils\n 81 | import dbt_common.exceptions\n 82 | \n 83 | \n 84 | NodeEdgeMap = Dict[str, List[str]]\n 85 | PackageName = str\n 86 | DocName = str\n 87 | RefName = str\n 88 | UniqueID = str\n 89 | \n 90 | \n 91 | def find_unique_id_for_package(storage, key, package: Optional[PackageName]):\n 92 | if key not in storage:\n 93 | return None\n 94 | \n 95 | pkg_dct: Mapping[PackageName, UniqueID] = storage[key]\n 96 | \n 97 | if package is None:\n 98 | if not pkg_dct:\n 99 | return None\n 100 | else:\n 101 | return next(iter(pkg_dct.values()))\n 102 | elif package in pkg_dct:\n 103 | return pkg_dct[package]\n 104 | else:\n 105 | return None\n 106 | \n 107 | \n 108 | class DocLookup(dbtClassMixin):\n 109 | def __init__(self, manifest: \"Manifest\") -> None:\n 110 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 111 | self.populate(manifest)\n 112 | \n 113 | def get_unique_id(self, key, package: Optional[PackageName]):\n 114 | return find_unique_id_for_package(self.storage, key, package)\n 115 | \n 116 | def find(self, key, package: Optional[PackageName], manifest: \"Manifest\"):\n 117 | unique_id = self.get_unique_id(key, package)\n 118 | if unique_id is not None:\n 119 | return self.perform_lookup(unique_id, manifest)\n 120 | return None\n 121 | \n 122 | def add_doc(self, doc: Documentation):\n 123 | if doc.name not in self.storage:\n 124 | self.storage[doc.name] = {}\n 125 | self.storage[doc.name][doc.package_name] = doc.unique_id\n 126 | \n 127 | def populate(self, manifest):\n 128 | for doc in manifest.docs.values():\n 129 | self.add_doc(doc)\n 130 | \n 131 | def perform_lookup(self, unique_id: UniqueID, manifest) -> Documentation:\n 132 | if unique_id not in manifest.docs:\n 133 | raise dbt_common.exceptions.DbtInternalError(\n 134 | f\"Doc {unique_id} found in cache but not found in manifest\"\n 135 | )\n 136 | return manifest.docs[unique_id]\n 137 | \n 138 | \n 139 | class SourceLookup(dbtClassMixin):\n 140 | def __init__(self, manifest: \"Manifest\") -> None:\n 141 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 142 | self.populate(manifest)\n 143 | \n 144 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 145 | return find_unique_id_for_package(self.storage, search_name, package)\n 146 | \n 147 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 148 | unique_id = self.get_unique_id(search_name, package)\n 149 | if unique_id is not None:\n 150 | return self.perform_lookup(unique_id, manifest)\n 151 | return None\n 152 | \n 153 | def add_source(self, source: SourceDefinition):\n 154 | if source.search_name not in self.storage:\n 155 | self.storage[source.search_name] = {}\n 156 | \n 157 | self.storage[source.search_name][source.package_name] = source.unique_id\n 158 | \n 159 | def populate(self, manifest):\n 160 | for source in manifest.sources.values():\n 161 | if hasattr(source, \"source_name\"):\n 162 | self.add_source(source)\n 163 | \n 164 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SourceDefinition:\n 165 | if unique_id not in manifest.sources:\n 166 | raise dbt_common.exceptions.DbtInternalError(\n 167 | f\"Source {unique_id} found in cache but not found in manifest\"\n 168 | )\n 169 | return manifest.sources[unique_id]\n 170 | \n 171 | \n 172 | class RefableLookup(dbtClassMixin):\n 173 | # model, seed, snapshot\n 174 | _lookup_types: ClassVar[set] = set(NodeType.refable())\n 175 | _versioned_types: ClassVar[set] = set(NodeType.versioned())\n 176 | \n 177 | def __init__(self, manifest: \"Manifest\") -> None:\n 178 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 179 | self.populate(manifest)\n 180 | \n 181 | def get_unique_id(\n 182 | self,\n 183 | key: str,\n 184 | package: Optional[PackageName],\n 185 | version: Optional[NodeVersion],\n 186 | node: Optional[GraphMemberNode] = None,\n 187 | ):\n 188 | if version:\n 189 | key = f\"{key}.v{version}\"\n 190 | \n 191 | unique_ids = self._find_unique_ids_for_package(key, package)\n 192 | if len(unique_ids) > 1:\n 193 | raise AmbiguousResourceNameRefError(key, unique_ids, node)\n 194 | else:\n 195 | return unique_ids[0] if unique_ids else None\n 196 | \n 197 | def find(\n 198 | self,\n 199 | key: str,\n 200 | package: Optional[PackageName],\n 201 | version: Optional[NodeVersion],\n 202 | manifest: \"Manifest\",\n 203 | source_node: Optional[GraphMemberNode] = None,\n 204 | ):\n 205 | unique_id = self.get_unique_id(key, package, version, source_node)\n 206 | if unique_id is not None:\n 207 | node = self.perform_lookup(unique_id, manifest)\n 208 | # If this is an unpinned ref (no 'version' arg was passed),\n 209 | # AND this is a versioned node,\n 210 | # AND this ref is being resolved at runtime -- get_node_info != {}\n 211 | # Only ModelNodes can be versioned.\n 212 | if (\n 213 | isinstance(node, ModelNode)\n 214 | and version is None\n 215 | and node.is_versioned\n 216 | and get_node_info()\n 217 | ):\n 218 | # Check to see if newer versions are available, and log an \"FYI\" if so\n 219 | max_version: UnparsedVersion = max(\n 220 | [\n 221 | UnparsedVersion(v.version)\n 222 | for v in manifest.nodes.values()\n 223 | if isinstance(v, ModelNode)\n 224 | and v.name == node.name\n 225 | and v.version is not None\n 226 | ]\n 227 | )\n 228 | assert node.latest_version is not None # for mypy, whenever i may find it\n 229 | if max_version > UnparsedVersion(node.latest_version):\n 230 | fire_event(\n 231 | UnpinnedRefNewVersionAvailable(\n 232 | node_info=get_node_info(),\n 233 | ref_node_name=node.name,\n 234 | ref_node_package=node.package_name,\n 235 | ref_node_version=str(node.version),\n 236 | ref_max_version=str(max_version.v),\n 237 | )\n 238 | )\n 239 | \n 240 | return node\n 241 | return None\n 242 | \n 243 | def add_node(self, node: ManifestNode):\n 244 | if node.resource_type in self._lookup_types:\n 245 | if node.name not in self.storage:\n 246 | self.storage[node.name] = {}\n 247 | \n 248 | if node.is_versioned:\n 249 | if node.search_name not in self.storage:\n 250 | self.storage[node.search_name] = {}\n 251 | self.storage[node.search_name][node.package_name] = node.unique_id\n 252 | if node.is_latest_version: # type: ignore\n 253 | self.storage[node.name][node.package_name] = node.unique_id\n 254 | else:\n 255 | self.storage[node.name][node.package_name] = node.unique_id\n 256 | \n 257 | def populate(self, manifest):\n 258 | for node in manifest.nodes.values():\n 259 | self.add_node(node)\n 260 | \n 261 | def perform_lookup(self, unique_id: UniqueID, manifest) -> ManifestNode:\n 262 | if unique_id in manifest.nodes:\n 263 | node = manifest.nodes[unique_id]\n 264 | else:\n 265 | raise dbt_common.exceptions.DbtInternalError(\n 266 | f\"Node {unique_id} found in cache but not found in manifest\"\n 267 | )\n 268 | return node\n 269 | \n 270 | def _find_unique_ids_for_package(self, key, package: Optional[PackageName]) -> List[str]:\n 271 | if key not in self.storage:\n 272 | return []\n 273 | \n 274 | pkg_dct: Mapping[PackageName, UniqueID] = self.storage[key]\n 275 | \n 276 | if package is None:\n 277 | if not pkg_dct:\n 278 | return []\n 279 | else:\n 280 | return list(pkg_dct.values())\n 281 | elif package in pkg_dct:\n 282 | return [pkg_dct[package]]\n 283 | else:\n 284 | return []\n 285 | \n 286 | \n 287 | class MetricLookup(dbtClassMixin):\n 288 | def __init__(self, manifest: \"Manifest\") -> None:\n 289 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 290 | self.populate(manifest)\n 291 | \n 292 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 293 | return find_unique_id_for_package(self.storage, search_name, package)\n 294 | \n 295 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 296 | unique_id = self.get_unique_id(search_name, package)\n 297 | if unique_id is not None:\n 298 | return self.perform_lookup(unique_id, manifest)\n 299 | return None\n 300 | \n 301 | def add_metric(self, metric: Metric):\n 302 | if metric.search_name not in self.storage:\n 303 | self.storage[metric.search_name] = {}\n 304 | \n 305 | self.storage[metric.search_name][metric.package_name] = metric.unique_id\n 306 | \n 307 | def populate(self, manifest):\n 308 | for metric in manifest.metrics.values():\n 309 | if hasattr(metric, \"name\"):\n 310 | self.add_metric(metric)\n 311 | \n 312 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> Metric:\n 313 | if unique_id not in manifest.metrics:\n 314 | raise dbt_common.exceptions.DbtInternalError(\n 315 | f\"Metric {unique_id} found in cache but not found in manifest\"\n 316 | )\n 317 | return manifest.metrics[unique_id]\n 318 | \n 319 | \n 320 | class SavedQueryLookup(dbtClassMixin):\n 321 | \"\"\"Lookup utility for finding SavedQuery nodes\"\"\"\n 322 | \n 323 | def __init__(self, manifest: \"Manifest\") -> None:\n 324 | self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}\n 325 | self.populate(manifest)\n 326 | \n 327 | def get_unique_id(self, search_name, package: Optional[PackageName]):\n 328 | return find_unique_id_for_package(self.storage, search_name, package)\n 329 | \n 330 | def find(self, search_name, package: Optional[PackageName], manifest: \"Manifest\"):\n 331 | unique_id = self.get_unique_id(search_name, package)\n 332 | if unique_id is not None:\n 333 | return self.perform_lookup(unique_id, manifest)\n 334 | return None\n 335 | \n 336 | def add_saved_query(self, saved_query: SavedQuery):\n 337 | if saved_query.search_name not in self.storage:\n 338 | self.storage[saved_query.search_name] = {}\n 339 | \n 340 | self.storage[saved_query.search_name][saved_query.package_name] = saved_query.unique_id\n 341 | \n 342 | def populate(self, manifest):\n 343 | for saved_query in manifest.saved_queries.values():\n 344 | if hasattr(saved_query, \"name\"):\n 345 | self.add_saved_query(saved_query)\n 346 | \n 347 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SavedQuery:\n 348 | if unique_id not in manifest.saved_queries:\n 349 | raise dbt_common.exceptions.DbtInternalError(\n 350 | f\"SavedQUery {unique_id} found in cache but not found in manifest\"\n 351 | )\n 352 | return manifest.saved_queries[unique_id]\n 353 | \n 354 | \n 355 | class SemanticModelByMeasureLookup(dbtClassMixin):\n 356 | \"\"\"Lookup utility for finding SemanticModel by measure\n 357 | \n 358 | This is possible because measure names are supposed to be unique across\n 359 | the semantic models in a manifest.\n 360 | \"\"\"\n 361 | \n 362 | def __init__(self, manifest: \"Manifest\") -> None:\n 363 | self.storage: DefaultDict[str, Dict[PackageName, UniqueID]] = defaultdict(dict)\n 364 | self.populate(manifest)\n 365 | \n 366 | def get_unique_id(self, search_name: str, package: Optional[PackageName]):\n 367 | return find_unique_id_for_package(self.storage, search_name, package)\n 368 | \n 369 | def find(\n 370 | self, search_name: str, package: Optional[PackageName], manifest: \"Manifest\"\n 371 | ) -> Optional[SemanticModel]:\n 372 | \"\"\"Tries to find a SemanticModel based on a measure name\"\"\"\n 373 | unique_id = self.get_unique_id(search_name, package)\n 374 | if unique_id is not None:\n 375 | return self.perform_lookup(unique_id, manifest)\n 376 | return None\n 377 | \n 378 | def add(self, semantic_model: SemanticModel):\n 379 | \"\"\"Sets all measures for a SemanticModel as paths to the SemanticModel's `unique_id`\"\"\"\n 380 | for measure in semantic_model.measures:\n 381 | self.storage[measure.name][semantic_model.package_name] = semantic_model.unique_id\n 382 | \n 383 | def populate(self, manifest: \"Manifest\"):\n 384 | \"\"\"Populate storage with all the measure + package paths to the Manifest's SemanticModels\"\"\"\n 385 | for semantic_model in manifest.semantic_models.values():\n 386 | self.add(semantic_model=semantic_model)\n 387 | for disabled in manifest.disabled.values():\n 388 | for node in disabled:\n 389 | if isinstance(node, SemanticModel):\n 390 | self.add(semantic_model=node)\n 391 | \n 392 | def perform_lookup(self, unique_id: UniqueID, manifest: \"Manifest\") -> SemanticModel:\n 393 | \"\"\"Tries to get a SemanticModel from the Manifest\"\"\"\n 394 | enabled_semantic_model: Optional[SemanticModel] = manifest.semantic_models.get(unique_id)\n 395 | disabled_semantic_model: Optional[List] = manifest.disabled.get(unique_id)\n 396 | \n 397 | if isinstance(enabled_semantic_model, SemanticModel):\n 398 | return enabled_semantic_model\n 399 | elif disabled_semantic_model is not None and isinstance(\n 400 | disabled_semantic_model[0], SemanticModel\n 401 | ):\n 402 | return disabled_semantic_model[0]\n 403 | else:\n 404 | raise dbt_common.exceptions.DbtInternalError(\n 405 | f\"Semantic model `{unique_id}` found in cache but not found in manifest\"\n 406 | )\n 407 | \n 408 | \n 409 | # This handles both models/seeds/snapshots and sources/metrics/exposures/semantic_models\n 410 | class DisabledLookup(dbtClassMixin):\n 411 | def __init__(self, manifest: \"Manifest\") -> None:\n 412 | self.storage: Dict[str, Dict[PackageName, List[Any]]] = {}\n 413 | self.populate(manifest)\n 414 | \n 415 | def populate(self, manifest):\n 416 | for node in list(chain.from_iterable(manifest.disabled.values())):\n 417 | self.add_node(node)\n 418 | \n 419 | def add_node(self, node):\n 420 | if node.search_name not in self.storage:\n 421 | self.storage[node.search_name] = {}\n 422 | if node.package_name not in self.storage[node.search_name]:\n 423 | self.storage[node.search_name][node.package_name] = []\n 424 | self.storage[node.search_name][node.package_name].append(node)\n 425 | \n 426 | # This should return a list of disabled nodes. It's different from\n 427 | # the other Lookup functions in that it returns full nodes, not just unique_ids\n 428 | def find(\n 429 | self, search_name, package: Optional[PackageName], version: Optional[NodeVersion] = None\n 430 | ):\n 431 | if version:\n 432 | search_name = f\"{search_name}.v{version}\"\n 433 | \n 434 | if search_name not in self.storage:\n 435 | return None\n 436 | \n 437 | pkg_dct: Mapping[PackageName, List[Any]] = self.storage[search_name]\n 438 | \n 439 | if package is None:\n 440 | if not pkg_dct:\n 441 | return None\n 442 | else:\n 443 | return next(iter(pkg_dct.values()))\n 444 | elif package in pkg_dct:\n 445 | return pkg_dct[package]\n 446 | else:\n 447 | return None\n 448 | \n 449 | \n 450 | class AnalysisLookup(RefableLookup):\n 451 | _lookup_types: ClassVar[set] = set([NodeType.Analysis])\n 452 | _versioned_types: ClassVar[set] = set()\n 453 | \n 454 | \n 455 | def _packages_to_search(\n 456 | current_project: str,\n 457 | node_package: str,\n 458 | target_package: Optional[str] = None,\n 459 | ) -> List[Optional[str]]:\n 460 | if target_package is not None:\n 461 | return [target_package]\n 462 | elif current_project == node_package:\n 463 | return [current_project, None]\n 464 | else:\n 465 | return [current_project, node_package, None]\n 466 | \n 467 | \n 468 | @dataclass\n 469 | class ManifestMetadata(BaseArtifactMetadata):\n 470 | \"\"\"Metadata for the manifest.\"\"\"\n 471 | \n 472 | dbt_schema_version: str = field(\n 473 | default_factory=lambda: str(WritableManifest.dbt_schema_version)\n 474 | )\n 475 | project_name: Optional[str] = field(\n 476 | default=None,\n 477 | metadata={\n 478 | \"description\": \"Name of the root project\",\n 479 | },\n 480 | )\n 481 | project_id: Optional[str] = field(\n 482 | default=None,\n 483 | metadata={\n 484 | \"description\": \"A unique identifier for the project, hashed from the project name\",\n 485 | },\n 486 | )\n 487 | user_id: Optional[UUID] = field(\n 488 | default=None,\n 489 | metadata={\n 490 | \"description\": \"A unique identifier for the user\",\n 491 | },\n 492 | )\n 493 | send_anonymous_usage_stats: Optional[bool] = field(\n 494 | default=None,\n 495 | metadata=dict(\n 496 | description=(\"Whether dbt is configured to send anonymous usage statistics\")\n 497 | ),\n 498 | )\n 499 | adapter_type: Optional[str] = field(\n 500 | default=None,\n 501 | metadata=dict(description=\"The type name of the adapter\"),\n 502 | )\n 503 | \n 504 | def __post_init__(self):\n 505 | if tracking.active_user is None:\n 506 | return\n 507 | \n 508 | if self.user_id is None:\n 509 | self.user_id = tracking.active_user.id\n 510 | \n 511 | if self.send_anonymous_usage_stats is None:\n 512 | self.send_anonymous_usage_stats = get_flags().SEND_ANONYMOUS_USAGE_STATS\n 513 | \n 514 | @classmethod\n 515 | def default(cls):\n 516 | return cls(\n 517 | dbt_schema_version=str(WritableManifest.dbt_schema_version),\n 518 | )\n 519 | \n 520 | \n 521 | def _sort_values(dct):\n 522 | \"\"\"Given a dictionary, sort each value. This makes output deterministic,\n 523 | which helps for tests.\n 524 | \"\"\"\n 525 | return {k: sorted(v) for k, v in dct.items()}\n 526 | \n 527 | \n 528 | def build_node_edges(nodes: List[ManifestNode]):\n 529 | \"\"\"Build the forward and backward edges on the given list of ManifestNodes\n 530 | and return them as two separate dictionaries, each mapping unique IDs to\n 531 | lists of edges.\n 532 | \"\"\"\n 533 | backward_edges: Dict[str, List[str]] = {}\n 534 | # pre-populate the forward edge dict for simplicity\n 535 | forward_edges: Dict[str, List[str]] = {n.unique_id: [] for n in nodes}\n 536 | for node in nodes:\n 537 | backward_edges[node.unique_id] = node.depends_on_nodes[:]\n 538 | for unique_id in backward_edges[node.unique_id]:\n 539 | if unique_id in forward_edges.keys():\n 540 | forward_edges[unique_id].append(node.unique_id)\n 541 | return _sort_values(forward_edges), _sort_values(backward_edges)\n 542 | \n 543 | \n 544 | # Build a map of children of macros and generic tests\n 545 | def build_macro_edges(nodes: List[Any]):\n 546 | forward_edges: Dict[str, List[str]] = {\n 547 | n.unique_id: [] for n in nodes if n.unique_id.startswith(\"macro\") or n.depends_on_macros\n 548 | }\n 549 | for node in nodes:\n 550 | for unique_id in node.depends_on_macros:\n 551 | if unique_id in forward_edges.keys():\n 552 | forward_edges[unique_id].append(node.unique_id)\n 553 | return _sort_values(forward_edges)\n 554 | \n 555 | \n 556 | def _deepcopy(value):\n 557 | return value.from_dict(value.to_dict(omit_none=True))\n 558 | \n 559 | \n 560 | class Locality(enum.IntEnum):\n 561 | Core = 1\n 562 | Imported = 2\n 563 | Root = 3\n 564 | \n 565 | \n 566 | @dataclass\n 567 | class MacroCandidate:\n 568 | locality: Locality\n 569 | macro: Macro\n 570 | \n 571 | def __eq__(self, other: object) -> bool:\n 572 | if not isinstance(other, MacroCandidate):\n 573 | return NotImplemented\n 574 | return self.locality == other.locality\n 575 | \n 576 | def __lt__(self, other: object) -> bool:\n 577 | if not isinstance(other, MacroCandidate):\n 578 | return NotImplemented\n 579 | if self.locality < other.locality:\n 580 | return True\n 581 | if self.locality > other.locality:\n 582 | return False\n 583 | return False\n 584 | \n 585 | \n 586 | @dataclass\n 587 | class MaterializationCandidate(MacroCandidate):\n 588 | # specificity describes where in the inheritance chain this materialization candidate is\n 589 | # a specificity of 0 means a materialization defined by the current adapter\n 590 | # the highest the specificity describes a default materialization. the value itself depends on\n 591 | # how many adapters there are in the inheritance chain\n 592 | specificity: int\n 593 | \n 594 | @classmethod\n 595 | def from_macro(cls, candidate: MacroCandidate, specificity: int) -> \"MaterializationCandidate\":\n 596 | return cls(\n 597 | locality=candidate.locality,\n 598 | macro=candidate.macro,\n 599 | specificity=specificity,\n 600 | )\n 601 | \n 602 | def __eq__(self, other: object) -> bool:\n 603 | if not isinstance(other, MaterializationCandidate):\n 604 | return NotImplemented\n 605 | equal = self.specificity == other.specificity and self.locality == other.locality\n 606 | if equal:\n 607 | raise DuplicateMaterializationNameError(self.macro, other)\n 608 | \n 609 | return equal\n 610 | \n 611 | def __lt__(self, other: object) -> bool:\n 612 | if not isinstance(other, MaterializationCandidate):\n 613 | return NotImplemented\n 614 | if self.specificity > other.specificity:\n 615 | return True\n 616 | if self.specificity < other.specificity:\n 617 | return False\n 618 | if self.locality < other.locality:\n 619 | return True\n 620 | if self.locality > other.locality:\n 621 | return False\n 622 | return False\n 623 | \n 624 | \n 625 | M = TypeVar(\"M\", bound=MacroCandidate)\n 626 | \n 627 | \n 628 | class CandidateList(List[M]):\n 629 | def last(self) -> Optional[Macro]:\n 630 | if not self:\n 631 | return None\n 632 | self.sort()\n 633 | return self[-1].macro\n 634 | \n 635 | \n 636 | def _get_locality(macro: Macro, root_project_name: str, internal_packages: Set[str]) -> Locality:\n 637 | if macro.package_name == root_project_name:\n 638 | return Locality.Root\n 639 | elif macro.package_name in internal_packages:\n 640 | return Locality.Core\n 641 | else:\n 642 | return Locality.Imported\n 643 | \n 644 | \n 645 | class Searchable(Protocol):\n 646 | resource_type: NodeType\n 647 | package_name: str\n 648 | \n 649 | @property\n 650 | def search_name(self) -> str:\n 651 | raise NotImplementedError(\"search_name not implemented\")\n 652 | \n 653 | \n 654 | D = TypeVar(\"D\")\n 655 | \n 656 | \n 657 | @dataclass\n 658 | class Disabled(Generic[D]):\n 659 | target: D\n 660 | \n 661 | \n 662 | MaybeMetricNode = Optional[Union[Metric, Disabled[Metric]]]\n 663 | \n 664 | \n 665 | MaybeSavedQueryNode = Optional[Union[SavedQuery, Disabled[SavedQuery]]]\n 666 | \n 667 | \n 668 | MaybeDocumentation = Optional[Documentation]\n 669 | \n 670 | \n 671 | MaybeParsedSource = Optional[\n 672 | Union[\n 673 | SourceDefinition,\n 674 | Disabled[SourceDefinition],\n 675 | ]\n 676 | ]\n 677 | \n 678 | \n 679 | MaybeNonSource = Optional[Union[ManifestNode, Disabled[ManifestNode]]]\n 680 | \n 681 | \n 682 | T = TypeVar(\"T\", bound=GraphMemberNode)\n 683 | \n 684 | \n 685 | # This contains macro methods that are in both the Manifest\n 686 | # and the MacroManifest\n 687 | class MacroMethods:\n 688 | # Just to make mypy happy. There must be a better way.\n 689 | def __init__(self):\n 690 | self.macros = []\n 691 | self.metadata = {}\n 692 | self._macros_by_name = {}\n 693 | self._macros_by_package = {}\n 694 | \n 695 | def find_macro_by_name(\n 696 | self, name: str, root_project_name: str, package: Optional[str]\n 697 | ) -> Optional[Macro]:\n 698 | \"\"\"Find a macro in the graph by its name and package name, or None for\n 699 | any package. The root project name is used to determine priority:\n 700 | - locally defined macros come first\n 701 | - then imported macros\n 702 | - then macros defined in the root project\n 703 | \"\"\"\n 704 | filter: Optional[Callable[[MacroCandidate], bool]] = None\n 705 | if package is not None:\n 706 | \n 707 | def filter(candidate: MacroCandidate) -> bool:\n 708 | return package == candidate.macro.package_name\n 709 | \n 710 | candidates: CandidateList = self._find_macros_by_name(\n 711 | name=name,\n 712 | root_project_name=root_project_name,\n 713 | filter=filter,\n 714 | )\n 715 | \n 716 | return candidates.last()\n 717 | \n 718 | def find_generate_macro_by_name(\n 719 | self, component: str, root_project_name: str, imported_package: Optional[str] = None\n 720 | ) -> Optional[Macro]:\n 721 | \"\"\"\n 722 | The default `generate_X_name` macros are similar to regular ones, but only\n 723 | includes imported packages when searching for a package.\n 724 | - if package is not provided:\n 725 | - if there is a `generate_{component}_name` macro in the root\n 726 | project, return it\n 727 | - return the `generate_{component}_name` macro from the 'dbt'\n 728 | internal project\n 729 | - if package is provided\n 730 | - return the `generate_{component}_name` macro from the imported\n 731 | package, if one exists\n 732 | \"\"\"\n 733 | \n 734 | def filter(candidate: MacroCandidate) -> bool:\n 735 | if imported_package:\n 736 | return (\n 737 | candidate.locality == Locality.Imported\n 738 | and imported_package == candidate.macro.package_name\n 739 | )\n 740 | else:\n 741 | return candidate.locality != Locality.Imported\n 742 | \n 743 | candidates: CandidateList = self._find_macros_by_name(\n 744 | name=f\"generate_{component}_name\",\n 745 | root_project_name=root_project_name,\n 746 | filter=filter,\n 747 | )\n 748 | \n 749 | return candidates.last()\n 750 | \n 751 | def _find_macros_by_name(\n 752 | self,\n 753 | name: str,\n 754 | root_project_name: str,\n 755 | filter: Optional[Callable[[MacroCandidate], bool]] = None,\n 756 | ) -> CandidateList:\n 757 | \"\"\"Find macros by their name.\"\"\"\n 758 | # avoid an import cycle\n 759 | from dbt.adapters.factory import get_adapter_package_names\n 760 | \n 761 | candidates: CandidateList = CandidateList()\n 762 | \n 763 | macros_by_name = self.get_macros_by_name()\n 764 | if name not in macros_by_name:\n 765 | return candidates\n 766 | \n 767 | packages = set(get_adapter_package_names(self.metadata.adapter_type))\n 768 | for macro in macros_by_name[name]:\n 769 | candidate = MacroCandidate(\n 770 | locality=_get_locality(macro, root_project_name, packages),\n 771 | macro=macro,\n 772 | )\n 773 | if filter is None or filter(candidate):\n 774 | candidates.append(candidate)\n 775 | \n 776 | return candidates\n 777 | \n 778 | def get_macros_by_name(self) -> Dict[str, List[Macro]]:\n 779 | if self._macros_by_name is None:\n 780 | # The by-name mapping doesn't exist yet (perhaps because the manifest\n 781 | # was deserialized), so we build it.\n 782 | self._macros_by_name = self._build_macros_by_name(self.macros)\n 783 | \n 784 | return self._macros_by_name\n 785 | \n 786 | @staticmethod\n 787 | def _build_macros_by_name(macros: Mapping[str, Macro]) -> Dict[str, List[Macro]]:\n 788 | # Convert a macro dictionary keyed on unique id to a flattened version\n 789 | # keyed on macro name for faster lookup by name. Since macro names are\n 790 | # not necessarily unique, the dict value is a list.\n 791 | macros_by_name: Dict[str, List[Macro]] = {}\n 792 | for macro in macros.values():\n 793 | if macro.name not in macros_by_name:\n 794 | macros_by_name[macro.name] = []\n 795 | \n 796 | macros_by_name[macro.name].append(macro)\n 797 | \n 798 | return macros_by_name\n 799 | \n 800 | def get_macros_by_package(self) -> Dict[str, Dict[str, Macro]]:\n 801 | if self._macros_by_package is None:\n 802 | # The by-package mapping doesn't exist yet (perhaps because the manifest\n 803 | # was deserialized), so we build it.\n 804 | self._macros_by_package = self._build_macros_by_package(self.macros)\n 805 | \n 806 | return self._macros_by_package\n 807 | \n 808 | @staticmethod\n 809 | def _build_macros_by_package(macros: Mapping[str, Macro]) -> Dict[str, Dict[str, Macro]]:\n 810 | # Convert a macro dictionary keyed on unique id to a flattened version\n 811 | # keyed on package name for faster lookup by name.\n 812 | macros_by_package: Dict[str, Dict[str, Macro]] = {}\n 813 | for macro in macros.values():\n 814 | if macro.package_name not in macros_by_package:\n 815 | macros_by_package[macro.package_name] = {}\n 816 | macros_by_name = macros_by_package[macro.package_name]\n 817 | macros_by_name[macro.name] = macro\n 818 | \n 819 | return macros_by_package\n 820 | \n 821 | \n 822 | @dataclass\n 823 | class ParsingInfo:\n 824 | static_analysis_parsed_path_count: int = 0\n 825 | static_analysis_path_count: int = 0\n 826 | \n 827 | \n 828 | @dataclass\n 829 | class ManifestStateCheck(dbtClassMixin):\n 830 | vars_hash: FileHash = field(default_factory=FileHash.empty)\n 831 | project_env_vars_hash: FileHash = field(default_factory=FileHash.empty)\n 832 | profile_env_vars_hash: FileHash = field(default_factory=FileHash.empty)\n 833 | profile_hash: FileHash = field(default_factory=FileHash.empty)\n 834 | project_hashes: MutableMapping[str, FileHash] = field(default_factory=dict)\n 835 | \n 836 | \n 837 | @dataclass\n 838 | class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):\n 839 | \"\"\"The manifest for the full graph, after parsing and during compilation.\"\"\"\n 840 | \n 841 | # These attributes are both positional and by keyword. If an attribute\n 842 | # is added it must all be added in the __reduce_ex__ method in the\n 843 | # args tuple in the right position.\n 844 | nodes: MutableMapping[str, ManifestNode] = field(default_factory=dict)\n 845 | sources: MutableMapping[str, SourceDefinition] = field(default_factory=dict)\n 846 | macros: MutableMapping[str, Macro] = field(default_factory=dict)\n 847 | docs: MutableMapping[str, Documentation] = field(default_factory=dict)\n 848 | exposures: MutableMapping[str, Exposure] = field(default_factory=dict)\n 849 | metrics: MutableMapping[str, Metric] = field(default_factory=dict)\n 850 | groups: MutableMapping[str, Group] = field(default_factory=dict)\n 851 | selectors: MutableMapping[str, Any] = field(default_factory=dict)\n 852 | files: MutableMapping[str, AnySourceFile] = field(default_factory=dict)\n 853 | metadata: ManifestMetadata = field(default_factory=ManifestMetadata)\n 854 | flat_graph: Dict[str, Any] = field(default_factory=dict)\n 855 | state_check: ManifestStateCheck = field(default_factory=ManifestStateCheck)\n 856 | source_patches: MutableMapping[SourceKey, SourcePatch] = field(default_factory=dict)\n 857 | disabled: MutableMapping[str, List[GraphMemberNode]] = field(default_factory=dict)\n 858 | env_vars: MutableMapping[str, str] = field(default_factory=dict)\n 859 | semantic_models: MutableMapping[str, SemanticModel] = field(default_factory=dict)\n 860 | unit_tests: MutableMapping[str, UnitTestDefinition] = field(default_factory=dict)\n 861 | saved_queries: MutableMapping[str, SavedQuery] = field(default_factory=dict)\n 862 | fixtures: MutableMapping[str, UnitTestFileFixture] = field(default_factory=dict)\n 863 | \n 864 | _doc_lookup: Optional[DocLookup] = field(\n 865 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 866 | )\n 867 | _source_lookup: Optional[SourceLookup] = field(\n 868 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 869 | )\n 870 | _ref_lookup: Optional[RefableLookup] = field(\n 871 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 872 | )\n 873 | _metric_lookup: Optional[MetricLookup] = field(\n 874 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 875 | )\n 876 | _saved_query_lookup: Optional[SavedQueryLookup] = field(\n 877 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 878 | )\n 879 | _semantic_model_by_measure_lookup: Optional[SemanticModelByMeasureLookup] = field(\n 880 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 881 | )\n 882 | _disabled_lookup: Optional[DisabledLookup] = field(\n 883 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 884 | )\n 885 | _analysis_lookup: Optional[AnalysisLookup] = field(\n 886 | default=None, metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None}\n 887 | )\n 888 | _parsing_info: ParsingInfo = field(\n 889 | default_factory=ParsingInfo,\n 890 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 891 | )\n 892 | _lock: Lock = field(\n 893 | default_factory=get_mp_context().Lock,\n 894 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 895 | )\n 896 | _macros_by_name: Optional[Dict[str, List[Macro]]] = field(\n 897 | default=None,\n 898 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 899 | )\n 900 | _macros_by_package: Optional[Dict[str, Dict[str, Macro]]] = field(\n 901 | default=None,\n 902 | metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n 903 | )\n 904 | \n 905 | def __pre_serialize__(self):\n 906 | # serialization won't work with anything except an empty source_patches because\n 907 | # tuple keys are not supported, so ensure it's empty\n 908 | self.source_patches = {}\n 909 | return self\n 910 | \n 911 | @classmethod\n 912 | def __post_deserialize__(cls, obj):\n 913 | obj._lock = get_mp_context().Lock()\n 914 | return obj\n 915 | \n 916 | def build_flat_graph(self):\n 917 | \"\"\"This attribute is used in context.common by each node, so we want to\n 918 | only build it once and avoid any concurrency issues around it.\n 919 | Make sure you don't call this until you're done with building your\n 920 | manifest!\n 921 | \"\"\"\n 922 | self.flat_graph = {\n 923 | \"exposures\": {k: v.to_dict(omit_none=False) for k, v in self.exposures.items()},\n 924 | \"groups\": {k: v.to_dict(omit_none=False) for k, v in self.groups.items()},\n 925 | \"metrics\": {k: v.to_dict(omit_none=False) for k, v in self.metrics.items()},\n 926 | \"nodes\": {k: v.to_dict(omit_none=False) for k, v in self.nodes.items()},\n 927 | \"sources\": {k: v.to_dict(omit_none=False) for k, v in self.sources.items()},\n 928 | \"semantic_models\": {\n 929 | k: v.to_dict(omit_none=False) for k, v in self.semantic_models.items()\n 930 | },\n 931 | \"saved_queries\": {\n 932 | k: v.to_dict(omit_none=False) for k, v in self.saved_queries.items()\n 933 | },\n 934 | }\n 935 | \n 936 | def build_disabled_by_file_id(self):\n 937 | disabled_by_file_id = {}\n 938 | for node_list in self.disabled.values():\n 939 | for node in node_list:\n 940 | disabled_by_file_id[node.file_id] = node\n 941 | return disabled_by_file_id\n 942 | \n 943 | def _get_parent_adapter_types(self, adapter_type: str) -> List[str]:\n 944 | # This is duplicated logic from core/dbt/context/providers.py\n 945 | # Ideally this would instead be incorporating actual dispatch logic\n 946 | from dbt.adapters.factory import get_adapter_type_names\n 947 | \n 948 | # order matters for dispatch:\n 949 | # 1. current adapter\n 950 | # 2. any parent adapters (dependencies)\n 951 | # 3. 'default'\n 952 | return get_adapter_type_names(adapter_type) + [\"default\"]\n 953 | \n 954 | def _materialization_candidates_for(\n 955 | self,\n 956 | project_name: str,\n 957 | materialization_name: str,\n 958 | adapter_type: str,\n 959 | specificity: int,\n 960 | ) -> CandidateList:\n 961 | full_name = dbt_common.utils.get_materialization_macro_name(\n 962 | materialization_name=materialization_name,\n 963 | adapter_type=adapter_type,\n 964 | with_prefix=False,\n 965 | )\n 966 | return CandidateList(\n 967 | MaterializationCandidate.from_macro(m, specificity)\n 968 | for m in self._find_macros_by_name(full_name, project_name)\n 969 | )\n 970 | \n 971 | def find_materialization_macro_by_name(\n 972 | self, project_name: str, materialization_name: str, adapter_type: str\n 973 | ) -> Optional[Macro]:\n 974 | candidates: CandidateList = CandidateList(\n 975 | chain.from_iterable(\n 976 | self._materialization_candidates_for(\n 977 | project_name=project_name,\n 978 | materialization_name=materialization_name,\n 979 | adapter_type=atype,\n 980 | specificity=specificity, # where in the inheritance chain this candidate is\n 981 | )\n 982 | for specificity, atype in enumerate(self._get_parent_adapter_types(adapter_type))\n 983 | )\n 984 | )\n 985 | return candidates.last()\n 986 | \n 987 | def get_resource_fqns(self) -> Mapping[str, PathSet]:\n 988 | resource_fqns: Dict[str, Set[Tuple[str, ...]]] = {}\n 989 | all_resources = chain(\n 990 | self.exposures.values(),\n 991 | self.nodes.values(),\n 992 | self.sources.values(),\n 993 | self.metrics.values(),\n 994 | self.semantic_models.values(),\n 995 | self.saved_queries.values(),\n 996 | )\n 997 | for resource in all_resources:\n 998 | resource_type_plural = resource.resource_type.pluralize()\n 999 | if resource_type_plural not in resource_fqns:\n1000 | resource_fqns[resource_type_plural] = set()\n1001 | resource_fqns[resource_type_plural].add(tuple(resource.fqn))\n1002 | return resource_fqns\n1003 | \n1004 | def get_used_schemas(self, resource_types=None):\n1005 | return frozenset(\n1006 | {\n1007 | (node.database, node.schema)\n1008 | for node in chain(self.nodes.values(), self.sources.values())\n1009 | if not resource_types or node.resource_type in resource_types\n1010 | }\n1011 | )\n1012 | \n1013 | def get_used_databases(self):\n1014 | return frozenset(x.database for x in chain(self.nodes.values(), self.sources.values()))\n1015 | \n1016 | def deepcopy(self):\n1017 | copy = Manifest(\n1018 | nodes={k: _deepcopy(v) for k, v in self.nodes.items()},\n1019 | sources={k: _deepcopy(v) for k, v in self.sources.items()},\n1020 | macros={k: _deepcopy(v) for k, v in self.macros.items()},\n1021 | docs={k: _deepcopy(v) for k, v in self.docs.items()},\n1022 | exposures={k: _deepcopy(v) for k, v in self.exposures.items()},\n1023 | metrics={k: _deepcopy(v) for k, v in self.metrics.items()},\n1024 | groups={k: _deepcopy(v) for k, v in self.groups.items()},\n1025 | selectors={k: _deepcopy(v) for k, v in self.selectors.items()},\n1026 | metadata=self.metadata,\n1027 | disabled={k: _deepcopy(v) for k, v in self.disabled.items()},\n1028 | files={k: _deepcopy(v) for k, v in self.files.items()},\n1029 | state_check=_deepcopy(self.state_check),\n1030 | semantic_models={k: _deepcopy(v) for k, v in self.semantic_models.items()},\n1031 | unit_tests={k: _deepcopy(v) for k, v in self.unit_tests.items()},\n1032 | saved_queries={k: _deepcopy(v) for k, v in self.saved_queries.items()},\n1033 | )\n1034 | copy.build_flat_graph()\n1035 | return copy\n1036 | \n1037 | def build_parent_and_child_maps(self):\n1038 | edge_members = list(\n1039 | chain(\n1040 | self.nodes.values(),\n1041 | self.sources.values(),\n1042 | self.exposures.values(),\n1043 | self.metrics.values(),\n1044 | self.semantic_models.values(),\n1045 | self.saved_queries.values(),\n1046 | )\n1047 | )\n1048 | forward_edges, backward_edges = build_node_edges(edge_members)\n1049 | self.child_map = forward_edges\n1050 | self.parent_map = backward_edges\n1051 | \n1052 | def build_macro_child_map(self):\n1053 | edge_members = list(\n1054 | chain(\n1055 | self.nodes.values(),\n1056 | self.macros.values(),\n1057 | )\n1058 | )\n1059 | forward_edges = build_macro_edges(edge_members)\n1060 | return forward_edges\n1061 | \n1062 | def build_group_map(self):\n1063 | groupable_nodes = list(\n1064 | chain(\n1065 | self.nodes.values(),\n1066 | self.saved_queries.values(),\n1067 | self.semantic_models.values(),\n1068 | self.metrics.values(),\n1069 | )\n1070 | )\n1071 | group_map = {group.name: [] for group in self.groups.values()}\n1072 | for node in groupable_nodes:\n1073 | if node.group is not None:\n1074 | # group updates are not included with state:modified and\n1075 | # by ignoring the groups that aren't in the group map we\n1076 | # can avoid hitting errors for groups that are not getting\n1077 | # updated. This is a hack but any groups that are not\n1078 | # valid will be caught in\n1079 | # parser.manifest.ManifestLoader.check_valid_group_config_node\n1080 | if node.group in group_map:\n1081 | group_map[node.group].append(node.unique_id)\n1082 | self.group_map = group_map\n1083 | \n1084 | def writable_manifest(self) -> \"WritableManifest\":\n1085 | self.build_parent_and_child_maps()\n1086 | self.build_group_map()\n1087 | return WritableManifest(\n1088 | nodes=self.nodes,\n1089 | sources=self.sources,\n1090 | macros=self.macros,\n1091 | docs=self.docs,\n1092 | exposures=self.exposures,\n1093 | metrics=self.metrics,\n1094 | groups=self.groups,\n1095 | selectors=self.selectors,\n1096 | metadata=self.metadata,\n1097 | disabled=self.disabled,\n1098 | child_map=self.child_map,\n1099 | parent_map=self.parent_map,\n1100 | group_map=self.group_map,\n1101 | semantic_models=self.semantic_models,\n1102 | unit_tests=self.unit_tests,\n1103 | saved_queries=self.saved_queries,\n1104 | )\n1105 | \n1106 | def write(self, path):\n1107 | self.writable_manifest().write(path)\n1108 | \n1109 | # Called in dbt.compilation.Linker.write_graph and\n1110 | # dbt.graph.queue.get and ._include_in_cost\n1111 | def expect(self, unique_id: str) -> GraphMemberNode:\n1112 | if unique_id in self.nodes:\n1113 | return self.nodes[unique_id]\n1114 | elif unique_id in self.sources:\n1115 | return self.sources[unique_id]\n1116 | elif unique_id in self.exposures:\n1117 | return self.exposures[unique_id]\n1118 | elif unique_id in self.metrics:\n1119 | return self.metrics[unique_id]\n1120 | elif unique_id in self.semantic_models:\n1121 | return self.semantic_models[unique_id]\n1122 | elif unique_id in self.unit_tests:\n1123 | return self.unit_tests[unique_id]\n1124 | elif unique_id in self.saved_queries:\n1125 | return self.saved_queries[unique_id]\n1126 | else:\n1127 | # something terrible has happened\n1128 | raise dbt_common.exceptions.DbtInternalError(\n1129 | \"Expected node {} not found in manifest\".format(unique_id)\n1130 | )\n1131 | \n1132 | @property\n1133 | def doc_lookup(self) -> DocLookup:\n1134 | if self._doc_lookup is None:\n1135 | self._doc_lookup = DocLookup(self)\n1136 | return self._doc_lookup\n1137 | \n1138 | def rebuild_doc_lookup(self):\n1139 | self._doc_lookup = DocLookup(self)\n1140 | \n1141 | @property\n1142 | def source_lookup(self) -> SourceLookup:\n1143 | if self._source_lookup is None:\n1144 | self._source_lookup = SourceLookup(self)\n1145 | return self._source_lookup\n1146 | \n1147 | def rebuild_source_lookup(self):\n1148 | self._source_lookup = SourceLookup(self)\n1149 | \n1150 | @property\n1151 | def ref_lookup(self) -> RefableLookup:\n1152 | if self._ref_lookup is None:\n1153 | self._ref_lookup = RefableLookup(self)\n1154 | return self._ref_lookup\n1155 | \n1156 | @property\n1157 | def metric_lookup(self) -> MetricLookup:\n1158 | if self._metric_lookup is None:\n1159 | self._metric_lookup = MetricLookup(self)\n1160 | return self._metric_lookup\n1161 | \n1162 | @property\n1163 | def saved_query_lookup(self) -> SavedQueryLookup:\n1164 | \"\"\"Retuns a SavedQueryLookup, instantiating it first if necessary.\"\"\"\n1165 | if self._saved_query_lookup is None:\n1166 | self._saved_query_lookup = SavedQueryLookup(self)\n1167 | return self._saved_query_lookup\n1168 | \n1169 | @property\n1170 | def semantic_model_by_measure_lookup(self) -> SemanticModelByMeasureLookup:\n1171 | \"\"\"Gets (and creates if necessary) the lookup utility for getting SemanticModels by measures\"\"\"\n1172 | if self._semantic_model_by_measure_lookup is None:\n1173 | self._semantic_model_by_measure_lookup = SemanticModelByMeasureLookup(self)\n1174 | return self._semantic_model_by_measure_lookup\n1175 | \n1176 | def rebuild_ref_lookup(self):\n1177 | self._ref_lookup = RefableLookup(self)\n1178 | \n1179 | @property\n1180 | def disabled_lookup(self) -> DisabledLookup:\n1181 | if self._disabled_lookup is None:\n1182 | self._disabled_lookup = DisabledLookup(self)\n1183 | return self._disabled_lookup\n1184 | \n1185 | def rebuild_disabled_lookup(self):\n1186 | self._disabled_lookup = DisabledLookup(self)\n1187 | \n1188 | @property\n1189 | def analysis_lookup(self) -> AnalysisLookup:\n1190 | if self._analysis_lookup is None:\n1191 | self._analysis_lookup = AnalysisLookup(self)\n1192 | return self._analysis_lookup\n1193 | \n1194 | @property\n1195 | def external_node_unique_ids(self):\n1196 | return [node.unique_id for node in self.nodes.values() if node.is_external_node]\n1197 | \n1198 | def resolve_refs(\n1199 | self,\n1200 | source_node: ModelNode,\n1201 | current_project: str, # TODO: ModelNode is overly restrictive typing\n1202 | ) -> List[MaybeNonSource]:\n1203 | resolved_refs: List[MaybeNonSource] = []\n1204 | for ref in source_node.refs:\n1205 | resolved = self.resolve_ref(\n1206 | source_node,\n1207 | ref.name,\n1208 | ref.package,\n1209 | ref.version,\n1210 | current_project,\n1211 | source_node.package_name,\n1212 | )\n1213 | resolved_refs.append(resolved)\n1214 | \n1215 | return resolved_refs\n1216 | \n1217 | # Called by dbt.parser.manifest._process_refs & ManifestLoader.check_for_model_deprecations\n1218 | def resolve_ref(\n1219 | self,\n1220 | source_node: GraphMemberNode,\n1221 | target_model_name: str,\n1222 | target_model_package: Optional[str],\n1223 | target_model_version: Optional[NodeVersion],\n1224 | current_project: str,\n1225 | node_package: str,\n1226 | ) -> MaybeNonSource:\n1227 | \n1228 | node: Optional[ManifestNode] = None\n1229 | disabled: Optional[List[ManifestNode]] = None\n1230 | \n1231 | candidates = _packages_to_search(current_project, node_package, target_model_package)\n1232 | for pkg in candidates:\n1233 | node = self.ref_lookup.find(\n1234 | target_model_name, pkg, target_model_version, self, source_node\n1235 | )\n1236 | \n1237 | if node is not None and hasattr(node, \"config\") and node.config.enabled:\n1238 | return node\n1239 | \n1240 | # it's possible that the node is disabled\n1241 | if disabled is None:\n1242 | disabled = self.disabled_lookup.find(target_model_name, pkg, target_model_version)\n1243 | \n1244 | if disabled:\n1245 | return Disabled(disabled[0])\n1246 | return None\n1247 | \n1248 | # Called by dbt.parser.manifest._resolve_sources_for_exposure\n1249 | # and dbt.parser.manifest._process_source_for_node\n1250 | def resolve_source(\n1251 | self,\n1252 | target_source_name: str,\n1253 | target_table_name: str,\n1254 | current_project: str,\n1255 | node_package: str,\n1256 | ) -> MaybeParsedSource:\n1257 | search_name = f\"{target_source_name}.{target_table_name}\"\n1258 | candidates = _packages_to_search(current_project, node_package)\n1259 | \n1260 | source: Optional[SourceDefinition] = None\n1261 | disabled: Optional[List[SourceDefinition]] = None\n1262 | \n1263 | for pkg in candidates:\n1264 | source = self.source_lookup.find(search_name, pkg, self)\n1265 | if source is not None and source.config.enabled:\n1266 | return source\n1267 | \n1268 | if disabled is None:\n1269 | disabled = self.disabled_lookup.find(\n1270 | f\"{target_source_name}.{target_table_name}\", pkg\n1271 | )\n1272 | \n1273 | if disabled:\n1274 | return Disabled(disabled[0])\n1275 | return None\n1276 | \n1277 | def resolve_metric(\n1278 | self,\n1279 | target_metric_name: str,\n1280 | target_metric_package: Optional[str],\n1281 | current_project: str,\n1282 | node_package: str,\n1283 | ) -> MaybeMetricNode:\n1284 | \n1285 | metric: Optional[Metric] = None\n1286 | disabled: Optional[List[Metric]] = None\n1287 | \n1288 | candidates = _packages_to_search(current_project, node_package, target_metric_package)\n1289 | for pkg in candidates:\n1290 | metric = self.metric_lookup.find(target_metric_name, pkg, self)\n1291 | \n1292 | if metric is not None and metric.config.enabled:\n1293 | return metric\n1294 | \n1295 | # it's possible that the node is disabled\n1296 | if disabled is None:\n1297 | disabled = self.disabled_lookup.find(f\"{target_metric_name}\", pkg)\n1298 | if disabled:\n1299 | return Disabled(disabled[0])\n1300 | return None\n1301 | \n1302 | def resolve_saved_query(\n1303 | self,\n1304 | target_saved_query_name: str,\n1305 | target_saved_query_package: Optional[str],\n1306 | current_project: str,\n1307 | node_package: str,\n1308 | ) -> MaybeSavedQueryNode:\n1309 | \"\"\"Tries to find the SavedQuery by name within the available project and packages.\n1310 | \n1311 | Will return the first enabled SavedQuery matching the name found while iterating over\n1312 | the scoped packages. If no enabled SavedQuery node match is found, returns the last\n1313 | disabled SavedQuery node. Otherwise it returns None.\n1314 | \"\"\"\n1315 | disabled: Optional[List[SavedQuery]] = None\n1316 | candidates = _packages_to_search(current_project, node_package, target_saved_query_package)\n1317 | for pkg in candidates:\n1318 | saved_query = self.saved_query_lookup.find(target_saved_query_name, pkg, self)\n1319 | \n1320 | if saved_query is not None and saved_query.config.enabled:\n1321 | return saved_query\n1322 | \n1323 | # it's possible that the node is disabled\n1324 | if disabled is None:\n1325 | disabled = self.disabled_lookup.find(f\"{target_saved_query_name}\", pkg)\n1326 | if disabled:\n1327 | return Disabled(disabled[0])\n1328 | \n1329 | return None\n1330 | \n1331 | def resolve_semantic_model_for_measure(\n1332 | self,\n1333 | target_measure_name: str,\n1334 | current_project: str,\n1335 | node_package: str,\n1336 | target_package: Optional[str] = None,\n1337 | ) -> Optional[SemanticModel]:\n1338 | \"\"\"Tries to find the SemanticModel that a measure belongs to\"\"\"\n1339 | candidates = _packages_to_search(current_project, node_package, target_package)\n1340 | \n1341 | for pkg in candidates:\n1342 | semantic_model = self.semantic_model_by_measure_lookup.find(\n1343 | target_measure_name, pkg, self\n1344 | )\n1345 | # need to return it even if it's disabled so know it's not fully missing\n1346 | if semantic_model is not None:\n1347 | return semantic_model\n1348 | \n1349 | return None\n1350 | \n1351 | # Called by DocsRuntimeContext.doc\n1352 | def resolve_doc(\n1353 | self,\n1354 | name: str,\n1355 | package: Optional[str],\n1356 | current_project: str,\n1357 | node_package: str,\n1358 | ) -> Optional[Documentation]:\n1359 | \"\"\"Resolve the given documentation. This follows the same algorithm as\n1360 | resolve_ref except the is_enabled checks are unnecessary as docs are\n1361 | always enabled.\n1362 | \"\"\"\n1363 | candidates = _packages_to_search(current_project, node_package, package)\n1364 | \n1365 | for pkg in candidates:\n1366 | result = self.doc_lookup.find(name, pkg, self)\n1367 | if result is not None:\n1368 | return result\n1369 | return None\n1370 | \n1371 | def is_invalid_private_ref(\n1372 | self, node: GraphMemberNode, target_model: MaybeNonSource, dependencies: Optional[Mapping]\n1373 | ) -> bool:\n1374 | dependencies = dependencies or {}\n1375 | if not isinstance(target_model, ModelNode):\n1376 | return False\n1377 | \n1378 | is_private_ref = (\n1379 | target_model.access == AccessType.Private\n1380 | # don't raise this reference error for ad hoc 'preview' queries\n1381 | and node.resource_type != NodeType.SqlOperation\n1382 | and node.resource_type != NodeType.RPCCall # TODO: rm\n1383 | )\n1384 | target_dependency = dependencies.get(target_model.package_name)\n1385 | restrict_package_access = target_dependency.restrict_access if target_dependency else False\n1386 | \n1387 | # TODO: SemanticModel and SourceDefinition do not have group, and so should not be able to make _any_ private ref.\n1388 | return is_private_ref and (\n1389 | not hasattr(node, \"group\")\n1390 | or not node.group\n1391 | or node.group != target_model.group\n1392 | or restrict_package_access\n1393 | )\n1394 | \n1395 | def is_invalid_protected_ref(\n1396 | self, node: GraphMemberNode, target_model: MaybeNonSource, dependencies: Optional[Mapping]\n1397 | ) -> bool:\n1398 | dependencies = dependencies or {}\n1399 | if not isinstance(target_model, ModelNode):\n1400 | return False\n1401 | \n1402 | is_protected_ref = (\n1403 | target_model.access == AccessType.Protected\n1404 | # don't raise this reference error for ad hoc 'preview' queries\n1405 | and node.resource_type != NodeType.SqlOperation\n1406 | and node.resource_type != NodeType.RPCCall # TODO: rm\n1407 | )\n1408 | target_dependency = dependencies.get(target_model.package_name)\n1409 | restrict_package_access = target_dependency.restrict_access if target_dependency else False\n1410 | \n1411 | return is_protected_ref and (\n1412 | node.package_name != target_model.package_name and restrict_package_access\n1413 | )\n1414 | \n1415 | # Called by GraphRunnableTask.defer_to_manifest\n1416 | def merge_from_artifact(\n1417 | self,\n1418 | adapter,\n1419 | other: \"WritableManifest\",\n1420 | selected: AbstractSet[UniqueID],\n1421 | favor_state: bool = False,\n1422 | ) -> None:\n1423 | \"\"\"Given the selected unique IDs and a writable manifest, update this\n1424 | manifest by replacing any unselected nodes with their counterpart.\n1425 | \n1426 | Only non-ephemeral refable nodes are examined.\n1427 | \"\"\"\n1428 | refables = set(NodeType.refable())\n1429 | merged = set()\n1430 | for unique_id, node in other.nodes.items():\n1431 | current = self.nodes.get(unique_id)\n1432 | if current and (\n1433 | node.resource_type in refables\n1434 | and not node.is_ephemeral\n1435 | and unique_id not in selected\n1436 | and (\n1437 | not adapter.get_relation(current.database, current.schema, current.identifier)\n1438 | or favor_state\n1439 | )\n1440 | ):\n1441 | merged.add(unique_id)\n1442 | self.nodes[unique_id] = node.replace(deferred=True)\n1443 | \n1444 | # for all other nodes, add 'defer_relation'\n1445 | elif current and node.resource_type in refables and not node.is_ephemeral:\n1446 | defer_relation = DeferRelation(\n1447 | node.database, node.schema, node.alias, node.relation_name\n1448 | )\n1449 | self.nodes[unique_id] = current.replace(defer_relation=defer_relation)\n1450 | \n1451 | # Rebuild the flat_graph, which powers the 'graph' context variable,\n1452 | # now that we've deferred some nodes\n1453 | self.build_flat_graph()\n1454 | \n1455 | # log up to 5 items\n1456 | sample = list(islice(merged, 5))\n1457 | fire_event(MergedFromState(num_merged=len(merged), sample=sample))\n1458 | \n1459 | # Methods that were formerly in ParseResult\n1460 | \n1461 | def add_macro(self, source_file: SourceFile, macro: Macro):\n1462 | if macro.unique_id in self.macros:\n1463 | # detect that the macro exists and emit an error\n1464 | raise DuplicateMacroInPackageError(macro=macro, macro_mapping=self.macros)\n1465 | \n1466 | self.macros[macro.unique_id] = macro\n1467 | \n1468 | if self._macros_by_name is None:\n1469 | self._macros_by_name = self._build_macros_by_name(self.macros)\n1470 | \n1471 | if macro.name not in self._macros_by_name:\n1472 | self._macros_by_name[macro.name] = []\n1473 | \n1474 | self._macros_by_name[macro.name].append(macro)\n1475 | \n1476 | if self._macros_by_package is None:\n1477 | self._macros_by_package = self._build_macros_by_package(self.macros)\n1478 | \n1479 | if macro.package_name not in self._macros_by_package:\n1480 | self._macros_by_package[macro.package_name] = {}\n1481 | \n1482 | self._macros_by_package[macro.package_name][macro.name] = macro\n1483 | \n1484 | source_file.macros.append(macro.unique_id)\n1485 | \n1486 | def has_file(self, source_file: SourceFile) -> bool:\n1487 | key = source_file.file_id\n1488 | if key is None:\n1489 | return False\n1490 | if key not in self.files:\n1491 | return False\n1492 | my_checksum = self.files[key].checksum\n1493 | return my_checksum == source_file.checksum\n1494 | \n1495 | def add_source(self, source_file: SchemaSourceFile, source: UnpatchedSourceDefinition):\n1496 | # sources can't be overwritten!\n1497 | _check_duplicates(source, self.sources)\n1498 | self.sources[source.unique_id] = source # type: ignore\n1499 | source_file.sources.append(source.unique_id)\n1500 | \n1501 | def add_node_nofile(self, node: ManifestNode):\n1502 | # nodes can't be overwritten!\n1503 | _check_duplicates(node, self.nodes)\n1504 | self.nodes[node.unique_id] = node\n1505 | \n1506 | def add_node(self, source_file: AnySourceFile, node: ManifestNode, test_from=None):\n1507 | self.add_node_nofile(node)\n1508 | if isinstance(source_file, SchemaSourceFile):\n1509 | if isinstance(node, GenericTestNode):\n1510 | assert test_from\n1511 | source_file.add_test(node.unique_id, test_from)\n1512 | if isinstance(node, Metric):\n1513 | source_file.metrics.append(node.unique_id)\n1514 | if isinstance(node, Exposure):\n1515 | source_file.exposures.append(node.unique_id)\n1516 | if isinstance(node, Group):\n1517 | source_file.groups.append(node.unique_id)\n1518 | elif isinstance(source_file, FixtureSourceFile):\n1519 | pass\n1520 | else:\n1521 | source_file.nodes.append(node.unique_id)\n1522 | \n1523 | def add_exposure(self, source_file: SchemaSourceFile, exposure: Exposure):\n1524 | _check_duplicates(exposure, self.exposures)\n1525 | self.exposures[exposure.unique_id] = exposure\n1526 | source_file.exposures.append(exposure.unique_id)\n1527 | \n1528 | def add_metric(self, source_file: SchemaSourceFile, metric: Metric, generated: bool = False):\n1529 | _check_duplicates(metric, self.metrics)\n1530 | self.metrics[metric.unique_id] = metric\n1531 | if not generated:\n1532 | source_file.metrics.append(metric.unique_id)\n1533 | else:\n1534 | source_file.generated_metrics.append(metric.unique_id)\n1535 | \n1536 | def add_group(self, source_file: SchemaSourceFile, group: Group):\n1537 | _check_duplicates(group, self.groups)\n1538 | self.groups[group.unique_id] = group\n1539 | source_file.groups.append(group.unique_id)\n1540 | \n1541 | def add_disabled_nofile(self, node: GraphMemberNode):\n1542 | # There can be multiple disabled nodes for the same unique_id\n1543 | if node.unique_id in self.disabled:\n1544 | self.disabled[node.unique_id].append(node)\n1545 | else:\n1546 | self.disabled[node.unique_id] = [node]\n1547 | \n1548 | def add_disabled(self, source_file: AnySourceFile, node: ResultNode, test_from=None):\n1549 | self.add_disabled_nofile(node)\n1550 | if isinstance(source_file, SchemaSourceFile):\n1551 | if isinstance(node, GenericTestNode):\n1552 | assert test_from\n1553 | source_file.add_test(node.unique_id, test_from)\n1554 | if isinstance(node, Metric):\n1555 | source_file.metrics.append(node.unique_id)\n1556 | if isinstance(node, SavedQuery):\n1557 | source_file.saved_queries.append(node.unique_id)\n1558 | if isinstance(node, SemanticModel):\n1559 | source_file.semantic_models.append(node.unique_id)\n1560 | if isinstance(node, Exposure):\n1561 | source_file.exposures.append(node.unique_id)\n1562 | elif isinstance(source_file, FixtureSourceFile):\n1563 | pass\n1564 | else:\n1565 | source_file.nodes.append(node.unique_id)\n1566 | \n1567 | def add_doc(self, source_file: SourceFile, doc: Documentation):\n1568 | _check_duplicates(doc, self.docs)\n1569 | self.docs[doc.unique_id] = doc\n1570 | source_file.docs.append(doc.unique_id)\n1571 | \n1572 | def add_semantic_model(self, source_file: SchemaSourceFile, semantic_model: SemanticModel):\n1573 | _check_duplicates(semantic_model, self.semantic_models)\n1574 | self.semantic_models[semantic_model.unique_id] = semantic_model\n1575 | source_file.semantic_models.append(semantic_model.unique_id)\n1576 | \n1577 | def add_unit_test(self, source_file: SchemaSourceFile, unit_test: UnitTestDefinition):\n1578 | if unit_test.unique_id in self.unit_tests:\n1579 | raise DuplicateResourceNameError(unit_test, self.unit_tests[unit_test.unique_id])\n1580 | self.unit_tests[unit_test.unique_id] = unit_test\n1581 | source_file.unit_tests.append(unit_test.unique_id)\n1582 | \n1583 | def add_fixture(self, source_file: FixtureSourceFile, fixture: UnitTestFileFixture):\n1584 | if fixture.unique_id in self.fixtures:\n1585 | raise DuplicateResourceNameError(fixture, self.fixtures[fixture.unique_id])\n1586 | self.fixtures[fixture.unique_id] = fixture\n1587 | source_file.fixture = fixture.unique_id\n1588 | \n1589 | def add_saved_query(self, source_file: SchemaSourceFile, saved_query: SavedQuery) -> None:\n1590 | _check_duplicates(saved_query, self.saved_queries)\n1591 | self.saved_queries[saved_query.unique_id] = saved_query\n1592 | source_file.saved_queries.append(saved_query.unique_id)\n1593 | \n1594 | # end of methods formerly in ParseResult\n1595 | \n1596 | # Provide support for copy.deepcopy() - we just need to avoid the lock!\n1597 | # pickle and deepcopy use this. It returns a callable object used to\n1598 | # create the initial version of the object and a tuple of arguments\n1599 | # for the object, i.e. the Manifest.\n1600 | # The order of the arguments must match the order of the attributes\n1601 | # in the Manifest class declaration, because they are used as\n1602 | # positional arguments to construct a Manifest.\n1603 | def __reduce_ex__(self, protocol):\n1604 | args = (\n1605 | self.nodes,\n1606 | self.sources,\n1607 | self.macros,\n1608 | self.docs,\n1609 | self.exposures,\n1610 | self.metrics,\n1611 | self.groups,\n1612 | self.selectors,\n1613 | self.files,\n1614 | self.metadata,\n1615 | self.flat_graph,\n1616 | self.state_check,\n1617 | self.source_patches,\n1618 | self.disabled,\n1619 | self.env_vars,\n1620 | self.semantic_models,\n1621 | self.unit_tests,\n1622 | self.saved_queries,\n1623 | self._doc_lookup,\n1624 | self._source_lookup,\n1625 | self._ref_lookup,\n1626 | self._metric_lookup,\n1627 | self._semantic_model_by_measure_lookup,\n1628 | self._disabled_lookup,\n1629 | self._analysis_lookup,\n1630 | )\n1631 | return self.__class__, args\n1632 | \n1633 | \n1634 | class MacroManifest(MacroMethods):\n1635 | def __init__(self, macros) -> None:\n1636 | self.macros = macros\n1637 | self.metadata = ManifestMetadata()\n1638 | # This is returned by the 'graph' context property\n1639 | # in the ProviderContext class.\n1640 | self.flat_graph: Dict[str, Any] = {}\n1641 | self._macros_by_name: Optional[Dict[str, List[Macro]]] = None\n1642 | self._macros_by_package: Optional[Dict[str, Dict[str, Macro]]] = None\n1643 | \n1644 | \n1645 | AnyManifest = Union[Manifest, MacroManifest]\n1646 | \n1647 | \n1648 | @dataclass\n1649 | @schema_version(\"manifest\", 12)\n1650 | class WritableManifest(ArtifactMixin):\n1651 | nodes: Mapping[UniqueID, ManifestNode] = field(\n1652 | metadata=dict(description=(\"The nodes defined in the dbt project and its dependencies\"))\n1653 | )\n1654 | sources: Mapping[UniqueID, SourceDefinition] = field(\n1655 | metadata=dict(description=(\"The sources defined in the dbt project and its dependencies\"))\n1656 | )\n1657 | macros: Mapping[UniqueID, Macro] = field(\n1658 | metadata=dict(description=(\"The macros defined in the dbt project and its dependencies\"))\n1659 | )\n1660 | docs: Mapping[UniqueID, Documentation] = field(\n1661 | metadata=dict(description=(\"The docs defined in the dbt project and its dependencies\"))\n1662 | )\n1663 | exposures: Mapping[UniqueID, Exposure] = field(\n1664 | metadata=dict(\n1665 | description=(\"The exposures defined in the dbt project and its dependencies\")\n1666 | )\n1667 | )\n1668 | metrics: Mapping[UniqueID, Metric] = field(\n1669 | metadata=dict(description=(\"The metrics defined in the dbt project and its dependencies\"))\n1670 | )\n1671 | groups: Mapping[UniqueID, Group] = field(\n1672 | metadata=dict(description=(\"The groups defined in the dbt project\"))\n1673 | )\n1674 | selectors: Mapping[UniqueID, Any] = field(\n1675 | metadata=dict(description=(\"The selectors defined in selectors.yml\"))\n1676 | )\n1677 | disabled: Optional[Mapping[UniqueID, List[GraphMemberNode]]] = field(\n1678 | metadata=dict(description=\"A mapping of the disabled nodes in the target\")\n1679 | )\n1680 | parent_map: Optional[NodeEdgeMap] = field(\n1681 | metadata=dict(\n1682 | description=\"A mapping from child nodes to their dependencies\",\n1683 | )\n1684 | )\n1685 | child_map: Optional[NodeEdgeMap] = field(\n1686 | metadata=dict(\n1687 | description=\"A mapping from parent nodes to their dependents\",\n1688 | )\n1689 | )\n1690 | group_map: Optional[NodeEdgeMap] = field(\n1691 | metadata=dict(\n1692 | description=\"A mapping from group names to their nodes\",\n1693 | )\n1694 | )\n1695 | saved_queries: Mapping[UniqueID, SavedQuery] = field(\n1696 | metadata=dict(description=(\"The saved queries defined in the dbt project\"))\n1697 | )\n1698 | semantic_models: Mapping[UniqueID, SemanticModel] = field(\n1699 | metadata=dict(description=(\"The semantic models defined in the dbt project\"))\n1700 | )\n1701 | metadata: ManifestMetadata = field(\n1702 | metadata=dict(\n1703 | description=\"Metadata about the manifest\",\n1704 | )\n1705 | )\n1706 | unit_tests: Mapping[UniqueID, UnitTestDefinition] = field(\n1707 | metadata=dict(\n1708 | description=\"The unit tests defined in the project\",\n1709 | )\n1710 | )\n1711 | \n1712 | @classmethod\n1713 | def compatible_previous_versions(cls) -> Iterable[Tuple[str, int]]:\n1714 | return [\n1715 | (\"manifest\", 4),\n1716 | (\"manifest\", 5),\n1717 | (\"manifest\", 6),\n1718 | (\"manifest\", 7),\n1719 | (\"manifest\", 8),\n1720 | (\"manifest\", 9),\n1721 | (\"manifest\", 10),\n1722 | (\"manifest\", 11),\n1723 | ]\n1724 | \n1725 | @classmethod\n1726 | def upgrade_schema_version(cls, data):\n1727 | \"\"\"This overrides the \"upgrade_schema_version\" call in VersionedSchema (via\n1728 | ArtifactMixin) to modify the dictionary passed in from earlier versions of the manifest.\"\"\"\n1729 | manifest_schema_version = get_artifact_schema_version(data)\n1730 | if manifest_schema_version <= 10:\n1731 | data = upgrade_manifest_json(data, manifest_schema_version)\n1732 | return cls.from_dict(data)\n1733 | \n1734 | def __post_serialize__(self, dct):\n1735 | for unique_id, node in dct[\"nodes\"].items():\n1736 | if \"config_call_dict\" in node:\n1737 | del node[\"config_call_dict\"]\n1738 | if \"defer_relation\" in node:\n1739 | del node[\"defer_relation\"]\n1740 | return dct\n1741 | \n1742 | \n1743 | def _check_duplicates(value: BaseNode, src: Mapping[str, BaseNode]):\n1744 | if value.unique_id in src:\n1745 | raise DuplicateResourceNameError(value, src[value.unique_id])\n1746 | \n1747 | \n1748 | K_T = TypeVar(\"K_T\")\n1749 | V_T = TypeVar(\"V_T\")\n1750 | \n1751 | \n1752 | def _expect_value(key: K_T, src: Mapping[K_T, V_T], old_file: SourceFile, name: str) -> V_T:\n1753 | if key not in src:\n1754 | raise CompilationError(\n1755 | 'Expected to find \"{}\" in cached \"result.{}\" based '\n1756 | \"on cached file information: {}!\".format(key, name, old_file)\n1757 | )\n1758 | return src[key]\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/context/macros.py b/core/dbt/context/macros.py\nindex 0000000..0000000 100644\n--- a/core/dbt/context/macros.py\n+++ b/core/dbt/context/macros.py\n@@ -67,7 +67,6 @@ class MacroNamespace(Mapping):\n raise KeyError(key)\n \n def get_from_package(self, package_name: Optional[str], name: str) -> Optional[MacroGenerator]:\n- pkg: FlatNamespace\n if package_name is None:\n return self.get(name)\n elif package_name == GLOBAL_PROJECT_NAME:\n@@ -125,7 +124,7 @@ class MacroNamespaceBuilder:\n raise DuplicateMacroNameError(macro_func.macro, macro, macro.package_name)\n hierarchy[macro.package_name][macro.name] = macro_func\n \n- def add_macro(self, macro: Macro, ctx: Dict[str, Any]):\n+ def add_macro(self, macro: Macro, ctx: Dict[str, Any]) -> None:\n macro_name: str = macro.name\n \n # MacroGenerator is in clients/jinja.py\n@@ -147,12 +146,15 @@ class MacroNamespaceBuilder:\n elif macro.package_name == self.root_package:\n self.globals[macro_name] = macro_func\n \n- def add_macros(self, macros: Iterable[Macro], ctx: Dict[str, Any]):\n+ def add_macros(self, macros: Iterable[Macro], ctx: Dict[str, Any]) -> None:\n for macro in macros:\n self.add_macro(macro, ctx)\n \n- def build_namespace(self, macros: Iterable[Macro], ctx: Dict[str, Any]) -> MacroNamespace:\n- self.add_macros(macros, ctx)\n+ def build_namespace(\n+ self, macros_by_package: Dict[str, Dict[str, Macro]], ctx: Dict[str, Any]\n+ ) -> MacroNamespace:\n+ for package in macros_by_package.values():\n+ self.add_macros(package.values(), ctx)\n \n # Iterate in reverse-order and overwrite: the packages that are first\n # in the list are the ones we want to \"win\".\ndiff --git a/core/dbt/context/manifest.py b/core/dbt/context/manifest.py\nindex 0000000..0000000 100644\n--- a/core/dbt/context/manifest.py\n+++ b/core/dbt/context/manifest.py\n@@ -8,7 +8,7 @@ from .base import contextproperty\n \n \n from .configured import ConfiguredContext\n-from .macros import MacroNamespaceBuilder\n+from .macros import MacroNamespace, MacroNamespaceBuilder\n \n \n class ManifestContext(ConfiguredContext):\n@@ -36,11 +36,11 @@ class ManifestContext(ConfiguredContext):\n # to be able to do: namespace.get_from_package(..)\n self.namespace = self._build_namespace()\n \n- def _build_namespace(self):\n+ def _build_namespace(self) -> MacroNamespace:\n # this takes all the macros in the manifest and adds them\n # to the MacroNamespaceBuilder stored in self.namespace\n builder = self._get_namespace_builder()\n- return builder.build_namespace(self.manifest.macros.values(), self._ctx)\n+ return builder.build_namespace(self.manifest.get_macros_by_package(), self._ctx)\n \n def _get_namespace_builder(self) -> MacroNamespaceBuilder:\n # avoid an import loop\n@@ -65,6 +65,7 @@ class ManifestContext(ConfiguredContext):\n dct.update(self.namespace.project_namespace)\n else:\n dct.update(self.namespace)\n+\n return dct\n \n @contextproperty()\ndiff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/manifest.py\n+++ b/core/dbt/contracts/graph/manifest.py\n@@ -689,6 +689,8 @@ class MacroMethods:\n def __init__(self):\n self.macros = []\n self.metadata = {}\n+ self._macros_by_name = {}\n+ self._macros_by_package = {}\n \n def find_macro_by_name(\n self, name: str, root_project_name: str, package: Optional[str]\n@@ -757,10 +759,13 @@ class MacroMethods:\n from dbt.adapters.factory import get_adapter_package_names\n \n candidates: CandidateList = CandidateList()\n+\n+ macros_by_name = self.get_macros_by_name()\n+ if name not in macros_by_name:\n+ return candidates\n+\n packages = set(get_adapter_package_names(self.metadata.adapter_type))\n- for unique_id, macro in self.macros.items():\n- if macro.name != name:\n- continue\n+ for macro in macros_by_name[name]:\n candidate = MacroCandidate(\n locality=_get_locality(macro, root_project_name, packages),\n macro=macro,\n@@ -770,6 +775,49 @@ class MacroMethods:\n \n return candidates\n \n+ def get_macros_by_name(self) -> Dict[str, List[Macro]]:\n+ if self._macros_by_name is None:\n+ # The by-name mapping doesn't exist yet (perhaps because the manifest\n+ # was deserialized), so we build it.\n+ self._macros_by_name = self._build_macros_by_name(self.macros)\n+\n+ return self._macros_by_name\n+\n+ @staticmethod\n+ def _build_macros_by_name(macros: Mapping[str, Macro]) -> Dict[str, List[Macro]]:\n+ # Convert a macro dictionary keyed on unique id to a flattened version\n+ # keyed on macro name for faster lookup by name. Since macro names are\n+ # not necessarily unique, the dict value is a list.\n+ macros_by_name: Dict[str, List[Macro]] = {}\n+ for macro in macros.values():\n+ if macro.name not in macros_by_name:\n+ macros_by_name[macro.name] = []\n+\n+ macros_by_name[macro.name].append(macro)\n+\n+ return macros_by_name\n+\n+ def get_macros_by_package(self) -> Dict[str, Dict[str, Macro]]:\n+ if self._macros_by_package is None:\n+ # The by-package mapping doesn't exist yet (perhaps because the manifest\n+ # was deserialized), so we build it.\n+ self._macros_by_package = self._build_macros_by_package(self.macros)\n+\n+ return self._macros_by_package\n+\n+ @staticmethod\n+ def _build_macros_by_package(macros: Mapping[str, Macro]) -> Dict[str, Dict[str, Macro]]:\n+ # Convert a macro dictionary keyed on unique id to a flattened version\n+ # keyed on package name for faster lookup by name.\n+ macros_by_package: Dict[str, Dict[str, Macro]] = {}\n+ for macro in macros.values():\n+ if macro.package_name not in macros_by_package:\n+ macros_by_package[macro.package_name] = {}\n+ macros_by_name = macros_by_package[macro.package_name]\n+ macros_by_name[macro.name] = macro\n+\n+ return macros_by_package\n+\n \n @dataclass\n class ParsingInfo:\n@@ -845,6 +893,14 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):\n default_factory=get_mp_context().Lock,\n metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n )\n+ _macros_by_name: Optional[Dict[str, List[Macro]]] = field(\n+ default=None,\n+ metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n+ )\n+ _macros_by_package: Optional[Dict[str, Dict[str, Macro]]] = field(\n+ default=None,\n+ metadata={\"serialize\": lambda x: None, \"deserialize\": lambda x: None},\n+ )\n \n def __pre_serialize__(self):\n # serialization won't work with anything except an empty source_patches because\n@@ -1408,6 +1464,23 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):\n raise DuplicateMacroInPackageError(macro=macro, macro_mapping=self.macros)\n \n self.macros[macro.unique_id] = macro\n+\n+ if self._macros_by_name is None:\n+ self._macros_by_name = self._build_macros_by_name(self.macros)\n+\n+ if macro.name not in self._macros_by_name:\n+ self._macros_by_name[macro.name] = []\n+\n+ self._macros_by_name[macro.name].append(macro)\n+\n+ if self._macros_by_package is None:\n+ self._macros_by_package = self._build_macros_by_package(self.macros)\n+\n+ if macro.package_name not in self._macros_by_package:\n+ self._macros_by_package[macro.package_name] = {}\n+\n+ self._macros_by_package[macro.package_name][macro.name] = macro\n+\n source_file.macros.append(macro.unique_id)\n \n def has_file(self, source_file: SourceFile) -> bool:\n@@ -1565,6 +1638,8 @@ class MacroManifest(MacroMethods):\n # This is returned by the 'graph' context property\n # in the ProviderContext class.\n self.flat_graph: Dict[str, Any] = {}\n+ self._macros_by_name: Optional[Dict[str, List[Macro]]] = None\n+ self._macros_by_package: Optional[Dict[str, Dict[str, Macro]]] = None\n \n \n AnyManifest = Union[Manifest, MacroManifest]"},"prompt_input_token_count":{"kind":"number","value":50997,"string":"50,997"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9423\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"c547aace361ea12c3de90a811e612481fefe766b\",\n \"pull_number\": 9423,\n \"issue_numbers\": [\n \"9422\"\n ],\n \"changed_files\": [\n \"core/dbt/context/macros.py\",\n \"core/dbt/context/manifest.py\",\n \"core/dbt/contracts/graph/manifest.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32288,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9427"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: af188624d5967ed996f40f1c1e20082878b8cc8a\nChanged files:\n- core/dbt/cli/main.py\n\n## Problem statement\n\nAdd the @requires.manifest decorator to the retry command\n### Housekeeping\n\n- [X] I am a maintainer of dbt-core\n\n### Short description\n\nThe retry command is missing the `@requires.manifest` decorator. This was simply an oversights.\n\n### Acceptance criteria\n\nThe retry command includes the `@requires.manifest` decorator\n\n### Suggested Tests\n\nNone\n\n### Impact to Other Teams\n\nNone\n\n### Will backports be required?\n\ntbd\n\n### Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/cli/main.py\n\n```python\n 1 | import functools\n 2 | from copy import copy\n 3 | from dataclasses import dataclass\n 4 | from typing import Callable, List, Optional, Union\n 5 | \n 6 | import click\n 7 | from click.exceptions import (\n 8 | Exit as ClickExit,\n 9 | BadOptionUsage,\n 10 | NoSuchOption,\n 11 | UsageError,\n 12 | )\n 13 | \n 14 | from dbt.cli import requires, params as p\n 15 | from dbt.cli.exceptions import (\n 16 | DbtInternalException,\n 17 | DbtUsageException,\n 18 | )\n 19 | from dbt.contracts.graph.manifest import Manifest\n 20 | from dbt.artifacts.catalog import CatalogArtifact\n 21 | from dbt.artifacts.run import RunExecutionResult\n 22 | from dbt_common.events.base_types import EventMsg\n 23 | from dbt.task.build import BuildTask\n 24 | from dbt.task.clean import CleanTask\n 25 | from dbt.task.clone import CloneTask\n 26 | from dbt.task.compile import CompileTask\n 27 | from dbt.task.debug import DebugTask\n 28 | from dbt.task.deps import DepsTask\n 29 | from dbt.task.docs.generate import GenerateTask\n 30 | from dbt.task.docs.serve import ServeTask\n 31 | from dbt.task.freshness import FreshnessTask\n 32 | from dbt.task.init import InitTask\n 33 | from dbt.task.list import ListTask\n 34 | from dbt.task.retry import RetryTask\n 35 | from dbt.task.run import RunTask\n 36 | from dbt.task.run_operation import RunOperationTask\n 37 | from dbt.task.seed import SeedTask\n 38 | from dbt.task.show import ShowTask\n 39 | from dbt.task.snapshot import SnapshotTask\n 40 | from dbt.task.test import TestTask\n 41 | \n 42 | \n 43 | @dataclass\n 44 | class dbtRunnerResult:\n 45 | \"\"\"Contains the result of an invocation of the dbtRunner\"\"\"\n 46 | \n 47 | success: bool\n 48 | \n 49 | exception: Optional[BaseException] = None\n 50 | result: Union[\n 51 | bool, # debug\n 52 | CatalogArtifact, # docs generate\n 53 | List[str], # list/ls\n 54 | Manifest, # parse\n 55 | None, # clean, deps, init, source\n 56 | RunExecutionResult, # build, compile, run, seed, snapshot, test, run-operation\n 57 | ] = None\n 58 | \n 59 | \n 60 | # Programmatic invocation\n 61 | class dbtRunner:\n 62 | def __init__(\n 63 | self,\n 64 | manifest: Optional[Manifest] = None,\n 65 | callbacks: Optional[List[Callable[[EventMsg], None]]] = None,\n 66 | ) -> None:\n 67 | self.manifest = manifest\n 68 | \n 69 | if callbacks is None:\n 70 | callbacks = []\n 71 | self.callbacks = callbacks\n 72 | \n 73 | def invoke(self, args: List[str], **kwargs) -> dbtRunnerResult:\n 74 | try:\n 75 | dbt_ctx = cli.make_context(cli.name, args)\n 76 | dbt_ctx.obj = {\n 77 | \"manifest\": self.manifest,\n 78 | \"callbacks\": self.callbacks,\n 79 | }\n 80 | \n 81 | for key, value in kwargs.items():\n 82 | dbt_ctx.params[key] = value\n 83 | # Hack to set parameter source to custom string\n 84 | dbt_ctx.set_parameter_source(key, \"kwargs\") # type: ignore\n 85 | \n 86 | result, success = cli.invoke(dbt_ctx)\n 87 | return dbtRunnerResult(\n 88 | result=result,\n 89 | success=success,\n 90 | )\n 91 | except requires.ResultExit as e:\n 92 | return dbtRunnerResult(\n 93 | result=e.result,\n 94 | success=False,\n 95 | )\n 96 | except requires.ExceptionExit as e:\n 97 | return dbtRunnerResult(\n 98 | exception=e.exception,\n 99 | success=False,\n100 | )\n101 | except (BadOptionUsage, NoSuchOption, UsageError) as e:\n102 | return dbtRunnerResult(\n103 | exception=DbtUsageException(e.message),\n104 | success=False,\n105 | )\n106 | except ClickExit as e:\n107 | if e.exit_code == 0:\n108 | return dbtRunnerResult(success=True)\n109 | return dbtRunnerResult(\n110 | exception=DbtInternalException(f\"unhandled exit code {e.exit_code}\"),\n111 | success=False,\n112 | )\n113 | except BaseException as e:\n114 | return dbtRunnerResult(\n115 | exception=e,\n116 | success=False,\n117 | )\n118 | \n119 | \n120 | # approach from https://github.com/pallets/click/issues/108#issuecomment-280489786\n121 | def global_flags(func):\n122 | @p.cache_selected_only\n123 | @p.debug\n124 | @p.defer\n125 | @p.deprecated_defer\n126 | @p.defer_state\n127 | @p.deprecated_favor_state\n128 | @p.deprecated_print\n129 | @p.deprecated_state\n130 | @p.enable_legacy_logger\n131 | @p.fail_fast\n132 | @p.favor_state\n133 | @p.indirect_selection\n134 | @p.log_cache_events\n135 | @p.log_file_max_bytes\n136 | @p.log_format\n137 | @p.log_format_file\n138 | @p.log_level\n139 | @p.log_level_file\n140 | @p.log_path\n141 | @p.macro_debugging\n142 | @p.partial_parse\n143 | @p.partial_parse_file_path\n144 | @p.partial_parse_file_diff\n145 | @p.populate_cache\n146 | @p.print\n147 | @p.printer_width\n148 | @p.quiet\n149 | @p.record_timing_info\n150 | @p.send_anonymous_usage_stats\n151 | @p.single_threaded\n152 | @p.state\n153 | @p.static_parser\n154 | @p.use_colors\n155 | @p.use_colors_file\n156 | @p.use_experimental_parser\n157 | @p.version\n158 | @p.version_check\n159 | @p.warn_error\n160 | @p.warn_error_options\n161 | @p.write_json\n162 | @functools.wraps(func)\n163 | def wrapper(*args, **kwargs):\n164 | return func(*args, **kwargs)\n165 | \n166 | return wrapper\n167 | \n168 | \n169 | # dbt\n170 | @click.group(\n171 | context_settings={\"help_option_names\": [\"-h\", \"--help\"]},\n172 | invoke_without_command=True,\n173 | no_args_is_help=True,\n174 | epilog=\"Specify one of these sub-commands and you can find more help from there.\",\n175 | )\n176 | @click.pass_context\n177 | @global_flags\n178 | @p.show_resource_report\n179 | def cli(ctx, **kwargs):\n180 | \"\"\"An ELT tool for managing your SQL transformations and data models.\n181 | For more documentation on these commands, visit: docs.getdbt.com\n182 | \"\"\"\n183 | \n184 | \n185 | # dbt build\n186 | @cli.command(\"build\")\n187 | @click.pass_context\n188 | @global_flags\n189 | @p.exclude\n190 | @p.full_refresh\n191 | @p.include_saved_query\n192 | @p.profile\n193 | @p.profiles_dir\n194 | @p.project_dir\n195 | @p.resource_type\n196 | @p.select\n197 | @p.selector\n198 | @p.show\n199 | @p.store_failures\n200 | @p.target\n201 | @p.target_path\n202 | @p.threads\n203 | @p.vars\n204 | @requires.postflight\n205 | @requires.preflight\n206 | @requires.profile\n207 | @requires.project\n208 | @requires.runtime_config\n209 | @requires.manifest\n210 | def build(ctx, **kwargs):\n211 | \"\"\"Run all seeds, models, snapshots, and tests in DAG order\"\"\"\n212 | task = BuildTask(\n213 | ctx.obj[\"flags\"],\n214 | ctx.obj[\"runtime_config\"],\n215 | ctx.obj[\"manifest\"],\n216 | )\n217 | \n218 | results = task.run()\n219 | success = task.interpret_results(results)\n220 | return results, success\n221 | \n222 | \n223 | # dbt clean\n224 | @cli.command(\"clean\")\n225 | @click.pass_context\n226 | @global_flags\n227 | @p.clean_project_files_only\n228 | @p.profile\n229 | @p.profiles_dir\n230 | @p.project_dir\n231 | @p.target\n232 | @p.target_path\n233 | @p.vars\n234 | @requires.postflight\n235 | @requires.preflight\n236 | @requires.unset_profile\n237 | @requires.project\n238 | def clean(ctx, **kwargs):\n239 | \"\"\"Delete all folders in the clean-targets list (usually the dbt_packages and target directories.)\"\"\"\n240 | task = CleanTask(ctx.obj[\"flags\"], ctx.obj[\"project\"])\n241 | \n242 | results = task.run()\n243 | success = task.interpret_results(results)\n244 | return results, success\n245 | \n246 | \n247 | # dbt docs\n248 | @cli.group()\n249 | @click.pass_context\n250 | @global_flags\n251 | def docs(ctx, **kwargs):\n252 | \"\"\"Generate or serve the documentation website for your project\"\"\"\n253 | \n254 | \n255 | # dbt docs generate\n256 | @docs.command(\"generate\")\n257 | @click.pass_context\n258 | @global_flags\n259 | @p.compile_docs\n260 | @p.exclude\n261 | @p.profile\n262 | @p.profiles_dir\n263 | @p.project_dir\n264 | @p.select\n265 | @p.selector\n266 | @p.empty_catalog\n267 | @p.static\n268 | @p.target\n269 | @p.target_path\n270 | @p.threads\n271 | @p.vars\n272 | @requires.postflight\n273 | @requires.preflight\n274 | @requires.profile\n275 | @requires.project\n276 | @requires.runtime_config\n277 | @requires.manifest(write=False)\n278 | def docs_generate(ctx, **kwargs):\n279 | \"\"\"Generate the documentation website for your project\"\"\"\n280 | task = GenerateTask(\n281 | ctx.obj[\"flags\"],\n282 | ctx.obj[\"runtime_config\"],\n283 | ctx.obj[\"manifest\"],\n284 | )\n285 | \n286 | results = task.run()\n287 | success = task.interpret_results(results)\n288 | return results, success\n289 | \n290 | \n291 | # dbt docs serve\n292 | @docs.command(\"serve\")\n293 | @click.pass_context\n294 | @global_flags\n295 | @p.browser\n296 | @p.port\n297 | @p.profile\n298 | @p.profiles_dir\n299 | @p.project_dir\n300 | @p.target\n301 | @p.target_path\n302 | @p.vars\n303 | @requires.postflight\n304 | @requires.preflight\n305 | @requires.profile\n306 | @requires.project\n307 | @requires.runtime_config\n308 | def docs_serve(ctx, **kwargs):\n309 | \"\"\"Serve the documentation website for your project\"\"\"\n310 | task = ServeTask(\n311 | ctx.obj[\"flags\"],\n312 | ctx.obj[\"runtime_config\"],\n313 | )\n314 | \n315 | results = task.run()\n316 | success = task.interpret_results(results)\n317 | return results, success\n318 | \n319 | \n320 | # dbt compile\n321 | @cli.command(\"compile\")\n322 | @click.pass_context\n323 | @global_flags\n324 | @p.exclude\n325 | @p.full_refresh\n326 | @p.show_output_format\n327 | @p.introspect\n328 | @p.profile\n329 | @p.profiles_dir\n330 | @p.project_dir\n331 | @p.empty\n332 | @p.select\n333 | @p.selector\n334 | @p.inline\n335 | @p.compile_inject_ephemeral_ctes\n336 | @p.target\n337 | @p.target_path\n338 | @p.threads\n339 | @p.vars\n340 | @requires.postflight\n341 | @requires.preflight\n342 | @requires.profile\n343 | @requires.project\n344 | @requires.runtime_config\n345 | @requires.manifest\n346 | def compile(ctx, **kwargs):\n347 | \"\"\"Generates executable SQL from source, model, test, and analysis files. Compiled SQL files are written to the\n348 | target/ directory.\"\"\"\n349 | task = CompileTask(\n350 | ctx.obj[\"flags\"],\n351 | ctx.obj[\"runtime_config\"],\n352 | ctx.obj[\"manifest\"],\n353 | )\n354 | \n355 | results = task.run()\n356 | success = task.interpret_results(results)\n357 | return results, success\n358 | \n359 | \n360 | # dbt show\n361 | @cli.command(\"show\")\n362 | @click.pass_context\n363 | @global_flags\n364 | @p.exclude\n365 | @p.full_refresh\n366 | @p.show_output_format\n367 | @p.show_limit\n368 | @p.introspect\n369 | @p.profile\n370 | @p.profiles_dir\n371 | @p.project_dir\n372 | @p.select\n373 | @p.selector\n374 | @p.inline\n375 | @p.target\n376 | @p.target_path\n377 | @p.threads\n378 | @p.vars\n379 | @requires.postflight\n380 | @requires.preflight\n381 | @requires.profile\n382 | @requires.project\n383 | @requires.runtime_config\n384 | @requires.manifest\n385 | def show(ctx, **kwargs):\n386 | \"\"\"Generates executable SQL for a named resource or inline query, runs that SQL, and returns a preview of the\n387 | results. Does not materialize anything to the warehouse.\"\"\"\n388 | task = ShowTask(\n389 | ctx.obj[\"flags\"],\n390 | ctx.obj[\"runtime_config\"],\n391 | ctx.obj[\"manifest\"],\n392 | )\n393 | \n394 | results = task.run()\n395 | success = task.interpret_results(results)\n396 | return results, success\n397 | \n398 | \n399 | # dbt debug\n400 | @cli.command(\"debug\")\n401 | @click.pass_context\n402 | @global_flags\n403 | @p.debug_connection\n404 | @p.config_dir\n405 | @p.profile\n406 | @p.profiles_dir_exists_false\n407 | @p.project_dir\n408 | @p.target\n409 | @p.vars\n410 | @requires.postflight\n411 | @requires.preflight\n412 | def debug(ctx, **kwargs):\n413 | \"\"\"Show information on the current dbt environment and check dependencies, then test the database connection. Not to be confused with the --debug option which increases verbosity.\"\"\"\n414 | \n415 | task = DebugTask(\n416 | ctx.obj[\"flags\"],\n417 | None,\n418 | )\n419 | \n420 | results = task.run()\n421 | success = task.interpret_results(results)\n422 | return results, success\n423 | \n424 | \n425 | # dbt deps\n426 | @cli.command(\"deps\")\n427 | @click.pass_context\n428 | @global_flags\n429 | @p.profile\n430 | @p.profiles_dir_exists_false\n431 | @p.project_dir\n432 | @p.target\n433 | @p.vars\n434 | @p.source\n435 | @p.lock\n436 | @p.upgrade\n437 | @p.add_package\n438 | @requires.postflight\n439 | @requires.preflight\n440 | @requires.unset_profile\n441 | @requires.project\n442 | def deps(ctx, **kwargs):\n443 | \"\"\"Install dbt packages specified.\n444 | In the following case, a new `package-lock.yml` will be generated and the packages are installed:\n445 | - user updated the packages.yml\n446 | - user specify the flag --update, which means for packages that are specified as a\n447 | range, dbt-core will try to install the newer version\n448 | Otherwise, deps will use `package-lock.yml` as source of truth to install packages.\n449 | \n450 | There is a way to add new packages by providing an `--add-package` flag to deps command\n451 | which will allow user to specify a package they want to add in the format of packagename@version.\n452 | \"\"\"\n453 | flags = ctx.obj[\"flags\"]\n454 | if flags.ADD_PACKAGE:\n455 | if not flags.ADD_PACKAGE[\"version\"] and flags.SOURCE != \"local\":\n456 | raise BadOptionUsage(\n457 | message=f\"Version is required in --add-package when a package when source is {flags.SOURCE}\",\n458 | option_name=\"--add-package\",\n459 | )\n460 | task = DepsTask(flags, ctx.obj[\"project\"])\n461 | results = task.run()\n462 | success = task.interpret_results(results)\n463 | return results, success\n464 | \n465 | \n466 | # dbt init\n467 | @cli.command(\"init\")\n468 | @click.pass_context\n469 | @global_flags\n470 | # for backwards compatibility, accept 'project_name' as an optional positional argument\n471 | @click.argument(\"project_name\", required=False)\n472 | @p.profile\n473 | @p.profiles_dir_exists_false\n474 | @p.project_dir\n475 | @p.skip_profile_setup\n476 | @p.target\n477 | @p.vars\n478 | @requires.postflight\n479 | @requires.preflight\n480 | def init(ctx, **kwargs):\n481 | \"\"\"Initialize a new dbt project.\"\"\"\n482 | task = InitTask(ctx.obj[\"flags\"], None)\n483 | \n484 | results = task.run()\n485 | success = task.interpret_results(results)\n486 | return results, success\n487 | \n488 | \n489 | # dbt list\n490 | @cli.command(\"list\")\n491 | @click.pass_context\n492 | @global_flags\n493 | @p.exclude\n494 | @p.models\n495 | @p.output\n496 | @p.output_keys\n497 | @p.profile\n498 | @p.profiles_dir\n499 | @p.project_dir\n500 | @p.resource_type\n501 | @p.raw_select\n502 | @p.selector\n503 | @p.target\n504 | @p.target_path\n505 | @p.vars\n506 | @requires.postflight\n507 | @requires.preflight\n508 | @requires.profile\n509 | @requires.project\n510 | @requires.runtime_config\n511 | @requires.manifest\n512 | def list(ctx, **kwargs):\n513 | \"\"\"List the resources in your project\"\"\"\n514 | task = ListTask(\n515 | ctx.obj[\"flags\"],\n516 | ctx.obj[\"runtime_config\"],\n517 | ctx.obj[\"manifest\"],\n518 | )\n519 | \n520 | results = task.run()\n521 | success = task.interpret_results(results)\n522 | return results, success\n523 | \n524 | \n525 | # Alias \"list\" to \"ls\"\n526 | ls = copy(cli.commands[\"list\"])\n527 | ls.hidden = True\n528 | cli.add_command(ls, \"ls\")\n529 | \n530 | \n531 | # dbt parse\n532 | @cli.command(\"parse\")\n533 | @click.pass_context\n534 | @global_flags\n535 | @p.profile\n536 | @p.profiles_dir\n537 | @p.project_dir\n538 | @p.target\n539 | @p.target_path\n540 | @p.threads\n541 | @p.vars\n542 | @requires.postflight\n543 | @requires.preflight\n544 | @requires.profile\n545 | @requires.project\n546 | @requires.runtime_config\n547 | @requires.manifest(write_perf_info=True)\n548 | def parse(ctx, **kwargs):\n549 | \"\"\"Parses the project and provides information on performance\"\"\"\n550 | # manifest generation and writing happens in @requires.manifest\n551 | return ctx.obj[\"manifest\"], True\n552 | \n553 | \n554 | # dbt run\n555 | @cli.command(\"run\")\n556 | @click.pass_context\n557 | @global_flags\n558 | @p.exclude\n559 | @p.full_refresh\n560 | @p.profile\n561 | @p.profiles_dir\n562 | @p.project_dir\n563 | @p.empty\n564 | @p.select\n565 | @p.selector\n566 | @p.target\n567 | @p.target_path\n568 | @p.threads\n569 | @p.vars\n570 | @requires.postflight\n571 | @requires.preflight\n572 | @requires.profile\n573 | @requires.project\n574 | @requires.runtime_config\n575 | @requires.manifest\n576 | def run(ctx, **kwargs):\n577 | \"\"\"Compile SQL and execute against the current target database.\"\"\"\n578 | task = RunTask(\n579 | ctx.obj[\"flags\"],\n580 | ctx.obj[\"runtime_config\"],\n581 | ctx.obj[\"manifest\"],\n582 | )\n583 | \n584 | results = task.run()\n585 | success = task.interpret_results(results)\n586 | return results, success\n587 | \n588 | \n589 | # dbt retry\n590 | @cli.command(\"retry\")\n591 | @click.pass_context\n592 | @global_flags\n593 | @p.project_dir\n594 | @p.profiles_dir\n595 | @p.vars\n596 | @p.profile\n597 | @p.target\n598 | @p.threads\n599 | @p.full_refresh\n600 | @requires.postflight\n601 | @requires.preflight\n602 | @requires.profile\n603 | @requires.project\n604 | @requires.runtime_config\n605 | def retry(ctx, **kwargs):\n606 | \"\"\"Retry the nodes that failed in the previous run.\"\"\"\n607 | task = RetryTask(\n608 | ctx.obj[\"flags\"],\n609 | ctx.obj[\"runtime_config\"],\n610 | ctx.obj[\"manifest\"],\n611 | )\n612 | \n613 | results = task.run()\n614 | success = task.interpret_results(results)\n615 | return results, success\n616 | \n617 | \n618 | # dbt clone\n619 | @cli.command(\"clone\")\n620 | @click.pass_context\n621 | @global_flags\n622 | @p.exclude\n623 | @p.full_refresh\n624 | @p.profile\n625 | @p.profiles_dir\n626 | @p.project_dir\n627 | @p.resource_type\n628 | @p.select\n629 | @p.selector\n630 | @p.target\n631 | @p.target_path\n632 | @p.threads\n633 | @p.vars\n634 | @requires.preflight\n635 | @requires.profile\n636 | @requires.project\n637 | @requires.runtime_config\n638 | @requires.manifest\n639 | @requires.postflight\n640 | def clone(ctx, **kwargs):\n641 | \"\"\"Create clones of selected nodes based on their location in the manifest provided to --state.\"\"\"\n642 | task = CloneTask(\n643 | ctx.obj[\"flags\"],\n644 | ctx.obj[\"runtime_config\"],\n645 | ctx.obj[\"manifest\"],\n646 | )\n647 | \n648 | results = task.run()\n649 | success = task.interpret_results(results)\n650 | return results, success\n651 | \n652 | \n653 | # dbt run operation\n654 | @cli.command(\"run-operation\")\n655 | @click.pass_context\n656 | @global_flags\n657 | @click.argument(\"macro\")\n658 | @p.args\n659 | @p.profile\n660 | @p.profiles_dir\n661 | @p.project_dir\n662 | @p.target\n663 | @p.target_path\n664 | @p.threads\n665 | @p.vars\n666 | @requires.postflight\n667 | @requires.preflight\n668 | @requires.profile\n669 | @requires.project\n670 | @requires.runtime_config\n671 | @requires.manifest\n672 | def run_operation(ctx, **kwargs):\n673 | \"\"\"Run the named macro with any supplied arguments.\"\"\"\n674 | task = RunOperationTask(\n675 | ctx.obj[\"flags\"],\n676 | ctx.obj[\"runtime_config\"],\n677 | ctx.obj[\"manifest\"],\n678 | )\n679 | \n680 | results = task.run()\n681 | success = task.interpret_results(results)\n682 | return results, success\n683 | \n684 | \n685 | # dbt seed\n686 | @cli.command(\"seed\")\n687 | @click.pass_context\n688 | @global_flags\n689 | @p.exclude\n690 | @p.full_refresh\n691 | @p.profile\n692 | @p.profiles_dir\n693 | @p.project_dir\n694 | @p.select\n695 | @p.selector\n696 | @p.show\n697 | @p.target\n698 | @p.target_path\n699 | @p.threads\n700 | @p.vars\n701 | @requires.postflight\n702 | @requires.preflight\n703 | @requires.profile\n704 | @requires.project\n705 | @requires.runtime_config\n706 | @requires.manifest\n707 | def seed(ctx, **kwargs):\n708 | \"\"\"Load data from csv files into your data warehouse.\"\"\"\n709 | task = SeedTask(\n710 | ctx.obj[\"flags\"],\n711 | ctx.obj[\"runtime_config\"],\n712 | ctx.obj[\"manifest\"],\n713 | )\n714 | results = task.run()\n715 | success = task.interpret_results(results)\n716 | return results, success\n717 | \n718 | \n719 | # dbt snapshot\n720 | @cli.command(\"snapshot\")\n721 | @click.pass_context\n722 | @global_flags\n723 | @p.exclude\n724 | @p.profile\n725 | @p.profiles_dir\n726 | @p.project_dir\n727 | @p.select\n728 | @p.selector\n729 | @p.target\n730 | @p.target_path\n731 | @p.threads\n732 | @p.vars\n733 | @requires.postflight\n734 | @requires.preflight\n735 | @requires.profile\n736 | @requires.project\n737 | @requires.runtime_config\n738 | @requires.manifest\n739 | def snapshot(ctx, **kwargs):\n740 | \"\"\"Execute snapshots defined in your project\"\"\"\n741 | task = SnapshotTask(\n742 | ctx.obj[\"flags\"],\n743 | ctx.obj[\"runtime_config\"],\n744 | ctx.obj[\"manifest\"],\n745 | )\n746 | \n747 | results = task.run()\n748 | success = task.interpret_results(results)\n749 | return results, success\n750 | \n751 | \n752 | # dbt source\n753 | @cli.group()\n754 | @click.pass_context\n755 | @global_flags\n756 | def source(ctx, **kwargs):\n757 | \"\"\"Manage your project's sources\"\"\"\n758 | \n759 | \n760 | # dbt source freshness\n761 | @source.command(\"freshness\")\n762 | @click.pass_context\n763 | @global_flags\n764 | @p.exclude\n765 | @p.output_path # TODO: Is this ok to re-use? We have three different output params, how much can we consolidate?\n766 | @p.profile\n767 | @p.profiles_dir\n768 | @p.project_dir\n769 | @p.select\n770 | @p.selector\n771 | @p.target\n772 | @p.target_path\n773 | @p.threads\n774 | @p.vars\n775 | @requires.postflight\n776 | @requires.preflight\n777 | @requires.profile\n778 | @requires.project\n779 | @requires.runtime_config\n780 | @requires.manifest\n781 | def freshness(ctx, **kwargs):\n782 | \"\"\"check the current freshness of the project's sources\"\"\"\n783 | task = FreshnessTask(\n784 | ctx.obj[\"flags\"],\n785 | ctx.obj[\"runtime_config\"],\n786 | ctx.obj[\"manifest\"],\n787 | )\n788 | \n789 | results = task.run()\n790 | success = task.interpret_results(results)\n791 | return results, success\n792 | \n793 | \n794 | # Alias \"source freshness\" to \"snapshot-freshness\"\n795 | snapshot_freshness = copy(cli.commands[\"source\"].commands[\"freshness\"]) # type: ignore\n796 | snapshot_freshness.hidden = True\n797 | cli.commands[\"source\"].add_command(snapshot_freshness, \"snapshot-freshness\") # type: ignore\n798 | \n799 | \n800 | # dbt test\n801 | @cli.command(\"test\")\n802 | @click.pass_context\n803 | @global_flags\n804 | @p.exclude\n805 | @p.profile\n806 | @p.profiles_dir\n807 | @p.project_dir\n808 | @p.select\n809 | @p.selector\n810 | @p.store_failures\n811 | @p.target\n812 | @p.target_path\n813 | @p.threads\n814 | @p.vars\n815 | @requires.postflight\n816 | @requires.preflight\n817 | @requires.profile\n818 | @requires.project\n819 | @requires.runtime_config\n820 | @requires.manifest\n821 | def test(ctx, **kwargs):\n822 | \"\"\"Runs tests on data in deployed models. Run this after `dbt run`\"\"\"\n823 | task = TestTask(\n824 | ctx.obj[\"flags\"],\n825 | ctx.obj[\"runtime_config\"],\n826 | ctx.obj[\"manifest\"],\n827 | )\n828 | \n829 | results = task.run()\n830 | success = task.interpret_results(results)\n831 | return results, success\n832 | \n833 | \n834 | # Support running as a module\n835 | if __name__ == \"__main__\":\n836 | cli()\n```\n\n## Files after the fix\n\n### File: core/dbt/cli/main.py\n\n```python\n 1 | import functools\n 2 | from copy import copy\n 3 | from dataclasses import dataclass\n 4 | from typing import Callable, List, Optional, Union\n 5 | \n 6 | import click\n 7 | from click.exceptions import (\n 8 | Exit as ClickExit,\n 9 | BadOptionUsage,\n 10 | NoSuchOption,\n 11 | UsageError,\n 12 | )\n 13 | \n 14 | from dbt.cli import requires, params as p\n 15 | from dbt.cli.exceptions import (\n 16 | DbtInternalException,\n 17 | DbtUsageException,\n 18 | )\n 19 | from dbt.contracts.graph.manifest import Manifest\n 20 | from dbt.artifacts.catalog import CatalogArtifact\n 21 | from dbt.artifacts.run import RunExecutionResult\n 22 | from dbt_common.events.base_types import EventMsg\n 23 | from dbt.task.build import BuildTask\n 24 | from dbt.task.clean import CleanTask\n 25 | from dbt.task.clone import CloneTask\n 26 | from dbt.task.compile import CompileTask\n 27 | from dbt.task.debug import DebugTask\n 28 | from dbt.task.deps import DepsTask\n 29 | from dbt.task.docs.generate import GenerateTask\n 30 | from dbt.task.docs.serve import ServeTask\n 31 | from dbt.task.freshness import FreshnessTask\n 32 | from dbt.task.init import InitTask\n 33 | from dbt.task.list import ListTask\n 34 | from dbt.task.retry import RetryTask\n 35 | from dbt.task.run import RunTask\n 36 | from dbt.task.run_operation import RunOperationTask\n 37 | from dbt.task.seed import SeedTask\n 38 | from dbt.task.show import ShowTask\n 39 | from dbt.task.snapshot import SnapshotTask\n 40 | from dbt.task.test import TestTask\n 41 | \n 42 | \n 43 | @dataclass\n 44 | class dbtRunnerResult:\n 45 | \"\"\"Contains the result of an invocation of the dbtRunner\"\"\"\n 46 | \n 47 | success: bool\n 48 | \n 49 | exception: Optional[BaseException] = None\n 50 | result: Union[\n 51 | bool, # debug\n 52 | CatalogArtifact, # docs generate\n 53 | List[str], # list/ls\n 54 | Manifest, # parse\n 55 | None, # clean, deps, init, source\n 56 | RunExecutionResult, # build, compile, run, seed, snapshot, test, run-operation\n 57 | ] = None\n 58 | \n 59 | \n 60 | # Programmatic invocation\n 61 | class dbtRunner:\n 62 | def __init__(\n 63 | self,\n 64 | manifest: Optional[Manifest] = None,\n 65 | callbacks: Optional[List[Callable[[EventMsg], None]]] = None,\n 66 | ) -> None:\n 67 | self.manifest = manifest\n 68 | \n 69 | if callbacks is None:\n 70 | callbacks = []\n 71 | self.callbacks = callbacks\n 72 | \n 73 | def invoke(self, args: List[str], **kwargs) -> dbtRunnerResult:\n 74 | try:\n 75 | dbt_ctx = cli.make_context(cli.name, args)\n 76 | dbt_ctx.obj = {\n 77 | \"manifest\": self.manifest,\n 78 | \"callbacks\": self.callbacks,\n 79 | }\n 80 | \n 81 | for key, value in kwargs.items():\n 82 | dbt_ctx.params[key] = value\n 83 | # Hack to set parameter source to custom string\n 84 | dbt_ctx.set_parameter_source(key, \"kwargs\") # type: ignore\n 85 | \n 86 | result, success = cli.invoke(dbt_ctx)\n 87 | return dbtRunnerResult(\n 88 | result=result,\n 89 | success=success,\n 90 | )\n 91 | except requires.ResultExit as e:\n 92 | return dbtRunnerResult(\n 93 | result=e.result,\n 94 | success=False,\n 95 | )\n 96 | except requires.ExceptionExit as e:\n 97 | return dbtRunnerResult(\n 98 | exception=e.exception,\n 99 | success=False,\n100 | )\n101 | except (BadOptionUsage, NoSuchOption, UsageError) as e:\n102 | return dbtRunnerResult(\n103 | exception=DbtUsageException(e.message),\n104 | success=False,\n105 | )\n106 | except ClickExit as e:\n107 | if e.exit_code == 0:\n108 | return dbtRunnerResult(success=True)\n109 | return dbtRunnerResult(\n110 | exception=DbtInternalException(f\"unhandled exit code {e.exit_code}\"),\n111 | success=False,\n112 | )\n113 | except BaseException as e:\n114 | return dbtRunnerResult(\n115 | exception=e,\n116 | success=False,\n117 | )\n118 | \n119 | \n120 | # approach from https://github.com/pallets/click/issues/108#issuecomment-280489786\n121 | def global_flags(func):\n122 | @p.cache_selected_only\n123 | @p.debug\n124 | @p.defer\n125 | @p.deprecated_defer\n126 | @p.defer_state\n127 | @p.deprecated_favor_state\n128 | @p.deprecated_print\n129 | @p.deprecated_state\n130 | @p.enable_legacy_logger\n131 | @p.fail_fast\n132 | @p.favor_state\n133 | @p.indirect_selection\n134 | @p.log_cache_events\n135 | @p.log_file_max_bytes\n136 | @p.log_format\n137 | @p.log_format_file\n138 | @p.log_level\n139 | @p.log_level_file\n140 | @p.log_path\n141 | @p.macro_debugging\n142 | @p.partial_parse\n143 | @p.partial_parse_file_path\n144 | @p.partial_parse_file_diff\n145 | @p.populate_cache\n146 | @p.print\n147 | @p.printer_width\n148 | @p.quiet\n149 | @p.record_timing_info\n150 | @p.send_anonymous_usage_stats\n151 | @p.single_threaded\n152 | @p.state\n153 | @p.static_parser\n154 | @p.use_colors\n155 | @p.use_colors_file\n156 | @p.use_experimental_parser\n157 | @p.version\n158 | @p.version_check\n159 | @p.warn_error\n160 | @p.warn_error_options\n161 | @p.write_json\n162 | @functools.wraps(func)\n163 | def wrapper(*args, **kwargs):\n164 | return func(*args, **kwargs)\n165 | \n166 | return wrapper\n167 | \n168 | \n169 | # dbt\n170 | @click.group(\n171 | context_settings={\"help_option_names\": [\"-h\", \"--help\"]},\n172 | invoke_without_command=True,\n173 | no_args_is_help=True,\n174 | epilog=\"Specify one of these sub-commands and you can find more help from there.\",\n175 | )\n176 | @click.pass_context\n177 | @global_flags\n178 | @p.show_resource_report\n179 | def cli(ctx, **kwargs):\n180 | \"\"\"An ELT tool for managing your SQL transformations and data models.\n181 | For more documentation on these commands, visit: docs.getdbt.com\n182 | \"\"\"\n183 | \n184 | \n185 | # dbt build\n186 | @cli.command(\"build\")\n187 | @click.pass_context\n188 | @global_flags\n189 | @p.exclude\n190 | @p.full_refresh\n191 | @p.include_saved_query\n192 | @p.profile\n193 | @p.profiles_dir\n194 | @p.project_dir\n195 | @p.resource_type\n196 | @p.select\n197 | @p.selector\n198 | @p.show\n199 | @p.store_failures\n200 | @p.target\n201 | @p.target_path\n202 | @p.threads\n203 | @p.vars\n204 | @requires.postflight\n205 | @requires.preflight\n206 | @requires.profile\n207 | @requires.project\n208 | @requires.runtime_config\n209 | @requires.manifest\n210 | def build(ctx, **kwargs):\n211 | \"\"\"Run all seeds, models, snapshots, and tests in DAG order\"\"\"\n212 | task = BuildTask(\n213 | ctx.obj[\"flags\"],\n214 | ctx.obj[\"runtime_config\"],\n215 | ctx.obj[\"manifest\"],\n216 | )\n217 | \n218 | results = task.run()\n219 | success = task.interpret_results(results)\n220 | return results, success\n221 | \n222 | \n223 | # dbt clean\n224 | @cli.command(\"clean\")\n225 | @click.pass_context\n226 | @global_flags\n227 | @p.clean_project_files_only\n228 | @p.profile\n229 | @p.profiles_dir\n230 | @p.project_dir\n231 | @p.target\n232 | @p.target_path\n233 | @p.vars\n234 | @requires.postflight\n235 | @requires.preflight\n236 | @requires.unset_profile\n237 | @requires.project\n238 | def clean(ctx, **kwargs):\n239 | \"\"\"Delete all folders in the clean-targets list (usually the dbt_packages and target directories.)\"\"\"\n240 | task = CleanTask(ctx.obj[\"flags\"], ctx.obj[\"project\"])\n241 | \n242 | results = task.run()\n243 | success = task.interpret_results(results)\n244 | return results, success\n245 | \n246 | \n247 | # dbt docs\n248 | @cli.group()\n249 | @click.pass_context\n250 | @global_flags\n251 | def docs(ctx, **kwargs):\n252 | \"\"\"Generate or serve the documentation website for your project\"\"\"\n253 | \n254 | \n255 | # dbt docs generate\n256 | @docs.command(\"generate\")\n257 | @click.pass_context\n258 | @global_flags\n259 | @p.compile_docs\n260 | @p.exclude\n261 | @p.profile\n262 | @p.profiles_dir\n263 | @p.project_dir\n264 | @p.select\n265 | @p.selector\n266 | @p.empty_catalog\n267 | @p.static\n268 | @p.target\n269 | @p.target_path\n270 | @p.threads\n271 | @p.vars\n272 | @requires.postflight\n273 | @requires.preflight\n274 | @requires.profile\n275 | @requires.project\n276 | @requires.runtime_config\n277 | @requires.manifest(write=False)\n278 | def docs_generate(ctx, **kwargs):\n279 | \"\"\"Generate the documentation website for your project\"\"\"\n280 | task = GenerateTask(\n281 | ctx.obj[\"flags\"],\n282 | ctx.obj[\"runtime_config\"],\n283 | ctx.obj[\"manifest\"],\n284 | )\n285 | \n286 | results = task.run()\n287 | success = task.interpret_results(results)\n288 | return results, success\n289 | \n290 | \n291 | # dbt docs serve\n292 | @docs.command(\"serve\")\n293 | @click.pass_context\n294 | @global_flags\n295 | @p.browser\n296 | @p.port\n297 | @p.profile\n298 | @p.profiles_dir\n299 | @p.project_dir\n300 | @p.target\n301 | @p.target_path\n302 | @p.vars\n303 | @requires.postflight\n304 | @requires.preflight\n305 | @requires.profile\n306 | @requires.project\n307 | @requires.runtime_config\n308 | def docs_serve(ctx, **kwargs):\n309 | \"\"\"Serve the documentation website for your project\"\"\"\n310 | task = ServeTask(\n311 | ctx.obj[\"flags\"],\n312 | ctx.obj[\"runtime_config\"],\n313 | )\n314 | \n315 | results = task.run()\n316 | success = task.interpret_results(results)\n317 | return results, success\n318 | \n319 | \n320 | # dbt compile\n321 | @cli.command(\"compile\")\n322 | @click.pass_context\n323 | @global_flags\n324 | @p.exclude\n325 | @p.full_refresh\n326 | @p.show_output_format\n327 | @p.introspect\n328 | @p.profile\n329 | @p.profiles_dir\n330 | @p.project_dir\n331 | @p.empty\n332 | @p.select\n333 | @p.selector\n334 | @p.inline\n335 | @p.compile_inject_ephemeral_ctes\n336 | @p.target\n337 | @p.target_path\n338 | @p.threads\n339 | @p.vars\n340 | @requires.postflight\n341 | @requires.preflight\n342 | @requires.profile\n343 | @requires.project\n344 | @requires.runtime_config\n345 | @requires.manifest\n346 | def compile(ctx, **kwargs):\n347 | \"\"\"Generates executable SQL from source, model, test, and analysis files. Compiled SQL files are written to the\n348 | target/ directory.\"\"\"\n349 | task = CompileTask(\n350 | ctx.obj[\"flags\"],\n351 | ctx.obj[\"runtime_config\"],\n352 | ctx.obj[\"manifest\"],\n353 | )\n354 | \n355 | results = task.run()\n356 | success = task.interpret_results(results)\n357 | return results, success\n358 | \n359 | \n360 | # dbt show\n361 | @cli.command(\"show\")\n362 | @click.pass_context\n363 | @global_flags\n364 | @p.exclude\n365 | @p.full_refresh\n366 | @p.show_output_format\n367 | @p.show_limit\n368 | @p.introspect\n369 | @p.profile\n370 | @p.profiles_dir\n371 | @p.project_dir\n372 | @p.select\n373 | @p.selector\n374 | @p.inline\n375 | @p.target\n376 | @p.target_path\n377 | @p.threads\n378 | @p.vars\n379 | @requires.postflight\n380 | @requires.preflight\n381 | @requires.profile\n382 | @requires.project\n383 | @requires.runtime_config\n384 | @requires.manifest\n385 | def show(ctx, **kwargs):\n386 | \"\"\"Generates executable SQL for a named resource or inline query, runs that SQL, and returns a preview of the\n387 | results. Does not materialize anything to the warehouse.\"\"\"\n388 | task = ShowTask(\n389 | ctx.obj[\"flags\"],\n390 | ctx.obj[\"runtime_config\"],\n391 | ctx.obj[\"manifest\"],\n392 | )\n393 | \n394 | results = task.run()\n395 | success = task.interpret_results(results)\n396 | return results, success\n397 | \n398 | \n399 | # dbt debug\n400 | @cli.command(\"debug\")\n401 | @click.pass_context\n402 | @global_flags\n403 | @p.debug_connection\n404 | @p.config_dir\n405 | @p.profile\n406 | @p.profiles_dir_exists_false\n407 | @p.project_dir\n408 | @p.target\n409 | @p.vars\n410 | @requires.postflight\n411 | @requires.preflight\n412 | def debug(ctx, **kwargs):\n413 | \"\"\"Show information on the current dbt environment and check dependencies, then test the database connection. Not to be confused with the --debug option which increases verbosity.\"\"\"\n414 | \n415 | task = DebugTask(\n416 | ctx.obj[\"flags\"],\n417 | None,\n418 | )\n419 | \n420 | results = task.run()\n421 | success = task.interpret_results(results)\n422 | return results, success\n423 | \n424 | \n425 | # dbt deps\n426 | @cli.command(\"deps\")\n427 | @click.pass_context\n428 | @global_flags\n429 | @p.profile\n430 | @p.profiles_dir_exists_false\n431 | @p.project_dir\n432 | @p.target\n433 | @p.vars\n434 | @p.source\n435 | @p.lock\n436 | @p.upgrade\n437 | @p.add_package\n438 | @requires.postflight\n439 | @requires.preflight\n440 | @requires.unset_profile\n441 | @requires.project\n442 | def deps(ctx, **kwargs):\n443 | \"\"\"Install dbt packages specified.\n444 | In the following case, a new `package-lock.yml` will be generated and the packages are installed:\n445 | - user updated the packages.yml\n446 | - user specify the flag --update, which means for packages that are specified as a\n447 | range, dbt-core will try to install the newer version\n448 | Otherwise, deps will use `package-lock.yml` as source of truth to install packages.\n449 | \n450 | There is a way to add new packages by providing an `--add-package` flag to deps command\n451 | which will allow user to specify a package they want to add in the format of packagename@version.\n452 | \"\"\"\n453 | flags = ctx.obj[\"flags\"]\n454 | if flags.ADD_PACKAGE:\n455 | if not flags.ADD_PACKAGE[\"version\"] and flags.SOURCE != \"local\":\n456 | raise BadOptionUsage(\n457 | message=f\"Version is required in --add-package when a package when source is {flags.SOURCE}\",\n458 | option_name=\"--add-package\",\n459 | )\n460 | task = DepsTask(flags, ctx.obj[\"project\"])\n461 | results = task.run()\n462 | success = task.interpret_results(results)\n463 | return results, success\n464 | \n465 | \n466 | # dbt init\n467 | @cli.command(\"init\")\n468 | @click.pass_context\n469 | @global_flags\n470 | # for backwards compatibility, accept 'project_name' as an optional positional argument\n471 | @click.argument(\"project_name\", required=False)\n472 | @p.profile\n473 | @p.profiles_dir_exists_false\n474 | @p.project_dir\n475 | @p.skip_profile_setup\n476 | @p.target\n477 | @p.vars\n478 | @requires.postflight\n479 | @requires.preflight\n480 | def init(ctx, **kwargs):\n481 | \"\"\"Initialize a new dbt project.\"\"\"\n482 | task = InitTask(ctx.obj[\"flags\"], None)\n483 | \n484 | results = task.run()\n485 | success = task.interpret_results(results)\n486 | return results, success\n487 | \n488 | \n489 | # dbt list\n490 | @cli.command(\"list\")\n491 | @click.pass_context\n492 | @global_flags\n493 | @p.exclude\n494 | @p.models\n495 | @p.output\n496 | @p.output_keys\n497 | @p.profile\n498 | @p.profiles_dir\n499 | @p.project_dir\n500 | @p.resource_type\n501 | @p.raw_select\n502 | @p.selector\n503 | @p.target\n504 | @p.target_path\n505 | @p.vars\n506 | @requires.postflight\n507 | @requires.preflight\n508 | @requires.profile\n509 | @requires.project\n510 | @requires.runtime_config\n511 | @requires.manifest\n512 | def list(ctx, **kwargs):\n513 | \"\"\"List the resources in your project\"\"\"\n514 | task = ListTask(\n515 | ctx.obj[\"flags\"],\n516 | ctx.obj[\"runtime_config\"],\n517 | ctx.obj[\"manifest\"],\n518 | )\n519 | \n520 | results = task.run()\n521 | success = task.interpret_results(results)\n522 | return results, success\n523 | \n524 | \n525 | # Alias \"list\" to \"ls\"\n526 | ls = copy(cli.commands[\"list\"])\n527 | ls.hidden = True\n528 | cli.add_command(ls, \"ls\")\n529 | \n530 | \n531 | # dbt parse\n532 | @cli.command(\"parse\")\n533 | @click.pass_context\n534 | @global_flags\n535 | @p.profile\n536 | @p.profiles_dir\n537 | @p.project_dir\n538 | @p.target\n539 | @p.target_path\n540 | @p.threads\n541 | @p.vars\n542 | @requires.postflight\n543 | @requires.preflight\n544 | @requires.profile\n545 | @requires.project\n546 | @requires.runtime_config\n547 | @requires.manifest(write_perf_info=True)\n548 | def parse(ctx, **kwargs):\n549 | \"\"\"Parses the project and provides information on performance\"\"\"\n550 | # manifest generation and writing happens in @requires.manifest\n551 | return ctx.obj[\"manifest\"], True\n552 | \n553 | \n554 | # dbt run\n555 | @cli.command(\"run\")\n556 | @click.pass_context\n557 | @global_flags\n558 | @p.exclude\n559 | @p.full_refresh\n560 | @p.profile\n561 | @p.profiles_dir\n562 | @p.project_dir\n563 | @p.empty\n564 | @p.select\n565 | @p.selector\n566 | @p.target\n567 | @p.target_path\n568 | @p.threads\n569 | @p.vars\n570 | @requires.postflight\n571 | @requires.preflight\n572 | @requires.profile\n573 | @requires.project\n574 | @requires.runtime_config\n575 | @requires.manifest\n576 | def run(ctx, **kwargs):\n577 | \"\"\"Compile SQL and execute against the current target database.\"\"\"\n578 | task = RunTask(\n579 | ctx.obj[\"flags\"],\n580 | ctx.obj[\"runtime_config\"],\n581 | ctx.obj[\"manifest\"],\n582 | )\n583 | \n584 | results = task.run()\n585 | success = task.interpret_results(results)\n586 | return results, success\n587 | \n588 | \n589 | # dbt retry\n590 | @cli.command(\"retry\")\n591 | @click.pass_context\n592 | @global_flags\n593 | @p.project_dir\n594 | @p.profiles_dir\n595 | @p.vars\n596 | @p.profile\n597 | @p.target\n598 | @p.threads\n599 | @p.full_refresh\n600 | @requires.postflight\n601 | @requires.preflight\n602 | @requires.profile\n603 | @requires.project\n604 | @requires.runtime_config\n605 | @requires.manifest\n606 | def retry(ctx, **kwargs):\n607 | \"\"\"Retry the nodes that failed in the previous run.\"\"\"\n608 | task = RetryTask(\n609 | ctx.obj[\"flags\"],\n610 | ctx.obj[\"runtime_config\"],\n611 | ctx.obj[\"manifest\"],\n612 | )\n613 | \n614 | results = task.run()\n615 | success = task.interpret_results(results)\n616 | return results, success\n617 | \n618 | \n619 | # dbt clone\n620 | @cli.command(\"clone\")\n621 | @click.pass_context\n622 | @global_flags\n623 | @p.exclude\n624 | @p.full_refresh\n625 | @p.profile\n626 | @p.profiles_dir\n627 | @p.project_dir\n628 | @p.resource_type\n629 | @p.select\n630 | @p.selector\n631 | @p.target\n632 | @p.target_path\n633 | @p.threads\n634 | @p.vars\n635 | @requires.preflight\n636 | @requires.profile\n637 | @requires.project\n638 | @requires.runtime_config\n639 | @requires.manifest\n640 | @requires.postflight\n641 | def clone(ctx, **kwargs):\n642 | \"\"\"Create clones of selected nodes based on their location in the manifest provided to --state.\"\"\"\n643 | task = CloneTask(\n644 | ctx.obj[\"flags\"],\n645 | ctx.obj[\"runtime_config\"],\n646 | ctx.obj[\"manifest\"],\n647 | )\n648 | \n649 | results = task.run()\n650 | success = task.interpret_results(results)\n651 | return results, success\n652 | \n653 | \n654 | # dbt run operation\n655 | @cli.command(\"run-operation\")\n656 | @click.pass_context\n657 | @global_flags\n658 | @click.argument(\"macro\")\n659 | @p.args\n660 | @p.profile\n661 | @p.profiles_dir\n662 | @p.project_dir\n663 | @p.target\n664 | @p.target_path\n665 | @p.threads\n666 | @p.vars\n667 | @requires.postflight\n668 | @requires.preflight\n669 | @requires.profile\n670 | @requires.project\n671 | @requires.runtime_config\n672 | @requires.manifest\n673 | def run_operation(ctx, **kwargs):\n674 | \"\"\"Run the named macro with any supplied arguments.\"\"\"\n675 | task = RunOperationTask(\n676 | ctx.obj[\"flags\"],\n677 | ctx.obj[\"runtime_config\"],\n678 | ctx.obj[\"manifest\"],\n679 | )\n680 | \n681 | results = task.run()\n682 | success = task.interpret_results(results)\n683 | return results, success\n684 | \n685 | \n686 | # dbt seed\n687 | @cli.command(\"seed\")\n688 | @click.pass_context\n689 | @global_flags\n690 | @p.exclude\n691 | @p.full_refresh\n692 | @p.profile\n693 | @p.profiles_dir\n694 | @p.project_dir\n695 | @p.select\n696 | @p.selector\n697 | @p.show\n698 | @p.target\n699 | @p.target_path\n700 | @p.threads\n701 | @p.vars\n702 | @requires.postflight\n703 | @requires.preflight\n704 | @requires.profile\n705 | @requires.project\n706 | @requires.runtime_config\n707 | @requires.manifest\n708 | def seed(ctx, **kwargs):\n709 | \"\"\"Load data from csv files into your data warehouse.\"\"\"\n710 | task = SeedTask(\n711 | ctx.obj[\"flags\"],\n712 | ctx.obj[\"runtime_config\"],\n713 | ctx.obj[\"manifest\"],\n714 | )\n715 | results = task.run()\n716 | success = task.interpret_results(results)\n717 | return results, success\n718 | \n719 | \n720 | # dbt snapshot\n721 | @cli.command(\"snapshot\")\n722 | @click.pass_context\n723 | @global_flags\n724 | @p.exclude\n725 | @p.profile\n726 | @p.profiles_dir\n727 | @p.project_dir\n728 | @p.select\n729 | @p.selector\n730 | @p.target\n731 | @p.target_path\n732 | @p.threads\n733 | @p.vars\n734 | @requires.postflight\n735 | @requires.preflight\n736 | @requires.profile\n737 | @requires.project\n738 | @requires.runtime_config\n739 | @requires.manifest\n740 | def snapshot(ctx, **kwargs):\n741 | \"\"\"Execute snapshots defined in your project\"\"\"\n742 | task = SnapshotTask(\n743 | ctx.obj[\"flags\"],\n744 | ctx.obj[\"runtime_config\"],\n745 | ctx.obj[\"manifest\"],\n746 | )\n747 | \n748 | results = task.run()\n749 | success = task.interpret_results(results)\n750 | return results, success\n751 | \n752 | \n753 | # dbt source\n754 | @cli.group()\n755 | @click.pass_context\n756 | @global_flags\n757 | def source(ctx, **kwargs):\n758 | \"\"\"Manage your project's sources\"\"\"\n759 | \n760 | \n761 | # dbt source freshness\n762 | @source.command(\"freshness\")\n763 | @click.pass_context\n764 | @global_flags\n765 | @p.exclude\n766 | @p.output_path # TODO: Is this ok to re-use? We have three different output params, how much can we consolidate?\n767 | @p.profile\n768 | @p.profiles_dir\n769 | @p.project_dir\n770 | @p.select\n771 | @p.selector\n772 | @p.target\n773 | @p.target_path\n774 | @p.threads\n775 | @p.vars\n776 | @requires.postflight\n777 | @requires.preflight\n778 | @requires.profile\n779 | @requires.project\n780 | @requires.runtime_config\n781 | @requires.manifest\n782 | def freshness(ctx, **kwargs):\n783 | \"\"\"check the current freshness of the project's sources\"\"\"\n784 | task = FreshnessTask(\n785 | ctx.obj[\"flags\"],\n786 | ctx.obj[\"runtime_config\"],\n787 | ctx.obj[\"manifest\"],\n788 | )\n789 | \n790 | results = task.run()\n791 | success = task.interpret_results(results)\n792 | return results, success\n793 | \n794 | \n795 | # Alias \"source freshness\" to \"snapshot-freshness\"\n796 | snapshot_freshness = copy(cli.commands[\"source\"].commands[\"freshness\"]) # type: ignore\n797 | snapshot_freshness.hidden = True\n798 | cli.commands[\"source\"].add_command(snapshot_freshness, \"snapshot-freshness\") # type: ignore\n799 | \n800 | \n801 | # dbt test\n802 | @cli.command(\"test\")\n803 | @click.pass_context\n804 | @global_flags\n805 | @p.exclude\n806 | @p.profile\n807 | @p.profiles_dir\n808 | @p.project_dir\n809 | @p.select\n810 | @p.selector\n811 | @p.store_failures\n812 | @p.target\n813 | @p.target_path\n814 | @p.threads\n815 | @p.vars\n816 | @requires.postflight\n817 | @requires.preflight\n818 | @requires.profile\n819 | @requires.project\n820 | @requires.runtime_config\n821 | @requires.manifest\n822 | def test(ctx, **kwargs):\n823 | \"\"\"Runs tests on data in deployed models. Run this after `dbt run`\"\"\"\n824 | task = TestTask(\n825 | ctx.obj[\"flags\"],\n826 | ctx.obj[\"runtime_config\"],\n827 | ctx.obj[\"manifest\"],\n828 | )\n829 | \n830 | results = task.run()\n831 | success = task.interpret_results(results)\n832 | return results, success\n833 | \n834 | \n835 | # Support running as a module\n836 | if __name__ == \"__main__\":\n837 | cli()\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py\nindex 0000000..0000000 100644\n--- a/core/dbt/cli/main.py\n+++ b/core/dbt/cli/main.py\n@@ -602,6 +602,7 @@ def run(ctx, **kwargs):\n @requires.profile\n @requires.project\n @requires.runtime_config\n+@requires.manifest\n def retry(ctx, **kwargs):\n \"\"\"Retry the nodes that failed in the previous run.\"\"\"\n task = RetryTask("},"prompt_input_token_count":{"kind":"number","value":16624,"string":"16,624"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9427\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"af188624d5967ed996f40f1c1e20082878b8cc8a\",\n \"pull_number\": 9427,\n \"issue_numbers\": [\n \"9426\"\n ],\n \"changed_files\": [\n \"core/dbt/cli/main.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": false\n}"}}},{"rowIdx":32289,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9452"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: bdcf2649632139296dc7c24fc50cbf9c8325df87\nChanged files:\n- core/setup.py\n\n## Problem statement\n\n[CT-3190] Pinning detective work\n### Housekeeping\n\n- [X] I am a maintainer of dbt-core\n\n### Short description\n\nWe recently pinned `types-requests<2.31.0` because it had a dependency conflict with `urllib3` which we have pinned to `~=1.0` because of another conflict with `requests` requiring `openssl`.\r\n\r\nThis ticket is to look into if those pins are still required and clean them up if not. \n\n### Acceptance criteria\n\nWe have confirmed that the pins are\r\n- required to continue to work\r\n_or_\r\n- not required and we have re-pinned appropriately\n\n### Impact to Other Teams\n\nadapters - based on the notes it seems like `urllib3` is pinned for the snowflake adapter as well so we will want to ensure changing the dependencies does not adversely affect them\n\n### Will backports be required?\n\nno\n\n### Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/setup.py\n\n```python\n 1 | #!/usr/bin/env python\n 2 | import os\n 3 | import sys\n 4 | \n 5 | if sys.version_info < (3, 8):\n 6 | print(\"Error: dbt does not support this version of Python.\")\n 7 | print(\"Please upgrade to Python 3.8 or higher.\")\n 8 | sys.exit(1)\n 9 | \n10 | \n11 | from setuptools import setup\n12 | \n13 | try:\n14 | from setuptools import find_namespace_packages\n15 | except ImportError:\n16 | # the user has a downlevel version of setuptools.\n17 | print(\"Error: dbt requires setuptools v40.1.0 or higher.\")\n18 | print('Please upgrade setuptools with \"pip install --upgrade setuptools\" ' \"and try again\")\n19 | sys.exit(1)\n20 | \n21 | \n22 | this_directory = os.path.abspath(os.path.dirname(__file__))\n23 | with open(os.path.join(this_directory, \"README.md\")) as f:\n24 | long_description = f.read()\n25 | \n26 | \n27 | package_name = \"dbt-core\"\n28 | package_version = \"1.8.0a1\"\n29 | description = \"\"\"With dbt, data analysts and engineers can build analytics \\\n30 | the way engineers build applications.\"\"\"\n31 | \n32 | \n33 | setup(\n34 | name=package_name,\n35 | version=package_version,\n36 | description=description,\n37 | long_description=long_description,\n38 | long_description_content_type=\"text/markdown\",\n39 | author=\"dbt Labs\",\n40 | author_email=\"info@dbtlabs.com\",\n41 | url=\"https://github.com/dbt-labs/dbt-core\",\n42 | packages=find_namespace_packages(include=[\"dbt\", \"dbt.*\"]),\n43 | include_package_data=True,\n44 | test_suite=\"test\",\n45 | entry_points={\n46 | \"console_scripts\": [\"dbt = dbt.cli.main:cli\"],\n47 | },\n48 | install_requires=[\n49 | # ----\n50 | # dbt-core uses these packages deeply, throughout the codebase, and there have been breaking changes in past patch releases (even though these are major-version-one).\n51 | # Pin to the patch or minor version, and bump in each new minor version of dbt-core.\n52 | \"agate~=1.7.0\",\n53 | \"Jinja2~=3.1.2\",\n54 | \"mashumaro[msgpack]~=3.9\",\n55 | # ----\n56 | # Legacy: This package has not been updated since 2019, and it is unused in dbt's logging system (since v1.0)\n57 | # The dependency here will be removed along with the removal of 'legacy logging', in a future release of dbt-core\n58 | \"logbook>=1.5,<1.6\",\n59 | # ----\n60 | # dbt-core uses these packages in standard ways. Pin to the major version, and check compatibility\n61 | # with major versions in each new minor version of dbt-core.\n62 | \"click>=8.0.2,<9\",\n63 | \"networkx>=2.3,<4\",\n64 | # ----\n65 | # These packages are major-version-0. Keep upper bounds on upcoming minor versions (which could have breaking changes)\n66 | # and check compatibility / bump in each new minor version of dbt-core.\n67 | \"pathspec>=0.9,<0.12\",\n68 | \"sqlparse>=0.2.3,<0.5\",\n69 | # ----\n70 | # These are major-version-0 packages also maintained by dbt-labs. Accept patches.\n71 | \"dbt-extractor~=0.5.0\",\n72 | \"minimal-snowplow-tracker~=0.0.2\",\n73 | \"dbt-semantic-interfaces~=0.5.0a2\",\n74 | \"dbt-common~=0.1.0\",\n75 | \"dbt-adapters~=0.1.0a2\",\n76 | # ----\n77 | # Expect compatibility with all new versions of these packages, so lower bounds only.\n78 | \"packaging>20.9\",\n79 | \"protobuf>=4.0.0\",\n80 | \"pytz>=2015.7\",\n81 | \"pyyaml>=6.0\",\n82 | \"daff>=1.3.46\",\n83 | \"typing-extensions>=4.4\",\n84 | # ----\n85 | ],\n86 | zip_safe=False,\n87 | classifiers=[\n88 | \"Development Status :: 5 - Production/Stable\",\n89 | \"License :: OSI Approved :: Apache Software License\",\n90 | \"Operating System :: Microsoft :: Windows\",\n91 | \"Operating System :: MacOS :: MacOS X\",\n92 | \"Operating System :: POSIX :: Linux\",\n93 | \"Programming Language :: Python :: 3.8\",\n94 | \"Programming Language :: Python :: 3.9\",\n95 | \"Programming Language :: Python :: 3.10\",\n96 | \"Programming Language :: Python :: 3.11\",\n97 | ],\n98 | python_requires=\">=3.8\",\n99 | )\n```\n\n## Files after the fix\n\n### File: core/setup.py\n\n```python\n 1 | #!/usr/bin/env python\n 2 | import os\n 3 | import sys\n 4 | \n 5 | if sys.version_info < (3, 8):\n 6 | print(\"Error: dbt does not support this version of Python.\")\n 7 | print(\"Please upgrade to Python 3.8 or higher.\")\n 8 | sys.exit(1)\n 9 | \n 10 | \n 11 | from setuptools import setup\n 12 | \n 13 | try:\n 14 | from setuptools import find_namespace_packages\n 15 | except ImportError:\n 16 | # the user has a downlevel version of setuptools.\n 17 | print(\"Error: dbt requires setuptools v40.1.0 or higher.\")\n 18 | print('Please upgrade setuptools with \"pip install --upgrade setuptools\" ' \"and try again\")\n 19 | sys.exit(1)\n 20 | \n 21 | \n 22 | this_directory = os.path.abspath(os.path.dirname(__file__))\n 23 | with open(os.path.join(this_directory, \"README.md\")) as f:\n 24 | long_description = f.read()\n 25 | \n 26 | \n 27 | package_name = \"dbt-core\"\n 28 | package_version = \"1.8.0a1\"\n 29 | description = \"\"\"With dbt, data analysts and engineers can build analytics \\\n 30 | the way engineers build applications.\"\"\"\n 31 | \n 32 | \n 33 | setup(\n 34 | name=package_name,\n 35 | version=package_version,\n 36 | description=description,\n 37 | long_description=long_description,\n 38 | long_description_content_type=\"text/markdown\",\n 39 | author=\"dbt Labs\",\n 40 | author_email=\"info@dbtlabs.com\",\n 41 | url=\"https://github.com/dbt-labs/dbt-core\",\n 42 | packages=find_namespace_packages(include=[\"dbt\", \"dbt.*\"]),\n 43 | include_package_data=True,\n 44 | test_suite=\"test\",\n 45 | entry_points={\n 46 | \"console_scripts\": [\"dbt = dbt.cli.main:cli\"],\n 47 | },\n 48 | install_requires=[\n 49 | # ----\n 50 | # dbt-core uses these packages deeply, throughout the codebase, and there have been breaking changes in past patch releases (even though these are major-version-one).\n 51 | # Pin to the patch or minor version, and bump in each new minor version of dbt-core.\n 52 | \"agate~=1.7.0\",\n 53 | \"Jinja2~=3.1.2\",\n 54 | \"mashumaro[msgpack]~=3.9\",\n 55 | # ----\n 56 | # Legacy: This package has not been updated since 2019, and it is unused in dbt's logging system (since v1.0)\n 57 | # The dependency here will be removed along with the removal of 'legacy logging', in a future release of dbt-core\n 58 | \"logbook>=1.5,<1.6\",\n 59 | # ----\n 60 | # dbt-core uses these packages in standard ways. Pin to the major version, and check compatibility\n 61 | # with major versions in each new minor version of dbt-core.\n 62 | \"click>=8.0.2,<9\",\n 63 | \"networkx>=2.3,<4\",\n 64 | \"requests<3.0.0\", # should match dbt-common\n 65 | # ----\n 66 | # These packages are major-version-0. Keep upper bounds on upcoming minor versions (which could have breaking changes)\n 67 | # and check compatibility / bump in each new minor version of dbt-core.\n 68 | \"pathspec>=0.9,<0.12\",\n 69 | \"sqlparse>=0.2.3,<0.5\",\n 70 | # ----\n 71 | # These are major-version-0 packages also maintained by dbt-labs. Accept patches.\n 72 | \"dbt-extractor~=0.5.0\",\n 73 | \"minimal-snowplow-tracker~=0.0.2\",\n 74 | \"dbt-semantic-interfaces~=0.5.0a2\",\n 75 | \"dbt-common~=0.1.0\",\n 76 | \"dbt-adapters~=0.1.0a2\",\n 77 | # ----\n 78 | # Expect compatibility with all new versions of these packages, so lower bounds only.\n 79 | \"packaging>20.9\",\n 80 | \"protobuf>=4.0.0\",\n 81 | \"pytz>=2015.7\",\n 82 | \"pyyaml>=6.0\",\n 83 | \"daff>=1.3.46\",\n 84 | \"typing-extensions>=4.4\",\n 85 | # ----\n 86 | ],\n 87 | zip_safe=False,\n 88 | classifiers=[\n 89 | \"Development Status :: 5 - Production/Stable\",\n 90 | \"License :: OSI Approved :: Apache Software License\",\n 91 | \"Operating System :: Microsoft :: Windows\",\n 92 | \"Operating System :: MacOS :: MacOS X\",\n 93 | \"Operating System :: POSIX :: Linux\",\n 94 | \"Programming Language :: Python :: 3.8\",\n 95 | \"Programming Language :: Python :: 3.9\",\n 96 | \"Programming Language :: Python :: 3.10\",\n 97 | \"Programming Language :: Python :: 3.11\",\n 98 | ],\n 99 | python_requires=\">=3.8\",\n100 | )\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/setup.py b/core/setup.py\nindex 0000000..0000000 100644\n--- a/core/setup.py\n+++ b/core/setup.py\n@@ -61,6 +61,7 @@ setup(\n # with major versions in each new minor version of dbt-core.\n \"click>=8.0.2,<9\",\n \"networkx>=2.3,<4\",\n+ \"requests<3.0.0\", # should match dbt-common\n # ----\n # These packages are major-version-0. Keep upper bounds on upcoming minor versions (which could have breaking changes)\n # and check compatibility / bump in each new minor version of dbt-core."},"prompt_input_token_count":{"kind":"number","value":2979,"string":"2,979"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9452\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"bdcf2649632139296dc7c24fc50cbf9c8325df87\",\n \"pull_number\": 9452,\n \"issue_numbers\": [\n \"8790\"\n ],\n \"changed_files\": [\n \"core/setup.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": false\n}"}}},{"rowIdx":32290,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9454"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 98bbbc126b48326a3acadeee96886202a744ed11\nChanged files:\n- core/dbt/task/docs/generate.py\n\n## Problem statement\n\n[CT-3429] [Bug] Selectors don't apply for sources and seeds in `dbt docs generate`\n### Is this a new bug in dbt-core?\r\n\r\n- [X] I believe this is a new bug in dbt-core\r\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\r\n\r\n### Current Behavior\r\n\r\nFollowing up from https://github.com/dbt-labs/dbt-core/pull/9159, if there are multiple seeds or sources in a dbt project and a selector is used, `catalog.json` should only contain the seeds or sources that match selection criteria (which is currently ignored).\r\n\r\n### Expected Behavior\r\n\r\nThe selection criteria above are respected.\r\n\r\n### Steps To Reproduce\r\n\r\n1. Add seeds `my_first_seed` and `my_second_seed` to project and run `dbt seed`\r\n2. Run `dbt docs generate --select my_first_seed`\r\n3. Inspect `catalog.json` to find that `my_second_seed` is in there even though it shouldn't be\r\n\r\n### Relevant log output\r\n\r\n_No response_\r\n\r\n### Environment\r\n\r\n```markdown\r\n- OS: MacOS (applies to all)\r\n- Python: 3.11\r\n- dbt: 1.7\r\n- adapter: Postgres, but probably applies to all\r\n```\r\n\r\n\r\n### Which database adapter are you using with dbt?\r\n\r\npostgres\r\n\r\n### Additional Context\r\n\r\nAcceptance Criteria:\r\n1. Fix TODOs here: https://github.com/dbt-labs/dbt-core/blob/201d75bd1c3d8da7225990f96ccfe8987dcd70a8/tests/functional/docs/test_generate.py#L90-L100\r\n2. Document other node types that selectors haven't been tested against\n\n## Hints\n\nFollow-up from technical refinement:\r\n1. Apply all selectors from other commands to `docs generate`\r\n\r\nFollow-up from pointing:\r\n1. Refine scope to sources and seeds\n\n## Files before the fix\n\n### File: core/dbt/task/docs/generate.py\n\n```python\n 1 | import os\n 2 | import shutil\n 3 | from datetime import datetime\n 4 | from typing import Dict, List, Any, Optional, Tuple, Set, Iterable\n 5 | import agate\n 6 | from itertools import chain\n 7 | \n 8 | import dbt_common.utils.formatting\n 9 | from dbt_common.dataclass_schema import ValidationError\n 10 | from dbt_common.clients.system import load_file_contents\n 11 | \n 12 | from dbt.task.docs import DOCS_INDEX_FILE_PATH\n 13 | from dbt.task.compile import CompileTask\n 14 | \n 15 | from dbt.adapters.factory import get_adapter\n 16 | from dbt.contracts.graph.nodes import ResultNode\n 17 | from dbt.contracts.graph.manifest import Manifest\n 18 | from dbt.artifacts.schemas.results import NodeStatus\n 19 | from dbt.artifacts.schemas.catalog import (\n 20 | TableMetadata,\n 21 | CatalogTable,\n 22 | CatalogResults,\n 23 | PrimitiveDict,\n 24 | CatalogKey,\n 25 | StatsItem,\n 26 | StatsDict,\n 27 | ColumnMetadata,\n 28 | CatalogArtifact,\n 29 | )\n 30 | from dbt_common.exceptions import DbtInternalError\n 31 | from dbt.exceptions import AmbiguousCatalogMatchError\n 32 | from dbt.graph import ResourceTypeSelector\n 33 | from dbt.node_types import EXECUTABLE_NODE_TYPES\n 34 | from dbt_common.events.functions import fire_event\n 35 | from dbt.adapters.events.types import (\n 36 | WriteCatalogFailure,\n 37 | CatalogWritten,\n 38 | CannotGenerateDocs,\n 39 | BuildingCatalog,\n 40 | )\n 41 | from dbt.parser.manifest import write_manifest\n 42 | import dbt.utils\n 43 | import dbt.compilation\n 44 | import dbt.exceptions\n 45 | from dbt.constants import (\n 46 | MANIFEST_FILE_NAME,\n 47 | )\n 48 | \n 49 | CATALOG_FILENAME = \"catalog.json\"\n 50 | \n 51 | \n 52 | def get_stripped_prefix(source: Dict[str, Any], prefix: str) -> Dict[str, Any]:\n 53 | \"\"\"Go through the source, extracting every key/value pair where the key starts\n 54 | with the given prefix.\n 55 | \"\"\"\n 56 | cut = len(prefix)\n 57 | return {k[cut:]: v for k, v in source.items() if k.startswith(prefix)}\n 58 | \n 59 | \n 60 | def build_catalog_table(data) -> CatalogTable:\n 61 | # build the new table's metadata + stats\n 62 | metadata = TableMetadata.from_dict(get_stripped_prefix(data, \"table_\"))\n 63 | stats = format_stats(get_stripped_prefix(data, \"stats:\"))\n 64 | \n 65 | return CatalogTable(\n 66 | metadata=metadata,\n 67 | stats=stats,\n 68 | columns={},\n 69 | )\n 70 | \n 71 | \n 72 | # keys are database name, schema name, table name\n 73 | class Catalog(Dict[CatalogKey, CatalogTable]):\n 74 | def __init__(self, columns: List[PrimitiveDict]) -> None:\n 75 | super().__init__()\n 76 | for col in columns:\n 77 | self.add_column(col)\n 78 | \n 79 | def get_table(self, data: PrimitiveDict) -> CatalogTable:\n 80 | database = data.get(\"table_database\")\n 81 | if database is None:\n 82 | dkey: Optional[str] = None\n 83 | else:\n 84 | dkey = str(database)\n 85 | \n 86 | try:\n 87 | key = CatalogKey(\n 88 | dkey,\n 89 | str(data[\"table_schema\"]),\n 90 | str(data[\"table_name\"]),\n 91 | )\n 92 | except KeyError as exc:\n 93 | raise dbt_common.exceptions.CompilationError(\n 94 | \"Catalog information missing required key {} (got {})\".format(exc, data)\n 95 | )\n 96 | table: CatalogTable\n 97 | if key in self:\n 98 | table = self[key]\n 99 | else:\n100 | table = build_catalog_table(data)\n101 | self[key] = table\n102 | return table\n103 | \n104 | def add_column(self, data: PrimitiveDict):\n105 | table = self.get_table(data)\n106 | column_data = get_stripped_prefix(data, \"column_\")\n107 | # the index should really never be that big so it's ok to end up\n108 | # serializing this to JSON (2^53 is the max safe value there)\n109 | column_data[\"index\"] = int(column_data[\"index\"])\n110 | \n111 | column = ColumnMetadata.from_dict(column_data)\n112 | table.columns[column.name] = column\n113 | \n114 | def make_unique_id_map(\n115 | self, manifest: Manifest\n116 | ) -> Tuple[Dict[str, CatalogTable], Dict[str, CatalogTable]]:\n117 | nodes: Dict[str, CatalogTable] = {}\n118 | sources: Dict[str, CatalogTable] = {}\n119 | \n120 | node_map, source_map = get_unique_id_mapping(manifest)\n121 | table: CatalogTable\n122 | for table in self.values():\n123 | key = table.key()\n124 | if key in node_map:\n125 | unique_id = node_map[key]\n126 | nodes[unique_id] = table.replace(unique_id=unique_id)\n127 | \n128 | unique_ids = source_map.get(table.key(), set())\n129 | for unique_id in unique_ids:\n130 | if unique_id in sources:\n131 | raise AmbiguousCatalogMatchError(\n132 | unique_id,\n133 | sources[unique_id].to_dict(omit_none=True),\n134 | table.to_dict(omit_none=True),\n135 | )\n136 | else:\n137 | sources[unique_id] = table.replace(unique_id=unique_id)\n138 | return nodes, sources\n139 | \n140 | \n141 | def format_stats(stats: PrimitiveDict) -> StatsDict:\n142 | \"\"\"Given a dictionary following this layout:\n143 | \n144 | {\n145 | 'encoded:label': 'Encoded',\n146 | 'encoded:value': 'Yes',\n147 | 'encoded:description': 'Indicates if the column is encoded',\n148 | 'encoded:include': True,\n149 | \n150 | 'size:label': 'Size',\n151 | 'size:value': 128,\n152 | 'size:description': 'Size of the table in MB',\n153 | 'size:include': True,\n154 | }\n155 | \n156 | format_stats will convert the dict into a StatsDict with keys of 'encoded'\n157 | and 'size'.\n158 | \"\"\"\n159 | stats_collector: StatsDict = {}\n160 | \n161 | base_keys = {k.split(\":\")[0] for k in stats}\n162 | for key in base_keys:\n163 | dct: PrimitiveDict = {\"id\": key}\n164 | for subkey in (\"label\", \"value\", \"description\", \"include\"):\n165 | dct[subkey] = stats[\"{}:{}\".format(key, subkey)]\n166 | \n167 | try:\n168 | stats_item = StatsItem.from_dict(dct)\n169 | except ValidationError:\n170 | continue\n171 | if stats_item.include:\n172 | stats_collector[key] = stats_item\n173 | \n174 | # we always have a 'has_stats' field, it's never included\n175 | has_stats = StatsItem(\n176 | id=\"has_stats\",\n177 | label=\"Has Stats?\",\n178 | value=len(stats_collector) > 0,\n179 | description=\"Indicates whether there are statistics for this table\",\n180 | include=False,\n181 | )\n182 | stats_collector[\"has_stats\"] = has_stats\n183 | return stats_collector\n184 | \n185 | \n186 | def mapping_key(node: ResultNode) -> CatalogKey:\n187 | dkey = dbt_common.utils.formatting.lowercase(node.database)\n188 | return CatalogKey(dkey, node.schema.lower(), node.identifier.lower())\n189 | \n190 | \n191 | def get_unique_id_mapping(\n192 | manifest: Manifest,\n193 | ) -> Tuple[Dict[CatalogKey, str], Dict[CatalogKey, Set[str]]]:\n194 | # A single relation could have multiple unique IDs pointing to it if a\n195 | # source were also a node.\n196 | node_map: Dict[CatalogKey, str] = {}\n197 | source_map: Dict[CatalogKey, Set[str]] = {}\n198 | for unique_id, node in manifest.nodes.items():\n199 | key = mapping_key(node)\n200 | node_map[key] = unique_id\n201 | \n202 | for unique_id, source in manifest.sources.items():\n203 | key = mapping_key(source)\n204 | if key not in source_map:\n205 | source_map[key] = set()\n206 | source_map[key].add(unique_id)\n207 | return node_map, source_map\n208 | \n209 | \n210 | class GenerateTask(CompileTask):\n211 | def run(self) -> CatalogArtifact:\n212 | compile_results = None\n213 | if self.args.compile:\n214 | compile_results = CompileTask.run(self)\n215 | if any(r.status == NodeStatus.Error for r in compile_results):\n216 | fire_event(CannotGenerateDocs())\n217 | return CatalogArtifact.from_results(\n218 | nodes={},\n219 | sources={},\n220 | generated_at=datetime.utcnow(),\n221 | errors=None,\n222 | compile_results=compile_results,\n223 | )\n224 | \n225 | shutil.copyfile(\n226 | DOCS_INDEX_FILE_PATH, os.path.join(self.config.project_target_path, \"index.html\")\n227 | )\n228 | \n229 | for asset_path in self.config.asset_paths:\n230 | to_asset_path = os.path.join(self.config.project_target_path, asset_path)\n231 | \n232 | if os.path.exists(to_asset_path):\n233 | shutil.rmtree(to_asset_path)\n234 | \n235 | if os.path.exists(asset_path):\n236 | shutil.copytree(asset_path, to_asset_path)\n237 | \n238 | if self.manifest is None:\n239 | raise DbtInternalError(\"self.manifest was None in run!\")\n240 | \n241 | if self.args.empty_catalog:\n242 | catalog_table: agate.Table = agate.Table([])\n243 | exceptions: List[Exception] = []\n244 | else:\n245 | adapter = get_adapter(self.config)\n246 | with adapter.connection_named(\"generate_catalog\"):\n247 | fire_event(BuildingCatalog())\n248 | # Get a list of relations we need from the catalog\n249 | relations = None\n250 | if self.job_queue is not None:\n251 | selected_node_ids = self.job_queue.get_selected_nodes()\n252 | selected_nodes = self._get_nodes_from_ids(self.manifest, selected_node_ids)\n253 | \n254 | source_ids = self._get_nodes_from_ids(\n255 | self.manifest, self.manifest.sources.keys()\n256 | )\n257 | selected_nodes.extend(source_ids)\n258 | \n259 | relations = {\n260 | adapter.Relation.create_from(adapter.config, node_id)\n261 | for node_id in selected_nodes\n262 | }\n263 | \n264 | # This generates the catalog as an agate.Table\n265 | catalogable_nodes = chain(\n266 | [\n267 | node\n268 | for node in self.manifest.nodes.values()\n269 | if (node.is_relational and not node.is_ephemeral_model)\n270 | ]\n271 | )\n272 | used_schemas = self.manifest.get_used_schemas()\n273 | catalog_table, exceptions = adapter.get_filtered_catalog(\n274 | catalogable_nodes, used_schemas, relations\n275 | )\n276 | \n277 | catalog_data: List[PrimitiveDict] = [\n278 | dict(zip(catalog_table.column_names, map(dbt.utils._coerce_decimal, row)))\n279 | for row in catalog_table\n280 | ]\n281 | \n282 | catalog = Catalog(catalog_data)\n283 | \n284 | errors: Optional[List[str]] = None\n285 | if exceptions:\n286 | errors = [str(e) for e in exceptions]\n287 | \n288 | nodes, sources = catalog.make_unique_id_map(self.manifest)\n289 | results = self.get_catalog_results(\n290 | nodes=nodes,\n291 | sources=sources,\n292 | generated_at=datetime.utcnow(),\n293 | compile_results=compile_results,\n294 | errors=errors,\n295 | )\n296 | \n297 | catalog_path = os.path.join(self.config.project_target_path, CATALOG_FILENAME)\n298 | results.write(catalog_path)\n299 | if self.args.compile:\n300 | write_manifest(self.manifest, self.config.project_target_path)\n301 | \n302 | if self.args.static:\n303 | \n304 | # Read manifest.json and catalog.json\n305 | read_manifest_data = load_file_contents(\n306 | os.path.join(self.config.project_target_path, MANIFEST_FILE_NAME)\n307 | )\n308 | read_catalog_data = load_file_contents(catalog_path)\n309 | \n310 | # Create new static index file contents\n311 | index_data = load_file_contents(DOCS_INDEX_FILE_PATH)\n312 | index_data = index_data.replace('\"MANIFEST.JSON INLINE DATA\"', read_manifest_data)\n313 | index_data = index_data.replace('\"CATALOG.JSON INLINE DATA\"', read_catalog_data)\n314 | \n315 | # Write out the new index file\n316 | static_index_path = os.path.join(self.config.project_target_path, \"static_index.html\")\n317 | with open(static_index_path, \"wb\") as static_index_file:\n318 | static_index_file.write(bytes(index_data, \"utf8\"))\n319 | \n320 | if exceptions:\n321 | fire_event(WriteCatalogFailure(num_exceptions=len(exceptions)))\n322 | fire_event(CatalogWritten(path=os.path.abspath(catalog_path)))\n323 | return results\n324 | \n325 | @staticmethod\n326 | def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n327 | selected: List[ResultNode] = []\n328 | for unique_id in node_ids:\n329 | if unique_id in manifest.nodes:\n330 | node = manifest.nodes[unique_id]\n331 | if node.is_relational and not node.is_ephemeral_model:\n332 | selected.append(node)\n333 | elif unique_id in manifest.sources:\n334 | source = manifest.sources[unique_id]\n335 | selected.append(source)\n336 | return selected\n337 | \n338 | def get_node_selector(self) -> ResourceTypeSelector:\n339 | if self.manifest is None or self.graph is None:\n340 | raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n341 | return ResourceTypeSelector(\n342 | graph=self.graph,\n343 | manifest=self.manifest,\n344 | previous_state=self.previous_state,\n345 | resource_types=EXECUTABLE_NODE_TYPES,\n346 | include_empty_nodes=True,\n347 | )\n348 | \n349 | def get_catalog_results(\n350 | self,\n351 | nodes: Dict[str, CatalogTable],\n352 | sources: Dict[str, CatalogTable],\n353 | generated_at: datetime,\n354 | compile_results: Optional[Any],\n355 | errors: Optional[List[str]],\n356 | ) -> CatalogArtifact:\n357 | return CatalogArtifact.from_results(\n358 | generated_at=generated_at,\n359 | nodes=nodes,\n360 | sources=sources,\n361 | compile_results=compile_results,\n362 | errors=errors,\n363 | )\n364 | \n365 | @classmethod\n366 | def interpret_results(self, results: Optional[CatalogResults]) -> bool:\n367 | if results is None:\n368 | return False\n369 | if results.errors:\n370 | return False\n371 | compile_results = results._compile_results\n372 | if compile_results is None:\n373 | return True\n374 | \n375 | return super().interpret_results(compile_results)\n```\n\n## Files after the fix\n\n### File: core/dbt/task/docs/generate.py\n\n```python\n 1 | import os\n 2 | import shutil\n 3 | from datetime import datetime\n 4 | from typing import Dict, List, Any, Optional, Tuple, Set, Iterable\n 5 | import agate\n 6 | from itertools import chain\n 7 | \n 8 | import dbt_common.utils.formatting\n 9 | from dbt_common.dataclass_schema import ValidationError\n 10 | from dbt_common.clients.system import load_file_contents\n 11 | \n 12 | from dbt.task.docs import DOCS_INDEX_FILE_PATH\n 13 | from dbt.task.compile import CompileTask\n 14 | \n 15 | from dbt.adapters.factory import get_adapter\n 16 | \n 17 | from dbt.graph.graph import UniqueId\n 18 | from dbt.contracts.graph.nodes import ResultNode\n 19 | from dbt.contracts.graph.manifest import Manifest\n 20 | from dbt.artifacts.schemas.results import NodeStatus\n 21 | from dbt.artifacts.schemas.catalog import (\n 22 | TableMetadata,\n 23 | CatalogTable,\n 24 | CatalogResults,\n 25 | PrimitiveDict,\n 26 | CatalogKey,\n 27 | StatsItem,\n 28 | StatsDict,\n 29 | ColumnMetadata,\n 30 | CatalogArtifact,\n 31 | )\n 32 | from dbt_common.exceptions import DbtInternalError\n 33 | from dbt.exceptions import AmbiguousCatalogMatchError\n 34 | from dbt.graph import ResourceTypeSelector\n 35 | from dbt.node_types import EXECUTABLE_NODE_TYPES, NodeType\n 36 | from dbt_common.events.functions import fire_event\n 37 | from dbt.adapters.events.types import (\n 38 | WriteCatalogFailure,\n 39 | CatalogWritten,\n 40 | CannotGenerateDocs,\n 41 | BuildingCatalog,\n 42 | )\n 43 | from dbt.parser.manifest import write_manifest\n 44 | import dbt.utils\n 45 | import dbt.compilation\n 46 | import dbt.exceptions\n 47 | from dbt.constants import (\n 48 | MANIFEST_FILE_NAME,\n 49 | )\n 50 | \n 51 | CATALOG_FILENAME = \"catalog.json\"\n 52 | \n 53 | \n 54 | def get_stripped_prefix(source: Dict[str, Any], prefix: str) -> Dict[str, Any]:\n 55 | \"\"\"Go through the source, extracting every key/value pair where the key starts\n 56 | with the given prefix.\n 57 | \"\"\"\n 58 | cut = len(prefix)\n 59 | return {k[cut:]: v for k, v in source.items() if k.startswith(prefix)}\n 60 | \n 61 | \n 62 | def build_catalog_table(data) -> CatalogTable:\n 63 | # build the new table's metadata + stats\n 64 | metadata = TableMetadata.from_dict(get_stripped_prefix(data, \"table_\"))\n 65 | stats = format_stats(get_stripped_prefix(data, \"stats:\"))\n 66 | \n 67 | return CatalogTable(\n 68 | metadata=metadata,\n 69 | stats=stats,\n 70 | columns={},\n 71 | )\n 72 | \n 73 | \n 74 | # keys are database name, schema name, table name\n 75 | class Catalog(Dict[CatalogKey, CatalogTable]):\n 76 | def __init__(self, columns: List[PrimitiveDict]) -> None:\n 77 | super().__init__()\n 78 | for col in columns:\n 79 | self.add_column(col)\n 80 | \n 81 | def get_table(self, data: PrimitiveDict) -> CatalogTable:\n 82 | database = data.get(\"table_database\")\n 83 | if database is None:\n 84 | dkey: Optional[str] = None\n 85 | else:\n 86 | dkey = str(database)\n 87 | \n 88 | try:\n 89 | key = CatalogKey(\n 90 | dkey,\n 91 | str(data[\"table_schema\"]),\n 92 | str(data[\"table_name\"]),\n 93 | )\n 94 | except KeyError as exc:\n 95 | raise dbt_common.exceptions.CompilationError(\n 96 | \"Catalog information missing required key {} (got {})\".format(exc, data)\n 97 | )\n 98 | table: CatalogTable\n 99 | if key in self:\n100 | table = self[key]\n101 | else:\n102 | table = build_catalog_table(data)\n103 | self[key] = table\n104 | return table\n105 | \n106 | def add_column(self, data: PrimitiveDict):\n107 | table = self.get_table(data)\n108 | column_data = get_stripped_prefix(data, \"column_\")\n109 | # the index should really never be that big so it's ok to end up\n110 | # serializing this to JSON (2^53 is the max safe value there)\n111 | column_data[\"index\"] = int(column_data[\"index\"])\n112 | \n113 | column = ColumnMetadata.from_dict(column_data)\n114 | table.columns[column.name] = column\n115 | \n116 | def make_unique_id_map(\n117 | self, manifest: Manifest, selected_node_ids: Optional[Set[UniqueId]] = None\n118 | ) -> Tuple[Dict[str, CatalogTable], Dict[str, CatalogTable]]:\n119 | \"\"\"\n120 | Create mappings between CatalogKeys and CatalogTables for nodes and sources, filtered by selected_node_ids.\n121 | \n122 | By default, selected_node_ids is None and all nodes and sources defined in the manifest are included in the mappings.\n123 | \"\"\"\n124 | nodes: Dict[str, CatalogTable] = {}\n125 | sources: Dict[str, CatalogTable] = {}\n126 | \n127 | node_map, source_map = get_unique_id_mapping(manifest)\n128 | table: CatalogTable\n129 | for table in self.values():\n130 | key = table.key()\n131 | if key in node_map:\n132 | unique_id = node_map[key]\n133 | if selected_node_ids is None or unique_id in selected_node_ids:\n134 | nodes[unique_id] = table.replace(unique_id=unique_id)\n135 | \n136 | unique_ids = source_map.get(table.key(), set())\n137 | for unique_id in unique_ids:\n138 | if unique_id in sources:\n139 | raise AmbiguousCatalogMatchError(\n140 | unique_id,\n141 | sources[unique_id].to_dict(omit_none=True),\n142 | table.to_dict(omit_none=True),\n143 | )\n144 | elif selected_node_ids is None or unique_id in selected_node_ids:\n145 | sources[unique_id] = table.replace(unique_id=unique_id)\n146 | return nodes, sources\n147 | \n148 | \n149 | def format_stats(stats: PrimitiveDict) -> StatsDict:\n150 | \"\"\"Given a dictionary following this layout:\n151 | \n152 | {\n153 | 'encoded:label': 'Encoded',\n154 | 'encoded:value': 'Yes',\n155 | 'encoded:description': 'Indicates if the column is encoded',\n156 | 'encoded:include': True,\n157 | \n158 | 'size:label': 'Size',\n159 | 'size:value': 128,\n160 | 'size:description': 'Size of the table in MB',\n161 | 'size:include': True,\n162 | }\n163 | \n164 | format_stats will convert the dict into a StatsDict with keys of 'encoded'\n165 | and 'size'.\n166 | \"\"\"\n167 | stats_collector: StatsDict = {}\n168 | \n169 | base_keys = {k.split(\":\")[0] for k in stats}\n170 | for key in base_keys:\n171 | dct: PrimitiveDict = {\"id\": key}\n172 | for subkey in (\"label\", \"value\", \"description\", \"include\"):\n173 | dct[subkey] = stats[\"{}:{}\".format(key, subkey)]\n174 | \n175 | try:\n176 | stats_item = StatsItem.from_dict(dct)\n177 | except ValidationError:\n178 | continue\n179 | if stats_item.include:\n180 | stats_collector[key] = stats_item\n181 | \n182 | # we always have a 'has_stats' field, it's never included\n183 | has_stats = StatsItem(\n184 | id=\"has_stats\",\n185 | label=\"Has Stats?\",\n186 | value=len(stats_collector) > 0,\n187 | description=\"Indicates whether there are statistics for this table\",\n188 | include=False,\n189 | )\n190 | stats_collector[\"has_stats\"] = has_stats\n191 | return stats_collector\n192 | \n193 | \n194 | def mapping_key(node: ResultNode) -> CatalogKey:\n195 | dkey = dbt_common.utils.formatting.lowercase(node.database)\n196 | return CatalogKey(dkey, node.schema.lower(), node.identifier.lower())\n197 | \n198 | \n199 | def get_unique_id_mapping(\n200 | manifest: Manifest,\n201 | ) -> Tuple[Dict[CatalogKey, str], Dict[CatalogKey, Set[str]]]:\n202 | # A single relation could have multiple unique IDs pointing to it if a\n203 | # source were also a node.\n204 | node_map: Dict[CatalogKey, str] = {}\n205 | source_map: Dict[CatalogKey, Set[str]] = {}\n206 | for unique_id, node in manifest.nodes.items():\n207 | key = mapping_key(node)\n208 | node_map[key] = unique_id\n209 | \n210 | for unique_id, source in manifest.sources.items():\n211 | key = mapping_key(source)\n212 | if key not in source_map:\n213 | source_map[key] = set()\n214 | source_map[key].add(unique_id)\n215 | return node_map, source_map\n216 | \n217 | \n218 | class GenerateTask(CompileTask):\n219 | def run(self) -> CatalogArtifact:\n220 | compile_results = None\n221 | if self.args.compile:\n222 | compile_results = CompileTask.run(self)\n223 | if any(r.status == NodeStatus.Error for r in compile_results):\n224 | fire_event(CannotGenerateDocs())\n225 | return CatalogArtifact.from_results(\n226 | nodes={},\n227 | sources={},\n228 | generated_at=datetime.utcnow(),\n229 | errors=None,\n230 | compile_results=compile_results,\n231 | )\n232 | \n233 | shutil.copyfile(\n234 | DOCS_INDEX_FILE_PATH, os.path.join(self.config.project_target_path, \"index.html\")\n235 | )\n236 | \n237 | for asset_path in self.config.asset_paths:\n238 | to_asset_path = os.path.join(self.config.project_target_path, asset_path)\n239 | \n240 | if os.path.exists(to_asset_path):\n241 | shutil.rmtree(to_asset_path)\n242 | \n243 | if os.path.exists(asset_path):\n244 | shutil.copytree(asset_path, to_asset_path)\n245 | \n246 | if self.manifest is None:\n247 | raise DbtInternalError(\"self.manifest was None in run!\")\n248 | \n249 | selected_node_ids: Optional[Set[UniqueId]] = None\n250 | if self.args.empty_catalog:\n251 | catalog_table: agate.Table = agate.Table([])\n252 | exceptions: List[Exception] = []\n253 | selected_node_ids = set()\n254 | else:\n255 | adapter = get_adapter(self.config)\n256 | with adapter.connection_named(\"generate_catalog\"):\n257 | fire_event(BuildingCatalog())\n258 | # Get a list of relations we need from the catalog\n259 | relations = None\n260 | if self.job_queue is not None:\n261 | selected_node_ids = self.job_queue.get_selected_nodes()\n262 | selected_nodes = self._get_nodes_from_ids(self.manifest, selected_node_ids)\n263 | \n264 | # Source selection is handled separately from main job_queue selection because\n265 | # SourceDefinition nodes cannot be safely compiled / run by the CompileRunner / CompileTask,\n266 | # but should still be included in the catalog based on the selection spec\n267 | selected_source_ids = self._get_selected_source_ids()\n268 | selected_source_nodes = self._get_nodes_from_ids(\n269 | self.manifest, selected_source_ids\n270 | )\n271 | selected_node_ids.update(selected_source_ids)\n272 | selected_nodes.extend(selected_source_nodes)\n273 | \n274 | relations = {\n275 | adapter.Relation.create_from(adapter.config, node)\n276 | for node in selected_nodes\n277 | }\n278 | \n279 | # This generates the catalog as an agate.Table\n280 | catalogable_nodes = chain(\n281 | [\n282 | node\n283 | for node in self.manifest.nodes.values()\n284 | if (node.is_relational and not node.is_ephemeral_model)\n285 | ]\n286 | )\n287 | used_schemas = self.manifest.get_used_schemas()\n288 | catalog_table, exceptions = adapter.get_filtered_catalog(\n289 | catalogable_nodes, used_schemas, relations\n290 | )\n291 | \n292 | catalog_data: List[PrimitiveDict] = [\n293 | dict(zip(catalog_table.column_names, map(dbt.utils._coerce_decimal, row)))\n294 | for row in catalog_table\n295 | ]\n296 | \n297 | catalog = Catalog(catalog_data)\n298 | \n299 | errors: Optional[List[str]] = None\n300 | if exceptions:\n301 | errors = [str(e) for e in exceptions]\n302 | \n303 | nodes, sources = catalog.make_unique_id_map(self.manifest, selected_node_ids)\n304 | results = self.get_catalog_results(\n305 | nodes=nodes,\n306 | sources=sources,\n307 | generated_at=datetime.utcnow(),\n308 | compile_results=compile_results,\n309 | errors=errors,\n310 | )\n311 | \n312 | catalog_path = os.path.join(self.config.project_target_path, CATALOG_FILENAME)\n313 | results.write(catalog_path)\n314 | if self.args.compile:\n315 | write_manifest(self.manifest, self.config.project_target_path)\n316 | \n317 | if self.args.static:\n318 | \n319 | # Read manifest.json and catalog.json\n320 | read_manifest_data = load_file_contents(\n321 | os.path.join(self.config.project_target_path, MANIFEST_FILE_NAME)\n322 | )\n323 | read_catalog_data = load_file_contents(catalog_path)\n324 | \n325 | # Create new static index file contents\n326 | index_data = load_file_contents(DOCS_INDEX_FILE_PATH)\n327 | index_data = index_data.replace('\"MANIFEST.JSON INLINE DATA\"', read_manifest_data)\n328 | index_data = index_data.replace('\"CATALOG.JSON INLINE DATA\"', read_catalog_data)\n329 | \n330 | # Write out the new index file\n331 | static_index_path = os.path.join(self.config.project_target_path, \"static_index.html\")\n332 | with open(static_index_path, \"wb\") as static_index_file:\n333 | static_index_file.write(bytes(index_data, \"utf8\"))\n334 | \n335 | if exceptions:\n336 | fire_event(WriteCatalogFailure(num_exceptions=len(exceptions)))\n337 | fire_event(CatalogWritten(path=os.path.abspath(catalog_path)))\n338 | return results\n339 | \n340 | def get_node_selector(self) -> ResourceTypeSelector:\n341 | if self.manifest is None or self.graph is None:\n342 | raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n343 | return ResourceTypeSelector(\n344 | graph=self.graph,\n345 | manifest=self.manifest,\n346 | previous_state=self.previous_state,\n347 | resource_types=EXECUTABLE_NODE_TYPES,\n348 | include_empty_nodes=True,\n349 | )\n350 | \n351 | def get_catalog_results(\n352 | self,\n353 | nodes: Dict[str, CatalogTable],\n354 | sources: Dict[str, CatalogTable],\n355 | generated_at: datetime,\n356 | compile_results: Optional[Any],\n357 | errors: Optional[List[str]],\n358 | ) -> CatalogArtifact:\n359 | return CatalogArtifact.from_results(\n360 | generated_at=generated_at,\n361 | nodes=nodes,\n362 | sources=sources,\n363 | compile_results=compile_results,\n364 | errors=errors,\n365 | )\n366 | \n367 | @classmethod\n368 | def interpret_results(self, results: Optional[CatalogResults]) -> bool:\n369 | if results is None:\n370 | return False\n371 | if results.errors:\n372 | return False\n373 | compile_results = results._compile_results\n374 | if compile_results is None:\n375 | return True\n376 | \n377 | return super().interpret_results(compile_results)\n378 | \n379 | @staticmethod\n380 | def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n381 | selected: List[ResultNode] = []\n382 | for unique_id in node_ids:\n383 | if unique_id in manifest.nodes:\n384 | node = manifest.nodes[unique_id]\n385 | if node.is_relational and not node.is_ephemeral_model:\n386 | selected.append(node)\n387 | elif unique_id in manifest.sources:\n388 | source = manifest.sources[unique_id]\n389 | selected.append(source)\n390 | return selected\n391 | \n392 | def _get_selected_source_ids(self) -> Set[UniqueId]:\n393 | if self.manifest is None or self.graph is None:\n394 | raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n395 | \n396 | source_selector = ResourceTypeSelector(\n397 | graph=self.graph,\n398 | manifest=self.manifest,\n399 | previous_state=self.previous_state,\n400 | resource_types=[NodeType.Source],\n401 | )\n402 | \n403 | return source_selector.get_graph_queue(self.get_selection_spec()).get_selected_nodes()\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/task/docs/generate.py b/core/dbt/task/docs/generate.py\nindex 0000000..0000000 100644\n--- a/core/dbt/task/docs/generate.py\n+++ b/core/dbt/task/docs/generate.py\n@@ -13,6 +13,8 @@ from dbt.task.docs import DOCS_INDEX_FILE_PATH\n from dbt.task.compile import CompileTask\n \n from dbt.adapters.factory import get_adapter\n+\n+from dbt.graph.graph import UniqueId\n from dbt.contracts.graph.nodes import ResultNode\n from dbt.contracts.graph.manifest import Manifest\n from dbt.artifacts.schemas.results import NodeStatus\n@@ -30,7 +32,7 @@ from dbt.artifacts.schemas.catalog import (\n from dbt_common.exceptions import DbtInternalError\n from dbt.exceptions import AmbiguousCatalogMatchError\n from dbt.graph import ResourceTypeSelector\n-from dbt.node_types import EXECUTABLE_NODE_TYPES\n+from dbt.node_types import EXECUTABLE_NODE_TYPES, NodeType\n from dbt_common.events.functions import fire_event\n from dbt.adapters.events.types import (\n WriteCatalogFailure,\n@@ -112,8 +114,13 @@ class Catalog(Dict[CatalogKey, CatalogTable]):\n table.columns[column.name] = column\n \n def make_unique_id_map(\n- self, manifest: Manifest\n+ self, manifest: Manifest, selected_node_ids: Optional[Set[UniqueId]] = None\n ) -> Tuple[Dict[str, CatalogTable], Dict[str, CatalogTable]]:\n+ \"\"\"\n+ Create mappings between CatalogKeys and CatalogTables for nodes and sources, filtered by selected_node_ids.\n+\n+ By default, selected_node_ids is None and all nodes and sources defined in the manifest are included in the mappings.\n+ \"\"\"\n nodes: Dict[str, CatalogTable] = {}\n sources: Dict[str, CatalogTable] = {}\n \n@@ -123,7 +130,8 @@ class Catalog(Dict[CatalogKey, CatalogTable]):\n key = table.key()\n if key in node_map:\n unique_id = node_map[key]\n- nodes[unique_id] = table.replace(unique_id=unique_id)\n+ if selected_node_ids is None or unique_id in selected_node_ids:\n+ nodes[unique_id] = table.replace(unique_id=unique_id)\n \n unique_ids = source_map.get(table.key(), set())\n for unique_id in unique_ids:\n@@ -133,7 +141,7 @@ class Catalog(Dict[CatalogKey, CatalogTable]):\n sources[unique_id].to_dict(omit_none=True),\n table.to_dict(omit_none=True),\n )\n- else:\n+ elif selected_node_ids is None or unique_id in selected_node_ids:\n sources[unique_id] = table.replace(unique_id=unique_id)\n return nodes, sources\n \n@@ -238,9 +246,11 @@ class GenerateTask(CompileTask):\n if self.manifest is None:\n raise DbtInternalError(\"self.manifest was None in run!\")\n \n+ selected_node_ids: Optional[Set[UniqueId]] = None\n if self.args.empty_catalog:\n catalog_table: agate.Table = agate.Table([])\n exceptions: List[Exception] = []\n+ selected_node_ids = set()\n else:\n adapter = get_adapter(self.config)\n with adapter.connection_named(\"generate_catalog\"):\n@@ -251,14 +261,19 @@ class GenerateTask(CompileTask):\n selected_node_ids = self.job_queue.get_selected_nodes()\n selected_nodes = self._get_nodes_from_ids(self.manifest, selected_node_ids)\n \n- source_ids = self._get_nodes_from_ids(\n- self.manifest, self.manifest.sources.keys()\n+ # Source selection is handled separately from main job_queue selection because\n+ # SourceDefinition nodes cannot be safely compiled / run by the CompileRunner / CompileTask,\n+ # but should still be included in the catalog based on the selection spec\n+ selected_source_ids = self._get_selected_source_ids()\n+ selected_source_nodes = self._get_nodes_from_ids(\n+ self.manifest, selected_source_ids\n )\n- selected_nodes.extend(source_ids)\n+ selected_node_ids.update(selected_source_ids)\n+ selected_nodes.extend(selected_source_nodes)\n \n relations = {\n- adapter.Relation.create_from(adapter.config, node_id)\n- for node_id in selected_nodes\n+ adapter.Relation.create_from(adapter.config, node)\n+ for node in selected_nodes\n }\n \n # This generates the catalog as an agate.Table\n@@ -285,7 +300,7 @@ class GenerateTask(CompileTask):\n if exceptions:\n errors = [str(e) for e in exceptions]\n \n- nodes, sources = catalog.make_unique_id_map(self.manifest)\n+ nodes, sources = catalog.make_unique_id_map(self.manifest, selected_node_ids)\n results = self.get_catalog_results(\n nodes=nodes,\n sources=sources,\n@@ -322,19 +337,6 @@ class GenerateTask(CompileTask):\n fire_event(CatalogWritten(path=os.path.abspath(catalog_path)))\n return results\n \n- @staticmethod\n- def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n- selected: List[ResultNode] = []\n- for unique_id in node_ids:\n- if unique_id in manifest.nodes:\n- node = manifest.nodes[unique_id]\n- if node.is_relational and not node.is_ephemeral_model:\n- selected.append(node)\n- elif unique_id in manifest.sources:\n- source = manifest.sources[unique_id]\n- selected.append(source)\n- return selected\n-\n def get_node_selector(self) -> ResourceTypeSelector:\n if self.manifest is None or self.graph is None:\n raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n@@ -373,3 +375,29 @@ class GenerateTask(CompileTask):\n return True\n \n return super().interpret_results(compile_results)\n+\n+ @staticmethod\n+ def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n+ selected: List[ResultNode] = []\n+ for unique_id in node_ids:\n+ if unique_id in manifest.nodes:\n+ node = manifest.nodes[unique_id]\n+ if node.is_relational and not node.is_ephemeral_model:\n+ selected.append(node)\n+ elif unique_id in manifest.sources:\n+ source = manifest.sources[unique_id]\n+ selected.append(source)\n+ return selected\n+\n+ def _get_selected_source_ids(self) -> Set[UniqueId]:\n+ if self.manifest is None or self.graph is None:\n+ raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n+\n+ source_selector = ResourceTypeSelector(\n+ graph=self.graph,\n+ manifest=self.manifest,\n+ previous_state=self.previous_state,\n+ resource_types=[NodeType.Source],\n+ )\n+\n+ return source_selector.get_graph_queue(self.get_selection_spec()).get_selected_nodes()"},"prompt_input_token_count":{"kind":"number","value":9486,"string":"9,486"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9454\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"98bbbc126b48326a3acadeee96886202a744ed11\",\n \"pull_number\": 9454,\n \"issue_numbers\": [\n \"9161\"\n ],\n \"changed_files\": [\n \"core/dbt/task/docs/generate.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32291,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9456"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 6663846026aba5d9b8e4abb47b58af2ff0462e40\nChanged files:\n- core/dbt/task/docs/generate.py\n\n## Problem statement\n\n[Regression] External nodes not included in catalog during docs generation\n### Is this a regression in a recent version of dbt-core?\n\n- [X] I believe this is a regression in dbt-core functionality\n- [X] I have searched the existing issues, and I could not find an existing issue for this regression\n\n### Current Behavior\n\nExternal nodes should be included in the catalog as a result of `dbt docs generate`. Currently, projects with external nodes are not included in the resulting catalog.json\n\n### Expected/Previous Behavior\n\ncatalog.json includes catalog entry for external node when project contains external node.\n\n### Steps To Reproduce\n\ntest passes 1.6.latest: https://github.com/dbt-labs/dbt-core/pull/9457\r\nsame test fails on main (and 1.7.latest, confirmed locally): https://github.com/dbt-labs/dbt-core/pull/9456\n\n### Relevant log output\n\n_No response_\n\n### Environment\n\n```markdown\n- OS:\r\n- Python:\r\n- dbt (working version): 1.6.9\r\n- dbt (regression version): 1.7.5, 1.8.0a2\n```\n\n\n### Which database adapter are you using with dbt?\n\n_No response_\n\n### Additional Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/task/docs/generate.py\n\n```python\n 1 | import os\n 2 | import shutil\n 3 | from datetime import datetime\n 4 | from typing import Dict, List, Any, Optional, Tuple, Set, Iterable\n 5 | import agate\n 6 | from itertools import chain\n 7 | \n 8 | import dbt_common.utils.formatting\n 9 | from dbt_common.dataclass_schema import ValidationError\n 10 | from dbt_common.clients.system import load_file_contents\n 11 | \n 12 | from dbt.task.docs import DOCS_INDEX_FILE_PATH\n 13 | from dbt.task.compile import CompileTask\n 14 | \n 15 | from dbt.adapters.factory import get_adapter\n 16 | from dbt.contracts.graph.nodes import ResultNode\n 17 | from dbt.contracts.graph.manifest import Manifest\n 18 | from dbt.artifacts.schemas.results import NodeStatus\n 19 | from dbt.artifacts.schemas.catalog import (\n 20 | TableMetadata,\n 21 | CatalogTable,\n 22 | CatalogResults,\n 23 | PrimitiveDict,\n 24 | CatalogKey,\n 25 | StatsItem,\n 26 | StatsDict,\n 27 | ColumnMetadata,\n 28 | CatalogArtifact,\n 29 | )\n 30 | from dbt_common.exceptions import DbtInternalError\n 31 | from dbt.exceptions import AmbiguousCatalogMatchError\n 32 | from dbt.graph import ResourceTypeSelector\n 33 | from dbt.node_types import EXECUTABLE_NODE_TYPES\n 34 | from dbt_common.events.functions import fire_event\n 35 | from dbt.adapters.events.types import (\n 36 | WriteCatalogFailure,\n 37 | CatalogWritten,\n 38 | CannotGenerateDocs,\n 39 | BuildingCatalog,\n 40 | )\n 41 | from dbt.parser.manifest import write_manifest\n 42 | import dbt.utils\n 43 | import dbt.compilation\n 44 | import dbt.exceptions\n 45 | from dbt.constants import (\n 46 | MANIFEST_FILE_NAME,\n 47 | )\n 48 | \n 49 | CATALOG_FILENAME = \"catalog.json\"\n 50 | \n 51 | \n 52 | def get_stripped_prefix(source: Dict[str, Any], prefix: str) -> Dict[str, Any]:\n 53 | \"\"\"Go through the source, extracting every key/value pair where the key starts\n 54 | with the given prefix.\n 55 | \"\"\"\n 56 | cut = len(prefix)\n 57 | return {k[cut:]: v for k, v in source.items() if k.startswith(prefix)}\n 58 | \n 59 | \n 60 | def build_catalog_table(data) -> CatalogTable:\n 61 | # build the new table's metadata + stats\n 62 | metadata = TableMetadata.from_dict(get_stripped_prefix(data, \"table_\"))\n 63 | stats = format_stats(get_stripped_prefix(data, \"stats:\"))\n 64 | \n 65 | return CatalogTable(\n 66 | metadata=metadata,\n 67 | stats=stats,\n 68 | columns={},\n 69 | )\n 70 | \n 71 | \n 72 | # keys are database name, schema name, table name\n 73 | class Catalog(Dict[CatalogKey, CatalogTable]):\n 74 | def __init__(self, columns: List[PrimitiveDict]) -> None:\n 75 | super().__init__()\n 76 | for col in columns:\n 77 | self.add_column(col)\n 78 | \n 79 | def get_table(self, data: PrimitiveDict) -> CatalogTable:\n 80 | database = data.get(\"table_database\")\n 81 | if database is None:\n 82 | dkey: Optional[str] = None\n 83 | else:\n 84 | dkey = str(database)\n 85 | \n 86 | try:\n 87 | key = CatalogKey(\n 88 | dkey,\n 89 | str(data[\"table_schema\"]),\n 90 | str(data[\"table_name\"]),\n 91 | )\n 92 | except KeyError as exc:\n 93 | raise dbt_common.exceptions.CompilationError(\n 94 | \"Catalog information missing required key {} (got {})\".format(exc, data)\n 95 | )\n 96 | table: CatalogTable\n 97 | if key in self:\n 98 | table = self[key]\n 99 | else:\n100 | table = build_catalog_table(data)\n101 | self[key] = table\n102 | return table\n103 | \n104 | def add_column(self, data: PrimitiveDict):\n105 | table = self.get_table(data)\n106 | column_data = get_stripped_prefix(data, \"column_\")\n107 | # the index should really never be that big so it's ok to end up\n108 | # serializing this to JSON (2^53 is the max safe value there)\n109 | column_data[\"index\"] = int(column_data[\"index\"])\n110 | \n111 | column = ColumnMetadata.from_dict(column_data)\n112 | table.columns[column.name] = column\n113 | \n114 | def make_unique_id_map(\n115 | self, manifest: Manifest\n116 | ) -> Tuple[Dict[str, CatalogTable], Dict[str, CatalogTable]]:\n117 | nodes: Dict[str, CatalogTable] = {}\n118 | sources: Dict[str, CatalogTable] = {}\n119 | \n120 | node_map, source_map = get_unique_id_mapping(manifest)\n121 | table: CatalogTable\n122 | for table in self.values():\n123 | key = table.key()\n124 | if key in node_map:\n125 | unique_id = node_map[key]\n126 | nodes[unique_id] = table.replace(unique_id=unique_id)\n127 | \n128 | unique_ids = source_map.get(table.key(), set())\n129 | for unique_id in unique_ids:\n130 | if unique_id in sources:\n131 | raise AmbiguousCatalogMatchError(\n132 | unique_id,\n133 | sources[unique_id].to_dict(omit_none=True),\n134 | table.to_dict(omit_none=True),\n135 | )\n136 | else:\n137 | sources[unique_id] = table.replace(unique_id=unique_id)\n138 | return nodes, sources\n139 | \n140 | \n141 | def format_stats(stats: PrimitiveDict) -> StatsDict:\n142 | \"\"\"Given a dictionary following this layout:\n143 | \n144 | {\n145 | 'encoded:label': 'Encoded',\n146 | 'encoded:value': 'Yes',\n147 | 'encoded:description': 'Indicates if the column is encoded',\n148 | 'encoded:include': True,\n149 | \n150 | 'size:label': 'Size',\n151 | 'size:value': 128,\n152 | 'size:description': 'Size of the table in MB',\n153 | 'size:include': True,\n154 | }\n155 | \n156 | format_stats will convert the dict into a StatsDict with keys of 'encoded'\n157 | and 'size'.\n158 | \"\"\"\n159 | stats_collector: StatsDict = {}\n160 | \n161 | base_keys = {k.split(\":\")[0] for k in stats}\n162 | for key in base_keys:\n163 | dct: PrimitiveDict = {\"id\": key}\n164 | for subkey in (\"label\", \"value\", \"description\", \"include\"):\n165 | dct[subkey] = stats[\"{}:{}\".format(key, subkey)]\n166 | \n167 | try:\n168 | stats_item = StatsItem.from_dict(dct)\n169 | except ValidationError:\n170 | continue\n171 | if stats_item.include:\n172 | stats_collector[key] = stats_item\n173 | \n174 | # we always have a 'has_stats' field, it's never included\n175 | has_stats = StatsItem(\n176 | id=\"has_stats\",\n177 | label=\"Has Stats?\",\n178 | value=len(stats_collector) > 0,\n179 | description=\"Indicates whether there are statistics for this table\",\n180 | include=False,\n181 | )\n182 | stats_collector[\"has_stats\"] = has_stats\n183 | return stats_collector\n184 | \n185 | \n186 | def mapping_key(node: ResultNode) -> CatalogKey:\n187 | dkey = dbt_common.utils.formatting.lowercase(node.database)\n188 | return CatalogKey(dkey, node.schema.lower(), node.identifier.lower())\n189 | \n190 | \n191 | def get_unique_id_mapping(\n192 | manifest: Manifest,\n193 | ) -> Tuple[Dict[CatalogKey, str], Dict[CatalogKey, Set[str]]]:\n194 | # A single relation could have multiple unique IDs pointing to it if a\n195 | # source were also a node.\n196 | node_map: Dict[CatalogKey, str] = {}\n197 | source_map: Dict[CatalogKey, Set[str]] = {}\n198 | for unique_id, node in manifest.nodes.items():\n199 | key = mapping_key(node)\n200 | node_map[key] = unique_id\n201 | \n202 | for unique_id, source in manifest.sources.items():\n203 | key = mapping_key(source)\n204 | if key not in source_map:\n205 | source_map[key] = set()\n206 | source_map[key].add(unique_id)\n207 | return node_map, source_map\n208 | \n209 | \n210 | class GenerateTask(CompileTask):\n211 | def run(self) -> CatalogArtifact:\n212 | compile_results = None\n213 | if self.args.compile:\n214 | compile_results = CompileTask.run(self)\n215 | if any(r.status == NodeStatus.Error for r in compile_results):\n216 | fire_event(CannotGenerateDocs())\n217 | return CatalogArtifact.from_results(\n218 | nodes={},\n219 | sources={},\n220 | generated_at=datetime.utcnow(),\n221 | errors=None,\n222 | compile_results=compile_results,\n223 | )\n224 | \n225 | shutil.copyfile(\n226 | DOCS_INDEX_FILE_PATH, os.path.join(self.config.project_target_path, \"index.html\")\n227 | )\n228 | \n229 | for asset_path in self.config.asset_paths:\n230 | to_asset_path = os.path.join(self.config.project_target_path, asset_path)\n231 | \n232 | if os.path.exists(to_asset_path):\n233 | shutil.rmtree(to_asset_path)\n234 | \n235 | if os.path.exists(asset_path):\n236 | shutil.copytree(asset_path, to_asset_path)\n237 | \n238 | if self.manifest is None:\n239 | raise DbtInternalError(\"self.manifest was None in run!\")\n240 | \n241 | if self.args.empty_catalog:\n242 | catalog_table: agate.Table = agate.Table([])\n243 | exceptions: List[Exception] = []\n244 | else:\n245 | adapter = get_adapter(self.config)\n246 | with adapter.connection_named(\"generate_catalog\"):\n247 | fire_event(BuildingCatalog())\n248 | # Get a list of relations we need from the catalog\n249 | relations = None\n250 | if self.job_queue is not None:\n251 | selected_node_ids = self.job_queue.get_selected_nodes()\n252 | selected_nodes = self._get_nodes_from_ids(self.manifest, selected_node_ids)\n253 | \n254 | source_ids = self._get_nodes_from_ids(\n255 | self.manifest, self.manifest.sources.keys()\n256 | )\n257 | selected_nodes.extend(source_ids)\n258 | \n259 | relations = {\n260 | adapter.Relation.create_from(adapter.config, node_id)\n261 | for node_id in selected_nodes\n262 | }\n263 | \n264 | # This generates the catalog as an agate.Table\n265 | catalogable_nodes = chain(\n266 | [\n267 | node\n268 | for node in self.manifest.nodes.values()\n269 | if (node.is_relational and not node.is_ephemeral_model)\n270 | ]\n271 | )\n272 | used_schemas = self.manifest.get_used_schemas()\n273 | catalog_table, exceptions = adapter.get_filtered_catalog(\n274 | catalogable_nodes, used_schemas, relations\n275 | )\n276 | \n277 | catalog_data: List[PrimitiveDict] = [\n278 | dict(zip(catalog_table.column_names, map(dbt.utils._coerce_decimal, row)))\n279 | for row in catalog_table\n280 | ]\n281 | \n282 | catalog = Catalog(catalog_data)\n283 | \n284 | errors: Optional[List[str]] = None\n285 | if exceptions:\n286 | errors = [str(e) for e in exceptions]\n287 | \n288 | nodes, sources = catalog.make_unique_id_map(self.manifest)\n289 | results = self.get_catalog_results(\n290 | nodes=nodes,\n291 | sources=sources,\n292 | generated_at=datetime.utcnow(),\n293 | compile_results=compile_results,\n294 | errors=errors,\n295 | )\n296 | \n297 | catalog_path = os.path.join(self.config.project_target_path, CATALOG_FILENAME)\n298 | results.write(catalog_path)\n299 | if self.args.compile:\n300 | write_manifest(self.manifest, self.config.project_target_path)\n301 | \n302 | if self.args.static:\n303 | \n304 | # Read manifest.json and catalog.json\n305 | read_manifest_data = load_file_contents(\n306 | os.path.join(self.config.project_target_path, MANIFEST_FILE_NAME)\n307 | )\n308 | read_catalog_data = load_file_contents(catalog_path)\n309 | \n310 | # Create new static index file contents\n311 | index_data = load_file_contents(DOCS_INDEX_FILE_PATH)\n312 | index_data = index_data.replace('\"MANIFEST.JSON INLINE DATA\"', read_manifest_data)\n313 | index_data = index_data.replace('\"CATALOG.JSON INLINE DATA\"', read_catalog_data)\n314 | \n315 | # Write out the new index file\n316 | static_index_path = os.path.join(self.config.project_target_path, \"static_index.html\")\n317 | with open(static_index_path, \"wb\") as static_index_file:\n318 | static_index_file.write(bytes(index_data, \"utf8\"))\n319 | \n320 | if exceptions:\n321 | fire_event(WriteCatalogFailure(num_exceptions=len(exceptions)))\n322 | fire_event(CatalogWritten(path=os.path.abspath(catalog_path)))\n323 | return results\n324 | \n325 | @staticmethod\n326 | def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n327 | selected: List[ResultNode] = []\n328 | for unique_id in node_ids:\n329 | if unique_id in manifest.nodes:\n330 | node = manifest.nodes[unique_id]\n331 | if node.is_relational and not node.is_ephemeral_model:\n332 | selected.append(node)\n333 | elif unique_id in manifest.sources:\n334 | source = manifest.sources[unique_id]\n335 | selected.append(source)\n336 | return selected\n337 | \n338 | def get_node_selector(self) -> ResourceTypeSelector:\n339 | if self.manifest is None or self.graph is None:\n340 | raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n341 | return ResourceTypeSelector(\n342 | graph=self.graph,\n343 | manifest=self.manifest,\n344 | previous_state=self.previous_state,\n345 | resource_types=EXECUTABLE_NODE_TYPES,\n346 | )\n347 | \n348 | def get_catalog_results(\n349 | self,\n350 | nodes: Dict[str, CatalogTable],\n351 | sources: Dict[str, CatalogTable],\n352 | generated_at: datetime,\n353 | compile_results: Optional[Any],\n354 | errors: Optional[List[str]],\n355 | ) -> CatalogArtifact:\n356 | return CatalogArtifact.from_results(\n357 | generated_at=generated_at,\n358 | nodes=nodes,\n359 | sources=sources,\n360 | compile_results=compile_results,\n361 | errors=errors,\n362 | )\n363 | \n364 | @classmethod\n365 | def interpret_results(self, results: Optional[CatalogResults]) -> bool:\n366 | if results is None:\n367 | return False\n368 | if results.errors:\n369 | return False\n370 | compile_results = results._compile_results\n371 | if compile_results is None:\n372 | return True\n373 | \n374 | return super().interpret_results(compile_results)\n```\n\n## Files after the fix\n\n### File: core/dbt/task/docs/generate.py\n\n```python\n 1 | import os\n 2 | import shutil\n 3 | from datetime import datetime\n 4 | from typing import Dict, List, Any, Optional, Tuple, Set, Iterable\n 5 | import agate\n 6 | from itertools import chain\n 7 | \n 8 | import dbt_common.utils.formatting\n 9 | from dbt_common.dataclass_schema import ValidationError\n 10 | from dbt_common.clients.system import load_file_contents\n 11 | \n 12 | from dbt.task.docs import DOCS_INDEX_FILE_PATH\n 13 | from dbt.task.compile import CompileTask\n 14 | \n 15 | from dbt.adapters.factory import get_adapter\n 16 | from dbt.contracts.graph.nodes import ResultNode\n 17 | from dbt.contracts.graph.manifest import Manifest\n 18 | from dbt.artifacts.schemas.results import NodeStatus\n 19 | from dbt.artifacts.schemas.catalog import (\n 20 | TableMetadata,\n 21 | CatalogTable,\n 22 | CatalogResults,\n 23 | PrimitiveDict,\n 24 | CatalogKey,\n 25 | StatsItem,\n 26 | StatsDict,\n 27 | ColumnMetadata,\n 28 | CatalogArtifact,\n 29 | )\n 30 | from dbt_common.exceptions import DbtInternalError\n 31 | from dbt.exceptions import AmbiguousCatalogMatchError\n 32 | from dbt.graph import ResourceTypeSelector\n 33 | from dbt.node_types import EXECUTABLE_NODE_TYPES\n 34 | from dbt_common.events.functions import fire_event\n 35 | from dbt.adapters.events.types import (\n 36 | WriteCatalogFailure,\n 37 | CatalogWritten,\n 38 | CannotGenerateDocs,\n 39 | BuildingCatalog,\n 40 | )\n 41 | from dbt.parser.manifest import write_manifest\n 42 | import dbt.utils\n 43 | import dbt.compilation\n 44 | import dbt.exceptions\n 45 | from dbt.constants import (\n 46 | MANIFEST_FILE_NAME,\n 47 | )\n 48 | \n 49 | CATALOG_FILENAME = \"catalog.json\"\n 50 | \n 51 | \n 52 | def get_stripped_prefix(source: Dict[str, Any], prefix: str) -> Dict[str, Any]:\n 53 | \"\"\"Go through the source, extracting every key/value pair where the key starts\n 54 | with the given prefix.\n 55 | \"\"\"\n 56 | cut = len(prefix)\n 57 | return {k[cut:]: v for k, v in source.items() if k.startswith(prefix)}\n 58 | \n 59 | \n 60 | def build_catalog_table(data) -> CatalogTable:\n 61 | # build the new table's metadata + stats\n 62 | metadata = TableMetadata.from_dict(get_stripped_prefix(data, \"table_\"))\n 63 | stats = format_stats(get_stripped_prefix(data, \"stats:\"))\n 64 | \n 65 | return CatalogTable(\n 66 | metadata=metadata,\n 67 | stats=stats,\n 68 | columns={},\n 69 | )\n 70 | \n 71 | \n 72 | # keys are database name, schema name, table name\n 73 | class Catalog(Dict[CatalogKey, CatalogTable]):\n 74 | def __init__(self, columns: List[PrimitiveDict]) -> None:\n 75 | super().__init__()\n 76 | for col in columns:\n 77 | self.add_column(col)\n 78 | \n 79 | def get_table(self, data: PrimitiveDict) -> CatalogTable:\n 80 | database = data.get(\"table_database\")\n 81 | if database is None:\n 82 | dkey: Optional[str] = None\n 83 | else:\n 84 | dkey = str(database)\n 85 | \n 86 | try:\n 87 | key = CatalogKey(\n 88 | dkey,\n 89 | str(data[\"table_schema\"]),\n 90 | str(data[\"table_name\"]),\n 91 | )\n 92 | except KeyError as exc:\n 93 | raise dbt_common.exceptions.CompilationError(\n 94 | \"Catalog information missing required key {} (got {})\".format(exc, data)\n 95 | )\n 96 | table: CatalogTable\n 97 | if key in self:\n 98 | table = self[key]\n 99 | else:\n100 | table = build_catalog_table(data)\n101 | self[key] = table\n102 | return table\n103 | \n104 | def add_column(self, data: PrimitiveDict):\n105 | table = self.get_table(data)\n106 | column_data = get_stripped_prefix(data, \"column_\")\n107 | # the index should really never be that big so it's ok to end up\n108 | # serializing this to JSON (2^53 is the max safe value there)\n109 | column_data[\"index\"] = int(column_data[\"index\"])\n110 | \n111 | column = ColumnMetadata.from_dict(column_data)\n112 | table.columns[column.name] = column\n113 | \n114 | def make_unique_id_map(\n115 | self, manifest: Manifest\n116 | ) -> Tuple[Dict[str, CatalogTable], Dict[str, CatalogTable]]:\n117 | nodes: Dict[str, CatalogTable] = {}\n118 | sources: Dict[str, CatalogTable] = {}\n119 | \n120 | node_map, source_map = get_unique_id_mapping(manifest)\n121 | table: CatalogTable\n122 | for table in self.values():\n123 | key = table.key()\n124 | if key in node_map:\n125 | unique_id = node_map[key]\n126 | nodes[unique_id] = table.replace(unique_id=unique_id)\n127 | \n128 | unique_ids = source_map.get(table.key(), set())\n129 | for unique_id in unique_ids:\n130 | if unique_id in sources:\n131 | raise AmbiguousCatalogMatchError(\n132 | unique_id,\n133 | sources[unique_id].to_dict(omit_none=True),\n134 | table.to_dict(omit_none=True),\n135 | )\n136 | else:\n137 | sources[unique_id] = table.replace(unique_id=unique_id)\n138 | return nodes, sources\n139 | \n140 | \n141 | def format_stats(stats: PrimitiveDict) -> StatsDict:\n142 | \"\"\"Given a dictionary following this layout:\n143 | \n144 | {\n145 | 'encoded:label': 'Encoded',\n146 | 'encoded:value': 'Yes',\n147 | 'encoded:description': 'Indicates if the column is encoded',\n148 | 'encoded:include': True,\n149 | \n150 | 'size:label': 'Size',\n151 | 'size:value': 128,\n152 | 'size:description': 'Size of the table in MB',\n153 | 'size:include': True,\n154 | }\n155 | \n156 | format_stats will convert the dict into a StatsDict with keys of 'encoded'\n157 | and 'size'.\n158 | \"\"\"\n159 | stats_collector: StatsDict = {}\n160 | \n161 | base_keys = {k.split(\":\")[0] for k in stats}\n162 | for key in base_keys:\n163 | dct: PrimitiveDict = {\"id\": key}\n164 | for subkey in (\"label\", \"value\", \"description\", \"include\"):\n165 | dct[subkey] = stats[\"{}:{}\".format(key, subkey)]\n166 | \n167 | try:\n168 | stats_item = StatsItem.from_dict(dct)\n169 | except ValidationError:\n170 | continue\n171 | if stats_item.include:\n172 | stats_collector[key] = stats_item\n173 | \n174 | # we always have a 'has_stats' field, it's never included\n175 | has_stats = StatsItem(\n176 | id=\"has_stats\",\n177 | label=\"Has Stats?\",\n178 | value=len(stats_collector) > 0,\n179 | description=\"Indicates whether there are statistics for this table\",\n180 | include=False,\n181 | )\n182 | stats_collector[\"has_stats\"] = has_stats\n183 | return stats_collector\n184 | \n185 | \n186 | def mapping_key(node: ResultNode) -> CatalogKey:\n187 | dkey = dbt_common.utils.formatting.lowercase(node.database)\n188 | return CatalogKey(dkey, node.schema.lower(), node.identifier.lower())\n189 | \n190 | \n191 | def get_unique_id_mapping(\n192 | manifest: Manifest,\n193 | ) -> Tuple[Dict[CatalogKey, str], Dict[CatalogKey, Set[str]]]:\n194 | # A single relation could have multiple unique IDs pointing to it if a\n195 | # source were also a node.\n196 | node_map: Dict[CatalogKey, str] = {}\n197 | source_map: Dict[CatalogKey, Set[str]] = {}\n198 | for unique_id, node in manifest.nodes.items():\n199 | key = mapping_key(node)\n200 | node_map[key] = unique_id\n201 | \n202 | for unique_id, source in manifest.sources.items():\n203 | key = mapping_key(source)\n204 | if key not in source_map:\n205 | source_map[key] = set()\n206 | source_map[key].add(unique_id)\n207 | return node_map, source_map\n208 | \n209 | \n210 | class GenerateTask(CompileTask):\n211 | def run(self) -> CatalogArtifact:\n212 | compile_results = None\n213 | if self.args.compile:\n214 | compile_results = CompileTask.run(self)\n215 | if any(r.status == NodeStatus.Error for r in compile_results):\n216 | fire_event(CannotGenerateDocs())\n217 | return CatalogArtifact.from_results(\n218 | nodes={},\n219 | sources={},\n220 | generated_at=datetime.utcnow(),\n221 | errors=None,\n222 | compile_results=compile_results,\n223 | )\n224 | \n225 | shutil.copyfile(\n226 | DOCS_INDEX_FILE_PATH, os.path.join(self.config.project_target_path, \"index.html\")\n227 | )\n228 | \n229 | for asset_path in self.config.asset_paths:\n230 | to_asset_path = os.path.join(self.config.project_target_path, asset_path)\n231 | \n232 | if os.path.exists(to_asset_path):\n233 | shutil.rmtree(to_asset_path)\n234 | \n235 | if os.path.exists(asset_path):\n236 | shutil.copytree(asset_path, to_asset_path)\n237 | \n238 | if self.manifest is None:\n239 | raise DbtInternalError(\"self.manifest was None in run!\")\n240 | \n241 | if self.args.empty_catalog:\n242 | catalog_table: agate.Table = agate.Table([])\n243 | exceptions: List[Exception] = []\n244 | else:\n245 | adapter = get_adapter(self.config)\n246 | with adapter.connection_named(\"generate_catalog\"):\n247 | fire_event(BuildingCatalog())\n248 | # Get a list of relations we need from the catalog\n249 | relations = None\n250 | if self.job_queue is not None:\n251 | selected_node_ids = self.job_queue.get_selected_nodes()\n252 | selected_nodes = self._get_nodes_from_ids(self.manifest, selected_node_ids)\n253 | \n254 | source_ids = self._get_nodes_from_ids(\n255 | self.manifest, self.manifest.sources.keys()\n256 | )\n257 | selected_nodes.extend(source_ids)\n258 | \n259 | relations = {\n260 | adapter.Relation.create_from(adapter.config, node_id)\n261 | for node_id in selected_nodes\n262 | }\n263 | \n264 | # This generates the catalog as an agate.Table\n265 | catalogable_nodes = chain(\n266 | [\n267 | node\n268 | for node in self.manifest.nodes.values()\n269 | if (node.is_relational and not node.is_ephemeral_model)\n270 | ]\n271 | )\n272 | used_schemas = self.manifest.get_used_schemas()\n273 | catalog_table, exceptions = adapter.get_filtered_catalog(\n274 | catalogable_nodes, used_schemas, relations\n275 | )\n276 | \n277 | catalog_data: List[PrimitiveDict] = [\n278 | dict(zip(catalog_table.column_names, map(dbt.utils._coerce_decimal, row)))\n279 | for row in catalog_table\n280 | ]\n281 | \n282 | catalog = Catalog(catalog_data)\n283 | \n284 | errors: Optional[List[str]] = None\n285 | if exceptions:\n286 | errors = [str(e) for e in exceptions]\n287 | \n288 | nodes, sources = catalog.make_unique_id_map(self.manifest)\n289 | results = self.get_catalog_results(\n290 | nodes=nodes,\n291 | sources=sources,\n292 | generated_at=datetime.utcnow(),\n293 | compile_results=compile_results,\n294 | errors=errors,\n295 | )\n296 | \n297 | catalog_path = os.path.join(self.config.project_target_path, CATALOG_FILENAME)\n298 | results.write(catalog_path)\n299 | if self.args.compile:\n300 | write_manifest(self.manifest, self.config.project_target_path)\n301 | \n302 | if self.args.static:\n303 | \n304 | # Read manifest.json and catalog.json\n305 | read_manifest_data = load_file_contents(\n306 | os.path.join(self.config.project_target_path, MANIFEST_FILE_NAME)\n307 | )\n308 | read_catalog_data = load_file_contents(catalog_path)\n309 | \n310 | # Create new static index file contents\n311 | index_data = load_file_contents(DOCS_INDEX_FILE_PATH)\n312 | index_data = index_data.replace('\"MANIFEST.JSON INLINE DATA\"', read_manifest_data)\n313 | index_data = index_data.replace('\"CATALOG.JSON INLINE DATA\"', read_catalog_data)\n314 | \n315 | # Write out the new index file\n316 | static_index_path = os.path.join(self.config.project_target_path, \"static_index.html\")\n317 | with open(static_index_path, \"wb\") as static_index_file:\n318 | static_index_file.write(bytes(index_data, \"utf8\"))\n319 | \n320 | if exceptions:\n321 | fire_event(WriteCatalogFailure(num_exceptions=len(exceptions)))\n322 | fire_event(CatalogWritten(path=os.path.abspath(catalog_path)))\n323 | return results\n324 | \n325 | @staticmethod\n326 | def _get_nodes_from_ids(manifest: Manifest, node_ids: Iterable[str]) -> List[ResultNode]:\n327 | selected: List[ResultNode] = []\n328 | for unique_id in node_ids:\n329 | if unique_id in manifest.nodes:\n330 | node = manifest.nodes[unique_id]\n331 | if node.is_relational and not node.is_ephemeral_model:\n332 | selected.append(node)\n333 | elif unique_id in manifest.sources:\n334 | source = manifest.sources[unique_id]\n335 | selected.append(source)\n336 | return selected\n337 | \n338 | def get_node_selector(self) -> ResourceTypeSelector:\n339 | if self.manifest is None or self.graph is None:\n340 | raise DbtInternalError(\"manifest and graph must be set to perform node selection\")\n341 | return ResourceTypeSelector(\n342 | graph=self.graph,\n343 | manifest=self.manifest,\n344 | previous_state=self.previous_state,\n345 | resource_types=EXECUTABLE_NODE_TYPES,\n346 | include_empty_nodes=True,\n347 | )\n348 | \n349 | def get_catalog_results(\n350 | self,\n351 | nodes: Dict[str, CatalogTable],\n352 | sources: Dict[str, CatalogTable],\n353 | generated_at: datetime,\n354 | compile_results: Optional[Any],\n355 | errors: Optional[List[str]],\n356 | ) -> CatalogArtifact:\n357 | return CatalogArtifact.from_results(\n358 | generated_at=generated_at,\n359 | nodes=nodes,\n360 | sources=sources,\n361 | compile_results=compile_results,\n362 | errors=errors,\n363 | )\n364 | \n365 | @classmethod\n366 | def interpret_results(self, results: Optional[CatalogResults]) -> bool:\n367 | if results is None:\n368 | return False\n369 | if results.errors:\n370 | return False\n371 | compile_results = results._compile_results\n372 | if compile_results is None:\n373 | return True\n374 | \n375 | return super().interpret_results(compile_results)\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/task/docs/generate.py b/core/dbt/task/docs/generate.py\nindex 0000000..0000000 100644\n--- a/core/dbt/task/docs/generate.py\n+++ b/core/dbt/task/docs/generate.py\n@@ -343,6 +343,7 @@ class GenerateTask(CompileTask):\n manifest=self.manifest,\n previous_state=self.previous_state,\n resource_types=EXECUTABLE_NODE_TYPES,\n+ include_empty_nodes=True,\n )\n \n def get_catalog_results("},"prompt_input_token_count":{"kind":"number","value":8918,"string":"8,918"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9456\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"6663846026aba5d9b8e4abb47b58af2ff0462e40\",\n \"pull_number\": 9456,\n \"issue_numbers\": [\n \"9458\"\n ],\n \"changed_files\": [\n \"core/dbt/task/docs/generate.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32292,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9465"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 1cbc6d333d79f4408ed620c5aef18b18a216e6c3\nChanged files:\n- core/dbt/artifacts/resources/types.py\n- core/dbt/compilation.py\n\n## Problem statement\n\n[Bug] \"FoundStats\" message has incorrect node name plurals\n### Is this a new bug in dbt-core?\n\n- [X] I believe this is a new bug in dbt-core\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\n\n### Current Behavior\n\n```\r\n12:30:00 Found ... models, ... snapshots, ... analysiss, ...\r\n```\n\n### Expected Behavior\n\n```\r\n12:30:00 Found ... models, ... snapshots, ... analyses, ...\r\n```\n\n### Steps To Reproduce\n\n1. Define a project with >1 analyses\r\n2. Compile the project\n\n### Relevant log output\n\n_No response_\n\n### Environment\n\n```markdown\n- OS: 13.4.1\r\n- Python: 3.10.11\r\n- dbt: main\n```\n\n\n### Which database adapter are you using with dbt?\n\n_No response_\n\n### Additional Context\n\nWe moved the `pluralize` logic into [dbt-common](https://github.com/dbt-labs/dbt-common/blob/6878a90c2ef313e8e183c315b58f9e6efdfabe0d/dbt_common/events/format.py#L38-L49).\r\n\r\nIf we're passing an object into `pluralize`, and it has its own `pluralize` method, we'll use it. If we're just passing a string, we won't.\n\n## Files before the fix\n\n### File: core/dbt/artifacts/resources/types.py\n\n```python\n 1 | from dbt_common.dataclass_schema import StrEnum\n 2 | \n 3 | \n 4 | class AccessType(StrEnum):\n 5 | Private = \"private\"\n 6 | Protected = \"protected\"\n 7 | Public = \"public\"\n 8 | \n 9 | @classmethod\n10 | def is_valid(cls, item):\n11 | try:\n12 | cls(item)\n13 | except ValueError:\n14 | return False\n15 | return True\n16 | \n17 | \n18 | class NodeType(StrEnum):\n19 | Model = \"model\"\n20 | Analysis = \"analysis\"\n21 | Test = \"test\"\n22 | Snapshot = \"snapshot\"\n23 | Operation = \"operation\"\n24 | Seed = \"seed\"\n25 | # TODO: rm?\n26 | RPCCall = \"rpc\"\n27 | SqlOperation = \"sql_operation\"\n28 | Documentation = \"doc\"\n29 | Source = \"source\"\n30 | Macro = \"macro\"\n31 | Exposure = \"exposure\"\n32 | Metric = \"metric\"\n33 | Group = \"group\"\n34 | SavedQuery = \"saved_query\"\n35 | SemanticModel = \"semantic_model\"\n36 | Unit = \"unit_test\"\n37 | Fixture = \"fixture\"\n38 | \n39 | def pluralize(self) -> str:\n40 | if self is self.Analysis:\n41 | return \"analyses\"\n42 | elif self is self.SavedQuery:\n43 | return \"saved_queries\"\n44 | return f\"{self}s\"\n45 | \n46 | \n47 | class RunHookType(StrEnum):\n48 | Start = \"on-run-start\"\n49 | End = \"on-run-end\"\n50 | \n51 | \n52 | class ModelLanguage(StrEnum):\n53 | python = \"python\"\n54 | sql = \"sql\"\n```\n\n### File: core/dbt/compilation.py\n\n```python\n 1 | import json\n 2 | \n 3 | import networkx as nx # type: ignore\n 4 | import os\n 5 | import pickle\n 6 | \n 7 | from collections import defaultdict\n 8 | from typing import List, Dict, Any, Tuple, Optional\n 9 | \n 10 | from dbt_common.invocation import get_invocation_id\n 11 | from dbt.flags import get_flags\n 12 | from dbt.adapters.factory import get_adapter\n 13 | from dbt.clients import jinja\n 14 | from dbt.context.providers import (\n 15 | generate_runtime_model_context,\n 16 | generate_runtime_unit_test_context,\n 17 | )\n 18 | from dbt_common.clients.system import make_directory\n 19 | from dbt.contracts.graph.manifest import Manifest, UniqueID\n 20 | from dbt.contracts.graph.nodes import (\n 21 | ManifestNode,\n 22 | ManifestSQLNode,\n 23 | GenericTestNode,\n 24 | GraphMemberNode,\n 25 | InjectedCTE,\n 26 | SeedNode,\n 27 | UnitTestNode,\n 28 | UnitTestDefinition,\n 29 | )\n 30 | from dbt.exceptions import (\n 31 | GraphDependencyNotFoundError,\n 32 | DbtInternalError,\n 33 | DbtRuntimeError,\n 34 | )\n 35 | from dbt.graph import Graph\n 36 | from dbt_common.events.functions import fire_event\n 37 | from dbt_common.events.types import Note\n 38 | from dbt_common.events.contextvars import get_node_info\n 39 | from dbt.events.types import WritingInjectedSQLForNode, FoundStats\n 40 | from dbt.node_types import NodeType, ModelLanguage\n 41 | from dbt_common.events.format import pluralize\n 42 | import dbt.tracking\n 43 | import sqlparse\n 44 | \n 45 | graph_file_name = \"graph.gpickle\"\n 46 | \n 47 | \n 48 | def print_compile_stats(stats):\n 49 | names = {\n 50 | NodeType.Model: \"model\",\n 51 | NodeType.Test: \"data test\",\n 52 | NodeType.Unit: \"unit test\",\n 53 | NodeType.Snapshot: \"snapshot\",\n 54 | NodeType.Analysis: \"analysis\",\n 55 | NodeType.Macro: \"macro\",\n 56 | NodeType.Operation: \"operation\",\n 57 | NodeType.Seed: \"seed\",\n 58 | NodeType.Source: \"source\",\n 59 | NodeType.Exposure: \"exposure\",\n 60 | NodeType.SemanticModel: \"semantic model\",\n 61 | NodeType.Metric: \"metric\",\n 62 | NodeType.Group: \"group\",\n 63 | }\n 64 | \n 65 | results = {k: 0 for k in names.keys()}\n 66 | results.update(stats)\n 67 | \n 68 | # create tracking event for resource_counts\n 69 | if dbt.tracking.active_user is not None:\n 70 | resource_counts = {k.pluralize(): v for k, v in results.items()}\n 71 | dbt.tracking.track_resource_counts(resource_counts)\n 72 | \n 73 | # do not include resource types that are not actually defined in the project\n 74 | stat_line = \", \".join([pluralize(ct, names.get(t)) for t, ct in stats.items() if t in names])\n 75 | \n 76 | fire_event(FoundStats(stat_line=stat_line))\n 77 | \n 78 | \n 79 | def _node_enabled(node: ManifestNode):\n 80 | # Disabled models are already excluded from the manifest\n 81 | if node.resource_type == NodeType.Test and not node.config.enabled:\n 82 | return False\n 83 | else:\n 84 | return True\n 85 | \n 86 | \n 87 | def _generate_stats(manifest: Manifest):\n 88 | stats: Dict[NodeType, int] = defaultdict(int)\n 89 | for node in manifest.nodes.values():\n 90 | if _node_enabled(node):\n 91 | stats[node.resource_type] += 1\n 92 | \n 93 | # Disabled nodes don't appear in the following collections, so we don't check.\n 94 | stats[NodeType.Source] += len(manifest.sources)\n 95 | stats[NodeType.Exposure] += len(manifest.exposures)\n 96 | stats[NodeType.Metric] += len(manifest.metrics)\n 97 | stats[NodeType.Macro] += len(manifest.macros)\n 98 | stats[NodeType.Group] += len(manifest.groups)\n 99 | stats[NodeType.SemanticModel] += len(manifest.semantic_models)\n100 | stats[NodeType.Unit] += len(manifest.unit_tests)\n101 | \n102 | # TODO: should we be counting dimensions + entities?\n103 | \n104 | return stats\n105 | \n106 | \n107 | def _add_prepended_cte(prepended_ctes, new_cte):\n108 | for cte in prepended_ctes:\n109 | if cte.id == new_cte.id and new_cte.sql:\n110 | cte.sql = new_cte.sql\n111 | return\n112 | if new_cte.sql:\n113 | prepended_ctes.append(new_cte)\n114 | \n115 | \n116 | def _extend_prepended_ctes(prepended_ctes, new_prepended_ctes):\n117 | for new_cte in new_prepended_ctes:\n118 | _add_prepended_cte(prepended_ctes, new_cte)\n119 | \n120 | \n121 | def _get_tests_for_node(manifest: Manifest, unique_id: UniqueID) -> List[UniqueID]:\n122 | \"\"\"Get a list of tests that depend on the node with the\n123 | provided unique id\"\"\"\n124 | \n125 | tests = []\n126 | if unique_id in manifest.child_map:\n127 | for child_unique_id in manifest.child_map[unique_id]:\n128 | if child_unique_id.startswith(\"test.\"):\n129 | tests.append(child_unique_id)\n130 | \n131 | return tests\n132 | \n133 | \n134 | class Linker:\n135 | def __init__(self, data=None) -> None:\n136 | if data is None:\n137 | data = {}\n138 | self.graph: nx.DiGraph = nx.DiGraph(**data)\n139 | \n140 | def edges(self):\n141 | return self.graph.edges()\n142 | \n143 | def nodes(self):\n144 | return self.graph.nodes()\n145 | \n146 | def find_cycles(self):\n147 | try:\n148 | cycle = nx.find_cycle(self.graph)\n149 | except nx.NetworkXNoCycle:\n150 | return None\n151 | else:\n152 | # cycles is a List[Tuple[str, ...]]\n153 | return \" --> \".join(c[0] for c in cycle)\n154 | \n155 | def dependency(self, node1, node2):\n156 | \"indicate that node1 depends on node2\"\n157 | self.graph.add_node(node1)\n158 | self.graph.add_node(node2)\n159 | self.graph.add_edge(node2, node1)\n160 | \n161 | def add_node(self, node):\n162 | self.graph.add_node(node)\n163 | \n164 | def write_graph(self, outfile: str, manifest: Manifest):\n165 | \"\"\"Write the graph to a gpickle file. Before doing so, serialize and\n166 | include all nodes in their corresponding graph entries.\n167 | \"\"\"\n168 | out_graph = self.graph.copy()\n169 | for node_id in self.graph:\n170 | data = manifest.expect(node_id).to_dict(omit_none=True)\n171 | out_graph.add_node(node_id, **data)\n172 | with open(outfile, \"wb\") as outfh:\n173 | pickle.dump(out_graph, outfh, protocol=pickle.HIGHEST_PROTOCOL)\n174 | \n175 | def link_node(self, node: GraphMemberNode, manifest: Manifest):\n176 | self.add_node(node.unique_id)\n177 | \n178 | for dependency in node.depends_on_nodes:\n179 | if dependency in manifest.nodes:\n180 | self.dependency(node.unique_id, (manifest.nodes[dependency].unique_id))\n181 | elif dependency in manifest.sources:\n182 | self.dependency(node.unique_id, (manifest.sources[dependency].unique_id))\n183 | elif dependency in manifest.metrics:\n184 | self.dependency(node.unique_id, (manifest.metrics[dependency].unique_id))\n185 | elif dependency in manifest.semantic_models:\n186 | self.dependency(node.unique_id, (manifest.semantic_models[dependency].unique_id))\n187 | else:\n188 | raise GraphDependencyNotFoundError(node, dependency)\n189 | \n190 | def link_graph(self, manifest: Manifest):\n191 | for source in manifest.sources.values():\n192 | self.add_node(source.unique_id)\n193 | for node in manifest.nodes.values():\n194 | self.link_node(node, manifest)\n195 | for semantic_model in manifest.semantic_models.values():\n196 | self.link_node(semantic_model, manifest)\n197 | for exposure in manifest.exposures.values():\n198 | self.link_node(exposure, manifest)\n199 | for metric in manifest.metrics.values():\n200 | self.link_node(metric, manifest)\n201 | for unit_test in manifest.unit_tests.values():\n202 | self.link_node(unit_test, manifest)\n203 | for saved_query in manifest.saved_queries.values():\n204 | self.link_node(saved_query, manifest)\n205 | \n206 | cycle = self.find_cycles()\n207 | \n208 | if cycle:\n209 | raise RuntimeError(\"Found a cycle: {}\".format(cycle))\n210 | \n211 | def add_test_edges(self, manifest: Manifest) -> None:\n212 | \"\"\"This method adds additional edges to the DAG. For a given non-test\n213 | executable node, add an edge from an upstream test to the given node if\n214 | the set of nodes the test depends on is a subset of the upstream nodes\n215 | for the given node.\"\"\"\n216 | \n217 | # Given a graph:\n218 | # model1 --> model2 --> model3\n219 | # | |\n220 | # | \\/\n221 | # \\/ test 2\n222 | # test1\n223 | #\n224 | # Produce the following graph:\n225 | # model1 --> model2 --> model3\n226 | # | /\\ | /\\ /\\\n227 | # | | \\/ | |\n228 | # \\/ | test2 ----| |\n229 | # test1 ----|---------------|\n230 | \n231 | for node_id in self.graph:\n232 | # If node is executable (in manifest.nodes) and does _not_\n233 | # represent a test, continue.\n234 | if (\n235 | node_id in manifest.nodes\n236 | and manifest.nodes[node_id].resource_type != NodeType.Test\n237 | ):\n238 | # Get *everything* upstream of the node\n239 | all_upstream_nodes = nx.traversal.bfs_tree(self.graph, node_id, reverse=True)\n240 | # Get the set of upstream nodes not including the current node.\n241 | upstream_nodes = set([n for n in all_upstream_nodes if n != node_id])\n242 | \n243 | # Get all tests that depend on any upstream nodes.\n244 | upstream_tests = []\n245 | for upstream_node in upstream_nodes:\n246 | # This gets tests with unique_ids starting with \"test.\"\n247 | upstream_tests += _get_tests_for_node(manifest, upstream_node)\n248 | \n249 | for upstream_test in upstream_tests:\n250 | # Get the set of all nodes that the test depends on\n251 | # including the upstream_node itself. This is necessary\n252 | # because tests can depend on multiple nodes (ex:\n253 | # relationship tests). Test nodes do not distinguish\n254 | # between what node the test is \"testing\" and what\n255 | # node(s) it depends on.\n256 | test_depends_on = set(manifest.nodes[upstream_test].depends_on_nodes)\n257 | \n258 | # If the set of nodes that an upstream test depends on\n259 | # is a subset of all upstream nodes of the current node,\n260 | # add an edge from the upstream test to the current node.\n261 | if test_depends_on.issubset(upstream_nodes):\n262 | self.graph.add_edge(upstream_test, node_id, edge_type=\"parent_test\")\n263 | \n264 | def get_graph(self, manifest: Manifest) -> Graph:\n265 | self.link_graph(manifest)\n266 | return Graph(self.graph)\n267 | \n268 | def get_graph_summary(self, manifest: Manifest) -> Dict[int, Dict[str, Any]]:\n269 | \"\"\"Create a smaller summary of the graph, suitable for basic diagnostics\n270 | and performance tuning. The summary includes only the edge structure,\n271 | node types, and node names. Each of the n nodes is assigned an integer\n272 | index 0, 1, 2,..., n-1 for compactness\"\"\"\n273 | graph_nodes = dict()\n274 | index_dict = dict()\n275 | for node_index, node_name in enumerate(self.graph):\n276 | index_dict[node_name] = node_index\n277 | data = manifest.expect(node_name).to_dict(omit_none=True)\n278 | graph_nodes[node_index] = {\"name\": node_name, \"type\": data[\"resource_type\"]}\n279 | \n280 | for node_index, node in graph_nodes.items():\n281 | successors = [index_dict[n] for n in self.graph.successors(node[\"name\"])]\n282 | if successors:\n283 | node[\"succ\"] = [index_dict[n] for n in self.graph.successors(node[\"name\"])]\n284 | \n285 | return graph_nodes\n286 | \n287 | \n288 | class Compiler:\n289 | def __init__(self, config) -> None:\n290 | self.config = config\n291 | \n292 | def initialize(self):\n293 | make_directory(self.config.project_target_path)\n294 | make_directory(self.config.packages_install_path)\n295 | \n296 | # creates a ModelContext which is converted to\n297 | # a dict for jinja rendering of SQL\n298 | def _create_node_context(\n299 | self,\n300 | node: ManifestSQLNode,\n301 | manifest: Manifest,\n302 | extra_context: Dict[str, Any],\n303 | ) -> Dict[str, Any]:\n304 | if isinstance(node, UnitTestNode):\n305 | context = generate_runtime_unit_test_context(node, self.config, manifest)\n306 | else:\n307 | context = generate_runtime_model_context(node, self.config, manifest)\n308 | context.update(extra_context)\n309 | \n310 | if isinstance(node, GenericTestNode):\n311 | # for test nodes, add a special keyword args value to the context\n312 | jinja.add_rendered_test_kwargs(context, node)\n313 | \n314 | return context\n315 | \n316 | def add_ephemeral_prefix(self, name: str):\n317 | adapter = get_adapter(self.config)\n318 | relation_cls = adapter.Relation\n319 | return relation_cls.add_ephemeral_prefix(name)\n320 | \n321 | def _recursively_prepend_ctes(\n322 | self,\n323 | model: ManifestSQLNode,\n324 | manifest: Manifest,\n325 | extra_context: Optional[Dict[str, Any]],\n326 | ) -> Tuple[ManifestSQLNode, List[InjectedCTE]]:\n327 | \"\"\"This method is called by the 'compile_node' method. Starting\n328 | from the node that it is passed in, it will recursively call\n329 | itself using the 'extra_ctes'. The 'ephemeral' models do\n330 | not produce SQL that is executed directly, instead they\n331 | are rolled up into the models that refer to them by\n332 | inserting CTEs into the SQL.\n333 | \"\"\"\n334 | if model.compiled_code is None:\n335 | raise DbtRuntimeError(\"Cannot inject ctes into an uncompiled node\", model)\n336 | \n337 | # tech debt: safe flag/arg access (#6259)\n338 | if not getattr(self.config.args, \"inject_ephemeral_ctes\", True):\n339 | return (model, [])\n340 | \n341 | # extra_ctes_injected flag says that we've already recursively injected the ctes\n342 | if model.extra_ctes_injected:\n343 | return (model, model.extra_ctes)\n344 | \n345 | # Just to make it plain that nothing is actually injected for this case\n346 | if len(model.extra_ctes) == 0:\n347 | # SeedNodes don't have compilation attributes\n348 | if not isinstance(model, SeedNode):\n349 | model.extra_ctes_injected = True\n350 | return (model, [])\n351 | \n352 | # This stores the ctes which will all be recursively\n353 | # gathered and then \"injected\" into the model.\n354 | prepended_ctes: List[InjectedCTE] = []\n355 | \n356 | # extra_ctes are added to the model by\n357 | # RuntimeRefResolver.create_relation, which adds an\n358 | # extra_cte for every model relation which is an\n359 | # ephemeral model. InjectedCTEs have a unique_id and sql.\n360 | # extra_ctes start out with sql set to None, and the sql is set in this loop.\n361 | for cte in model.extra_ctes:\n362 | if cte.id not in manifest.nodes:\n363 | raise DbtInternalError(\n364 | f\"During compilation, found a cte reference that \"\n365 | f\"could not be resolved: {cte.id}\"\n366 | )\n367 | cte_model = manifest.nodes[cte.id]\n368 | assert not isinstance(cte_model, SeedNode)\n369 | \n370 | if not cte_model.is_ephemeral_model:\n371 | raise DbtInternalError(f\"{cte.id} is not ephemeral\")\n372 | \n373 | # This model has already been compiled and extra_ctes_injected, so it's been\n374 | # through here before. We already checked above for extra_ctes_injected, but\n375 | # checking again because updates maybe have happened in another thread.\n376 | if cte_model.compiled is True and cte_model.extra_ctes_injected is True:\n377 | new_prepended_ctes = cte_model.extra_ctes\n378 | \n379 | # if the cte_model isn't compiled, i.e. first time here\n380 | else:\n381 | # This is an ephemeral parsed model that we can compile.\n382 | # Render the raw_code and set compiled to True\n383 | cte_model = self._compile_code(cte_model, manifest, extra_context)\n384 | # recursively call this method, sets extra_ctes_injected to True\n385 | cte_model, new_prepended_ctes = self._recursively_prepend_ctes(\n386 | cte_model, manifest, extra_context\n387 | )\n388 | # Write compiled SQL file\n389 | self._write_node(cte_model)\n390 | \n391 | _extend_prepended_ctes(prepended_ctes, new_prepended_ctes)\n392 | \n393 | new_cte_name = self.add_ephemeral_prefix(cte_model.name)\n394 | rendered_sql = cte_model._pre_injected_sql or cte_model.compiled_code\n395 | sql = f\" {new_cte_name} as (\\n{rendered_sql}\\n)\"\n396 | \n397 | _add_prepended_cte(prepended_ctes, InjectedCTE(id=cte.id, sql=sql))\n398 | \n399 | # Check again before updating for multi-threading\n400 | if not model.extra_ctes_injected:\n401 | injected_sql = inject_ctes_into_sql(\n402 | model.compiled_code,\n403 | prepended_ctes,\n404 | )\n405 | model.extra_ctes_injected = True\n406 | model._pre_injected_sql = model.compiled_code\n407 | model.compiled_code = injected_sql\n408 | model.extra_ctes = prepended_ctes\n409 | \n410 | # if model.extra_ctes is not set to prepended ctes, something went wrong\n411 | return model, model.extra_ctes\n412 | \n413 | # Sets compiled_code and compiled flag in the ManifestSQLNode passed in,\n414 | # creates a \"context\" dictionary for jinja rendering,\n415 | # and then renders the \"compiled_code\" using the node, the\n416 | # raw_code and the context.\n417 | def _compile_code(\n418 | self,\n419 | node: ManifestSQLNode,\n420 | manifest: Manifest,\n421 | extra_context: Optional[Dict[str, Any]] = None,\n422 | ) -> ManifestSQLNode:\n423 | if extra_context is None:\n424 | extra_context = {}\n425 | \n426 | if node.language == ModelLanguage.python:\n427 | context = self._create_node_context(node, manifest, extra_context)\n428 | \n429 | postfix = jinja.get_rendered(\n430 | \"{{ py_script_postfix(model) }}\",\n431 | context,\n432 | node,\n433 | )\n434 | # we should NOT jinja render the python model's 'raw code'\n435 | node.compiled_code = f\"{node.raw_code}\\n\\n{postfix}\"\n436 | \n437 | else:\n438 | context = self._create_node_context(node, manifest, extra_context)\n439 | node.compiled_code = jinja.get_rendered(\n440 | node.raw_code,\n441 | context,\n442 | node,\n443 | )\n444 | \n445 | node.compiled = True\n446 | \n447 | # relation_name is set at parse time, except for tests without store_failures,\n448 | # but cli param can turn on store_failures, so we set here.\n449 | if (\n450 | node.resource_type == NodeType.Test\n451 | and node.relation_name is None\n452 | and node.is_relational\n453 | ):\n454 | adapter = get_adapter(self.config)\n455 | relation_cls = adapter.Relation\n456 | relation_name = str(relation_cls.create_from(self.config, node))\n457 | node.relation_name = relation_name\n458 | \n459 | return node\n460 | \n461 | # This method doesn't actually \"compile\" any of the nodes. That is done by the\n462 | # \"compile_node\" method. This creates a Linker and builds the networkx graph,\n463 | # writes out the graph.gpickle file, and prints the stats, returning a Graph object.\n464 | def compile(self, manifest: Manifest, write=True, add_test_edges=False) -> Graph:\n465 | self.initialize()\n466 | linker = Linker()\n467 | linker.link_graph(manifest)\n468 | \n469 | # Create a file containing basic information about graph structure,\n470 | # supporting diagnostics and performance analysis.\n471 | summaries: Dict = dict()\n472 | summaries[\"_invocation_id\"] = get_invocation_id()\n473 | summaries[\"linked\"] = linker.get_graph_summary(manifest)\n474 | \n475 | # This is only called for the \"build\" command\n476 | if add_test_edges:\n477 | manifest.build_parent_and_child_maps()\n478 | linker.add_test_edges(manifest)\n479 | \n480 | # Create another diagnostic summary, just as above, but this time\n481 | # including the test edges.\n482 | summaries[\"with_test_edges\"] = linker.get_graph_summary(manifest)\n483 | \n484 | with open(\n485 | os.path.join(self.config.project_target_path, \"graph_summary.json\"), \"w\"\n486 | ) as out_stream:\n487 | try:\n488 | out_stream.write(json.dumps(summaries))\n489 | except Exception as e: # This is non-essential information, so merely note failures.\n490 | fire_event(\n491 | Note(\n492 | msg=f\"An error was encountered writing the graph summary information: {e}\"\n493 | )\n494 | )\n495 | \n496 | stats = _generate_stats(manifest)\n497 | \n498 | if write:\n499 | self.write_graph_file(linker, manifest)\n500 | \n501 | # Do not print these for list command\n502 | if self.config.args.which != \"list\":\n503 | stats = _generate_stats(manifest)\n504 | print_compile_stats(stats)\n505 | \n506 | return Graph(linker.graph)\n507 | \n508 | def write_graph_file(self, linker: Linker, manifest: Manifest):\n509 | filename = graph_file_name\n510 | graph_path = os.path.join(self.config.project_target_path, filename)\n511 | flags = get_flags()\n512 | if flags.WRITE_JSON:\n513 | linker.write_graph(graph_path, manifest)\n514 | \n515 | # writes the \"compiled_code\" into the target/compiled directory\n516 | def _write_node(self, node: ManifestSQLNode) -> ManifestSQLNode:\n517 | if not node.extra_ctes_injected or node.resource_type in (\n518 | NodeType.Snapshot,\n519 | NodeType.Seed,\n520 | ):\n521 | return node\n522 | fire_event(WritingInjectedSQLForNode(node_info=get_node_info()))\n523 | \n524 | if node.compiled_code:\n525 | node.compiled_path = node.get_target_write_path(self.config.target_path, \"compiled\")\n526 | node.write_node(self.config.project_root, node.compiled_path, node.compiled_code)\n527 | return node\n528 | \n529 | def compile_node(\n530 | self,\n531 | node: ManifestSQLNode,\n532 | manifest: Manifest,\n533 | extra_context: Optional[Dict[str, Any]] = None,\n534 | write: bool = True,\n535 | ) -> ManifestSQLNode:\n536 | \"\"\"This is the main entry point into this code. It's called by\n537 | CompileRunner.compile, GenericRPCRunner.compile, and\n538 | RunTask.get_hook_sql. It calls '_compile_code' to render\n539 | the node's raw_code into compiled_code, and then calls the\n540 | recursive method to \"prepend\" the ctes.\n541 | \"\"\"\n542 | if isinstance(node, UnitTestDefinition):\n543 | return node\n544 | \n545 | # Make sure Lexer for sqlparse 0.4.4 is initialized\n546 | from sqlparse.lexer import Lexer # type: ignore\n547 | \n548 | if hasattr(Lexer, \"get_default_instance\"):\n549 | Lexer.get_default_instance()\n550 | \n551 | node = self._compile_code(node, manifest, extra_context)\n552 | \n553 | node, _ = self._recursively_prepend_ctes(node, manifest, extra_context)\n554 | if write:\n555 | self._write_node(node)\n556 | return node\n557 | \n558 | \n559 | def inject_ctes_into_sql(sql: str, ctes: List[InjectedCTE]) -> str:\n560 | \"\"\"\n561 | `ctes` is a list of InjectedCTEs like:\n562 | \n563 | [\n564 | InjectedCTE(\n565 | id=\"cte_id_1\",\n566 | sql=\"__dbt__cte__ephemeral as (select * from table)\",\n567 | ),\n568 | InjectedCTE(\n569 | id=\"cte_id_2\",\n570 | sql=\"__dbt__cte__events as (select id, type from events)\",\n571 | ),\n572 | ]\n573 | \n574 | Given `sql` like:\n575 | \n576 | \"with internal_cte as (select * from sessions)\n577 | select * from internal_cte\"\n578 | \n579 | This will spit out:\n580 | \n581 | \"with __dbt__cte__ephemeral as (select * from table),\n582 | __dbt__cte__events as (select id, type from events),\n583 | internal_cte as (select * from sessions)\n584 | select * from internal_cte\"\n585 | \n586 | (Whitespace enhanced for readability.)\n587 | \"\"\"\n588 | if len(ctes) == 0:\n589 | return sql\n590 | \n591 | parsed_stmts = sqlparse.parse(sql)\n592 | parsed = parsed_stmts[0]\n593 | \n594 | with_stmt = None\n595 | for token in parsed.tokens:\n596 | if token.is_keyword and token.normalized == \"WITH\":\n597 | with_stmt = token\n598 | elif token.is_keyword and token.normalized == \"RECURSIVE\" and with_stmt is not None:\n599 | with_stmt = token\n600 | break\n601 | elif not token.is_whitespace and with_stmt is not None:\n602 | break\n603 | \n604 | if with_stmt is None:\n605 | # no with stmt, add one, and inject CTEs right at the beginning\n606 | # [original_sql]\n607 | first_token = parsed.token_first()\n608 | with_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, \"with\")\n609 | parsed.insert_before(first_token, with_token)\n610 | # [with][original_sql]\n611 | injected_ctes = \", \".join(c.sql for c in ctes) + \" \"\n612 | injected_ctes_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, injected_ctes)\n613 | parsed.insert_after(with_token, injected_ctes_token)\n614 | # [with][joined_ctes][original_sql]\n615 | else:\n616 | # with stmt exists so we don't need to add one, but we do need to add a comma\n617 | # between the injected ctes and the original sql\n618 | # [with][original_sql]\n619 | injected_ctes = \", \".join(c.sql for c in ctes)\n620 | injected_ctes_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, injected_ctes)\n621 | parsed.insert_after(with_stmt, injected_ctes_token)\n622 | # [with][joined_ctes][original_sql]\n623 | comma_token = sqlparse.sql.Token(sqlparse.tokens.Punctuation, \", \")\n624 | parsed.insert_after(injected_ctes_token, comma_token)\n625 | # [with][joined_ctes][, ][original_sql]\n626 | \n627 | return str(parsed)\n```\n\n## Files after the fix\n\n### File: core/dbt/artifacts/resources/types.py\n\n```python\n 1 | from dbt_common.dataclass_schema import StrEnum\n 2 | \n 3 | \n 4 | class AccessType(StrEnum):\n 5 | Private = \"private\"\n 6 | Protected = \"protected\"\n 7 | Public = \"public\"\n 8 | \n 9 | @classmethod\n10 | def is_valid(cls, item):\n11 | try:\n12 | cls(item)\n13 | except ValueError:\n14 | return False\n15 | return True\n16 | \n17 | \n18 | class NodeType(StrEnum):\n19 | Model = \"model\"\n20 | Analysis = \"analysis\"\n21 | Test = \"test\" # renamed to 'data_test'; preserved as 'test' here for back-compat\n22 | Snapshot = \"snapshot\"\n23 | Operation = \"operation\"\n24 | Seed = \"seed\"\n25 | # TODO: rm?\n26 | RPCCall = \"rpc\"\n27 | SqlOperation = \"sql_operation\"\n28 | Documentation = \"doc\"\n29 | Source = \"source\"\n30 | Macro = \"macro\"\n31 | Exposure = \"exposure\"\n32 | Metric = \"metric\"\n33 | Group = \"group\"\n34 | SavedQuery = \"saved_query\"\n35 | SemanticModel = \"semantic_model\"\n36 | Unit = \"unit_test\"\n37 | Fixture = \"fixture\"\n38 | \n39 | def pluralize(self) -> str:\n40 | if self is self.Analysis:\n41 | return \"analyses\"\n42 | elif self is self.SavedQuery:\n43 | return \"saved_queries\"\n44 | elif self is self.Test:\n45 | return \"data_tests\"\n46 | return f\"{self}s\"\n47 | \n48 | \n49 | class RunHookType(StrEnum):\n50 | Start = \"on-run-start\"\n51 | End = \"on-run-end\"\n52 | \n53 | \n54 | class ModelLanguage(StrEnum):\n55 | python = \"python\"\n56 | sql = \"sql\"\n```\n\n### File: core/dbt/compilation.py\n\n```python\n 1 | import json\n 2 | \n 3 | import networkx as nx # type: ignore\n 4 | import os\n 5 | import pickle\n 6 | \n 7 | from collections import defaultdict\n 8 | from typing import List, Dict, Any, Tuple, Optional\n 9 | \n 10 | from dbt_common.invocation import get_invocation_id\n 11 | from dbt.flags import get_flags\n 12 | from dbt.adapters.factory import get_adapter\n 13 | from dbt.clients import jinja\n 14 | from dbt.context.providers import (\n 15 | generate_runtime_model_context,\n 16 | generate_runtime_unit_test_context,\n 17 | )\n 18 | from dbt_common.clients.system import make_directory\n 19 | from dbt.contracts.graph.manifest import Manifest, UniqueID\n 20 | from dbt.contracts.graph.nodes import (\n 21 | ManifestNode,\n 22 | ManifestSQLNode,\n 23 | GenericTestNode,\n 24 | GraphMemberNode,\n 25 | InjectedCTE,\n 26 | SeedNode,\n 27 | UnitTestNode,\n 28 | UnitTestDefinition,\n 29 | )\n 30 | from dbt.exceptions import (\n 31 | GraphDependencyNotFoundError,\n 32 | DbtInternalError,\n 33 | DbtRuntimeError,\n 34 | )\n 35 | from dbt.graph import Graph\n 36 | from dbt_common.events.functions import fire_event\n 37 | from dbt_common.events.types import Note\n 38 | from dbt_common.events.contextvars import get_node_info\n 39 | from dbt.events.types import WritingInjectedSQLForNode, FoundStats\n 40 | from dbt.node_types import NodeType, ModelLanguage\n 41 | from dbt_common.events.format import pluralize\n 42 | import dbt.tracking\n 43 | import sqlparse\n 44 | \n 45 | graph_file_name = \"graph.gpickle\"\n 46 | \n 47 | \n 48 | def print_compile_stats(stats: Dict[NodeType, int]):\n 49 | # create tracking event for resource_counts\n 50 | if dbt.tracking.active_user is not None:\n 51 | resource_counts = {k.pluralize(): v for k, v in stats.items()}\n 52 | dbt.tracking.track_resource_counts(resource_counts)\n 53 | \n 54 | # do not include resource types that are not actually defined in the project\n 55 | stat_line = \", \".join([pluralize(ct, t) for t, ct in stats.items() if ct != 0])\n 56 | fire_event(FoundStats(stat_line=stat_line))\n 57 | \n 58 | \n 59 | def _node_enabled(node: ManifestNode):\n 60 | # Disabled models are already excluded from the manifest\n 61 | if node.resource_type == NodeType.Test and not node.config.enabled:\n 62 | return False\n 63 | else:\n 64 | return True\n 65 | \n 66 | \n 67 | def _generate_stats(manifest: Manifest) -> Dict[NodeType, int]:\n 68 | stats: Dict[NodeType, int] = defaultdict(int)\n 69 | for node in manifest.nodes.values():\n 70 | if _node_enabled(node):\n 71 | stats[node.resource_type] += 1\n 72 | \n 73 | # Disabled nodes don't appear in the following collections, so we don't check.\n 74 | stats[NodeType.Source] += len(manifest.sources)\n 75 | stats[NodeType.Exposure] += len(manifest.exposures)\n 76 | stats[NodeType.Metric] += len(manifest.metrics)\n 77 | stats[NodeType.Macro] += len(manifest.macros)\n 78 | stats[NodeType.Group] += len(manifest.groups)\n 79 | stats[NodeType.SemanticModel] += len(manifest.semantic_models)\n 80 | stats[NodeType.Unit] += len(manifest.unit_tests)\n 81 | \n 82 | # TODO: should we be counting dimensions + entities?\n 83 | \n 84 | return stats\n 85 | \n 86 | \n 87 | def _add_prepended_cte(prepended_ctes, new_cte):\n 88 | for cte in prepended_ctes:\n 89 | if cte.id == new_cte.id and new_cte.sql:\n 90 | cte.sql = new_cte.sql\n 91 | return\n 92 | if new_cte.sql:\n 93 | prepended_ctes.append(new_cte)\n 94 | \n 95 | \n 96 | def _extend_prepended_ctes(prepended_ctes, new_prepended_ctes):\n 97 | for new_cte in new_prepended_ctes:\n 98 | _add_prepended_cte(prepended_ctes, new_cte)\n 99 | \n100 | \n101 | def _get_tests_for_node(manifest: Manifest, unique_id: UniqueID) -> List[UniqueID]:\n102 | \"\"\"Get a list of tests that depend on the node with the\n103 | provided unique id\"\"\"\n104 | \n105 | tests = []\n106 | if unique_id in manifest.child_map:\n107 | for child_unique_id in manifest.child_map[unique_id]:\n108 | if child_unique_id.startswith(\"test.\"):\n109 | tests.append(child_unique_id)\n110 | \n111 | return tests\n112 | \n113 | \n114 | class Linker:\n115 | def __init__(self, data=None) -> None:\n116 | if data is None:\n117 | data = {}\n118 | self.graph: nx.DiGraph = nx.DiGraph(**data)\n119 | \n120 | def edges(self):\n121 | return self.graph.edges()\n122 | \n123 | def nodes(self):\n124 | return self.graph.nodes()\n125 | \n126 | def find_cycles(self):\n127 | try:\n128 | cycle = nx.find_cycle(self.graph)\n129 | except nx.NetworkXNoCycle:\n130 | return None\n131 | else:\n132 | # cycles is a List[Tuple[str, ...]]\n133 | return \" --> \".join(c[0] for c in cycle)\n134 | \n135 | def dependency(self, node1, node2):\n136 | \"indicate that node1 depends on node2\"\n137 | self.graph.add_node(node1)\n138 | self.graph.add_node(node2)\n139 | self.graph.add_edge(node2, node1)\n140 | \n141 | def add_node(self, node):\n142 | self.graph.add_node(node)\n143 | \n144 | def write_graph(self, outfile: str, manifest: Manifest):\n145 | \"\"\"Write the graph to a gpickle file. Before doing so, serialize and\n146 | include all nodes in their corresponding graph entries.\n147 | \"\"\"\n148 | out_graph = self.graph.copy()\n149 | for node_id in self.graph:\n150 | data = manifest.expect(node_id).to_dict(omit_none=True)\n151 | out_graph.add_node(node_id, **data)\n152 | with open(outfile, \"wb\") as outfh:\n153 | pickle.dump(out_graph, outfh, protocol=pickle.HIGHEST_PROTOCOL)\n154 | \n155 | def link_node(self, node: GraphMemberNode, manifest: Manifest):\n156 | self.add_node(node.unique_id)\n157 | \n158 | for dependency in node.depends_on_nodes:\n159 | if dependency in manifest.nodes:\n160 | self.dependency(node.unique_id, (manifest.nodes[dependency].unique_id))\n161 | elif dependency in manifest.sources:\n162 | self.dependency(node.unique_id, (manifest.sources[dependency].unique_id))\n163 | elif dependency in manifest.metrics:\n164 | self.dependency(node.unique_id, (manifest.metrics[dependency].unique_id))\n165 | elif dependency in manifest.semantic_models:\n166 | self.dependency(node.unique_id, (manifest.semantic_models[dependency].unique_id))\n167 | else:\n168 | raise GraphDependencyNotFoundError(node, dependency)\n169 | \n170 | def link_graph(self, manifest: Manifest):\n171 | for source in manifest.sources.values():\n172 | self.add_node(source.unique_id)\n173 | for node in manifest.nodes.values():\n174 | self.link_node(node, manifest)\n175 | for semantic_model in manifest.semantic_models.values():\n176 | self.link_node(semantic_model, manifest)\n177 | for exposure in manifest.exposures.values():\n178 | self.link_node(exposure, manifest)\n179 | for metric in manifest.metrics.values():\n180 | self.link_node(metric, manifest)\n181 | for unit_test in manifest.unit_tests.values():\n182 | self.link_node(unit_test, manifest)\n183 | for saved_query in manifest.saved_queries.values():\n184 | self.link_node(saved_query, manifest)\n185 | \n186 | cycle = self.find_cycles()\n187 | \n188 | if cycle:\n189 | raise RuntimeError(\"Found a cycle: {}\".format(cycle))\n190 | \n191 | def add_test_edges(self, manifest: Manifest) -> None:\n192 | \"\"\"This method adds additional edges to the DAG. For a given non-test\n193 | executable node, add an edge from an upstream test to the given node if\n194 | the set of nodes the test depends on is a subset of the upstream nodes\n195 | for the given node.\"\"\"\n196 | \n197 | # Given a graph:\n198 | # model1 --> model2 --> model3\n199 | # | |\n200 | # | \\/\n201 | # \\/ test 2\n202 | # test1\n203 | #\n204 | # Produce the following graph:\n205 | # model1 --> model2 --> model3\n206 | # | /\\ | /\\ /\\\n207 | # | | \\/ | |\n208 | # \\/ | test2 ----| |\n209 | # test1 ----|---------------|\n210 | \n211 | for node_id in self.graph:\n212 | # If node is executable (in manifest.nodes) and does _not_\n213 | # represent a test, continue.\n214 | if (\n215 | node_id in manifest.nodes\n216 | and manifest.nodes[node_id].resource_type != NodeType.Test\n217 | ):\n218 | # Get *everything* upstream of the node\n219 | all_upstream_nodes = nx.traversal.bfs_tree(self.graph, node_id, reverse=True)\n220 | # Get the set of upstream nodes not including the current node.\n221 | upstream_nodes = set([n for n in all_upstream_nodes if n != node_id])\n222 | \n223 | # Get all tests that depend on any upstream nodes.\n224 | upstream_tests = []\n225 | for upstream_node in upstream_nodes:\n226 | # This gets tests with unique_ids starting with \"test.\"\n227 | upstream_tests += _get_tests_for_node(manifest, upstream_node)\n228 | \n229 | for upstream_test in upstream_tests:\n230 | # Get the set of all nodes that the test depends on\n231 | # including the upstream_node itself. This is necessary\n232 | # because tests can depend on multiple nodes (ex:\n233 | # relationship tests). Test nodes do not distinguish\n234 | # between what node the test is \"testing\" and what\n235 | # node(s) it depends on.\n236 | test_depends_on = set(manifest.nodes[upstream_test].depends_on_nodes)\n237 | \n238 | # If the set of nodes that an upstream test depends on\n239 | # is a subset of all upstream nodes of the current node,\n240 | # add an edge from the upstream test to the current node.\n241 | if test_depends_on.issubset(upstream_nodes):\n242 | self.graph.add_edge(upstream_test, node_id, edge_type=\"parent_test\")\n243 | \n244 | def get_graph(self, manifest: Manifest) -> Graph:\n245 | self.link_graph(manifest)\n246 | return Graph(self.graph)\n247 | \n248 | def get_graph_summary(self, manifest: Manifest) -> Dict[int, Dict[str, Any]]:\n249 | \"\"\"Create a smaller summary of the graph, suitable for basic diagnostics\n250 | and performance tuning. The summary includes only the edge structure,\n251 | node types, and node names. Each of the n nodes is assigned an integer\n252 | index 0, 1, 2,..., n-1 for compactness\"\"\"\n253 | graph_nodes = dict()\n254 | index_dict = dict()\n255 | for node_index, node_name in enumerate(self.graph):\n256 | index_dict[node_name] = node_index\n257 | data = manifest.expect(node_name).to_dict(omit_none=True)\n258 | graph_nodes[node_index] = {\"name\": node_name, \"type\": data[\"resource_type\"]}\n259 | \n260 | for node_index, node in graph_nodes.items():\n261 | successors = [index_dict[n] for n in self.graph.successors(node[\"name\"])]\n262 | if successors:\n263 | node[\"succ\"] = [index_dict[n] for n in self.graph.successors(node[\"name\"])]\n264 | \n265 | return graph_nodes\n266 | \n267 | \n268 | class Compiler:\n269 | def __init__(self, config) -> None:\n270 | self.config = config\n271 | \n272 | def initialize(self):\n273 | make_directory(self.config.project_target_path)\n274 | make_directory(self.config.packages_install_path)\n275 | \n276 | # creates a ModelContext which is converted to\n277 | # a dict for jinja rendering of SQL\n278 | def _create_node_context(\n279 | self,\n280 | node: ManifestSQLNode,\n281 | manifest: Manifest,\n282 | extra_context: Dict[str, Any],\n283 | ) -> Dict[str, Any]:\n284 | if isinstance(node, UnitTestNode):\n285 | context = generate_runtime_unit_test_context(node, self.config, manifest)\n286 | else:\n287 | context = generate_runtime_model_context(node, self.config, manifest)\n288 | context.update(extra_context)\n289 | \n290 | if isinstance(node, GenericTestNode):\n291 | # for test nodes, add a special keyword args value to the context\n292 | jinja.add_rendered_test_kwargs(context, node)\n293 | \n294 | return context\n295 | \n296 | def add_ephemeral_prefix(self, name: str):\n297 | adapter = get_adapter(self.config)\n298 | relation_cls = adapter.Relation\n299 | return relation_cls.add_ephemeral_prefix(name)\n300 | \n301 | def _recursively_prepend_ctes(\n302 | self,\n303 | model: ManifestSQLNode,\n304 | manifest: Manifest,\n305 | extra_context: Optional[Dict[str, Any]],\n306 | ) -> Tuple[ManifestSQLNode, List[InjectedCTE]]:\n307 | \"\"\"This method is called by the 'compile_node' method. Starting\n308 | from the node that it is passed in, it will recursively call\n309 | itself using the 'extra_ctes'. The 'ephemeral' models do\n310 | not produce SQL that is executed directly, instead they\n311 | are rolled up into the models that refer to them by\n312 | inserting CTEs into the SQL.\n313 | \"\"\"\n314 | if model.compiled_code is None:\n315 | raise DbtRuntimeError(\"Cannot inject ctes into an uncompiled node\", model)\n316 | \n317 | # tech debt: safe flag/arg access (#6259)\n318 | if not getattr(self.config.args, \"inject_ephemeral_ctes\", True):\n319 | return (model, [])\n320 | \n321 | # extra_ctes_injected flag says that we've already recursively injected the ctes\n322 | if model.extra_ctes_injected:\n323 | return (model, model.extra_ctes)\n324 | \n325 | # Just to make it plain that nothing is actually injected for this case\n326 | if len(model.extra_ctes) == 0:\n327 | # SeedNodes don't have compilation attributes\n328 | if not isinstance(model, SeedNode):\n329 | model.extra_ctes_injected = True\n330 | return (model, [])\n331 | \n332 | # This stores the ctes which will all be recursively\n333 | # gathered and then \"injected\" into the model.\n334 | prepended_ctes: List[InjectedCTE] = []\n335 | \n336 | # extra_ctes are added to the model by\n337 | # RuntimeRefResolver.create_relation, which adds an\n338 | # extra_cte for every model relation which is an\n339 | # ephemeral model. InjectedCTEs have a unique_id and sql.\n340 | # extra_ctes start out with sql set to None, and the sql is set in this loop.\n341 | for cte in model.extra_ctes:\n342 | if cte.id not in manifest.nodes:\n343 | raise DbtInternalError(\n344 | f\"During compilation, found a cte reference that \"\n345 | f\"could not be resolved: {cte.id}\"\n346 | )\n347 | cte_model = manifest.nodes[cte.id]\n348 | assert not isinstance(cte_model, SeedNode)\n349 | \n350 | if not cte_model.is_ephemeral_model:\n351 | raise DbtInternalError(f\"{cte.id} is not ephemeral\")\n352 | \n353 | # This model has already been compiled and extra_ctes_injected, so it's been\n354 | # through here before. We already checked above for extra_ctes_injected, but\n355 | # checking again because updates maybe have happened in another thread.\n356 | if cte_model.compiled is True and cte_model.extra_ctes_injected is True:\n357 | new_prepended_ctes = cte_model.extra_ctes\n358 | \n359 | # if the cte_model isn't compiled, i.e. first time here\n360 | else:\n361 | # This is an ephemeral parsed model that we can compile.\n362 | # Render the raw_code and set compiled to True\n363 | cte_model = self._compile_code(cte_model, manifest, extra_context)\n364 | # recursively call this method, sets extra_ctes_injected to True\n365 | cte_model, new_prepended_ctes = self._recursively_prepend_ctes(\n366 | cte_model, manifest, extra_context\n367 | )\n368 | # Write compiled SQL file\n369 | self._write_node(cte_model)\n370 | \n371 | _extend_prepended_ctes(prepended_ctes, new_prepended_ctes)\n372 | \n373 | new_cte_name = self.add_ephemeral_prefix(cte_model.name)\n374 | rendered_sql = cte_model._pre_injected_sql or cte_model.compiled_code\n375 | sql = f\" {new_cte_name} as (\\n{rendered_sql}\\n)\"\n376 | \n377 | _add_prepended_cte(prepended_ctes, InjectedCTE(id=cte.id, sql=sql))\n378 | \n379 | # Check again before updating for multi-threading\n380 | if not model.extra_ctes_injected:\n381 | injected_sql = inject_ctes_into_sql(\n382 | model.compiled_code,\n383 | prepended_ctes,\n384 | )\n385 | model.extra_ctes_injected = True\n386 | model._pre_injected_sql = model.compiled_code\n387 | model.compiled_code = injected_sql\n388 | model.extra_ctes = prepended_ctes\n389 | \n390 | # if model.extra_ctes is not set to prepended ctes, something went wrong\n391 | return model, model.extra_ctes\n392 | \n393 | # Sets compiled_code and compiled flag in the ManifestSQLNode passed in,\n394 | # creates a \"context\" dictionary for jinja rendering,\n395 | # and then renders the \"compiled_code\" using the node, the\n396 | # raw_code and the context.\n397 | def _compile_code(\n398 | self,\n399 | node: ManifestSQLNode,\n400 | manifest: Manifest,\n401 | extra_context: Optional[Dict[str, Any]] = None,\n402 | ) -> ManifestSQLNode:\n403 | if extra_context is None:\n404 | extra_context = {}\n405 | \n406 | if node.language == ModelLanguage.python:\n407 | context = self._create_node_context(node, manifest, extra_context)\n408 | \n409 | postfix = jinja.get_rendered(\n410 | \"{{ py_script_postfix(model) }}\",\n411 | context,\n412 | node,\n413 | )\n414 | # we should NOT jinja render the python model's 'raw code'\n415 | node.compiled_code = f\"{node.raw_code}\\n\\n{postfix}\"\n416 | \n417 | else:\n418 | context = self._create_node_context(node, manifest, extra_context)\n419 | node.compiled_code = jinja.get_rendered(\n420 | node.raw_code,\n421 | context,\n422 | node,\n423 | )\n424 | \n425 | node.compiled = True\n426 | \n427 | # relation_name is set at parse time, except for tests without store_failures,\n428 | # but cli param can turn on store_failures, so we set here.\n429 | if (\n430 | node.resource_type == NodeType.Test\n431 | and node.relation_name is None\n432 | and node.is_relational\n433 | ):\n434 | adapter = get_adapter(self.config)\n435 | relation_cls = adapter.Relation\n436 | relation_name = str(relation_cls.create_from(self.config, node))\n437 | node.relation_name = relation_name\n438 | \n439 | return node\n440 | \n441 | # This method doesn't actually \"compile\" any of the nodes. That is done by the\n442 | # \"compile_node\" method. This creates a Linker and builds the networkx graph,\n443 | # writes out the graph.gpickle file, and prints the stats, returning a Graph object.\n444 | def compile(self, manifest: Manifest, write=True, add_test_edges=False) -> Graph:\n445 | self.initialize()\n446 | linker = Linker()\n447 | linker.link_graph(manifest)\n448 | \n449 | # Create a file containing basic information about graph structure,\n450 | # supporting diagnostics and performance analysis.\n451 | summaries: Dict = dict()\n452 | summaries[\"_invocation_id\"] = get_invocation_id()\n453 | summaries[\"linked\"] = linker.get_graph_summary(manifest)\n454 | \n455 | # This is only called for the \"build\" command\n456 | if add_test_edges:\n457 | manifest.build_parent_and_child_maps()\n458 | linker.add_test_edges(manifest)\n459 | \n460 | # Create another diagnostic summary, just as above, but this time\n461 | # including the test edges.\n462 | summaries[\"with_test_edges\"] = linker.get_graph_summary(manifest)\n463 | \n464 | with open(\n465 | os.path.join(self.config.project_target_path, \"graph_summary.json\"), \"w\"\n466 | ) as out_stream:\n467 | try:\n468 | out_stream.write(json.dumps(summaries))\n469 | except Exception as e: # This is non-essential information, so merely note failures.\n470 | fire_event(\n471 | Note(\n472 | msg=f\"An error was encountered writing the graph summary information: {e}\"\n473 | )\n474 | )\n475 | \n476 | stats = _generate_stats(manifest)\n477 | \n478 | if write:\n479 | self.write_graph_file(linker, manifest)\n480 | \n481 | # Do not print these for list command\n482 | if self.config.args.which != \"list\":\n483 | stats = _generate_stats(manifest)\n484 | print_compile_stats(stats)\n485 | \n486 | return Graph(linker.graph)\n487 | \n488 | def write_graph_file(self, linker: Linker, manifest: Manifest):\n489 | filename = graph_file_name\n490 | graph_path = os.path.join(self.config.project_target_path, filename)\n491 | flags = get_flags()\n492 | if flags.WRITE_JSON:\n493 | linker.write_graph(graph_path, manifest)\n494 | \n495 | # writes the \"compiled_code\" into the target/compiled directory\n496 | def _write_node(self, node: ManifestSQLNode) -> ManifestSQLNode:\n497 | if not node.extra_ctes_injected or node.resource_type in (\n498 | NodeType.Snapshot,\n499 | NodeType.Seed,\n500 | ):\n501 | return node\n502 | fire_event(WritingInjectedSQLForNode(node_info=get_node_info()))\n503 | \n504 | if node.compiled_code:\n505 | node.compiled_path = node.get_target_write_path(self.config.target_path, \"compiled\")\n506 | node.write_node(self.config.project_root, node.compiled_path, node.compiled_code)\n507 | return node\n508 | \n509 | def compile_node(\n510 | self,\n511 | node: ManifestSQLNode,\n512 | manifest: Manifest,\n513 | extra_context: Optional[Dict[str, Any]] = None,\n514 | write: bool = True,\n515 | ) -> ManifestSQLNode:\n516 | \"\"\"This is the main entry point into this code. It's called by\n517 | CompileRunner.compile, GenericRPCRunner.compile, and\n518 | RunTask.get_hook_sql. It calls '_compile_code' to render\n519 | the node's raw_code into compiled_code, and then calls the\n520 | recursive method to \"prepend\" the ctes.\n521 | \"\"\"\n522 | if isinstance(node, UnitTestDefinition):\n523 | return node\n524 | \n525 | # Make sure Lexer for sqlparse 0.4.4 is initialized\n526 | from sqlparse.lexer import Lexer # type: ignore\n527 | \n528 | if hasattr(Lexer, \"get_default_instance\"):\n529 | Lexer.get_default_instance()\n530 | \n531 | node = self._compile_code(node, manifest, extra_context)\n532 | \n533 | node, _ = self._recursively_prepend_ctes(node, manifest, extra_context)\n534 | if write:\n535 | self._write_node(node)\n536 | return node\n537 | \n538 | \n539 | def inject_ctes_into_sql(sql: str, ctes: List[InjectedCTE]) -> str:\n540 | \"\"\"\n541 | `ctes` is a list of InjectedCTEs like:\n542 | \n543 | [\n544 | InjectedCTE(\n545 | id=\"cte_id_1\",\n546 | sql=\"__dbt__cte__ephemeral as (select * from table)\",\n547 | ),\n548 | InjectedCTE(\n549 | id=\"cte_id_2\",\n550 | sql=\"__dbt__cte__events as (select id, type from events)\",\n551 | ),\n552 | ]\n553 | \n554 | Given `sql` like:\n555 | \n556 | \"with internal_cte as (select * from sessions)\n557 | select * from internal_cte\"\n558 | \n559 | This will spit out:\n560 | \n561 | \"with __dbt__cte__ephemeral as (select * from table),\n562 | __dbt__cte__events as (select id, type from events),\n563 | internal_cte as (select * from sessions)\n564 | select * from internal_cte\"\n565 | \n566 | (Whitespace enhanced for readability.)\n567 | \"\"\"\n568 | if len(ctes) == 0:\n569 | return sql\n570 | \n571 | parsed_stmts = sqlparse.parse(sql)\n572 | parsed = parsed_stmts[0]\n573 | \n574 | with_stmt = None\n575 | for token in parsed.tokens:\n576 | if token.is_keyword and token.normalized == \"WITH\":\n577 | with_stmt = token\n578 | elif token.is_keyword and token.normalized == \"RECURSIVE\" and with_stmt is not None:\n579 | with_stmt = token\n580 | break\n581 | elif not token.is_whitespace and with_stmt is not None:\n582 | break\n583 | \n584 | if with_stmt is None:\n585 | # no with stmt, add one, and inject CTEs right at the beginning\n586 | # [original_sql]\n587 | first_token = parsed.token_first()\n588 | with_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, \"with\")\n589 | parsed.insert_before(first_token, with_token)\n590 | # [with][original_sql]\n591 | injected_ctes = \", \".join(c.sql for c in ctes) + \" \"\n592 | injected_ctes_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, injected_ctes)\n593 | parsed.insert_after(with_token, injected_ctes_token)\n594 | # [with][joined_ctes][original_sql]\n595 | else:\n596 | # with stmt exists so we don't need to add one, but we do need to add a comma\n597 | # between the injected ctes and the original sql\n598 | # [with][original_sql]\n599 | injected_ctes = \", \".join(c.sql for c in ctes)\n600 | injected_ctes_token = sqlparse.sql.Token(sqlparse.tokens.Keyword, injected_ctes)\n601 | parsed.insert_after(with_stmt, injected_ctes_token)\n602 | # [with][joined_ctes][original_sql]\n603 | comma_token = sqlparse.sql.Token(sqlparse.tokens.Punctuation, \", \")\n604 | parsed.insert_after(injected_ctes_token, comma_token)\n605 | # [with][joined_ctes][, ][original_sql]\n606 | \n607 | return str(parsed)\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/artifacts/resources/types.py b/core/dbt/artifacts/resources/types.py\nindex 0000000..0000000 100644\n--- a/core/dbt/artifacts/resources/types.py\n+++ b/core/dbt/artifacts/resources/types.py\n@@ -18,7 +18,7 @@ class AccessType(StrEnum):\n class NodeType(StrEnum):\n Model = \"model\"\n Analysis = \"analysis\"\n- Test = \"test\"\n+ Test = \"test\" # renamed to 'data_test'; preserved as 'test' here for back-compat\n Snapshot = \"snapshot\"\n Operation = \"operation\"\n Seed = \"seed\"\n@@ -41,6 +41,8 @@ class NodeType(StrEnum):\n return \"analyses\"\n elif self is self.SavedQuery:\n return \"saved_queries\"\n+ elif self is self.Test:\n+ return \"data_tests\"\n return f\"{self}s\"\n \n \ndiff --git a/core/dbt/compilation.py b/core/dbt/compilation.py\nindex 0000000..0000000 100644\n--- a/core/dbt/compilation.py\n+++ b/core/dbt/compilation.py\n@@ -45,34 +45,14 @@ import sqlparse\n graph_file_name = \"graph.gpickle\"\n \n \n-def print_compile_stats(stats):\n- names = {\n- NodeType.Model: \"model\",\n- NodeType.Test: \"data test\",\n- NodeType.Unit: \"unit test\",\n- NodeType.Snapshot: \"snapshot\",\n- NodeType.Analysis: \"analysis\",\n- NodeType.Macro: \"macro\",\n- NodeType.Operation: \"operation\",\n- NodeType.Seed: \"seed\",\n- NodeType.Source: \"source\",\n- NodeType.Exposure: \"exposure\",\n- NodeType.SemanticModel: \"semantic model\",\n- NodeType.Metric: \"metric\",\n- NodeType.Group: \"group\",\n- }\n-\n- results = {k: 0 for k in names.keys()}\n- results.update(stats)\n-\n+def print_compile_stats(stats: Dict[NodeType, int]):\n # create tracking event for resource_counts\n if dbt.tracking.active_user is not None:\n- resource_counts = {k.pluralize(): v for k, v in results.items()}\n+ resource_counts = {k.pluralize(): v for k, v in stats.items()}\n dbt.tracking.track_resource_counts(resource_counts)\n \n # do not include resource types that are not actually defined in the project\n- stat_line = \", \".join([pluralize(ct, names.get(t)) for t, ct in stats.items() if t in names])\n-\n+ stat_line = \", \".join([pluralize(ct, t) for t, ct in stats.items() if ct != 0])\n fire_event(FoundStats(stat_line=stat_line))\n \n \n@@ -84,7 +64,7 @@ def _node_enabled(node: ManifestNode):\n return True\n \n \n-def _generate_stats(manifest: Manifest):\n+def _generate_stats(manifest: Manifest) -> Dict[NodeType, int]:\n stats: Dict[NodeType, int] = defaultdict(int)\n for node in manifest.nodes.values():\n if _node_enabled(node):"},"prompt_input_token_count":{"kind":"number","value":17096,"string":"17,096"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9465\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"1cbc6d333d79f4408ed620c5aef18b18a216e6c3\",\n \"pull_number\": 9465,\n \"issue_numbers\": [\n \"9464\"\n ],\n \"changed_files\": [\n \"core/dbt/artifacts/resources/types.py\",\n \"core/dbt/compilation.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32293,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9480"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 5ae8f6aad71545818a1f179abb45d5867f0e2e4f\nChanged files:\n- core/dbt/contracts/graph/nodes.py\n- core/dbt/task/list.py\n\n## Problem statement\n\n[CT-3039] Ensure that list command works for unit_tests and has reasonable output\n### Description\n\nFrom https://github.com/dbt-labs/dbt-core/issues/8651 and https://github.com/dbt-labs/dbt-core/issues/8606\n\nWe should be able to list unit tests in a project using `--select test_type:unit`.\n\n### Acceptance Criteria \n\nList command works for unit tests and has reasonable output. \n`dbt list --select test_type:unit` \n`dbt list --select test_type:data` \n\n`dbt list --resource-type test` to return all data and all unit tests \n \n### Impact to other teams\n \nNone \n \n### Will backports be required?\n \nNo \n\n### Context\n\n## Hints\n\nLooks like `dbt list` doesn't work with the test_type: resource selector as of yet: \r\n\r\n```\r\n❯ dbt build -s +my_model,test_type:unit\r\n16:42:55 Running with dbt=1.8.0-a1\r\n16:42:55 target not specified in profile 'postgres', using 'default'\r\n16:42:55 Registered adapter: postgres=1.8.0-a1\r\n16:42:55 Found 8 models, 3 seeds, 20 tests, 0 sources, 0 exposures, 0 metrics, 410 macros, 0 groups, 0 semantic models, 5 unit tests\r\n16:42:55 \r\n16:42:56 Concurrency: 1 threads (target='default')\r\n16:42:56 \r\n16:42:56 1 of 5 START unit_test test_my_model ........................................... [RUN]\r\n16:42:56 1 of 5 PASS test_my_model ...................................................... [PASS in 0.12s]\r\n16:42:56 2 of 5 START unit_test test_my_model_datetime .................................. [RUN]\r\n16:42:56 2 of 5 PASS test_my_model_datetime ............................................. [PASS in 0.11s]\r\n16:42:56 3 of 5 START unit_test test_my_model_empty ..................................... [RUN]\r\n16:42:56 3 of 5 PASS test_my_model_empty ................................................ [PASS in 0.08s]\r\n16:42:56 4 of 5 START unit_test test_my_model_overrides ................................. [RUN]\r\n16:42:56 4 of 5 PASS test_my_model_overrides ............................................ [PASS in 0.07s]\r\n16:42:56 5 of 5 START unit_test test_my_model_string_concat ............................. [RUN]\r\n16:42:56 5 of 5 PASS test_my_model_string_concat ........................................ [PASS in 0.07s]\r\n16:42:56 \r\n16:42:56 Finished running 5 unit_tests in 0 hours 0 minutes and 1.00 seconds (1.00s).\r\n16:42:56 \r\n16:42:56 Completed successfully\r\n16:42:56 \r\n16:42:56 Done. PASS=5 WARN=0 ERROR=0 SKIP=0 TOTAL=5\r\n```\r\n\r\n```\r\n❯ dbt ls -s +my_model,test_type:unit\r\n16:43:05 Running with dbt=1.8.0-a1\r\n16:43:05 target not specified in profile 'postgres', using 'default'\r\n16:43:05 Registered adapter: postgres=1.8.0-a1\r\n16:43:05 Found 8 models, 3 seeds, 20 tests, 0 sources, 0 exposures, 0 metrics, 410 macros, 0 groups, 0 semantic models, 5 unit tests\r\n16:43:05 No nodes selected!\r\n```\r\n\r\n```\r\n❯ dbt ls -s test_type:unit\r\n16:48:01 Running with dbt=1.8.0-a1\r\n16:48:01 target not specified in profile 'postgres', using 'default'\r\n16:48:01 Registered adapter: postgres=1.8.0-a1\r\n16:48:01 Found 8 models, 3 seeds, 20 tests, 0 sources, 0 exposures, 0 metrics, 410 macros, 0 groups, 0 semantic models, 5 unit tests\r\n16:48:01 No nodes selected!\r\n```\nIf you have a `models/_models.yml` file like this:\r\n\r\n```yaml\r\nmodels:\r\n - name: my_model\r\n columns:\r\n - name: id\r\n tests:\r\n - unique\r\n versions: \r\n - v: 1\r\n - v: 2\r\n```\r\n\r\nThen here is the output of `dbt list`:\r\n\r\n```\r\n(dbt_1.7) $ dbt ls -s +my_model,resource_type:test\r\n\r\n00:41:29 Running with dbt=1.7.4\r\n00:41:30 Registered adapter: postgres=1.7.4\r\n00:41:30 Found 3 models, 1 snapshot, 1 analysis, 1 seed, 2 tests, 1 source, 0 exposures, 1 metric, 401 macros, 0 groups, 1 semantic model\r\nmy_project.unique_my_model_v1_id\r\nmy_project.unique_my_model_v2_id\r\n```\r\n\r\nNote that there are 2 tests and they each have a unique node name.\r\n\r\nIn a group discussion yesterday about https://github.com/dbt-labs/dbt-core/issues/9344, we considered what should happen if there is a single unit test with two versions.\r\n\r\nWe decided that it should behave similarly and output two nodes:\r\n```\r\n00:41:30 Found .. 2 unit tests ...\r\nmy_project.my_unit_test_my_model_v1\r\nmy_project.my_unit_test_my_model_v2\r\n```\n\n## Files before the fix\n\n### File: core/dbt/contracts/graph/nodes.py\n\n```python\n 1 | import os\n 2 | from datetime import datetime\n 3 | import time\n 4 | from dataclasses import dataclass, field\n 5 | import hashlib\n 6 | \n 7 | from mashumaro.types import SerializableType\n 8 | from typing import Optional, Union, List, Dict, Any, Sequence, Tuple, Iterator, Literal\n 9 | \n 10 | from dbt import deprecations\n 11 | from dbt_common.contracts.constraints import (\n 12 | ColumnLevelConstraint,\n 13 | ConstraintType,\n 14 | ModelLevelConstraint,\n 15 | )\n 16 | from dbt_common.dataclass_schema import dbtClassMixin, ExtensibleDbtClassMixin\n 17 | \n 18 | from dbt_common.clients.system import write_file\n 19 | from dbt.contracts.files import FileHash\n 20 | from dbt.contracts.graph.saved_queries import Export, QueryParams\n 21 | from dbt.contracts.graph.semantic_models import (\n 22 | Defaults,\n 23 | Dimension,\n 24 | Entity,\n 25 | Measure,\n 26 | SourceFileMetadata,\n 27 | )\n 28 | from dbt.contracts.graph.unparsed import (\n 29 | ConstantPropertyInput,\n 30 | ExposureType,\n 31 | ExternalTable,\n 32 | FreshnessThreshold,\n 33 | HasYamlMetadata,\n 34 | MaturityType,\n 35 | Owner,\n 36 | Quoting,\n 37 | TestDef,\n 38 | NodeVersion,\n 39 | UnparsedSourceDefinition,\n 40 | UnparsedSourceTableDefinition,\n 41 | UnparsedColumn,\n 42 | UnitTestOverrides,\n 43 | UnitTestInputFixture,\n 44 | UnitTestOutputFixture,\n 45 | UnitTestNodeVersions,\n 46 | )\n 47 | from dbt.contracts.graph.node_args import ModelNodeArgs\n 48 | from dbt.contracts.graph.semantic_layer_common import WhereFilterIntersection\n 49 | from dbt.contracts.util import Replaceable\n 50 | from dbt_common.contracts.config.properties import AdditionalPropertiesMixin\n 51 | from dbt_common.events.functions import warn_or_error\n 52 | from dbt.exceptions import ParsingError, ContractBreakingChangeError, ValidationError\n 53 | from dbt.events.types import (\n 54 | SeedIncreased,\n 55 | SeedExceedsLimitSamePath,\n 56 | SeedExceedsLimitAndPathChanged,\n 57 | SeedExceedsLimitChecksumChanged,\n 58 | UnversionedBreakingChange,\n 59 | )\n 60 | from dbt_common.events.contextvars import set_log_contextvars\n 61 | from dbt.flags import get_flags\n 62 | from dbt.node_types import (\n 63 | NodeType,\n 64 | AccessType,\n 65 | REFABLE_NODE_TYPES,\n 66 | VERSIONED_NODE_TYPES,\n 67 | )\n 68 | from dbt_semantic_interfaces.references import (\n 69 | EntityReference,\n 70 | MeasureReference,\n 71 | LinkableElementReference,\n 72 | SemanticModelReference,\n 73 | TimeDimensionReference,\n 74 | )\n 75 | from dbt_semantic_interfaces.references import MetricReference as DSIMetricReference\n 76 | from dbt_semantic_interfaces.type_enums import (\n 77 | ConversionCalculationType,\n 78 | MetricType,\n 79 | TimeGranularity,\n 80 | )\n 81 | \n 82 | from .model_config import (\n 83 | NodeConfig,\n 84 | ModelConfig,\n 85 | SeedConfig,\n 86 | TestConfig,\n 87 | SourceConfig,\n 88 | MetricConfig,\n 89 | ExposureConfig,\n 90 | EmptySnapshotConfig,\n 91 | SnapshotConfig,\n 92 | SemanticModelConfig,\n 93 | UnitTestConfig,\n 94 | UnitTestNodeConfig,\n 95 | SavedQueryConfig,\n 96 | )\n 97 | \n 98 | from dbt.artifacts.resources import (\n 99 | BaseResource,\n 100 | Docs,\n 101 | MacroDependsOn,\n 102 | MacroArgument,\n 103 | Documentation as DocumentationResource,\n 104 | Macro as MacroResource,\n 105 | Group as GroupResource,\n 106 | )\n 107 | \n 108 | \n 109 | # =====================================================================\n 110 | # This contains the classes for all of the nodes and node-like objects\n 111 | # in the manifest. In the \"nodes\" dictionary of the manifest we find\n 112 | # all of the objects in the ManifestNode union below. In addition the\n 113 | # manifest contains \"macros\", \"sources\", \"metrics\", \"exposures\", \"docs\",\n 114 | # and \"disabled\" dictionaries.\n 115 | #\n 116 | # The SeedNode is a ManifestNode, but can't be compiled because it has\n 117 | # no SQL.\n 118 | #\n 119 | # All objects defined in this file should have BaseNode as a parent\n 120 | # class.\n 121 | #\n 122 | # The two objects which do not show up in the DAG are Macro and\n 123 | # Documentation.\n 124 | # =====================================================================\n 125 | \n 126 | \n 127 | # ==================================================\n 128 | # Various parent classes and node attribute classes\n 129 | # ==================================================\n 130 | \n 131 | \n 132 | @dataclass\n 133 | class BaseNode(BaseResource):\n 134 | \"\"\"All nodes or node-like objects in this file should have this as a base class\"\"\"\n 135 | \n 136 | @property\n 137 | def search_name(self):\n 138 | return self.name\n 139 | \n 140 | @property\n 141 | def file_id(self):\n 142 | return f\"{self.package_name}://{self.original_file_path}\"\n 143 | \n 144 | @property\n 145 | def is_refable(self):\n 146 | return self.resource_type in REFABLE_NODE_TYPES\n 147 | \n 148 | @property\n 149 | def should_store_failures(self):\n 150 | return False\n 151 | \n 152 | # will this node map to an object in the database?\n 153 | @property\n 154 | def is_relational(self):\n 155 | return self.resource_type in REFABLE_NODE_TYPES\n 156 | \n 157 | @property\n 158 | def is_versioned(self):\n 159 | return self.resource_type in VERSIONED_NODE_TYPES and self.version is not None\n 160 | \n 161 | @property\n 162 | def is_ephemeral(self):\n 163 | return self.config.materialized == \"ephemeral\"\n 164 | \n 165 | @property\n 166 | def is_ephemeral_model(self):\n 167 | return self.is_refable and self.is_ephemeral\n 168 | \n 169 | def get_materialization(self):\n 170 | return self.config.materialized\n 171 | \n 172 | \n 173 | @dataclass\n 174 | class GraphNode(BaseNode):\n 175 | \"\"\"Nodes in the DAG. Macro and Documentation don't have fqn.\"\"\"\n 176 | \n 177 | fqn: List[str]\n 178 | \n 179 | def same_fqn(self, other) -> bool:\n 180 | return self.fqn == other.fqn\n 181 | \n 182 | \n 183 | @dataclass\n 184 | class RefArgs(dbtClassMixin):\n 185 | name: str\n 186 | package: Optional[str] = None\n 187 | version: Optional[NodeVersion] = None\n 188 | \n 189 | @property\n 190 | def positional_args(self) -> List[str]:\n 191 | if self.package:\n 192 | return [self.package, self.name]\n 193 | else:\n 194 | return [self.name]\n 195 | \n 196 | @property\n 197 | def keyword_args(self) -> Dict[str, Optional[NodeVersion]]:\n 198 | if self.version:\n 199 | return {\"version\": self.version}\n 200 | else:\n 201 | return {}\n 202 | \n 203 | \n 204 | @dataclass\n 205 | class ColumnInfo(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 206 | \"\"\"Used in all ManifestNodes and SourceDefinition\"\"\"\n 207 | \n 208 | name: str\n 209 | description: str = \"\"\n 210 | meta: Dict[str, Any] = field(default_factory=dict)\n 211 | data_type: Optional[str] = None\n 212 | constraints: List[ColumnLevelConstraint] = field(default_factory=list)\n 213 | quote: Optional[bool] = None\n 214 | tags: List[str] = field(default_factory=list)\n 215 | _extra: Dict[str, Any] = field(default_factory=dict)\n 216 | \n 217 | \n 218 | @dataclass\n 219 | class Contract(dbtClassMixin, Replaceable):\n 220 | enforced: bool = False\n 221 | alias_types: bool = True\n 222 | checksum: Optional[str] = None\n 223 | \n 224 | \n 225 | # Metrics, exposures,\n 226 | @dataclass\n 227 | class HasRelationMetadata(dbtClassMixin, Replaceable):\n 228 | database: Optional[str]\n 229 | schema: str\n 230 | \n 231 | # Can't set database to None like it ought to be\n 232 | # because it messes up the subclasses and default parameters\n 233 | # so hack it here\n 234 | @classmethod\n 235 | def __pre_deserialize__(cls, data):\n 236 | data = super().__pre_deserialize__(data)\n 237 | if \"database\" not in data:\n 238 | data[\"database\"] = None\n 239 | return data\n 240 | \n 241 | @property\n 242 | def quoting_dict(self) -> Dict[str, bool]:\n 243 | if hasattr(self, \"quoting\"):\n 244 | return self.quoting.to_dict(omit_none=True)\n 245 | else:\n 246 | return {}\n 247 | \n 248 | \n 249 | @dataclass\n 250 | class DeferRelation(HasRelationMetadata):\n 251 | alias: str\n 252 | relation_name: Optional[str]\n 253 | \n 254 | @property\n 255 | def identifier(self):\n 256 | return self.alias\n 257 | \n 258 | \n 259 | @dataclass\n 260 | class DependsOn(MacroDependsOn):\n 261 | nodes: List[str] = field(default_factory=list)\n 262 | \n 263 | def add_node(self, value: str):\n 264 | if value not in self.nodes:\n 265 | self.nodes.append(value)\n 266 | \n 267 | \n 268 | @dataclass\n 269 | class ParsedNodeMandatory(GraphNode, HasRelationMetadata, Replaceable):\n 270 | alias: str\n 271 | checksum: FileHash\n 272 | config: NodeConfig = field(default_factory=NodeConfig)\n 273 | \n 274 | @property\n 275 | def identifier(self):\n 276 | return self.alias\n 277 | \n 278 | \n 279 | # This needs to be in all ManifestNodes and also in SourceDefinition,\n 280 | # because of \"source freshness\"\n 281 | @dataclass\n 282 | class NodeInfoMixin:\n 283 | _event_status: Dict[str, Any] = field(default_factory=dict)\n 284 | \n 285 | @property\n 286 | def node_info(self):\n 287 | node_info = {\n 288 | \"node_path\": getattr(self, \"path\", None),\n 289 | \"node_name\": getattr(self, \"name\", None),\n 290 | \"unique_id\": getattr(self, \"unique_id\", None),\n 291 | \"resource_type\": str(getattr(self, \"resource_type\", \"\")),\n 292 | \"materialized\": self.config.get(\"materialized\"),\n 293 | \"node_status\": str(self._event_status.get(\"node_status\")),\n 294 | \"node_started_at\": self._event_status.get(\"started_at\"),\n 295 | \"node_finished_at\": self._event_status.get(\"finished_at\"),\n 296 | \"meta\": getattr(self, \"meta\", {}),\n 297 | \"node_relation\": {\n 298 | \"database\": getattr(self, \"database\", None),\n 299 | \"schema\": getattr(self, \"schema\", None),\n 300 | \"alias\": getattr(self, \"alias\", None),\n 301 | \"relation_name\": getattr(self, \"relation_name\", None),\n 302 | },\n 303 | }\n 304 | return node_info\n 305 | \n 306 | def update_event_status(self, **kwargs):\n 307 | for k, v in kwargs.items():\n 308 | self._event_status[k] = v\n 309 | set_log_contextvars(node_info=self.node_info)\n 310 | \n 311 | def clear_event_status(self):\n 312 | self._event_status = dict()\n 313 | \n 314 | \n 315 | @dataclass\n 316 | class ParsedNode(NodeInfoMixin, ParsedNodeMandatory, SerializableType):\n 317 | tags: List[str] = field(default_factory=list)\n 318 | description: str = field(default=\"\")\n 319 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n 320 | meta: Dict[str, Any] = field(default_factory=dict)\n 321 | group: Optional[str] = None\n 322 | docs: Docs = field(default_factory=Docs)\n 323 | patch_path: Optional[str] = None\n 324 | build_path: Optional[str] = None\n 325 | deferred: bool = False\n 326 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n 327 | created_at: float = field(default_factory=lambda: time.time())\n 328 | config_call_dict: Dict[str, Any] = field(default_factory=dict)\n 329 | relation_name: Optional[str] = None\n 330 | raw_code: str = \"\"\n 331 | \n 332 | def get_target_write_path(self, target_path: str, subdirectory: str):\n 333 | # This is called for both the \"compiled\" subdirectory of \"target\" and the \"run\" subdirectory\n 334 | if os.path.basename(self.path) == os.path.basename(self.original_file_path):\n 335 | # One-to-one relationship of nodes to files.\n 336 | path = self.original_file_path\n 337 | else:\n 338 | # Many-to-one relationship of nodes to files.\n 339 | path = os.path.join(self.original_file_path, self.path)\n 340 | target_write_path = os.path.join(target_path, subdirectory, self.package_name, path)\n 341 | return target_write_path\n 342 | \n 343 | def write_node(self, project_root: str, compiled_path, compiled_code: str):\n 344 | if os.path.isabs(compiled_path):\n 345 | full_path = compiled_path\n 346 | else:\n 347 | full_path = os.path.join(project_root, compiled_path)\n 348 | write_file(full_path, compiled_code)\n 349 | \n 350 | def _serialize(self):\n 351 | return self.to_dict()\n 352 | \n 353 | def __post_serialize__(self, dct):\n 354 | dct = super().__post_serialize__(dct)\n 355 | if \"_event_status\" in dct:\n 356 | del dct[\"_event_status\"]\n 357 | return dct\n 358 | \n 359 | @classmethod\n 360 | def _deserialize(cls, dct: Dict[str, int]):\n 361 | # The serialized ParsedNodes do not differ from each other\n 362 | # in fields that would allow 'from_dict' to distinguis\n 363 | # between them.\n 364 | resource_type = dct[\"resource_type\"]\n 365 | if resource_type == \"model\":\n 366 | return ModelNode.from_dict(dct)\n 367 | elif resource_type == \"analysis\":\n 368 | return AnalysisNode.from_dict(dct)\n 369 | elif resource_type == \"seed\":\n 370 | return SeedNode.from_dict(dct)\n 371 | elif resource_type == \"rpc\":\n 372 | return RPCNode.from_dict(dct)\n 373 | elif resource_type == \"sql\":\n 374 | return SqlNode.from_dict(dct)\n 375 | elif resource_type == \"test\":\n 376 | if \"test_metadata\" in dct:\n 377 | return GenericTestNode.from_dict(dct)\n 378 | else:\n 379 | return SingularTestNode.from_dict(dct)\n 380 | elif resource_type == \"operation\":\n 381 | return HookNode.from_dict(dct)\n 382 | elif resource_type == \"seed\":\n 383 | return SeedNode.from_dict(dct)\n 384 | elif resource_type == \"snapshot\":\n 385 | return SnapshotNode.from_dict(dct)\n 386 | else:\n 387 | return cls.from_dict(dct)\n 388 | \n 389 | def _persist_column_docs(self) -> bool:\n 390 | if hasattr(self.config, \"persist_docs\"):\n 391 | assert isinstance(self.config, NodeConfig)\n 392 | return bool(self.config.persist_docs.get(\"columns\"))\n 393 | return False\n 394 | \n 395 | def _persist_relation_docs(self) -> bool:\n 396 | if hasattr(self.config, \"persist_docs\"):\n 397 | assert isinstance(self.config, NodeConfig)\n 398 | return bool(self.config.persist_docs.get(\"relation\"))\n 399 | return False\n 400 | \n 401 | def same_persisted_description(self, other) -> bool:\n 402 | # the check on configs will handle the case where we have different\n 403 | # persist settings, so we only have to care about the cases where they\n 404 | # are the same..\n 405 | if self._persist_relation_docs():\n 406 | if self.description != other.description:\n 407 | return False\n 408 | \n 409 | if self._persist_column_docs():\n 410 | # assert other._persist_column_docs()\n 411 | column_descriptions = {k: v.description for k, v in self.columns.items()}\n 412 | other_column_descriptions = {k: v.description for k, v in other.columns.items()}\n 413 | if column_descriptions != other_column_descriptions:\n 414 | return False\n 415 | \n 416 | return True\n 417 | \n 418 | def same_body(self, other) -> bool:\n 419 | return self.raw_code == other.raw_code\n 420 | \n 421 | def same_database_representation(self, other) -> bool:\n 422 | # compare the config representation, not the node's config value. This\n 423 | # compares the configured value, rather than the ultimate value (so\n 424 | # generate_*_name and unset values derived from the target are\n 425 | # ignored)\n 426 | keys = (\"database\", \"schema\", \"alias\")\n 427 | for key in keys:\n 428 | mine = self.unrendered_config.get(key)\n 429 | others = other.unrendered_config.get(key)\n 430 | if mine != others:\n 431 | return False\n 432 | return True\n 433 | \n 434 | def same_config(self, old) -> bool:\n 435 | return self.config.same_contents(\n 436 | self.unrendered_config,\n 437 | old.unrendered_config,\n 438 | )\n 439 | \n 440 | def build_contract_checksum(self):\n 441 | pass\n 442 | \n 443 | def same_contract(self, old, adapter_type=None) -> bool:\n 444 | # This would only apply to seeds\n 445 | return True\n 446 | \n 447 | def same_contents(self, old, adapter_type) -> bool:\n 448 | if old is None:\n 449 | return False\n 450 | \n 451 | # Need to ensure that same_contract is called because it\n 452 | # could throw an error\n 453 | same_contract = self.same_contract(old, adapter_type)\n 454 | return (\n 455 | self.same_body(old)\n 456 | and self.same_config(old)\n 457 | and self.same_persisted_description(old)\n 458 | and self.same_fqn(old)\n 459 | and self.same_database_representation(old)\n 460 | and same_contract\n 461 | and True\n 462 | )\n 463 | \n 464 | @property\n 465 | def is_external_node(self):\n 466 | return False\n 467 | \n 468 | \n 469 | @dataclass\n 470 | class InjectedCTE(dbtClassMixin, Replaceable):\n 471 | \"\"\"Used in CompiledNodes as part of ephemeral model processing\"\"\"\n 472 | \n 473 | id: str\n 474 | sql: str\n 475 | \n 476 | \n 477 | @dataclass\n 478 | class CompiledNode(ParsedNode):\n 479 | \"\"\"Contains attributes necessary for SQL files and nodes with refs, sources, etc,\n 480 | so all ManifestNodes except SeedNode.\"\"\"\n 481 | \n 482 | language: str = \"sql\"\n 483 | refs: List[RefArgs] = field(default_factory=list)\n 484 | sources: List[List[str]] = field(default_factory=list)\n 485 | metrics: List[List[str]] = field(default_factory=list)\n 486 | depends_on: DependsOn = field(default_factory=DependsOn)\n 487 | compiled_path: Optional[str] = None\n 488 | compiled: bool = False\n 489 | compiled_code: Optional[str] = None\n 490 | extra_ctes_injected: bool = False\n 491 | extra_ctes: List[InjectedCTE] = field(default_factory=list)\n 492 | _pre_injected_sql: Optional[str] = None\n 493 | contract: Contract = field(default_factory=Contract)\n 494 | \n 495 | @property\n 496 | def empty(self):\n 497 | return not self.raw_code.strip()\n 498 | \n 499 | def set_cte(self, cte_id: str, sql: str):\n 500 | \"\"\"This is the equivalent of what self.extra_ctes[cte_id] = sql would\n 501 | do if extra_ctes were an OrderedDict\n 502 | \"\"\"\n 503 | for cte in self.extra_ctes:\n 504 | # Because it's possible that multiple threads are compiling the\n 505 | # node at the same time, we don't want to overwrite already compiled\n 506 | # sql in the extra_ctes with empty sql.\n 507 | if cte.id == cte_id:\n 508 | break\n 509 | else:\n 510 | self.extra_ctes.append(InjectedCTE(id=cte_id, sql=sql))\n 511 | \n 512 | def __post_serialize__(self, dct):\n 513 | dct = super().__post_serialize__(dct)\n 514 | if \"_pre_injected_sql\" in dct:\n 515 | del dct[\"_pre_injected_sql\"]\n 516 | # Remove compiled attributes\n 517 | if \"compiled\" in dct and dct[\"compiled\"] is False:\n 518 | del dct[\"compiled\"]\n 519 | del dct[\"extra_ctes_injected\"]\n 520 | del dct[\"extra_ctes\"]\n 521 | # \"omit_none\" means these might not be in the dictionary\n 522 | if \"compiled_code\" in dct:\n 523 | del dct[\"compiled_code\"]\n 524 | return dct\n 525 | \n 526 | @property\n 527 | def depends_on_nodes(self):\n 528 | return self.depends_on.nodes\n 529 | \n 530 | @property\n 531 | def depends_on_macros(self):\n 532 | return self.depends_on.macros\n 533 | \n 534 | \n 535 | # ====================================\n 536 | # CompiledNode subclasses\n 537 | # ====================================\n 538 | \n 539 | \n 540 | @dataclass\n 541 | class AnalysisNode(CompiledNode):\n 542 | resource_type: Literal[NodeType.Analysis]\n 543 | \n 544 | \n 545 | @dataclass\n 546 | class HookNode(CompiledNode):\n 547 | resource_type: Literal[NodeType.Operation]\n 548 | index: Optional[int] = None\n 549 | \n 550 | \n 551 | @dataclass\n 552 | class ModelNode(CompiledNode):\n 553 | resource_type: Literal[NodeType.Model]\n 554 | access: AccessType = AccessType.Protected\n 555 | config: ModelConfig = field(default_factory=ModelConfig)\n 556 | constraints: List[ModelLevelConstraint] = field(default_factory=list)\n 557 | version: Optional[NodeVersion] = None\n 558 | latest_version: Optional[NodeVersion] = None\n 559 | deprecation_date: Optional[datetime] = None\n 560 | defer_relation: Optional[DeferRelation] = None\n 561 | \n 562 | @classmethod\n 563 | def from_args(cls, args: ModelNodeArgs) -> \"ModelNode\":\n 564 | unique_id = args.unique_id\n 565 | \n 566 | # build unrendered config -- for usage in ParsedNode.same_contents\n 567 | unrendered_config = {}\n 568 | unrendered_config[\"alias\"] = args.identifier\n 569 | unrendered_config[\"schema\"] = args.schema\n 570 | if args.database:\n 571 | unrendered_config[\"database\"] = args.database\n 572 | \n 573 | return cls(\n 574 | resource_type=NodeType.Model,\n 575 | name=args.name,\n 576 | package_name=args.package_name,\n 577 | unique_id=unique_id,\n 578 | fqn=args.fqn,\n 579 | version=args.version,\n 580 | latest_version=args.latest_version,\n 581 | relation_name=args.relation_name,\n 582 | database=args.database,\n 583 | schema=args.schema,\n 584 | alias=args.identifier,\n 585 | deprecation_date=args.deprecation_date,\n 586 | checksum=FileHash.from_contents(f\"{unique_id},{args.generated_at}\"),\n 587 | access=AccessType(args.access),\n 588 | original_file_path=\"\",\n 589 | path=\"\",\n 590 | unrendered_config=unrendered_config,\n 591 | depends_on=DependsOn(nodes=args.depends_on_nodes),\n 592 | config=ModelConfig(enabled=args.enabled),\n 593 | )\n 594 | \n 595 | @property\n 596 | def is_external_node(self) -> bool:\n 597 | return not self.original_file_path and not self.path\n 598 | \n 599 | @property\n 600 | def is_latest_version(self) -> bool:\n 601 | return self.version is not None and self.version == self.latest_version\n 602 | \n 603 | @property\n 604 | def search_name(self):\n 605 | if self.version is None:\n 606 | return self.name\n 607 | else:\n 608 | return f\"{self.name}.v{self.version}\"\n 609 | \n 610 | @property\n 611 | def materialization_enforces_constraints(self) -> bool:\n 612 | return self.config.materialized in [\"table\", \"incremental\"]\n 613 | \n 614 | def same_contents(self, old, adapter_type) -> bool:\n 615 | return super().same_contents(old, adapter_type) and self.same_ref_representation(old)\n 616 | \n 617 | def same_ref_representation(self, old) -> bool:\n 618 | return (\n 619 | # Changing the latest_version may break downstream unpinned refs\n 620 | self.latest_version == old.latest_version\n 621 | # Changes to access or deprecation_date may lead to ref-related parsing errors\n 622 | and self.access == old.access\n 623 | and self.deprecation_date == old.deprecation_date\n 624 | )\n 625 | \n 626 | def build_contract_checksum(self):\n 627 | # We don't need to construct the checksum if the model does not\n 628 | # have contract enforced, because it won't be used.\n 629 | # This needs to be executed after contract config is set\n 630 | \n 631 | # Avoid rebuilding the checksum if it has already been set.\n 632 | if self.contract.checksum is not None:\n 633 | return\n 634 | \n 635 | if self.contract.enforced is True:\n 636 | contract_state = \"\"\n 637 | # We need to sort the columns so that order doesn't matter\n 638 | # columns is a str: ColumnInfo dictionary\n 639 | sorted_columns = sorted(self.columns.values(), key=lambda col: col.name)\n 640 | for column in sorted_columns:\n 641 | contract_state += f\"|{column.name}\"\n 642 | contract_state += str(column.data_type)\n 643 | contract_state += str(column.constraints)\n 644 | if self.materialization_enforces_constraints:\n 645 | contract_state += self.config.materialized\n 646 | contract_state += str(self.constraints)\n 647 | data = contract_state.encode(\"utf-8\")\n 648 | self.contract.checksum = hashlib.new(\"sha256\", data).hexdigest()\n 649 | \n 650 | def same_contract(self, old, adapter_type=None) -> bool:\n 651 | # If the contract wasn't previously enforced:\n 652 | if old.contract.enforced is False and self.contract.enforced is False:\n 653 | # No change -- same_contract: True\n 654 | return True\n 655 | if old.contract.enforced is False and self.contract.enforced is True:\n 656 | # Now it's enforced. This is a change, but not a breaking change -- same_contract: False\n 657 | return False\n 658 | \n 659 | # Otherwise: The contract was previously enforced, and we need to check for changes.\n 660 | # Happy path: The contract is still being enforced, and the checksums are identical.\n 661 | if self.contract.enforced is True and self.contract.checksum == old.contract.checksum:\n 662 | # No change -- same_contract: True\n 663 | return True\n 664 | \n 665 | # Otherwise: There has been a change.\n 666 | # We need to determine if it is a **breaking** change.\n 667 | # These are the categories of breaking changes:\n 668 | contract_enforced_disabled: bool = False\n 669 | columns_removed: List[str] = []\n 670 | column_type_changes: List[Dict[str, str]] = []\n 671 | enforced_column_constraint_removed: List[\n 672 | Dict[str, str]\n 673 | ] = [] # column_name, constraint_type\n 674 | enforced_model_constraint_removed: List[Dict[str, Any]] = [] # constraint_type, columns\n 675 | materialization_changed: List[str] = []\n 676 | \n 677 | if old.contract.enforced is True and self.contract.enforced is False:\n 678 | # Breaking change: the contract was previously enforced, and it no longer is\n 679 | contract_enforced_disabled = True\n 680 | \n 681 | # TODO: this avoid the circular imports but isn't ideal\n 682 | from dbt.adapters.factory import get_adapter_constraint_support\n 683 | from dbt.adapters.base import ConstraintSupport\n 684 | \n 685 | constraint_support = get_adapter_constraint_support(adapter_type)\n 686 | column_constraints_exist = False\n 687 | \n 688 | # Next, compare each column from the previous contract (old.columns)\n 689 | for old_key, old_value in sorted(old.columns.items()):\n 690 | # Has this column been removed?\n 691 | if old_key not in self.columns.keys():\n 692 | columns_removed.append(old_value.name)\n 693 | # Has this column's data type changed?\n 694 | elif old_value.data_type != self.columns[old_key].data_type:\n 695 | column_type_changes.append(\n 696 | {\n 697 | \"column_name\": str(old_value.name),\n 698 | \"previous_column_type\": str(old_value.data_type),\n 699 | \"current_column_type\": str(self.columns[old_key].data_type),\n 700 | }\n 701 | )\n 702 | \n 703 | # track if there are any column level constraints for the materialization check late\n 704 | if old_value.constraints:\n 705 | column_constraints_exist = True\n 706 | \n 707 | # Have enforced columns level constraints changed?\n 708 | # Constraints are only enforced for table and incremental materializations.\n 709 | # We only really care if the old node was one of those materializations for breaking changes\n 710 | if (\n 711 | old_key in self.columns.keys()\n 712 | and old_value.constraints != self.columns[old_key].constraints\n 713 | and old.materialization_enforces_constraints\n 714 | ):\n 715 | for old_constraint in old_value.constraints:\n 716 | if (\n 717 | old_constraint not in self.columns[old_key].constraints\n 718 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 719 | ):\n 720 | enforced_column_constraint_removed.append(\n 721 | {\n 722 | \"column_name\": old_key,\n 723 | \"constraint_name\": old_constraint.name,\n 724 | \"constraint_type\": ConstraintType(old_constraint.type),\n 725 | }\n 726 | )\n 727 | \n 728 | # Now compare the model level constraints\n 729 | if old.constraints != self.constraints and old.materialization_enforces_constraints:\n 730 | for old_constraint in old.constraints:\n 731 | if (\n 732 | old_constraint not in self.constraints\n 733 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 734 | ):\n 735 | enforced_model_constraint_removed.append(\n 736 | {\n 737 | \"constraint_name\": old_constraint.name,\n 738 | \"constraint_type\": ConstraintType(old_constraint.type),\n 739 | \"columns\": old_constraint.columns,\n 740 | }\n 741 | )\n 742 | \n 743 | # Check for relevant materialization changes.\n 744 | if (\n 745 | old.materialization_enforces_constraints\n 746 | and not self.materialization_enforces_constraints\n 747 | and (old.constraints or column_constraints_exist)\n 748 | ):\n 749 | materialization_changed = [old.config.materialized, self.config.materialized]\n 750 | \n 751 | # If a column has been added, it will be missing in the old.columns, and present in self.columns\n 752 | # That's a change (caught by the different checksums), but not a breaking change\n 753 | \n 754 | # Did we find any changes that we consider breaking? If there's an enforced contract, that's\n 755 | # a warning unless the model is versioned, then it's an error.\n 756 | if (\n 757 | contract_enforced_disabled\n 758 | or columns_removed\n 759 | or column_type_changes\n 760 | or enforced_model_constraint_removed\n 761 | or enforced_column_constraint_removed\n 762 | or materialization_changed\n 763 | ):\n 764 | \n 765 | breaking_changes = []\n 766 | if contract_enforced_disabled:\n 767 | breaking_changes.append(\n 768 | \"Contract enforcement was removed: Previously, this model had an enforced contract. It is no longer configured to enforce its contract, and this is a breaking change.\"\n 769 | )\n 770 | if columns_removed:\n 771 | columns_removed_str = \"\\n - \".join(columns_removed)\n 772 | breaking_changes.append(f\"Columns were removed: \\n - {columns_removed_str}\")\n 773 | if column_type_changes:\n 774 | column_type_changes_str = \"\\n - \".join(\n 775 | [\n 776 | f\"{c['column_name']} ({c['previous_column_type']} -> {c['current_column_type']})\"\n 777 | for c in column_type_changes\n 778 | ]\n 779 | )\n 780 | breaking_changes.append(\n 781 | f\"Columns with data_type changes: \\n - {column_type_changes_str}\"\n 782 | )\n 783 | if enforced_column_constraint_removed:\n 784 | column_constraint_changes_str = \"\\n - \".join(\n 785 | [\n 786 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on column {c['column_name']}\"\n 787 | for c in enforced_column_constraint_removed\n 788 | ]\n 789 | )\n 790 | breaking_changes.append(\n 791 | f\"Enforced column level constraints were removed: \\n - {column_constraint_changes_str}\"\n 792 | )\n 793 | if enforced_model_constraint_removed:\n 794 | model_constraint_changes_str = \"\\n - \".join(\n 795 | [\n 796 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on columns {c['columns']}\"\n 797 | for c in enforced_model_constraint_removed\n 798 | ]\n 799 | )\n 800 | breaking_changes.append(\n 801 | f\"Enforced model level constraints were removed: \\n - {model_constraint_changes_str}\"\n 802 | )\n 803 | if materialization_changed:\n 804 | materialization_changes_str = (\n 805 | f\"{materialization_changed[0]} -> {materialization_changed[1]}\"\n 806 | )\n 807 | \n 808 | breaking_changes.append(\n 809 | f\"Materialization changed with enforced constraints: \\n - {materialization_changes_str}\"\n 810 | )\n 811 | \n 812 | if self.version is None:\n 813 | warn_or_error(\n 814 | UnversionedBreakingChange(\n 815 | contract_enforced_disabled=contract_enforced_disabled,\n 816 | columns_removed=columns_removed,\n 817 | column_type_changes=column_type_changes,\n 818 | enforced_column_constraint_removed=enforced_column_constraint_removed,\n 819 | enforced_model_constraint_removed=enforced_model_constraint_removed,\n 820 | breaking_changes=breaking_changes,\n 821 | model_name=self.name,\n 822 | model_file_path=self.original_file_path,\n 823 | ),\n 824 | node=self,\n 825 | )\n 826 | else:\n 827 | raise (\n 828 | ContractBreakingChangeError(\n 829 | breaking_changes=breaking_changes,\n 830 | node=self,\n 831 | )\n 832 | )\n 833 | \n 834 | # Otherwise, the contract has changed -- same_contract: False\n 835 | return False\n 836 | \n 837 | \n 838 | # TODO: rm?\n 839 | @dataclass\n 840 | class RPCNode(CompiledNode):\n 841 | resource_type: Literal[NodeType.RPCCall]\n 842 | \n 843 | \n 844 | @dataclass\n 845 | class SqlNode(CompiledNode):\n 846 | resource_type: Literal[NodeType.SqlOperation]\n 847 | \n 848 | \n 849 | # ====================================\n 850 | # Seed node\n 851 | # ====================================\n 852 | \n 853 | \n 854 | @dataclass\n 855 | class SeedNode(ParsedNode): # No SQLDefaults!\n 856 | resource_type: Literal[NodeType.Seed]\n 857 | config: SeedConfig = field(default_factory=SeedConfig)\n 858 | # seeds need the root_path because the contents are not loaded initially\n 859 | # and we need the root_path to load the seed later\n 860 | root_path: Optional[str] = None\n 861 | depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)\n 862 | defer_relation: Optional[DeferRelation] = None\n 863 | \n 864 | def same_seeds(self, other: \"SeedNode\") -> bool:\n 865 | # for seeds, we check the hashes. If the hashes are different types,\n 866 | # no match. If the hashes are both the same 'path', log a warning and\n 867 | # assume they are the same\n 868 | # if the current checksum is a path, we want to log a warning.\n 869 | result = self.checksum == other.checksum\n 870 | \n 871 | if self.checksum.name == \"path\":\n 872 | msg: str\n 873 | if other.checksum.name != \"path\":\n 874 | warn_or_error(\n 875 | SeedIncreased(package_name=self.package_name, name=self.name), node=self\n 876 | )\n 877 | elif result:\n 878 | warn_or_error(\n 879 | SeedExceedsLimitSamePath(package_name=self.package_name, name=self.name),\n 880 | node=self,\n 881 | )\n 882 | elif not result:\n 883 | warn_or_error(\n 884 | SeedExceedsLimitAndPathChanged(package_name=self.package_name, name=self.name),\n 885 | node=self,\n 886 | )\n 887 | else:\n 888 | warn_or_error(\n 889 | SeedExceedsLimitChecksumChanged(\n 890 | package_name=self.package_name,\n 891 | name=self.name,\n 892 | checksum_name=other.checksum.name,\n 893 | ),\n 894 | node=self,\n 895 | )\n 896 | \n 897 | return result\n 898 | \n 899 | @property\n 900 | def empty(self):\n 901 | \"\"\"Seeds are never empty\"\"\"\n 902 | return False\n 903 | \n 904 | def _disallow_implicit_dependencies(self):\n 905 | \"\"\"Disallow seeds to take implicit upstream dependencies via pre/post hooks\"\"\"\n 906 | # Seeds are root nodes in the DAG. They cannot depend on other nodes.\n 907 | # However, it's possible to define pre- and post-hooks on seeds, and for those\n 908 | # hooks to include {{ ref(...) }}. This worked in previous versions, but it\n 909 | # was never officially documented or supported behavior. Let's raise an explicit error,\n 910 | # which will surface during parsing if the user has written code such that we attempt\n 911 | # to capture & record a ref/source/metric call on the SeedNode.\n 912 | # For more details: https://github.com/dbt-labs/dbt-core/issues/6806\n 913 | hooks = [f'- pre_hook: \"{hook.sql}\"' for hook in self.config.pre_hook] + [\n 914 | f'- post_hook: \"{hook.sql}\"' for hook in self.config.post_hook\n 915 | ]\n 916 | hook_list = \"\\n\".join(hooks)\n 917 | message = f\"\"\"\n 918 | Seeds cannot depend on other nodes. dbt detected a seed with a pre- or post-hook\n 919 | that calls 'ref', 'source', or 'metric', either directly or indirectly via other macros.\n 920 | \n 921 | Error raised for '{self.unique_id}', which has these hooks defined: \\n{hook_list}\n 922 | \"\"\"\n 923 | raise ParsingError(message)\n 924 | \n 925 | @property\n 926 | def refs(self):\n 927 | self._disallow_implicit_dependencies()\n 928 | \n 929 | @property\n 930 | def sources(self):\n 931 | self._disallow_implicit_dependencies()\n 932 | \n 933 | @property\n 934 | def metrics(self):\n 935 | self._disallow_implicit_dependencies()\n 936 | \n 937 | def same_body(self, other) -> bool:\n 938 | return self.same_seeds(other)\n 939 | \n 940 | @property\n 941 | def depends_on_nodes(self):\n 942 | return []\n 943 | \n 944 | @property\n 945 | def depends_on_macros(self) -> List[str]:\n 946 | return self.depends_on.macros\n 947 | \n 948 | @property\n 949 | def extra_ctes(self):\n 950 | return []\n 951 | \n 952 | @property\n 953 | def extra_ctes_injected(self):\n 954 | return False\n 955 | \n 956 | @property\n 957 | def language(self):\n 958 | return \"sql\"\n 959 | \n 960 | \n 961 | # ====================================\n 962 | # Singular Test node\n 963 | # ====================================\n 964 | \n 965 | \n 966 | class TestShouldStoreFailures:\n 967 | @property\n 968 | def should_store_failures(self):\n 969 | if self.config.store_failures:\n 970 | return self.config.store_failures\n 971 | return get_flags().STORE_FAILURES\n 972 | \n 973 | @property\n 974 | def is_relational(self):\n 975 | if self.should_store_failures:\n 976 | return True\n 977 | return False\n 978 | \n 979 | \n 980 | @dataclass\n 981 | class SingularTestNode(TestShouldStoreFailures, CompiledNode):\n 982 | resource_type: Literal[NodeType.Test]\n 983 | # Was not able to make mypy happy and keep the code working. We need to\n 984 | # refactor the various configs.\n 985 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n 986 | \n 987 | @property\n 988 | def test_node_type(self):\n 989 | return \"singular\"\n 990 | \n 991 | \n 992 | # ====================================\n 993 | # Generic Test node\n 994 | # ====================================\n 995 | \n 996 | \n 997 | @dataclass\n 998 | class TestMetadata(dbtClassMixin, Replaceable):\n 999 | __test__ = False\n1000 | \n1001 | name: str\n1002 | # kwargs are the args that are left in the test builder after\n1003 | # removing configs. They are set from the test builder when\n1004 | # the test node is created.\n1005 | kwargs: Dict[str, Any] = field(default_factory=dict)\n1006 | namespace: Optional[str] = None\n1007 | \n1008 | \n1009 | # This has to be separated out because it has no default and so\n1010 | # has to be included as a superclass, not an attribute\n1011 | @dataclass\n1012 | class HasTestMetadata(dbtClassMixin):\n1013 | test_metadata: TestMetadata\n1014 | \n1015 | \n1016 | @dataclass\n1017 | class GenericTestNode(TestShouldStoreFailures, CompiledNode, HasTestMetadata):\n1018 | resource_type: Literal[NodeType.Test]\n1019 | column_name: Optional[str] = None\n1020 | file_key_name: Optional[str] = None\n1021 | # Was not able to make mypy happy and keep the code working. We need to\n1022 | # refactor the various configs.\n1023 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n1024 | attached_node: Optional[str] = None\n1025 | \n1026 | def same_contents(self, other, adapter_type: Optional[str]) -> bool:\n1027 | if other is None:\n1028 | return False\n1029 | \n1030 | return self.same_config(other) and self.same_fqn(other) and True\n1031 | \n1032 | @property\n1033 | def test_node_type(self):\n1034 | return \"generic\"\n1035 | \n1036 | \n1037 | @dataclass\n1038 | class UnitTestSourceDefinition(ModelNode):\n1039 | source_name: str = \"undefined\"\n1040 | quoting: Quoting = field(default_factory=Quoting)\n1041 | \n1042 | @property\n1043 | def search_name(self):\n1044 | return f\"{self.source_name}.{self.name}\"\n1045 | \n1046 | \n1047 | @dataclass\n1048 | class UnitTestNode(CompiledNode):\n1049 | resource_type: Literal[NodeType.Unit]\n1050 | tested_node_unique_id: Optional[str] = None\n1051 | this_input_node_unique_id: Optional[str] = None\n1052 | overrides: Optional[UnitTestOverrides] = None\n1053 | config: UnitTestNodeConfig = field(default_factory=UnitTestNodeConfig)\n1054 | \n1055 | \n1056 | @dataclass\n1057 | class UnitTestDefinitionMandatory:\n1058 | model: str\n1059 | given: Sequence[UnitTestInputFixture]\n1060 | expect: UnitTestOutputFixture\n1061 | \n1062 | \n1063 | @dataclass\n1064 | class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):\n1065 | description: str = \"\"\n1066 | overrides: Optional[UnitTestOverrides] = None\n1067 | depends_on: DependsOn = field(default_factory=DependsOn)\n1068 | config: UnitTestConfig = field(default_factory=UnitTestConfig)\n1069 | checksum: Optional[str] = None\n1070 | schema: Optional[str] = None\n1071 | created_at: float = field(default_factory=lambda: time.time())\n1072 | versions: Optional[UnitTestNodeVersions] = None\n1073 | version: Optional[NodeVersion] = None\n1074 | \n1075 | @property\n1076 | def build_path(self):\n1077 | # TODO: is this actually necessary?\n1078 | return self.original_file_path\n1079 | \n1080 | @property\n1081 | def compiled_path(self):\n1082 | # TODO: is this actually necessary?\n1083 | return self.original_file_path\n1084 | \n1085 | @property\n1086 | def depends_on_nodes(self):\n1087 | return self.depends_on.nodes\n1088 | \n1089 | @property\n1090 | def tags(self) -> List[str]:\n1091 | tags = self.config.tags\n1092 | return [tags] if isinstance(tags, str) else tags\n1093 | \n1094 | def build_unit_test_checksum(self):\n1095 | # everything except 'description'\n1096 | data = f\"{self.model}-{self.versions}-{self.given}-{self.expect}-{self.overrides}\"\n1097 | \n1098 | # include underlying fixture data\n1099 | for input in self.given:\n1100 | if input.fixture:\n1101 | data += f\"-{input.rows}\"\n1102 | \n1103 | self.checksum = hashlib.new(\"sha256\", data.encode(\"utf-8\")).hexdigest()\n1104 | \n1105 | def same_contents(self, other: Optional[\"UnitTestDefinition\"]) -> bool:\n1106 | if other is None:\n1107 | return False\n1108 | \n1109 | return self.checksum == other.checksum\n1110 | \n1111 | \n1112 | @dataclass\n1113 | class UnitTestFileFixture(BaseNode):\n1114 | resource_type: Literal[NodeType.Fixture]\n1115 | rows: Optional[List[Dict[str, Any]]] = None\n1116 | \n1117 | \n1118 | # ====================================\n1119 | # Snapshot node\n1120 | # ====================================\n1121 | \n1122 | \n1123 | @dataclass\n1124 | class IntermediateSnapshotNode(CompiledNode):\n1125 | # at an intermediate stage in parsing, where we've built something better\n1126 | # than an unparsed node for rendering in parse mode, it's pretty possible\n1127 | # that we won't have critical snapshot-related information that is only\n1128 | # defined in config blocks. To fix that, we have an intermediate type that\n1129 | # uses a regular node config, which the snapshot parser will then convert\n1130 | # into a full ParsedSnapshotNode after rendering. Note: it currently does\n1131 | # not work to set snapshot config in schema files because of the validation.\n1132 | resource_type: Literal[NodeType.Snapshot]\n1133 | config: EmptySnapshotConfig = field(default_factory=EmptySnapshotConfig)\n1134 | \n1135 | \n1136 | @dataclass\n1137 | class SnapshotNode(CompiledNode):\n1138 | resource_type: Literal[NodeType.Snapshot]\n1139 | config: SnapshotConfig\n1140 | defer_relation: Optional[DeferRelation] = None\n1141 | \n1142 | \n1143 | # ====================================\n1144 | # Macro\n1145 | # ====================================\n1146 | \n1147 | \n1148 | @dataclass\n1149 | class Macro(MacroResource, BaseNode):\n1150 | def same_contents(self, other: Optional[\"Macro\"]) -> bool:\n1151 | if other is None:\n1152 | return False\n1153 | # the only thing that makes one macro different from another with the\n1154 | # same name/package is its content\n1155 | return self.macro_sql == other.macro_sql\n1156 | \n1157 | @property\n1158 | def depends_on_macros(self):\n1159 | return self.depends_on.macros\n1160 | \n1161 | \n1162 | # ====================================\n1163 | # Documentation node\n1164 | # ====================================\n1165 | \n1166 | \n1167 | @dataclass\n1168 | class Documentation(DocumentationResource, BaseNode):\n1169 | @property\n1170 | def search_name(self):\n1171 | return self.name\n1172 | \n1173 | def same_contents(self, other: Optional[\"Documentation\"]) -> bool:\n1174 | if other is None:\n1175 | return False\n1176 | # the only thing that makes one doc different from another with the\n1177 | # same name/package is its content\n1178 | return self.block_contents == other.block_contents\n1179 | \n1180 | \n1181 | # ====================================\n1182 | # Source node\n1183 | # ====================================\n1184 | \n1185 | \n1186 | def normalize_test(testdef: TestDef) -> Dict[str, Any]:\n1187 | if isinstance(testdef, str):\n1188 | return {testdef: {}}\n1189 | else:\n1190 | return testdef\n1191 | \n1192 | \n1193 | @dataclass\n1194 | class UnpatchedSourceDefinition(BaseNode):\n1195 | source: UnparsedSourceDefinition\n1196 | table: UnparsedSourceTableDefinition\n1197 | fqn: List[str]\n1198 | resource_type: Literal[NodeType.Source]\n1199 | patch_path: Optional[str] = None\n1200 | \n1201 | def get_full_source_name(self):\n1202 | return f\"{self.source.name}_{self.table.name}\"\n1203 | \n1204 | def get_source_representation(self):\n1205 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1206 | \n1207 | def validate_data_tests(self):\n1208 | \"\"\"\n1209 | sources parse tests differently than models, so we need to do some validation\n1210 | here where it's done in the PatchParser for other nodes\n1211 | \"\"\"\n1212 | # source table-level tests\n1213 | if self.tests and self.data_tests:\n1214 | raise ValidationError(\n1215 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1216 | )\n1217 | if self.tests:\n1218 | deprecations.warn(\n1219 | \"project-test-config\",\n1220 | deprecated_path=\"tests\",\n1221 | exp_path=\"data_tests\",\n1222 | )\n1223 | self.data_tests.extend(self.tests)\n1224 | self.tests.clear()\n1225 | \n1226 | # column-level tests\n1227 | for column in self.columns:\n1228 | if column.tests and column.data_tests:\n1229 | raise ValidationError(\n1230 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1231 | )\n1232 | if column.tests:\n1233 | deprecations.warn(\n1234 | \"project-test-config\",\n1235 | deprecated_path=\"tests\",\n1236 | exp_path=\"data_tests\",\n1237 | )\n1238 | column.data_tests.extend(column.tests)\n1239 | column.tests.clear()\n1240 | \n1241 | @property\n1242 | def quote_columns(self) -> Optional[bool]:\n1243 | result = None\n1244 | if self.source.quoting.column is not None:\n1245 | result = self.source.quoting.column\n1246 | if self.table.quoting.column is not None:\n1247 | result = self.table.quoting.column\n1248 | return result\n1249 | \n1250 | @property\n1251 | def columns(self) -> Sequence[UnparsedColumn]:\n1252 | return [] if self.table.columns is None else self.table.columns\n1253 | \n1254 | def get_tests(self) -> Iterator[Tuple[Dict[str, Any], Optional[UnparsedColumn]]]:\n1255 | self.validate_data_tests()\n1256 | for data_test in self.data_tests:\n1257 | yield normalize_test(data_test), None\n1258 | \n1259 | for column in self.columns:\n1260 | if column.data_tests is not None:\n1261 | for data_test in column.data_tests:\n1262 | yield normalize_test(data_test), column\n1263 | \n1264 | @property\n1265 | def data_tests(self) -> List[TestDef]:\n1266 | if self.table.data_tests is None:\n1267 | return []\n1268 | else:\n1269 | return self.table.data_tests\n1270 | \n1271 | # deprecated\n1272 | @property\n1273 | def tests(self) -> List[TestDef]:\n1274 | if self.table.tests is None:\n1275 | return []\n1276 | else:\n1277 | return self.table.tests\n1278 | \n1279 | \n1280 | @dataclass\n1281 | class ParsedSourceMandatory(GraphNode, HasRelationMetadata):\n1282 | source_name: str\n1283 | source_description: str\n1284 | loader: str\n1285 | identifier: str\n1286 | resource_type: Literal[NodeType.Source]\n1287 | \n1288 | \n1289 | @dataclass\n1290 | class SourceDefinition(NodeInfoMixin, ParsedSourceMandatory):\n1291 | quoting: Quoting = field(default_factory=Quoting)\n1292 | loaded_at_field: Optional[str] = None\n1293 | freshness: Optional[FreshnessThreshold] = None\n1294 | external: Optional[ExternalTable] = None\n1295 | description: str = \"\"\n1296 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n1297 | meta: Dict[str, Any] = field(default_factory=dict)\n1298 | source_meta: Dict[str, Any] = field(default_factory=dict)\n1299 | tags: List[str] = field(default_factory=list)\n1300 | config: SourceConfig = field(default_factory=SourceConfig)\n1301 | patch_path: Optional[str] = None\n1302 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1303 | relation_name: Optional[str] = None\n1304 | created_at: float = field(default_factory=lambda: time.time())\n1305 | \n1306 | def __post_serialize__(self, dct):\n1307 | if \"_event_status\" in dct:\n1308 | del dct[\"_event_status\"]\n1309 | return dct\n1310 | \n1311 | def same_database_representation(self, other: \"SourceDefinition\") -> bool:\n1312 | return (\n1313 | self.database == other.database\n1314 | and self.schema == other.schema\n1315 | and self.identifier == other.identifier\n1316 | and True\n1317 | )\n1318 | \n1319 | def same_quoting(self, other: \"SourceDefinition\") -> bool:\n1320 | return self.quoting == other.quoting\n1321 | \n1322 | def same_freshness(self, other: \"SourceDefinition\") -> bool:\n1323 | return (\n1324 | self.freshness == other.freshness\n1325 | and self.loaded_at_field == other.loaded_at_field\n1326 | and True\n1327 | )\n1328 | \n1329 | def same_external(self, other: \"SourceDefinition\") -> bool:\n1330 | return self.external == other.external\n1331 | \n1332 | def same_config(self, old: \"SourceDefinition\") -> bool:\n1333 | return self.config.same_contents(\n1334 | self.unrendered_config,\n1335 | old.unrendered_config,\n1336 | )\n1337 | \n1338 | def same_contents(self, old: Optional[\"SourceDefinition\"]) -> bool:\n1339 | # existing when it didn't before is a change!\n1340 | if old is None:\n1341 | return True\n1342 | \n1343 | # config changes are changes (because the only config is \"enforced\", and\n1344 | # enabling a source is a change!)\n1345 | # changing the database/schema/identifier is a change\n1346 | # messing around with external stuff is a change (uh, right?)\n1347 | # quoting changes are changes\n1348 | # freshness changes are changes, I guess\n1349 | # metadata/tags changes are not \"changes\"\n1350 | # patching/description changes are not \"changes\"\n1351 | return (\n1352 | self.same_database_representation(old)\n1353 | and self.same_fqn(old)\n1354 | and self.same_config(old)\n1355 | and self.same_quoting(old)\n1356 | and self.same_freshness(old)\n1357 | and self.same_external(old)\n1358 | and True\n1359 | )\n1360 | \n1361 | def get_full_source_name(self):\n1362 | return f\"{self.source_name}_{self.name}\"\n1363 | \n1364 | def get_source_representation(self):\n1365 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1366 | \n1367 | @property\n1368 | def is_refable(self):\n1369 | return False\n1370 | \n1371 | @property\n1372 | def is_ephemeral(self):\n1373 | return False\n1374 | \n1375 | @property\n1376 | def is_ephemeral_model(self):\n1377 | return False\n1378 | \n1379 | @property\n1380 | def depends_on_nodes(self):\n1381 | return []\n1382 | \n1383 | @property\n1384 | def depends_on(self):\n1385 | return DependsOn(macros=[], nodes=[])\n1386 | \n1387 | @property\n1388 | def refs(self):\n1389 | return []\n1390 | \n1391 | @property\n1392 | def sources(self):\n1393 | return []\n1394 | \n1395 | @property\n1396 | def has_freshness(self) -> bool:\n1397 | return bool(self.freshness)\n1398 | \n1399 | @property\n1400 | def search_name(self):\n1401 | return f\"{self.source_name}.{self.name}\"\n1402 | \n1403 | @property\n1404 | def group(self):\n1405 | return None\n1406 | \n1407 | \n1408 | # ====================================\n1409 | # Exposure node\n1410 | # ====================================\n1411 | \n1412 | \n1413 | @dataclass\n1414 | class Exposure(GraphNode):\n1415 | type: ExposureType\n1416 | owner: Owner\n1417 | resource_type: Literal[NodeType.Exposure]\n1418 | description: str = \"\"\n1419 | label: Optional[str] = None\n1420 | maturity: Optional[MaturityType] = None\n1421 | meta: Dict[str, Any] = field(default_factory=dict)\n1422 | tags: List[str] = field(default_factory=list)\n1423 | config: ExposureConfig = field(default_factory=ExposureConfig)\n1424 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1425 | url: Optional[str] = None\n1426 | depends_on: DependsOn = field(default_factory=DependsOn)\n1427 | refs: List[RefArgs] = field(default_factory=list)\n1428 | sources: List[List[str]] = field(default_factory=list)\n1429 | metrics: List[List[str]] = field(default_factory=list)\n1430 | created_at: float = field(default_factory=lambda: time.time())\n1431 | \n1432 | @property\n1433 | def depends_on_nodes(self):\n1434 | return self.depends_on.nodes\n1435 | \n1436 | @property\n1437 | def search_name(self):\n1438 | return self.name\n1439 | \n1440 | def same_depends_on(self, old: \"Exposure\") -> bool:\n1441 | return set(self.depends_on.nodes) == set(old.depends_on.nodes)\n1442 | \n1443 | def same_description(self, old: \"Exposure\") -> bool:\n1444 | return self.description == old.description\n1445 | \n1446 | def same_label(self, old: \"Exposure\") -> bool:\n1447 | return self.label == old.label\n1448 | \n1449 | def same_maturity(self, old: \"Exposure\") -> bool:\n1450 | return self.maturity == old.maturity\n1451 | \n1452 | def same_owner(self, old: \"Exposure\") -> bool:\n1453 | return self.owner == old.owner\n1454 | \n1455 | def same_exposure_type(self, old: \"Exposure\") -> bool:\n1456 | return self.type == old.type\n1457 | \n1458 | def same_url(self, old: \"Exposure\") -> bool:\n1459 | return self.url == old.url\n1460 | \n1461 | def same_config(self, old: \"Exposure\") -> bool:\n1462 | return self.config.same_contents(\n1463 | self.unrendered_config,\n1464 | old.unrendered_config,\n1465 | )\n1466 | \n1467 | def same_contents(self, old: Optional[\"Exposure\"]) -> bool:\n1468 | # existing when it didn't before is a change!\n1469 | # metadata/tags changes are not \"changes\"\n1470 | if old is None:\n1471 | return True\n1472 | \n1473 | return (\n1474 | self.same_fqn(old)\n1475 | and self.same_exposure_type(old)\n1476 | and self.same_owner(old)\n1477 | and self.same_maturity(old)\n1478 | and self.same_url(old)\n1479 | and self.same_description(old)\n1480 | and self.same_label(old)\n1481 | and self.same_depends_on(old)\n1482 | and self.same_config(old)\n1483 | and True\n1484 | )\n1485 | \n1486 | @property\n1487 | def group(self):\n1488 | return None\n1489 | \n1490 | \n1491 | # ====================================\n1492 | # Metric node\n1493 | # ====================================\n1494 | \n1495 | \n1496 | @dataclass\n1497 | class MetricInputMeasure(dbtClassMixin):\n1498 | name: str\n1499 | filter: Optional[WhereFilterIntersection] = None\n1500 | alias: Optional[str] = None\n1501 | join_to_timespine: bool = False\n1502 | fill_nulls_with: Optional[int] = None\n1503 | \n1504 | def measure_reference(self) -> MeasureReference:\n1505 | return MeasureReference(element_name=self.name)\n1506 | \n1507 | def post_aggregation_measure_reference(self) -> MeasureReference:\n1508 | return MeasureReference(element_name=self.alias or self.name)\n1509 | \n1510 | \n1511 | @dataclass\n1512 | class MetricTimeWindow(dbtClassMixin):\n1513 | count: int\n1514 | granularity: TimeGranularity\n1515 | \n1516 | \n1517 | @dataclass\n1518 | class MetricInput(dbtClassMixin):\n1519 | name: str\n1520 | filter: Optional[WhereFilterIntersection] = None\n1521 | alias: Optional[str] = None\n1522 | offset_window: Optional[MetricTimeWindow] = None\n1523 | offset_to_grain: Optional[TimeGranularity] = None\n1524 | \n1525 | def as_reference(self) -> DSIMetricReference:\n1526 | return DSIMetricReference(element_name=self.name)\n1527 | \n1528 | def post_aggregation_reference(self) -> DSIMetricReference:\n1529 | return DSIMetricReference(element_name=self.alias or self.name)\n1530 | \n1531 | \n1532 | @dataclass\n1533 | class ConversionTypeParams(dbtClassMixin):\n1534 | base_measure: MetricInputMeasure\n1535 | conversion_measure: MetricInputMeasure\n1536 | entity: str\n1537 | calculation: ConversionCalculationType = ConversionCalculationType.CONVERSION_RATE\n1538 | window: Optional[MetricTimeWindow] = None\n1539 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n1540 | \n1541 | \n1542 | @dataclass\n1543 | class MetricTypeParams(dbtClassMixin):\n1544 | measure: Optional[MetricInputMeasure] = None\n1545 | input_measures: List[MetricInputMeasure] = field(default_factory=list)\n1546 | numerator: Optional[MetricInput] = None\n1547 | denominator: Optional[MetricInput] = None\n1548 | expr: Optional[str] = None\n1549 | window: Optional[MetricTimeWindow] = None\n1550 | grain_to_date: Optional[TimeGranularity] = None\n1551 | metrics: Optional[List[MetricInput]] = None\n1552 | conversion_type_params: Optional[ConversionTypeParams] = None\n1553 | \n1554 | \n1555 | @dataclass\n1556 | class MetricReference(dbtClassMixin, Replaceable):\n1557 | sql: Optional[Union[str, int]] = None\n1558 | unique_id: Optional[str] = None\n1559 | \n1560 | \n1561 | @dataclass\n1562 | class Metric(GraphNode):\n1563 | name: str\n1564 | description: str\n1565 | label: str\n1566 | type: MetricType\n1567 | type_params: MetricTypeParams\n1568 | filter: Optional[WhereFilterIntersection] = None\n1569 | metadata: Optional[SourceFileMetadata] = None\n1570 | resource_type: Literal[NodeType.Metric]\n1571 | meta: Dict[str, Any] = field(default_factory=dict)\n1572 | tags: List[str] = field(default_factory=list)\n1573 | config: MetricConfig = field(default_factory=MetricConfig)\n1574 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1575 | sources: List[List[str]] = field(default_factory=list)\n1576 | depends_on: DependsOn = field(default_factory=DependsOn)\n1577 | refs: List[RefArgs] = field(default_factory=list)\n1578 | metrics: List[List[str]] = field(default_factory=list)\n1579 | created_at: float = field(default_factory=lambda: time.time())\n1580 | group: Optional[str] = None\n1581 | \n1582 | @property\n1583 | def depends_on_nodes(self):\n1584 | return self.depends_on.nodes\n1585 | \n1586 | @property\n1587 | def search_name(self):\n1588 | return self.name\n1589 | \n1590 | @property\n1591 | def input_measures(self) -> List[MetricInputMeasure]:\n1592 | return self.type_params.input_measures\n1593 | \n1594 | @property\n1595 | def measure_references(self) -> List[MeasureReference]:\n1596 | return [x.measure_reference() for x in self.input_measures]\n1597 | \n1598 | @property\n1599 | def input_metrics(self) -> List[MetricInput]:\n1600 | return self.type_params.metrics or []\n1601 | \n1602 | def same_description(self, old: \"Metric\") -> bool:\n1603 | return self.description == old.description\n1604 | \n1605 | def same_label(self, old: \"Metric\") -> bool:\n1606 | return self.label == old.label\n1607 | \n1608 | def same_config(self, old: \"Metric\") -> bool:\n1609 | return self.config.same_contents(\n1610 | self.unrendered_config,\n1611 | old.unrendered_config,\n1612 | )\n1613 | \n1614 | def same_filter(self, old: \"Metric\") -> bool:\n1615 | return True # TODO\n1616 | \n1617 | def same_metadata(self, old: \"Metric\") -> bool:\n1618 | return True # TODO\n1619 | \n1620 | def same_type(self, old: \"Metric\") -> bool:\n1621 | return self.type == old.type\n1622 | \n1623 | def same_type_params(self, old: \"Metric\") -> bool:\n1624 | return True # TODO\n1625 | \n1626 | def same_contents(self, old: Optional[\"Metric\"]) -> bool:\n1627 | # existing when it didn't before is a change!\n1628 | # metadata/tags changes are not \"changes\"\n1629 | if old is None:\n1630 | return True\n1631 | \n1632 | return (\n1633 | self.same_filter(old)\n1634 | and self.same_metadata(old)\n1635 | and self.same_type(old)\n1636 | and self.same_type_params(old)\n1637 | and self.same_description(old)\n1638 | and self.same_label(old)\n1639 | and self.same_config(old)\n1640 | and True\n1641 | )\n1642 | \n1643 | \n1644 | # ====================================\n1645 | # Group node\n1646 | # ====================================\n1647 | \n1648 | \n1649 | @dataclass\n1650 | class Group(GroupResource, BaseNode):\n1651 | pass\n1652 | \n1653 | \n1654 | # ====================================\n1655 | # SemanticModel and related classes\n1656 | # ====================================\n1657 | \n1658 | \n1659 | @dataclass\n1660 | class NodeRelation(dbtClassMixin):\n1661 | alias: str\n1662 | schema_name: str # TODO: Could this be called simply \"schema\" so we could reuse StateRelation?\n1663 | database: Optional[str] = None\n1664 | relation_name: Optional[str] = None\n1665 | \n1666 | \n1667 | @dataclass\n1668 | class SemanticModel(GraphNode):\n1669 | model: str\n1670 | node_relation: Optional[NodeRelation]\n1671 | description: Optional[str] = None\n1672 | label: Optional[str] = None\n1673 | defaults: Optional[Defaults] = None\n1674 | entities: Sequence[Entity] = field(default_factory=list)\n1675 | measures: Sequence[Measure] = field(default_factory=list)\n1676 | dimensions: Sequence[Dimension] = field(default_factory=list)\n1677 | metadata: Optional[SourceFileMetadata] = None\n1678 | depends_on: DependsOn = field(default_factory=DependsOn)\n1679 | refs: List[RefArgs] = field(default_factory=list)\n1680 | created_at: float = field(default_factory=lambda: time.time())\n1681 | config: SemanticModelConfig = field(default_factory=SemanticModelConfig)\n1682 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1683 | primary_entity: Optional[str] = None\n1684 | group: Optional[str] = None\n1685 | \n1686 | @property\n1687 | def entity_references(self) -> List[LinkableElementReference]:\n1688 | return [entity.reference for entity in self.entities]\n1689 | \n1690 | @property\n1691 | def dimension_references(self) -> List[LinkableElementReference]:\n1692 | return [dimension.reference for dimension in self.dimensions]\n1693 | \n1694 | @property\n1695 | def measure_references(self) -> List[MeasureReference]:\n1696 | return [measure.reference for measure in self.measures]\n1697 | \n1698 | @property\n1699 | def has_validity_dimensions(self) -> bool:\n1700 | return any([dim.validity_params is not None for dim in self.dimensions])\n1701 | \n1702 | @property\n1703 | def validity_start_dimension(self) -> Optional[Dimension]:\n1704 | validity_start_dims = [\n1705 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_start\n1706 | ]\n1707 | if not validity_start_dims:\n1708 | return None\n1709 | return validity_start_dims[0]\n1710 | \n1711 | @property\n1712 | def validity_end_dimension(self) -> Optional[Dimension]:\n1713 | validity_end_dims = [\n1714 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_end\n1715 | ]\n1716 | if not validity_end_dims:\n1717 | return None\n1718 | return validity_end_dims[0]\n1719 | \n1720 | @property\n1721 | def partitions(self) -> List[Dimension]: # noqa: D\n1722 | return [dim for dim in self.dimensions or [] if dim.is_partition]\n1723 | \n1724 | @property\n1725 | def partition(self) -> Optional[Dimension]:\n1726 | partitions = self.partitions\n1727 | if not partitions:\n1728 | return None\n1729 | return partitions[0]\n1730 | \n1731 | @property\n1732 | def reference(self) -> SemanticModelReference:\n1733 | return SemanticModelReference(semantic_model_name=self.name)\n1734 | \n1735 | @property\n1736 | def depends_on_nodes(self):\n1737 | return self.depends_on.nodes\n1738 | \n1739 | @property\n1740 | def depends_on_macros(self):\n1741 | return self.depends_on.macros\n1742 | \n1743 | def checked_agg_time_dimension_for_measure(\n1744 | self, measure_reference: MeasureReference\n1745 | ) -> TimeDimensionReference:\n1746 | measure: Optional[Measure] = None\n1747 | for measure in self.measures:\n1748 | if measure.reference == measure_reference:\n1749 | measure = measure\n1750 | \n1751 | assert (\n1752 | measure is not None\n1753 | ), f\"No measure with name ({measure_reference.element_name}) in semantic_model with name ({self.name})\"\n1754 | \n1755 | default_agg_time_dimension = (\n1756 | self.defaults.agg_time_dimension if self.defaults is not None else None\n1757 | )\n1758 | \n1759 | agg_time_dimension_name = measure.agg_time_dimension or default_agg_time_dimension\n1760 | assert agg_time_dimension_name is not None, (\n1761 | f\"Aggregation time dimension for measure {measure.name} on semantic model {self.name} is not set! \"\n1762 | \"To fix this either specify a default `agg_time_dimension` for the semantic model or define an \"\n1763 | \"`agg_time_dimension` on the measure directly.\"\n1764 | )\n1765 | return TimeDimensionReference(element_name=agg_time_dimension_name)\n1766 | \n1767 | @property\n1768 | def primary_entity_reference(self) -> Optional[EntityReference]:\n1769 | return (\n1770 | EntityReference(element_name=self.primary_entity)\n1771 | if self.primary_entity is not None\n1772 | else None\n1773 | )\n1774 | \n1775 | def same_model(self, old: \"SemanticModel\") -> bool:\n1776 | return self.model == old.same_model\n1777 | \n1778 | def same_node_relation(self, old: \"SemanticModel\") -> bool:\n1779 | return self.node_relation == old.node_relation\n1780 | \n1781 | def same_description(self, old: \"SemanticModel\") -> bool:\n1782 | return self.description == old.description\n1783 | \n1784 | def same_defaults(self, old: \"SemanticModel\") -> bool:\n1785 | return self.defaults == old.defaults\n1786 | \n1787 | def same_entities(self, old: \"SemanticModel\") -> bool:\n1788 | return self.entities == old.entities\n1789 | \n1790 | def same_dimensions(self, old: \"SemanticModel\") -> bool:\n1791 | return self.dimensions == old.dimensions\n1792 | \n1793 | def same_measures(self, old: \"SemanticModel\") -> bool:\n1794 | return self.measures == old.measures\n1795 | \n1796 | def same_config(self, old: \"SemanticModel\") -> bool:\n1797 | return self.config == old.config\n1798 | \n1799 | def same_primary_entity(self, old: \"SemanticModel\") -> bool:\n1800 | return self.primary_entity == old.primary_entity\n1801 | \n1802 | def same_group(self, old: \"SemanticModel\") -> bool:\n1803 | return self.group == old.group\n1804 | \n1805 | def same_contents(self, old: Optional[\"SemanticModel\"]) -> bool:\n1806 | # existing when it didn't before is a change!\n1807 | # metadata/tags changes are not \"changes\"\n1808 | if old is None:\n1809 | return True\n1810 | \n1811 | return (\n1812 | self.same_model(old)\n1813 | and self.same_node_relation(old)\n1814 | and self.same_description(old)\n1815 | and self.same_defaults(old)\n1816 | and self.same_entities(old)\n1817 | and self.same_dimensions(old)\n1818 | and self.same_measures(old)\n1819 | and self.same_config(old)\n1820 | and self.same_primary_entity(old)\n1821 | and self.same_group(old)\n1822 | and True\n1823 | )\n1824 | \n1825 | \n1826 | # ====================================\n1827 | # SavedQuery and related classes\n1828 | # ====================================\n1829 | \n1830 | \n1831 | @dataclass\n1832 | class SavedQueryMandatory(GraphNode):\n1833 | query_params: QueryParams\n1834 | exports: List[Export]\n1835 | \n1836 | \n1837 | @dataclass\n1838 | class SavedQuery(NodeInfoMixin, SavedQueryMandatory):\n1839 | description: Optional[str] = None\n1840 | label: Optional[str] = None\n1841 | metadata: Optional[SourceFileMetadata] = None\n1842 | config: SavedQueryConfig = field(default_factory=SavedQueryConfig)\n1843 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1844 | group: Optional[str] = None\n1845 | depends_on: DependsOn = field(default_factory=DependsOn)\n1846 | created_at: float = field(default_factory=lambda: time.time())\n1847 | refs: List[RefArgs] = field(default_factory=list)\n1848 | \n1849 | @property\n1850 | def metrics(self) -> List[str]:\n1851 | return self.query_params.metrics\n1852 | \n1853 | @property\n1854 | def depends_on_nodes(self):\n1855 | return self.depends_on.nodes\n1856 | \n1857 | def same_metrics(self, old: \"SavedQuery\") -> bool:\n1858 | return self.query_params.metrics == old.query_params.metrics\n1859 | \n1860 | def same_group_by(self, old: \"SavedQuery\") -> bool:\n1861 | return self.query_params.group_by == old.query_params.group_by\n1862 | \n1863 | def same_description(self, old: \"SavedQuery\") -> bool:\n1864 | return self.description == old.description\n1865 | \n1866 | def same_where(self, old: \"SavedQuery\") -> bool:\n1867 | return self.query_params.where == old.query_params.where\n1868 | \n1869 | def same_label(self, old: \"SavedQuery\") -> bool:\n1870 | return self.label == old.label\n1871 | \n1872 | def same_config(self, old: \"SavedQuery\") -> bool:\n1873 | return self.config == old.config\n1874 | \n1875 | def same_group(self, old: \"SavedQuery\") -> bool:\n1876 | return self.group == old.group\n1877 | \n1878 | def same_exports(self, old: \"SavedQuery\") -> bool:\n1879 | if len(self.exports) != len(old.exports):\n1880 | return False\n1881 | \n1882 | # exports should be in the same order, so we zip them for easy iteration\n1883 | for (old_export, new_export) in zip(old.exports, self.exports):\n1884 | if not new_export.same_contents(old_export):\n1885 | return False\n1886 | \n1887 | return True\n1888 | \n1889 | def same_contents(self, old: Optional[\"SavedQuery\"]) -> bool:\n1890 | # existing when it didn't before is a change!\n1891 | # metadata/tags changes are not \"changes\"\n1892 | if old is None:\n1893 | return True\n1894 | \n1895 | return (\n1896 | self.same_metrics(old)\n1897 | and self.same_group_by(old)\n1898 | and self.same_description(old)\n1899 | and self.same_where(old)\n1900 | and self.same_label(old)\n1901 | and self.same_config(old)\n1902 | and self.same_group(old)\n1903 | and True\n1904 | )\n1905 | \n1906 | \n1907 | # ====================================\n1908 | # Patches\n1909 | # ====================================\n1910 | \n1911 | \n1912 | @dataclass\n1913 | class ParsedPatch(HasYamlMetadata, Replaceable):\n1914 | name: str\n1915 | description: str\n1916 | meta: Dict[str, Any]\n1917 | docs: Docs\n1918 | config: Dict[str, Any]\n1919 | \n1920 | \n1921 | # The parsed node update is only the 'patch', not the test. The test became a\n1922 | # regular parsed node. Note that description and columns must be present, but\n1923 | # may be empty.\n1924 | @dataclass\n1925 | class ParsedNodePatch(ParsedPatch):\n1926 | columns: Dict[str, ColumnInfo]\n1927 | access: Optional[str]\n1928 | version: Optional[NodeVersion]\n1929 | latest_version: Optional[NodeVersion]\n1930 | constraints: List[Dict[str, Any]]\n1931 | deprecation_date: Optional[datetime]\n1932 | \n1933 | \n1934 | @dataclass\n1935 | class ParsedMacroPatch(ParsedPatch):\n1936 | arguments: List[MacroArgument] = field(default_factory=list)\n1937 | \n1938 | \n1939 | # ====================================\n1940 | # Node unions/categories\n1941 | # ====================================\n1942 | \n1943 | \n1944 | # ManifestNode without SeedNode, which doesn't have the\n1945 | # SQL related attributes\n1946 | ManifestSQLNode = Union[\n1947 | AnalysisNode,\n1948 | SingularTestNode,\n1949 | HookNode,\n1950 | ModelNode,\n1951 | RPCNode,\n1952 | SqlNode,\n1953 | GenericTestNode,\n1954 | SnapshotNode,\n1955 | UnitTestNode,\n1956 | ]\n1957 | \n1958 | # All SQL nodes plus SeedNode (csv files)\n1959 | ManifestNode = Union[\n1960 | ManifestSQLNode,\n1961 | SeedNode,\n1962 | ]\n1963 | \n1964 | ResultNode = Union[\n1965 | ManifestNode,\n1966 | SourceDefinition,\n1967 | ]\n1968 | \n1969 | # All nodes that can be in the DAG\n1970 | GraphMemberNode = Union[\n1971 | ResultNode,\n1972 | Exposure,\n1973 | Metric,\n1974 | SavedQuery,\n1975 | SemanticModel,\n1976 | UnitTestDefinition,\n1977 | ]\n1978 | \n1979 | # All \"nodes\" (or node-like objects) in this file\n1980 | Resource = Union[\n1981 | GraphMemberNode,\n1982 | Documentation,\n1983 | Macro,\n1984 | Group,\n1985 | ]\n1986 | \n1987 | TestNode = Union[SingularTestNode, GenericTestNode]\n```\n\n### File: core/dbt/task/list.py\n\n```python\n 1 | import json\n 2 | \n 3 | from dbt.contracts.graph.nodes import Exposure, SourceDefinition, Metric, SemanticModel\n 4 | from dbt.flags import get_flags\n 5 | from dbt.graph import ResourceTypeSelector\n 6 | from dbt.task.runnable import GraphRunnableTask\n 7 | from dbt.task.test import TestSelector\n 8 | from dbt.node_types import NodeType\n 9 | from dbt_common.events.functions import (\n 10 | fire_event,\n 11 | warn_or_error,\n 12 | )\n 13 | from dbt.events.types import NoNodesSelected, ListCmdOut\n 14 | from dbt_common.exceptions import DbtRuntimeError, DbtInternalError\n 15 | from dbt_common.events.contextvars import task_contextvars\n 16 | \n 17 | \n 18 | class ListTask(GraphRunnableTask):\n 19 | DEFAULT_RESOURCE_VALUES = frozenset(\n 20 | (\n 21 | NodeType.Model,\n 22 | NodeType.Snapshot,\n 23 | NodeType.Seed,\n 24 | NodeType.Test,\n 25 | NodeType.Source,\n 26 | NodeType.Exposure,\n 27 | NodeType.Metric,\n 28 | NodeType.SemanticModel,\n 29 | )\n 30 | )\n 31 | ALL_RESOURCE_VALUES = DEFAULT_RESOURCE_VALUES | frozenset((NodeType.Analysis,))\n 32 | ALLOWED_KEYS = frozenset(\n 33 | (\n 34 | \"alias\",\n 35 | \"name\",\n 36 | \"package_name\",\n 37 | \"depends_on\",\n 38 | \"tags\",\n 39 | \"config\",\n 40 | \"resource_type\",\n 41 | \"source_name\",\n 42 | \"original_file_path\",\n 43 | \"unique_id\",\n 44 | )\n 45 | )\n 46 | \n 47 | def __init__(self, args, config, manifest) -> None:\n 48 | super().__init__(args, config, manifest)\n 49 | if self.args.models:\n 50 | if self.args.select:\n 51 | raise DbtRuntimeError('\"models\" and \"select\" are mutually exclusive arguments')\n 52 | if self.args.resource_types:\n 53 | raise DbtRuntimeError(\n 54 | '\"models\" and \"resource_type\" are mutually exclusive ' \"arguments\"\n 55 | )\n 56 | \n 57 | def _iterate_selected_nodes(self):\n 58 | selector = self.get_node_selector()\n 59 | spec = self.get_selection_spec()\n 60 | nodes = sorted(selector.get_selected(spec))\n 61 | if not nodes:\n 62 | warn_or_error(NoNodesSelected())\n 63 | return\n 64 | if self.manifest is None:\n 65 | raise DbtInternalError(\"manifest is None in _iterate_selected_nodes\")\n 66 | for node in nodes:\n 67 | if node in self.manifest.nodes:\n 68 | yield self.manifest.nodes[node]\n 69 | elif node in self.manifest.sources:\n 70 | yield self.manifest.sources[node]\n 71 | elif node in self.manifest.exposures:\n 72 | yield self.manifest.exposures[node]\n 73 | elif node in self.manifest.metrics:\n 74 | yield self.manifest.metrics[node]\n 75 | elif node in self.manifest.semantic_models:\n 76 | yield self.manifest.semantic_models[node]\n 77 | else:\n 78 | raise DbtRuntimeError(\n 79 | f'Got an unexpected result from node selection: \"{node}\"'\n 80 | f\"Expected a source or a node!\"\n 81 | )\n 82 | \n 83 | def generate_selectors(self):\n 84 | for node in self._iterate_selected_nodes():\n 85 | if node.resource_type == NodeType.Source:\n 86 | assert isinstance(node, SourceDefinition)\n 87 | # sources are searched for by pkg.source_name.table_name\n 88 | source_selector = \".\".join([node.package_name, node.source_name, node.name])\n 89 | yield f\"source:{source_selector}\"\n 90 | elif node.resource_type == NodeType.Exposure:\n 91 | assert isinstance(node, Exposure)\n 92 | # exposures are searched for by pkg.exposure_name\n 93 | exposure_selector = \".\".join([node.package_name, node.name])\n 94 | yield f\"exposure:{exposure_selector}\"\n 95 | elif node.resource_type == NodeType.Metric:\n 96 | assert isinstance(node, Metric)\n 97 | # metrics are searched for by pkg.metric_name\n 98 | metric_selector = \".\".join([node.package_name, node.name])\n 99 | yield f\"metric:{metric_selector}\"\n100 | elif node.resource_type == NodeType.SemanticModel:\n101 | assert isinstance(node, SemanticModel)\n102 | semantic_model_selector = \".\".join([node.package_name, node.name])\n103 | yield f\"semantic_model:{semantic_model_selector}\"\n104 | else:\n105 | # everything else is from `fqn`\n106 | yield \".\".join(node.fqn)\n107 | \n108 | def generate_names(self):\n109 | for node in self._iterate_selected_nodes():\n110 | yield node.search_name\n111 | \n112 | def generate_json(self):\n113 | for node in self._iterate_selected_nodes():\n114 | yield json.dumps(\n115 | {\n116 | k: v\n117 | for k, v in node.to_dict(omit_none=False).items()\n118 | if (\n119 | k in self.args.output_keys\n120 | if self.args.output_keys\n121 | else k in self.ALLOWED_KEYS\n122 | )\n123 | }\n124 | )\n125 | \n126 | def generate_paths(self):\n127 | for node in self._iterate_selected_nodes():\n128 | yield node.original_file_path\n129 | \n130 | def run(self):\n131 | # We set up a context manager here with \"task_contextvars\" because we\n132 | # we need the project_root in compile_manifest.\n133 | with task_contextvars(project_root=self.config.project_root):\n134 | self.compile_manifest()\n135 | output = self.args.output\n136 | if output == \"selector\":\n137 | generator = self.generate_selectors\n138 | elif output == \"name\":\n139 | generator = self.generate_names\n140 | elif output == \"json\":\n141 | generator = self.generate_json\n142 | elif output == \"path\":\n143 | generator = self.generate_paths\n144 | else:\n145 | raise DbtInternalError(\"Invalid output {}\".format(output))\n146 | \n147 | return self.output_results(generator())\n148 | \n149 | def output_results(self, results):\n150 | \"\"\"Log, or output a plain, newline-delimited, and ready-to-pipe list of nodes found.\"\"\"\n151 | for result in results:\n152 | self.node_results.append(result)\n153 | if get_flags().LOG_FORMAT == \"json\":\n154 | fire_event(ListCmdOut(msg=result))\n155 | else:\n156 | # Cleaner to leave as print than to mutate the logger not to print timestamps.\n157 | print(result)\n158 | return self.node_results\n159 | \n160 | @property\n161 | def resource_types(self):\n162 | if self.args.models:\n163 | return [NodeType.Model]\n164 | \n165 | if not self.args.resource_types:\n166 | return list(self.DEFAULT_RESOURCE_VALUES)\n167 | \n168 | values = set(self.args.resource_types)\n169 | if \"default\" in values:\n170 | values.remove(\"default\")\n171 | values.update(self.DEFAULT_RESOURCE_VALUES)\n172 | if \"all\" in values:\n173 | values.remove(\"all\")\n174 | values.update(self.ALL_RESOURCE_VALUES)\n175 | return list(values)\n176 | \n177 | @property\n178 | def selection_arg(self):\n179 | # for backwards compatibility, list accepts both --models and --select,\n180 | # with slightly different behavior: --models implies --resource-type model\n181 | if self.args.models:\n182 | return self.args.models\n183 | else:\n184 | return self.args.select\n185 | \n186 | def get_node_selector(self):\n187 | if self.manifest is None or self.graph is None:\n188 | raise DbtInternalError(\"manifest and graph must be set to get perform node selection\")\n189 | if self.resource_types == [NodeType.Test]:\n190 | return TestSelector(\n191 | graph=self.graph,\n192 | manifest=self.manifest,\n193 | previous_state=self.previous_state,\n194 | )\n195 | else:\n196 | return ResourceTypeSelector(\n197 | graph=self.graph,\n198 | manifest=self.manifest,\n199 | previous_state=self.previous_state,\n200 | resource_types=self.resource_types,\n201 | include_empty_nodes=True,\n202 | )\n203 | \n204 | def interpret_results(self, results):\n205 | # list command should always return 0 as exit code\n206 | return True\n```\n\n## Files after the fix\n\n### File: core/dbt/contracts/graph/nodes.py\n\n```python\n 1 | import os\n 2 | from datetime import datetime\n 3 | import time\n 4 | from dataclasses import dataclass, field\n 5 | import hashlib\n 6 | \n 7 | from mashumaro.types import SerializableType\n 8 | from typing import Optional, Union, List, Dict, Any, Sequence, Tuple, Iterator, Literal\n 9 | \n 10 | from dbt import deprecations\n 11 | from dbt_common.contracts.constraints import (\n 12 | ColumnLevelConstraint,\n 13 | ConstraintType,\n 14 | ModelLevelConstraint,\n 15 | )\n 16 | from dbt_common.dataclass_schema import dbtClassMixin, ExtensibleDbtClassMixin\n 17 | \n 18 | from dbt_common.clients.system import write_file\n 19 | from dbt.contracts.files import FileHash\n 20 | from dbt.contracts.graph.saved_queries import Export, QueryParams\n 21 | from dbt.contracts.graph.semantic_models import (\n 22 | Defaults,\n 23 | Dimension,\n 24 | Entity,\n 25 | Measure,\n 26 | SourceFileMetadata,\n 27 | )\n 28 | from dbt.contracts.graph.unparsed import (\n 29 | ConstantPropertyInput,\n 30 | ExposureType,\n 31 | ExternalTable,\n 32 | FreshnessThreshold,\n 33 | HasYamlMetadata,\n 34 | MaturityType,\n 35 | Owner,\n 36 | Quoting,\n 37 | TestDef,\n 38 | NodeVersion,\n 39 | UnparsedSourceDefinition,\n 40 | UnparsedSourceTableDefinition,\n 41 | UnparsedColumn,\n 42 | UnitTestOverrides,\n 43 | UnitTestInputFixture,\n 44 | UnitTestOutputFixture,\n 45 | UnitTestNodeVersions,\n 46 | )\n 47 | from dbt.contracts.graph.node_args import ModelNodeArgs\n 48 | from dbt.contracts.graph.semantic_layer_common import WhereFilterIntersection\n 49 | from dbt.contracts.util import Replaceable\n 50 | from dbt_common.contracts.config.properties import AdditionalPropertiesMixin\n 51 | from dbt_common.events.functions import warn_or_error\n 52 | from dbt.exceptions import ParsingError, ContractBreakingChangeError, ValidationError\n 53 | from dbt.events.types import (\n 54 | SeedIncreased,\n 55 | SeedExceedsLimitSamePath,\n 56 | SeedExceedsLimitAndPathChanged,\n 57 | SeedExceedsLimitChecksumChanged,\n 58 | UnversionedBreakingChange,\n 59 | )\n 60 | from dbt_common.events.contextvars import set_log_contextvars\n 61 | from dbt.flags import get_flags\n 62 | from dbt.node_types import (\n 63 | NodeType,\n 64 | AccessType,\n 65 | REFABLE_NODE_TYPES,\n 66 | VERSIONED_NODE_TYPES,\n 67 | )\n 68 | from dbt_semantic_interfaces.references import (\n 69 | EntityReference,\n 70 | MeasureReference,\n 71 | LinkableElementReference,\n 72 | SemanticModelReference,\n 73 | TimeDimensionReference,\n 74 | )\n 75 | from dbt_semantic_interfaces.references import MetricReference as DSIMetricReference\n 76 | from dbt_semantic_interfaces.type_enums import (\n 77 | ConversionCalculationType,\n 78 | MetricType,\n 79 | TimeGranularity,\n 80 | )\n 81 | \n 82 | from .model_config import (\n 83 | NodeConfig,\n 84 | ModelConfig,\n 85 | SeedConfig,\n 86 | TestConfig,\n 87 | SourceConfig,\n 88 | MetricConfig,\n 89 | ExposureConfig,\n 90 | EmptySnapshotConfig,\n 91 | SnapshotConfig,\n 92 | SemanticModelConfig,\n 93 | UnitTestConfig,\n 94 | UnitTestNodeConfig,\n 95 | SavedQueryConfig,\n 96 | )\n 97 | \n 98 | from dbt.artifacts.resources import (\n 99 | BaseResource,\n 100 | Docs,\n 101 | MacroDependsOn,\n 102 | MacroArgument,\n 103 | Documentation as DocumentationResource,\n 104 | Macro as MacroResource,\n 105 | Group as GroupResource,\n 106 | )\n 107 | \n 108 | \n 109 | # =====================================================================\n 110 | # This contains the classes for all of the nodes and node-like objects\n 111 | # in the manifest. In the \"nodes\" dictionary of the manifest we find\n 112 | # all of the objects in the ManifestNode union below. In addition the\n 113 | # manifest contains \"macros\", \"sources\", \"metrics\", \"exposures\", \"docs\",\n 114 | # and \"disabled\" dictionaries.\n 115 | #\n 116 | # The SeedNode is a ManifestNode, but can't be compiled because it has\n 117 | # no SQL.\n 118 | #\n 119 | # All objects defined in this file should have BaseNode as a parent\n 120 | # class.\n 121 | #\n 122 | # The two objects which do not show up in the DAG are Macro and\n 123 | # Documentation.\n 124 | # =====================================================================\n 125 | \n 126 | \n 127 | # ==================================================\n 128 | # Various parent classes and node attribute classes\n 129 | # ==================================================\n 130 | \n 131 | \n 132 | @dataclass\n 133 | class BaseNode(BaseResource):\n 134 | \"\"\"All nodes or node-like objects in this file should have this as a base class\"\"\"\n 135 | \n 136 | @property\n 137 | def search_name(self):\n 138 | return self.name\n 139 | \n 140 | @property\n 141 | def file_id(self):\n 142 | return f\"{self.package_name}://{self.original_file_path}\"\n 143 | \n 144 | @property\n 145 | def is_refable(self):\n 146 | return self.resource_type in REFABLE_NODE_TYPES\n 147 | \n 148 | @property\n 149 | def should_store_failures(self):\n 150 | return False\n 151 | \n 152 | # will this node map to an object in the database?\n 153 | @property\n 154 | def is_relational(self):\n 155 | return self.resource_type in REFABLE_NODE_TYPES\n 156 | \n 157 | @property\n 158 | def is_versioned(self):\n 159 | return self.resource_type in VERSIONED_NODE_TYPES and self.version is not None\n 160 | \n 161 | @property\n 162 | def is_ephemeral(self):\n 163 | return self.config.materialized == \"ephemeral\"\n 164 | \n 165 | @property\n 166 | def is_ephemeral_model(self):\n 167 | return self.is_refable and self.is_ephemeral\n 168 | \n 169 | def get_materialization(self):\n 170 | return self.config.materialized\n 171 | \n 172 | \n 173 | @dataclass\n 174 | class GraphNode(BaseNode):\n 175 | \"\"\"Nodes in the DAG. Macro and Documentation don't have fqn.\"\"\"\n 176 | \n 177 | fqn: List[str]\n 178 | \n 179 | def same_fqn(self, other) -> bool:\n 180 | return self.fqn == other.fqn\n 181 | \n 182 | \n 183 | @dataclass\n 184 | class RefArgs(dbtClassMixin):\n 185 | name: str\n 186 | package: Optional[str] = None\n 187 | version: Optional[NodeVersion] = None\n 188 | \n 189 | @property\n 190 | def positional_args(self) -> List[str]:\n 191 | if self.package:\n 192 | return [self.package, self.name]\n 193 | else:\n 194 | return [self.name]\n 195 | \n 196 | @property\n 197 | def keyword_args(self) -> Dict[str, Optional[NodeVersion]]:\n 198 | if self.version:\n 199 | return {\"version\": self.version}\n 200 | else:\n 201 | return {}\n 202 | \n 203 | \n 204 | @dataclass\n 205 | class ColumnInfo(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 206 | \"\"\"Used in all ManifestNodes and SourceDefinition\"\"\"\n 207 | \n 208 | name: str\n 209 | description: str = \"\"\n 210 | meta: Dict[str, Any] = field(default_factory=dict)\n 211 | data_type: Optional[str] = None\n 212 | constraints: List[ColumnLevelConstraint] = field(default_factory=list)\n 213 | quote: Optional[bool] = None\n 214 | tags: List[str] = field(default_factory=list)\n 215 | _extra: Dict[str, Any] = field(default_factory=dict)\n 216 | \n 217 | \n 218 | @dataclass\n 219 | class Contract(dbtClassMixin, Replaceable):\n 220 | enforced: bool = False\n 221 | alias_types: bool = True\n 222 | checksum: Optional[str] = None\n 223 | \n 224 | \n 225 | # Metrics, exposures,\n 226 | @dataclass\n 227 | class HasRelationMetadata(dbtClassMixin, Replaceable):\n 228 | database: Optional[str]\n 229 | schema: str\n 230 | \n 231 | # Can't set database to None like it ought to be\n 232 | # because it messes up the subclasses and default parameters\n 233 | # so hack it here\n 234 | @classmethod\n 235 | def __pre_deserialize__(cls, data):\n 236 | data = super().__pre_deserialize__(data)\n 237 | if \"database\" not in data:\n 238 | data[\"database\"] = None\n 239 | return data\n 240 | \n 241 | @property\n 242 | def quoting_dict(self) -> Dict[str, bool]:\n 243 | if hasattr(self, \"quoting\"):\n 244 | return self.quoting.to_dict(omit_none=True)\n 245 | else:\n 246 | return {}\n 247 | \n 248 | \n 249 | @dataclass\n 250 | class DeferRelation(HasRelationMetadata):\n 251 | alias: str\n 252 | relation_name: Optional[str]\n 253 | \n 254 | @property\n 255 | def identifier(self):\n 256 | return self.alias\n 257 | \n 258 | \n 259 | @dataclass\n 260 | class DependsOn(MacroDependsOn):\n 261 | nodes: List[str] = field(default_factory=list)\n 262 | \n 263 | def add_node(self, value: str):\n 264 | if value not in self.nodes:\n 265 | self.nodes.append(value)\n 266 | \n 267 | \n 268 | @dataclass\n 269 | class ParsedNodeMandatory(GraphNode, HasRelationMetadata, Replaceable):\n 270 | alias: str\n 271 | checksum: FileHash\n 272 | config: NodeConfig = field(default_factory=NodeConfig)\n 273 | \n 274 | @property\n 275 | def identifier(self):\n 276 | return self.alias\n 277 | \n 278 | \n 279 | # This needs to be in all ManifestNodes and also in SourceDefinition,\n 280 | # because of \"source freshness\"\n 281 | @dataclass\n 282 | class NodeInfoMixin:\n 283 | _event_status: Dict[str, Any] = field(default_factory=dict)\n 284 | \n 285 | @property\n 286 | def node_info(self):\n 287 | node_info = {\n 288 | \"node_path\": getattr(self, \"path\", None),\n 289 | \"node_name\": getattr(self, \"name\", None),\n 290 | \"unique_id\": getattr(self, \"unique_id\", None),\n 291 | \"resource_type\": str(getattr(self, \"resource_type\", \"\")),\n 292 | \"materialized\": self.config.get(\"materialized\"),\n 293 | \"node_status\": str(self._event_status.get(\"node_status\")),\n 294 | \"node_started_at\": self._event_status.get(\"started_at\"),\n 295 | \"node_finished_at\": self._event_status.get(\"finished_at\"),\n 296 | \"meta\": getattr(self, \"meta\", {}),\n 297 | \"node_relation\": {\n 298 | \"database\": getattr(self, \"database\", None),\n 299 | \"schema\": getattr(self, \"schema\", None),\n 300 | \"alias\": getattr(self, \"alias\", None),\n 301 | \"relation_name\": getattr(self, \"relation_name\", None),\n 302 | },\n 303 | }\n 304 | return node_info\n 305 | \n 306 | def update_event_status(self, **kwargs):\n 307 | for k, v in kwargs.items():\n 308 | self._event_status[k] = v\n 309 | set_log_contextvars(node_info=self.node_info)\n 310 | \n 311 | def clear_event_status(self):\n 312 | self._event_status = dict()\n 313 | \n 314 | \n 315 | @dataclass\n 316 | class ParsedNode(NodeInfoMixin, ParsedNodeMandatory, SerializableType):\n 317 | tags: List[str] = field(default_factory=list)\n 318 | description: str = field(default=\"\")\n 319 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n 320 | meta: Dict[str, Any] = field(default_factory=dict)\n 321 | group: Optional[str] = None\n 322 | docs: Docs = field(default_factory=Docs)\n 323 | patch_path: Optional[str] = None\n 324 | build_path: Optional[str] = None\n 325 | deferred: bool = False\n 326 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n 327 | created_at: float = field(default_factory=lambda: time.time())\n 328 | config_call_dict: Dict[str, Any] = field(default_factory=dict)\n 329 | relation_name: Optional[str] = None\n 330 | raw_code: str = \"\"\n 331 | \n 332 | def get_target_write_path(self, target_path: str, subdirectory: str):\n 333 | # This is called for both the \"compiled\" subdirectory of \"target\" and the \"run\" subdirectory\n 334 | if os.path.basename(self.path) == os.path.basename(self.original_file_path):\n 335 | # One-to-one relationship of nodes to files.\n 336 | path = self.original_file_path\n 337 | else:\n 338 | # Many-to-one relationship of nodes to files.\n 339 | path = os.path.join(self.original_file_path, self.path)\n 340 | target_write_path = os.path.join(target_path, subdirectory, self.package_name, path)\n 341 | return target_write_path\n 342 | \n 343 | def write_node(self, project_root: str, compiled_path, compiled_code: str):\n 344 | if os.path.isabs(compiled_path):\n 345 | full_path = compiled_path\n 346 | else:\n 347 | full_path = os.path.join(project_root, compiled_path)\n 348 | write_file(full_path, compiled_code)\n 349 | \n 350 | def _serialize(self):\n 351 | return self.to_dict()\n 352 | \n 353 | def __post_serialize__(self, dct):\n 354 | dct = super().__post_serialize__(dct)\n 355 | if \"_event_status\" in dct:\n 356 | del dct[\"_event_status\"]\n 357 | return dct\n 358 | \n 359 | @classmethod\n 360 | def _deserialize(cls, dct: Dict[str, int]):\n 361 | # The serialized ParsedNodes do not differ from each other\n 362 | # in fields that would allow 'from_dict' to distinguis\n 363 | # between them.\n 364 | resource_type = dct[\"resource_type\"]\n 365 | if resource_type == \"model\":\n 366 | return ModelNode.from_dict(dct)\n 367 | elif resource_type == \"analysis\":\n 368 | return AnalysisNode.from_dict(dct)\n 369 | elif resource_type == \"seed\":\n 370 | return SeedNode.from_dict(dct)\n 371 | elif resource_type == \"rpc\":\n 372 | return RPCNode.from_dict(dct)\n 373 | elif resource_type == \"sql\":\n 374 | return SqlNode.from_dict(dct)\n 375 | elif resource_type == \"test\":\n 376 | if \"test_metadata\" in dct:\n 377 | return GenericTestNode.from_dict(dct)\n 378 | else:\n 379 | return SingularTestNode.from_dict(dct)\n 380 | elif resource_type == \"operation\":\n 381 | return HookNode.from_dict(dct)\n 382 | elif resource_type == \"seed\":\n 383 | return SeedNode.from_dict(dct)\n 384 | elif resource_type == \"snapshot\":\n 385 | return SnapshotNode.from_dict(dct)\n 386 | else:\n 387 | return cls.from_dict(dct)\n 388 | \n 389 | def _persist_column_docs(self) -> bool:\n 390 | if hasattr(self.config, \"persist_docs\"):\n 391 | assert isinstance(self.config, NodeConfig)\n 392 | return bool(self.config.persist_docs.get(\"columns\"))\n 393 | return False\n 394 | \n 395 | def _persist_relation_docs(self) -> bool:\n 396 | if hasattr(self.config, \"persist_docs\"):\n 397 | assert isinstance(self.config, NodeConfig)\n 398 | return bool(self.config.persist_docs.get(\"relation\"))\n 399 | return False\n 400 | \n 401 | def same_persisted_description(self, other) -> bool:\n 402 | # the check on configs will handle the case where we have different\n 403 | # persist settings, so we only have to care about the cases where they\n 404 | # are the same..\n 405 | if self._persist_relation_docs():\n 406 | if self.description != other.description:\n 407 | return False\n 408 | \n 409 | if self._persist_column_docs():\n 410 | # assert other._persist_column_docs()\n 411 | column_descriptions = {k: v.description for k, v in self.columns.items()}\n 412 | other_column_descriptions = {k: v.description for k, v in other.columns.items()}\n 413 | if column_descriptions != other_column_descriptions:\n 414 | return False\n 415 | \n 416 | return True\n 417 | \n 418 | def same_body(self, other) -> bool:\n 419 | return self.raw_code == other.raw_code\n 420 | \n 421 | def same_database_representation(self, other) -> bool:\n 422 | # compare the config representation, not the node's config value. This\n 423 | # compares the configured value, rather than the ultimate value (so\n 424 | # generate_*_name and unset values derived from the target are\n 425 | # ignored)\n 426 | keys = (\"database\", \"schema\", \"alias\")\n 427 | for key in keys:\n 428 | mine = self.unrendered_config.get(key)\n 429 | others = other.unrendered_config.get(key)\n 430 | if mine != others:\n 431 | return False\n 432 | return True\n 433 | \n 434 | def same_config(self, old) -> bool:\n 435 | return self.config.same_contents(\n 436 | self.unrendered_config,\n 437 | old.unrendered_config,\n 438 | )\n 439 | \n 440 | def build_contract_checksum(self):\n 441 | pass\n 442 | \n 443 | def same_contract(self, old, adapter_type=None) -> bool:\n 444 | # This would only apply to seeds\n 445 | return True\n 446 | \n 447 | def same_contents(self, old, adapter_type) -> bool:\n 448 | if old is None:\n 449 | return False\n 450 | \n 451 | # Need to ensure that same_contract is called because it\n 452 | # could throw an error\n 453 | same_contract = self.same_contract(old, adapter_type)\n 454 | return (\n 455 | self.same_body(old)\n 456 | and self.same_config(old)\n 457 | and self.same_persisted_description(old)\n 458 | and self.same_fqn(old)\n 459 | and self.same_database_representation(old)\n 460 | and same_contract\n 461 | and True\n 462 | )\n 463 | \n 464 | @property\n 465 | def is_external_node(self):\n 466 | return False\n 467 | \n 468 | \n 469 | @dataclass\n 470 | class InjectedCTE(dbtClassMixin, Replaceable):\n 471 | \"\"\"Used in CompiledNodes as part of ephemeral model processing\"\"\"\n 472 | \n 473 | id: str\n 474 | sql: str\n 475 | \n 476 | \n 477 | @dataclass\n 478 | class CompiledNode(ParsedNode):\n 479 | \"\"\"Contains attributes necessary for SQL files and nodes with refs, sources, etc,\n 480 | so all ManifestNodes except SeedNode.\"\"\"\n 481 | \n 482 | language: str = \"sql\"\n 483 | refs: List[RefArgs] = field(default_factory=list)\n 484 | sources: List[List[str]] = field(default_factory=list)\n 485 | metrics: List[List[str]] = field(default_factory=list)\n 486 | depends_on: DependsOn = field(default_factory=DependsOn)\n 487 | compiled_path: Optional[str] = None\n 488 | compiled: bool = False\n 489 | compiled_code: Optional[str] = None\n 490 | extra_ctes_injected: bool = False\n 491 | extra_ctes: List[InjectedCTE] = field(default_factory=list)\n 492 | _pre_injected_sql: Optional[str] = None\n 493 | contract: Contract = field(default_factory=Contract)\n 494 | \n 495 | @property\n 496 | def empty(self):\n 497 | return not self.raw_code.strip()\n 498 | \n 499 | def set_cte(self, cte_id: str, sql: str):\n 500 | \"\"\"This is the equivalent of what self.extra_ctes[cte_id] = sql would\n 501 | do if extra_ctes were an OrderedDict\n 502 | \"\"\"\n 503 | for cte in self.extra_ctes:\n 504 | # Because it's possible that multiple threads are compiling the\n 505 | # node at the same time, we don't want to overwrite already compiled\n 506 | # sql in the extra_ctes with empty sql.\n 507 | if cte.id == cte_id:\n 508 | break\n 509 | else:\n 510 | self.extra_ctes.append(InjectedCTE(id=cte_id, sql=sql))\n 511 | \n 512 | def __post_serialize__(self, dct):\n 513 | dct = super().__post_serialize__(dct)\n 514 | if \"_pre_injected_sql\" in dct:\n 515 | del dct[\"_pre_injected_sql\"]\n 516 | # Remove compiled attributes\n 517 | if \"compiled\" in dct and dct[\"compiled\"] is False:\n 518 | del dct[\"compiled\"]\n 519 | del dct[\"extra_ctes_injected\"]\n 520 | del dct[\"extra_ctes\"]\n 521 | # \"omit_none\" means these might not be in the dictionary\n 522 | if \"compiled_code\" in dct:\n 523 | del dct[\"compiled_code\"]\n 524 | return dct\n 525 | \n 526 | @property\n 527 | def depends_on_nodes(self):\n 528 | return self.depends_on.nodes\n 529 | \n 530 | @property\n 531 | def depends_on_macros(self):\n 532 | return self.depends_on.macros\n 533 | \n 534 | \n 535 | # ====================================\n 536 | # CompiledNode subclasses\n 537 | # ====================================\n 538 | \n 539 | \n 540 | @dataclass\n 541 | class AnalysisNode(CompiledNode):\n 542 | resource_type: Literal[NodeType.Analysis]\n 543 | \n 544 | \n 545 | @dataclass\n 546 | class HookNode(CompiledNode):\n 547 | resource_type: Literal[NodeType.Operation]\n 548 | index: Optional[int] = None\n 549 | \n 550 | \n 551 | @dataclass\n 552 | class ModelNode(CompiledNode):\n 553 | resource_type: Literal[NodeType.Model]\n 554 | access: AccessType = AccessType.Protected\n 555 | config: ModelConfig = field(default_factory=ModelConfig)\n 556 | constraints: List[ModelLevelConstraint] = field(default_factory=list)\n 557 | version: Optional[NodeVersion] = None\n 558 | latest_version: Optional[NodeVersion] = None\n 559 | deprecation_date: Optional[datetime] = None\n 560 | defer_relation: Optional[DeferRelation] = None\n 561 | \n 562 | @classmethod\n 563 | def from_args(cls, args: ModelNodeArgs) -> \"ModelNode\":\n 564 | unique_id = args.unique_id\n 565 | \n 566 | # build unrendered config -- for usage in ParsedNode.same_contents\n 567 | unrendered_config = {}\n 568 | unrendered_config[\"alias\"] = args.identifier\n 569 | unrendered_config[\"schema\"] = args.schema\n 570 | if args.database:\n 571 | unrendered_config[\"database\"] = args.database\n 572 | \n 573 | return cls(\n 574 | resource_type=NodeType.Model,\n 575 | name=args.name,\n 576 | package_name=args.package_name,\n 577 | unique_id=unique_id,\n 578 | fqn=args.fqn,\n 579 | version=args.version,\n 580 | latest_version=args.latest_version,\n 581 | relation_name=args.relation_name,\n 582 | database=args.database,\n 583 | schema=args.schema,\n 584 | alias=args.identifier,\n 585 | deprecation_date=args.deprecation_date,\n 586 | checksum=FileHash.from_contents(f\"{unique_id},{args.generated_at}\"),\n 587 | access=AccessType(args.access),\n 588 | original_file_path=\"\",\n 589 | path=\"\",\n 590 | unrendered_config=unrendered_config,\n 591 | depends_on=DependsOn(nodes=args.depends_on_nodes),\n 592 | config=ModelConfig(enabled=args.enabled),\n 593 | )\n 594 | \n 595 | @property\n 596 | def is_external_node(self) -> bool:\n 597 | return not self.original_file_path and not self.path\n 598 | \n 599 | @property\n 600 | def is_latest_version(self) -> bool:\n 601 | return self.version is not None and self.version == self.latest_version\n 602 | \n 603 | @property\n 604 | def search_name(self):\n 605 | if self.version is None:\n 606 | return self.name\n 607 | else:\n 608 | return f\"{self.name}.v{self.version}\"\n 609 | \n 610 | @property\n 611 | def materialization_enforces_constraints(self) -> bool:\n 612 | return self.config.materialized in [\"table\", \"incremental\"]\n 613 | \n 614 | def same_contents(self, old, adapter_type) -> bool:\n 615 | return super().same_contents(old, adapter_type) and self.same_ref_representation(old)\n 616 | \n 617 | def same_ref_representation(self, old) -> bool:\n 618 | return (\n 619 | # Changing the latest_version may break downstream unpinned refs\n 620 | self.latest_version == old.latest_version\n 621 | # Changes to access or deprecation_date may lead to ref-related parsing errors\n 622 | and self.access == old.access\n 623 | and self.deprecation_date == old.deprecation_date\n 624 | )\n 625 | \n 626 | def build_contract_checksum(self):\n 627 | # We don't need to construct the checksum if the model does not\n 628 | # have contract enforced, because it won't be used.\n 629 | # This needs to be executed after contract config is set\n 630 | \n 631 | # Avoid rebuilding the checksum if it has already been set.\n 632 | if self.contract.checksum is not None:\n 633 | return\n 634 | \n 635 | if self.contract.enforced is True:\n 636 | contract_state = \"\"\n 637 | # We need to sort the columns so that order doesn't matter\n 638 | # columns is a str: ColumnInfo dictionary\n 639 | sorted_columns = sorted(self.columns.values(), key=lambda col: col.name)\n 640 | for column in sorted_columns:\n 641 | contract_state += f\"|{column.name}\"\n 642 | contract_state += str(column.data_type)\n 643 | contract_state += str(column.constraints)\n 644 | if self.materialization_enforces_constraints:\n 645 | contract_state += self.config.materialized\n 646 | contract_state += str(self.constraints)\n 647 | data = contract_state.encode(\"utf-8\")\n 648 | self.contract.checksum = hashlib.new(\"sha256\", data).hexdigest()\n 649 | \n 650 | def same_contract(self, old, adapter_type=None) -> bool:\n 651 | # If the contract wasn't previously enforced:\n 652 | if old.contract.enforced is False and self.contract.enforced is False:\n 653 | # No change -- same_contract: True\n 654 | return True\n 655 | if old.contract.enforced is False and self.contract.enforced is True:\n 656 | # Now it's enforced. This is a change, but not a breaking change -- same_contract: False\n 657 | return False\n 658 | \n 659 | # Otherwise: The contract was previously enforced, and we need to check for changes.\n 660 | # Happy path: The contract is still being enforced, and the checksums are identical.\n 661 | if self.contract.enforced is True and self.contract.checksum == old.contract.checksum:\n 662 | # No change -- same_contract: True\n 663 | return True\n 664 | \n 665 | # Otherwise: There has been a change.\n 666 | # We need to determine if it is a **breaking** change.\n 667 | # These are the categories of breaking changes:\n 668 | contract_enforced_disabled: bool = False\n 669 | columns_removed: List[str] = []\n 670 | column_type_changes: List[Dict[str, str]] = []\n 671 | enforced_column_constraint_removed: List[\n 672 | Dict[str, str]\n 673 | ] = [] # column_name, constraint_type\n 674 | enforced_model_constraint_removed: List[Dict[str, Any]] = [] # constraint_type, columns\n 675 | materialization_changed: List[str] = []\n 676 | \n 677 | if old.contract.enforced is True and self.contract.enforced is False:\n 678 | # Breaking change: the contract was previously enforced, and it no longer is\n 679 | contract_enforced_disabled = True\n 680 | \n 681 | # TODO: this avoid the circular imports but isn't ideal\n 682 | from dbt.adapters.factory import get_adapter_constraint_support\n 683 | from dbt.adapters.base import ConstraintSupport\n 684 | \n 685 | constraint_support = get_adapter_constraint_support(adapter_type)\n 686 | column_constraints_exist = False\n 687 | \n 688 | # Next, compare each column from the previous contract (old.columns)\n 689 | for old_key, old_value in sorted(old.columns.items()):\n 690 | # Has this column been removed?\n 691 | if old_key not in self.columns.keys():\n 692 | columns_removed.append(old_value.name)\n 693 | # Has this column's data type changed?\n 694 | elif old_value.data_type != self.columns[old_key].data_type:\n 695 | column_type_changes.append(\n 696 | {\n 697 | \"column_name\": str(old_value.name),\n 698 | \"previous_column_type\": str(old_value.data_type),\n 699 | \"current_column_type\": str(self.columns[old_key].data_type),\n 700 | }\n 701 | )\n 702 | \n 703 | # track if there are any column level constraints for the materialization check late\n 704 | if old_value.constraints:\n 705 | column_constraints_exist = True\n 706 | \n 707 | # Have enforced columns level constraints changed?\n 708 | # Constraints are only enforced for table and incremental materializations.\n 709 | # We only really care if the old node was one of those materializations for breaking changes\n 710 | if (\n 711 | old_key in self.columns.keys()\n 712 | and old_value.constraints != self.columns[old_key].constraints\n 713 | and old.materialization_enforces_constraints\n 714 | ):\n 715 | for old_constraint in old_value.constraints:\n 716 | if (\n 717 | old_constraint not in self.columns[old_key].constraints\n 718 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 719 | ):\n 720 | enforced_column_constraint_removed.append(\n 721 | {\n 722 | \"column_name\": old_key,\n 723 | \"constraint_name\": old_constraint.name,\n 724 | \"constraint_type\": ConstraintType(old_constraint.type),\n 725 | }\n 726 | )\n 727 | \n 728 | # Now compare the model level constraints\n 729 | if old.constraints != self.constraints and old.materialization_enforces_constraints:\n 730 | for old_constraint in old.constraints:\n 731 | if (\n 732 | old_constraint not in self.constraints\n 733 | and constraint_support[old_constraint.type] == ConstraintSupport.ENFORCED\n 734 | ):\n 735 | enforced_model_constraint_removed.append(\n 736 | {\n 737 | \"constraint_name\": old_constraint.name,\n 738 | \"constraint_type\": ConstraintType(old_constraint.type),\n 739 | \"columns\": old_constraint.columns,\n 740 | }\n 741 | )\n 742 | \n 743 | # Check for relevant materialization changes.\n 744 | if (\n 745 | old.materialization_enforces_constraints\n 746 | and not self.materialization_enforces_constraints\n 747 | and (old.constraints or column_constraints_exist)\n 748 | ):\n 749 | materialization_changed = [old.config.materialized, self.config.materialized]\n 750 | \n 751 | # If a column has been added, it will be missing in the old.columns, and present in self.columns\n 752 | # That's a change (caught by the different checksums), but not a breaking change\n 753 | \n 754 | # Did we find any changes that we consider breaking? If there's an enforced contract, that's\n 755 | # a warning unless the model is versioned, then it's an error.\n 756 | if (\n 757 | contract_enforced_disabled\n 758 | or columns_removed\n 759 | or column_type_changes\n 760 | or enforced_model_constraint_removed\n 761 | or enforced_column_constraint_removed\n 762 | or materialization_changed\n 763 | ):\n 764 | \n 765 | breaking_changes = []\n 766 | if contract_enforced_disabled:\n 767 | breaking_changes.append(\n 768 | \"Contract enforcement was removed: Previously, this model had an enforced contract. It is no longer configured to enforce its contract, and this is a breaking change.\"\n 769 | )\n 770 | if columns_removed:\n 771 | columns_removed_str = \"\\n - \".join(columns_removed)\n 772 | breaking_changes.append(f\"Columns were removed: \\n - {columns_removed_str}\")\n 773 | if column_type_changes:\n 774 | column_type_changes_str = \"\\n - \".join(\n 775 | [\n 776 | f\"{c['column_name']} ({c['previous_column_type']} -> {c['current_column_type']})\"\n 777 | for c in column_type_changes\n 778 | ]\n 779 | )\n 780 | breaking_changes.append(\n 781 | f\"Columns with data_type changes: \\n - {column_type_changes_str}\"\n 782 | )\n 783 | if enforced_column_constraint_removed:\n 784 | column_constraint_changes_str = \"\\n - \".join(\n 785 | [\n 786 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on column {c['column_name']}\"\n 787 | for c in enforced_column_constraint_removed\n 788 | ]\n 789 | )\n 790 | breaking_changes.append(\n 791 | f\"Enforced column level constraints were removed: \\n - {column_constraint_changes_str}\"\n 792 | )\n 793 | if enforced_model_constraint_removed:\n 794 | model_constraint_changes_str = \"\\n - \".join(\n 795 | [\n 796 | f\"'{c['constraint_name'] if c['constraint_name'] is not None else c['constraint_type']}' constraint on columns {c['columns']}\"\n 797 | for c in enforced_model_constraint_removed\n 798 | ]\n 799 | )\n 800 | breaking_changes.append(\n 801 | f\"Enforced model level constraints were removed: \\n - {model_constraint_changes_str}\"\n 802 | )\n 803 | if materialization_changed:\n 804 | materialization_changes_str = (\n 805 | f\"{materialization_changed[0]} -> {materialization_changed[1]}\"\n 806 | )\n 807 | \n 808 | breaking_changes.append(\n 809 | f\"Materialization changed with enforced constraints: \\n - {materialization_changes_str}\"\n 810 | )\n 811 | \n 812 | if self.version is None:\n 813 | warn_or_error(\n 814 | UnversionedBreakingChange(\n 815 | contract_enforced_disabled=contract_enforced_disabled,\n 816 | columns_removed=columns_removed,\n 817 | column_type_changes=column_type_changes,\n 818 | enforced_column_constraint_removed=enforced_column_constraint_removed,\n 819 | enforced_model_constraint_removed=enforced_model_constraint_removed,\n 820 | breaking_changes=breaking_changes,\n 821 | model_name=self.name,\n 822 | model_file_path=self.original_file_path,\n 823 | ),\n 824 | node=self,\n 825 | )\n 826 | else:\n 827 | raise (\n 828 | ContractBreakingChangeError(\n 829 | breaking_changes=breaking_changes,\n 830 | node=self,\n 831 | )\n 832 | )\n 833 | \n 834 | # Otherwise, the contract has changed -- same_contract: False\n 835 | return False\n 836 | \n 837 | \n 838 | # TODO: rm?\n 839 | @dataclass\n 840 | class RPCNode(CompiledNode):\n 841 | resource_type: Literal[NodeType.RPCCall]\n 842 | \n 843 | \n 844 | @dataclass\n 845 | class SqlNode(CompiledNode):\n 846 | resource_type: Literal[NodeType.SqlOperation]\n 847 | \n 848 | \n 849 | # ====================================\n 850 | # Seed node\n 851 | # ====================================\n 852 | \n 853 | \n 854 | @dataclass\n 855 | class SeedNode(ParsedNode): # No SQLDefaults!\n 856 | resource_type: Literal[NodeType.Seed]\n 857 | config: SeedConfig = field(default_factory=SeedConfig)\n 858 | # seeds need the root_path because the contents are not loaded initially\n 859 | # and we need the root_path to load the seed later\n 860 | root_path: Optional[str] = None\n 861 | depends_on: MacroDependsOn = field(default_factory=MacroDependsOn)\n 862 | defer_relation: Optional[DeferRelation] = None\n 863 | \n 864 | def same_seeds(self, other: \"SeedNode\") -> bool:\n 865 | # for seeds, we check the hashes. If the hashes are different types,\n 866 | # no match. If the hashes are both the same 'path', log a warning and\n 867 | # assume they are the same\n 868 | # if the current checksum is a path, we want to log a warning.\n 869 | result = self.checksum == other.checksum\n 870 | \n 871 | if self.checksum.name == \"path\":\n 872 | msg: str\n 873 | if other.checksum.name != \"path\":\n 874 | warn_or_error(\n 875 | SeedIncreased(package_name=self.package_name, name=self.name), node=self\n 876 | )\n 877 | elif result:\n 878 | warn_or_error(\n 879 | SeedExceedsLimitSamePath(package_name=self.package_name, name=self.name),\n 880 | node=self,\n 881 | )\n 882 | elif not result:\n 883 | warn_or_error(\n 884 | SeedExceedsLimitAndPathChanged(package_name=self.package_name, name=self.name),\n 885 | node=self,\n 886 | )\n 887 | else:\n 888 | warn_or_error(\n 889 | SeedExceedsLimitChecksumChanged(\n 890 | package_name=self.package_name,\n 891 | name=self.name,\n 892 | checksum_name=other.checksum.name,\n 893 | ),\n 894 | node=self,\n 895 | )\n 896 | \n 897 | return result\n 898 | \n 899 | @property\n 900 | def empty(self):\n 901 | \"\"\"Seeds are never empty\"\"\"\n 902 | return False\n 903 | \n 904 | def _disallow_implicit_dependencies(self):\n 905 | \"\"\"Disallow seeds to take implicit upstream dependencies via pre/post hooks\"\"\"\n 906 | # Seeds are root nodes in the DAG. They cannot depend on other nodes.\n 907 | # However, it's possible to define pre- and post-hooks on seeds, and for those\n 908 | # hooks to include {{ ref(...) }}. This worked in previous versions, but it\n 909 | # was never officially documented or supported behavior. Let's raise an explicit error,\n 910 | # which will surface during parsing if the user has written code such that we attempt\n 911 | # to capture & record a ref/source/metric call on the SeedNode.\n 912 | # For more details: https://github.com/dbt-labs/dbt-core/issues/6806\n 913 | hooks = [f'- pre_hook: \"{hook.sql}\"' for hook in self.config.pre_hook] + [\n 914 | f'- post_hook: \"{hook.sql}\"' for hook in self.config.post_hook\n 915 | ]\n 916 | hook_list = \"\\n\".join(hooks)\n 917 | message = f\"\"\"\n 918 | Seeds cannot depend on other nodes. dbt detected a seed with a pre- or post-hook\n 919 | that calls 'ref', 'source', or 'metric', either directly or indirectly via other macros.\n 920 | \n 921 | Error raised for '{self.unique_id}', which has these hooks defined: \\n{hook_list}\n 922 | \"\"\"\n 923 | raise ParsingError(message)\n 924 | \n 925 | @property\n 926 | def refs(self):\n 927 | self._disallow_implicit_dependencies()\n 928 | \n 929 | @property\n 930 | def sources(self):\n 931 | self._disallow_implicit_dependencies()\n 932 | \n 933 | @property\n 934 | def metrics(self):\n 935 | self._disallow_implicit_dependencies()\n 936 | \n 937 | def same_body(self, other) -> bool:\n 938 | return self.same_seeds(other)\n 939 | \n 940 | @property\n 941 | def depends_on_nodes(self):\n 942 | return []\n 943 | \n 944 | @property\n 945 | def depends_on_macros(self) -> List[str]:\n 946 | return self.depends_on.macros\n 947 | \n 948 | @property\n 949 | def extra_ctes(self):\n 950 | return []\n 951 | \n 952 | @property\n 953 | def extra_ctes_injected(self):\n 954 | return False\n 955 | \n 956 | @property\n 957 | def language(self):\n 958 | return \"sql\"\n 959 | \n 960 | \n 961 | # ====================================\n 962 | # Singular Test node\n 963 | # ====================================\n 964 | \n 965 | \n 966 | class TestShouldStoreFailures:\n 967 | @property\n 968 | def should_store_failures(self):\n 969 | if self.config.store_failures:\n 970 | return self.config.store_failures\n 971 | return get_flags().STORE_FAILURES\n 972 | \n 973 | @property\n 974 | def is_relational(self):\n 975 | if self.should_store_failures:\n 976 | return True\n 977 | return False\n 978 | \n 979 | \n 980 | @dataclass\n 981 | class SingularTestNode(TestShouldStoreFailures, CompiledNode):\n 982 | resource_type: Literal[NodeType.Test]\n 983 | # Was not able to make mypy happy and keep the code working. We need to\n 984 | # refactor the various configs.\n 985 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n 986 | \n 987 | @property\n 988 | def test_node_type(self):\n 989 | return \"singular\"\n 990 | \n 991 | \n 992 | # ====================================\n 993 | # Generic Test node\n 994 | # ====================================\n 995 | \n 996 | \n 997 | @dataclass\n 998 | class TestMetadata(dbtClassMixin, Replaceable):\n 999 | __test__ = False\n1000 | \n1001 | name: str\n1002 | # kwargs are the args that are left in the test builder after\n1003 | # removing configs. They are set from the test builder when\n1004 | # the test node is created.\n1005 | kwargs: Dict[str, Any] = field(default_factory=dict)\n1006 | namespace: Optional[str] = None\n1007 | \n1008 | \n1009 | # This has to be separated out because it has no default and so\n1010 | # has to be included as a superclass, not an attribute\n1011 | @dataclass\n1012 | class HasTestMetadata(dbtClassMixin):\n1013 | test_metadata: TestMetadata\n1014 | \n1015 | \n1016 | @dataclass\n1017 | class GenericTestNode(TestShouldStoreFailures, CompiledNode, HasTestMetadata):\n1018 | resource_type: Literal[NodeType.Test]\n1019 | column_name: Optional[str] = None\n1020 | file_key_name: Optional[str] = None\n1021 | # Was not able to make mypy happy and keep the code working. We need to\n1022 | # refactor the various configs.\n1023 | config: TestConfig = field(default_factory=TestConfig) # type: ignore\n1024 | attached_node: Optional[str] = None\n1025 | \n1026 | def same_contents(self, other, adapter_type: Optional[str]) -> bool:\n1027 | if other is None:\n1028 | return False\n1029 | \n1030 | return self.same_config(other) and self.same_fqn(other) and True\n1031 | \n1032 | @property\n1033 | def test_node_type(self):\n1034 | return \"generic\"\n1035 | \n1036 | \n1037 | @dataclass\n1038 | class UnitTestSourceDefinition(ModelNode):\n1039 | source_name: str = \"undefined\"\n1040 | quoting: Quoting = field(default_factory=Quoting)\n1041 | \n1042 | @property\n1043 | def search_name(self):\n1044 | return f\"{self.source_name}.{self.name}\"\n1045 | \n1046 | \n1047 | @dataclass\n1048 | class UnitTestNode(CompiledNode):\n1049 | resource_type: Literal[NodeType.Unit]\n1050 | tested_node_unique_id: Optional[str] = None\n1051 | this_input_node_unique_id: Optional[str] = None\n1052 | overrides: Optional[UnitTestOverrides] = None\n1053 | config: UnitTestNodeConfig = field(default_factory=UnitTestNodeConfig)\n1054 | \n1055 | \n1056 | @dataclass\n1057 | class UnitTestDefinitionMandatory:\n1058 | model: str\n1059 | given: Sequence[UnitTestInputFixture]\n1060 | expect: UnitTestOutputFixture\n1061 | \n1062 | \n1063 | @dataclass\n1064 | class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):\n1065 | description: str = \"\"\n1066 | overrides: Optional[UnitTestOverrides] = None\n1067 | depends_on: DependsOn = field(default_factory=DependsOn)\n1068 | config: UnitTestConfig = field(default_factory=UnitTestConfig)\n1069 | checksum: Optional[str] = None\n1070 | schema: Optional[str] = None\n1071 | created_at: float = field(default_factory=lambda: time.time())\n1072 | versions: Optional[UnitTestNodeVersions] = None\n1073 | version: Optional[NodeVersion] = None\n1074 | \n1075 | @property\n1076 | def build_path(self):\n1077 | # TODO: is this actually necessary?\n1078 | return self.original_file_path\n1079 | \n1080 | @property\n1081 | def compiled_path(self):\n1082 | # TODO: is this actually necessary?\n1083 | return self.original_file_path\n1084 | \n1085 | @property\n1086 | def depends_on_nodes(self):\n1087 | return self.depends_on.nodes\n1088 | \n1089 | @property\n1090 | def tags(self) -> List[str]:\n1091 | tags = self.config.tags\n1092 | return [tags] if isinstance(tags, str) else tags\n1093 | \n1094 | @property\n1095 | def versioned_name(self) -> str:\n1096 | versioned_name = self.name\n1097 | if self.version is not None:\n1098 | versioned_name += f\"_v{self.version}\"\n1099 | return versioned_name\n1100 | \n1101 | def build_unit_test_checksum(self):\n1102 | # everything except 'description'\n1103 | data = f\"{self.model}-{self.versions}-{self.given}-{self.expect}-{self.overrides}\"\n1104 | \n1105 | # include underlying fixture data\n1106 | for input in self.given:\n1107 | if input.fixture:\n1108 | data += f\"-{input.rows}\"\n1109 | \n1110 | self.checksum = hashlib.new(\"sha256\", data.encode(\"utf-8\")).hexdigest()\n1111 | \n1112 | def same_contents(self, other: Optional[\"UnitTestDefinition\"]) -> bool:\n1113 | if other is None:\n1114 | return False\n1115 | \n1116 | return self.checksum == other.checksum\n1117 | \n1118 | \n1119 | @dataclass\n1120 | class UnitTestFileFixture(BaseNode):\n1121 | resource_type: Literal[NodeType.Fixture]\n1122 | rows: Optional[List[Dict[str, Any]]] = None\n1123 | \n1124 | \n1125 | # ====================================\n1126 | # Snapshot node\n1127 | # ====================================\n1128 | \n1129 | \n1130 | @dataclass\n1131 | class IntermediateSnapshotNode(CompiledNode):\n1132 | # at an intermediate stage in parsing, where we've built something better\n1133 | # than an unparsed node for rendering in parse mode, it's pretty possible\n1134 | # that we won't have critical snapshot-related information that is only\n1135 | # defined in config blocks. To fix that, we have an intermediate type that\n1136 | # uses a regular node config, which the snapshot parser will then convert\n1137 | # into a full ParsedSnapshotNode after rendering. Note: it currently does\n1138 | # not work to set snapshot config in schema files because of the validation.\n1139 | resource_type: Literal[NodeType.Snapshot]\n1140 | config: EmptySnapshotConfig = field(default_factory=EmptySnapshotConfig)\n1141 | \n1142 | \n1143 | @dataclass\n1144 | class SnapshotNode(CompiledNode):\n1145 | resource_type: Literal[NodeType.Snapshot]\n1146 | config: SnapshotConfig\n1147 | defer_relation: Optional[DeferRelation] = None\n1148 | \n1149 | \n1150 | # ====================================\n1151 | # Macro\n1152 | # ====================================\n1153 | \n1154 | \n1155 | @dataclass\n1156 | class Macro(MacroResource, BaseNode):\n1157 | def same_contents(self, other: Optional[\"Macro\"]) -> bool:\n1158 | if other is None:\n1159 | return False\n1160 | # the only thing that makes one macro different from another with the\n1161 | # same name/package is its content\n1162 | return self.macro_sql == other.macro_sql\n1163 | \n1164 | @property\n1165 | def depends_on_macros(self):\n1166 | return self.depends_on.macros\n1167 | \n1168 | \n1169 | # ====================================\n1170 | # Documentation node\n1171 | # ====================================\n1172 | \n1173 | \n1174 | @dataclass\n1175 | class Documentation(DocumentationResource, BaseNode):\n1176 | @property\n1177 | def search_name(self):\n1178 | return self.name\n1179 | \n1180 | def same_contents(self, other: Optional[\"Documentation\"]) -> bool:\n1181 | if other is None:\n1182 | return False\n1183 | # the only thing that makes one doc different from another with the\n1184 | # same name/package is its content\n1185 | return self.block_contents == other.block_contents\n1186 | \n1187 | \n1188 | # ====================================\n1189 | # Source node\n1190 | # ====================================\n1191 | \n1192 | \n1193 | def normalize_test(testdef: TestDef) -> Dict[str, Any]:\n1194 | if isinstance(testdef, str):\n1195 | return {testdef: {}}\n1196 | else:\n1197 | return testdef\n1198 | \n1199 | \n1200 | @dataclass\n1201 | class UnpatchedSourceDefinition(BaseNode):\n1202 | source: UnparsedSourceDefinition\n1203 | table: UnparsedSourceTableDefinition\n1204 | fqn: List[str]\n1205 | resource_type: Literal[NodeType.Source]\n1206 | patch_path: Optional[str] = None\n1207 | \n1208 | def get_full_source_name(self):\n1209 | return f\"{self.source.name}_{self.table.name}\"\n1210 | \n1211 | def get_source_representation(self):\n1212 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1213 | \n1214 | def validate_data_tests(self):\n1215 | \"\"\"\n1216 | sources parse tests differently than models, so we need to do some validation\n1217 | here where it's done in the PatchParser for other nodes\n1218 | \"\"\"\n1219 | # source table-level tests\n1220 | if self.tests and self.data_tests:\n1221 | raise ValidationError(\n1222 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1223 | )\n1224 | if self.tests:\n1225 | deprecations.warn(\n1226 | \"project-test-config\",\n1227 | deprecated_path=\"tests\",\n1228 | exp_path=\"data_tests\",\n1229 | )\n1230 | self.data_tests.extend(self.tests)\n1231 | self.tests.clear()\n1232 | \n1233 | # column-level tests\n1234 | for column in self.columns:\n1235 | if column.tests and column.data_tests:\n1236 | raise ValidationError(\n1237 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n1238 | )\n1239 | if column.tests:\n1240 | deprecations.warn(\n1241 | \"project-test-config\",\n1242 | deprecated_path=\"tests\",\n1243 | exp_path=\"data_tests\",\n1244 | )\n1245 | column.data_tests.extend(column.tests)\n1246 | column.tests.clear()\n1247 | \n1248 | @property\n1249 | def quote_columns(self) -> Optional[bool]:\n1250 | result = None\n1251 | if self.source.quoting.column is not None:\n1252 | result = self.source.quoting.column\n1253 | if self.table.quoting.column is not None:\n1254 | result = self.table.quoting.column\n1255 | return result\n1256 | \n1257 | @property\n1258 | def columns(self) -> Sequence[UnparsedColumn]:\n1259 | return [] if self.table.columns is None else self.table.columns\n1260 | \n1261 | def get_tests(self) -> Iterator[Tuple[Dict[str, Any], Optional[UnparsedColumn]]]:\n1262 | self.validate_data_tests()\n1263 | for data_test in self.data_tests:\n1264 | yield normalize_test(data_test), None\n1265 | \n1266 | for column in self.columns:\n1267 | if column.data_tests is not None:\n1268 | for data_test in column.data_tests:\n1269 | yield normalize_test(data_test), column\n1270 | \n1271 | @property\n1272 | def data_tests(self) -> List[TestDef]:\n1273 | if self.table.data_tests is None:\n1274 | return []\n1275 | else:\n1276 | return self.table.data_tests\n1277 | \n1278 | # deprecated\n1279 | @property\n1280 | def tests(self) -> List[TestDef]:\n1281 | if self.table.tests is None:\n1282 | return []\n1283 | else:\n1284 | return self.table.tests\n1285 | \n1286 | \n1287 | @dataclass\n1288 | class ParsedSourceMandatory(GraphNode, HasRelationMetadata):\n1289 | source_name: str\n1290 | source_description: str\n1291 | loader: str\n1292 | identifier: str\n1293 | resource_type: Literal[NodeType.Source]\n1294 | \n1295 | \n1296 | @dataclass\n1297 | class SourceDefinition(NodeInfoMixin, ParsedSourceMandatory):\n1298 | quoting: Quoting = field(default_factory=Quoting)\n1299 | loaded_at_field: Optional[str] = None\n1300 | freshness: Optional[FreshnessThreshold] = None\n1301 | external: Optional[ExternalTable] = None\n1302 | description: str = \"\"\n1303 | columns: Dict[str, ColumnInfo] = field(default_factory=dict)\n1304 | meta: Dict[str, Any] = field(default_factory=dict)\n1305 | source_meta: Dict[str, Any] = field(default_factory=dict)\n1306 | tags: List[str] = field(default_factory=list)\n1307 | config: SourceConfig = field(default_factory=SourceConfig)\n1308 | patch_path: Optional[str] = None\n1309 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1310 | relation_name: Optional[str] = None\n1311 | created_at: float = field(default_factory=lambda: time.time())\n1312 | \n1313 | def __post_serialize__(self, dct):\n1314 | if \"_event_status\" in dct:\n1315 | del dct[\"_event_status\"]\n1316 | return dct\n1317 | \n1318 | def same_database_representation(self, other: \"SourceDefinition\") -> bool:\n1319 | return (\n1320 | self.database == other.database\n1321 | and self.schema == other.schema\n1322 | and self.identifier == other.identifier\n1323 | and True\n1324 | )\n1325 | \n1326 | def same_quoting(self, other: \"SourceDefinition\") -> bool:\n1327 | return self.quoting == other.quoting\n1328 | \n1329 | def same_freshness(self, other: \"SourceDefinition\") -> bool:\n1330 | return (\n1331 | self.freshness == other.freshness\n1332 | and self.loaded_at_field == other.loaded_at_field\n1333 | and True\n1334 | )\n1335 | \n1336 | def same_external(self, other: \"SourceDefinition\") -> bool:\n1337 | return self.external == other.external\n1338 | \n1339 | def same_config(self, old: \"SourceDefinition\") -> bool:\n1340 | return self.config.same_contents(\n1341 | self.unrendered_config,\n1342 | old.unrendered_config,\n1343 | )\n1344 | \n1345 | def same_contents(self, old: Optional[\"SourceDefinition\"]) -> bool:\n1346 | # existing when it didn't before is a change!\n1347 | if old is None:\n1348 | return True\n1349 | \n1350 | # config changes are changes (because the only config is \"enforced\", and\n1351 | # enabling a source is a change!)\n1352 | # changing the database/schema/identifier is a change\n1353 | # messing around with external stuff is a change (uh, right?)\n1354 | # quoting changes are changes\n1355 | # freshness changes are changes, I guess\n1356 | # metadata/tags changes are not \"changes\"\n1357 | # patching/description changes are not \"changes\"\n1358 | return (\n1359 | self.same_database_representation(old)\n1360 | and self.same_fqn(old)\n1361 | and self.same_config(old)\n1362 | and self.same_quoting(old)\n1363 | and self.same_freshness(old)\n1364 | and self.same_external(old)\n1365 | and True\n1366 | )\n1367 | \n1368 | def get_full_source_name(self):\n1369 | return f\"{self.source_name}_{self.name}\"\n1370 | \n1371 | def get_source_representation(self):\n1372 | return f'source(\"{self.source.name}\", \"{self.table.name}\")'\n1373 | \n1374 | @property\n1375 | def is_refable(self):\n1376 | return False\n1377 | \n1378 | @property\n1379 | def is_ephemeral(self):\n1380 | return False\n1381 | \n1382 | @property\n1383 | def is_ephemeral_model(self):\n1384 | return False\n1385 | \n1386 | @property\n1387 | def depends_on_nodes(self):\n1388 | return []\n1389 | \n1390 | @property\n1391 | def depends_on(self):\n1392 | return DependsOn(macros=[], nodes=[])\n1393 | \n1394 | @property\n1395 | def refs(self):\n1396 | return []\n1397 | \n1398 | @property\n1399 | def sources(self):\n1400 | return []\n1401 | \n1402 | @property\n1403 | def has_freshness(self) -> bool:\n1404 | return bool(self.freshness)\n1405 | \n1406 | @property\n1407 | def search_name(self):\n1408 | return f\"{self.source_name}.{self.name}\"\n1409 | \n1410 | @property\n1411 | def group(self):\n1412 | return None\n1413 | \n1414 | \n1415 | # ====================================\n1416 | # Exposure node\n1417 | # ====================================\n1418 | \n1419 | \n1420 | @dataclass\n1421 | class Exposure(GraphNode):\n1422 | type: ExposureType\n1423 | owner: Owner\n1424 | resource_type: Literal[NodeType.Exposure]\n1425 | description: str = \"\"\n1426 | label: Optional[str] = None\n1427 | maturity: Optional[MaturityType] = None\n1428 | meta: Dict[str, Any] = field(default_factory=dict)\n1429 | tags: List[str] = field(default_factory=list)\n1430 | config: ExposureConfig = field(default_factory=ExposureConfig)\n1431 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1432 | url: Optional[str] = None\n1433 | depends_on: DependsOn = field(default_factory=DependsOn)\n1434 | refs: List[RefArgs] = field(default_factory=list)\n1435 | sources: List[List[str]] = field(default_factory=list)\n1436 | metrics: List[List[str]] = field(default_factory=list)\n1437 | created_at: float = field(default_factory=lambda: time.time())\n1438 | \n1439 | @property\n1440 | def depends_on_nodes(self):\n1441 | return self.depends_on.nodes\n1442 | \n1443 | @property\n1444 | def search_name(self):\n1445 | return self.name\n1446 | \n1447 | def same_depends_on(self, old: \"Exposure\") -> bool:\n1448 | return set(self.depends_on.nodes) == set(old.depends_on.nodes)\n1449 | \n1450 | def same_description(self, old: \"Exposure\") -> bool:\n1451 | return self.description == old.description\n1452 | \n1453 | def same_label(self, old: \"Exposure\") -> bool:\n1454 | return self.label == old.label\n1455 | \n1456 | def same_maturity(self, old: \"Exposure\") -> bool:\n1457 | return self.maturity == old.maturity\n1458 | \n1459 | def same_owner(self, old: \"Exposure\") -> bool:\n1460 | return self.owner == old.owner\n1461 | \n1462 | def same_exposure_type(self, old: \"Exposure\") -> bool:\n1463 | return self.type == old.type\n1464 | \n1465 | def same_url(self, old: \"Exposure\") -> bool:\n1466 | return self.url == old.url\n1467 | \n1468 | def same_config(self, old: \"Exposure\") -> bool:\n1469 | return self.config.same_contents(\n1470 | self.unrendered_config,\n1471 | old.unrendered_config,\n1472 | )\n1473 | \n1474 | def same_contents(self, old: Optional[\"Exposure\"]) -> bool:\n1475 | # existing when it didn't before is a change!\n1476 | # metadata/tags changes are not \"changes\"\n1477 | if old is None:\n1478 | return True\n1479 | \n1480 | return (\n1481 | self.same_fqn(old)\n1482 | and self.same_exposure_type(old)\n1483 | and self.same_owner(old)\n1484 | and self.same_maturity(old)\n1485 | and self.same_url(old)\n1486 | and self.same_description(old)\n1487 | and self.same_label(old)\n1488 | and self.same_depends_on(old)\n1489 | and self.same_config(old)\n1490 | and True\n1491 | )\n1492 | \n1493 | @property\n1494 | def group(self):\n1495 | return None\n1496 | \n1497 | \n1498 | # ====================================\n1499 | # Metric node\n1500 | # ====================================\n1501 | \n1502 | \n1503 | @dataclass\n1504 | class MetricInputMeasure(dbtClassMixin):\n1505 | name: str\n1506 | filter: Optional[WhereFilterIntersection] = None\n1507 | alias: Optional[str] = None\n1508 | join_to_timespine: bool = False\n1509 | fill_nulls_with: Optional[int] = None\n1510 | \n1511 | def measure_reference(self) -> MeasureReference:\n1512 | return MeasureReference(element_name=self.name)\n1513 | \n1514 | def post_aggregation_measure_reference(self) -> MeasureReference:\n1515 | return MeasureReference(element_name=self.alias or self.name)\n1516 | \n1517 | \n1518 | @dataclass\n1519 | class MetricTimeWindow(dbtClassMixin):\n1520 | count: int\n1521 | granularity: TimeGranularity\n1522 | \n1523 | \n1524 | @dataclass\n1525 | class MetricInput(dbtClassMixin):\n1526 | name: str\n1527 | filter: Optional[WhereFilterIntersection] = None\n1528 | alias: Optional[str] = None\n1529 | offset_window: Optional[MetricTimeWindow] = None\n1530 | offset_to_grain: Optional[TimeGranularity] = None\n1531 | \n1532 | def as_reference(self) -> DSIMetricReference:\n1533 | return DSIMetricReference(element_name=self.name)\n1534 | \n1535 | def post_aggregation_reference(self) -> DSIMetricReference:\n1536 | return DSIMetricReference(element_name=self.alias or self.name)\n1537 | \n1538 | \n1539 | @dataclass\n1540 | class ConversionTypeParams(dbtClassMixin):\n1541 | base_measure: MetricInputMeasure\n1542 | conversion_measure: MetricInputMeasure\n1543 | entity: str\n1544 | calculation: ConversionCalculationType = ConversionCalculationType.CONVERSION_RATE\n1545 | window: Optional[MetricTimeWindow] = None\n1546 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n1547 | \n1548 | \n1549 | @dataclass\n1550 | class MetricTypeParams(dbtClassMixin):\n1551 | measure: Optional[MetricInputMeasure] = None\n1552 | input_measures: List[MetricInputMeasure] = field(default_factory=list)\n1553 | numerator: Optional[MetricInput] = None\n1554 | denominator: Optional[MetricInput] = None\n1555 | expr: Optional[str] = None\n1556 | window: Optional[MetricTimeWindow] = None\n1557 | grain_to_date: Optional[TimeGranularity] = None\n1558 | metrics: Optional[List[MetricInput]] = None\n1559 | conversion_type_params: Optional[ConversionTypeParams] = None\n1560 | \n1561 | \n1562 | @dataclass\n1563 | class MetricReference(dbtClassMixin, Replaceable):\n1564 | sql: Optional[Union[str, int]] = None\n1565 | unique_id: Optional[str] = None\n1566 | \n1567 | \n1568 | @dataclass\n1569 | class Metric(GraphNode):\n1570 | name: str\n1571 | description: str\n1572 | label: str\n1573 | type: MetricType\n1574 | type_params: MetricTypeParams\n1575 | filter: Optional[WhereFilterIntersection] = None\n1576 | metadata: Optional[SourceFileMetadata] = None\n1577 | resource_type: Literal[NodeType.Metric]\n1578 | meta: Dict[str, Any] = field(default_factory=dict)\n1579 | tags: List[str] = field(default_factory=list)\n1580 | config: MetricConfig = field(default_factory=MetricConfig)\n1581 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1582 | sources: List[List[str]] = field(default_factory=list)\n1583 | depends_on: DependsOn = field(default_factory=DependsOn)\n1584 | refs: List[RefArgs] = field(default_factory=list)\n1585 | metrics: List[List[str]] = field(default_factory=list)\n1586 | created_at: float = field(default_factory=lambda: time.time())\n1587 | group: Optional[str] = None\n1588 | \n1589 | @property\n1590 | def depends_on_nodes(self):\n1591 | return self.depends_on.nodes\n1592 | \n1593 | @property\n1594 | def search_name(self):\n1595 | return self.name\n1596 | \n1597 | @property\n1598 | def input_measures(self) -> List[MetricInputMeasure]:\n1599 | return self.type_params.input_measures\n1600 | \n1601 | @property\n1602 | def measure_references(self) -> List[MeasureReference]:\n1603 | return [x.measure_reference() for x in self.input_measures]\n1604 | \n1605 | @property\n1606 | def input_metrics(self) -> List[MetricInput]:\n1607 | return self.type_params.metrics or []\n1608 | \n1609 | def same_description(self, old: \"Metric\") -> bool:\n1610 | return self.description == old.description\n1611 | \n1612 | def same_label(self, old: \"Metric\") -> bool:\n1613 | return self.label == old.label\n1614 | \n1615 | def same_config(self, old: \"Metric\") -> bool:\n1616 | return self.config.same_contents(\n1617 | self.unrendered_config,\n1618 | old.unrendered_config,\n1619 | )\n1620 | \n1621 | def same_filter(self, old: \"Metric\") -> bool:\n1622 | return True # TODO\n1623 | \n1624 | def same_metadata(self, old: \"Metric\") -> bool:\n1625 | return True # TODO\n1626 | \n1627 | def same_type(self, old: \"Metric\") -> bool:\n1628 | return self.type == old.type\n1629 | \n1630 | def same_type_params(self, old: \"Metric\") -> bool:\n1631 | return True # TODO\n1632 | \n1633 | def same_contents(self, old: Optional[\"Metric\"]) -> bool:\n1634 | # existing when it didn't before is a change!\n1635 | # metadata/tags changes are not \"changes\"\n1636 | if old is None:\n1637 | return True\n1638 | \n1639 | return (\n1640 | self.same_filter(old)\n1641 | and self.same_metadata(old)\n1642 | and self.same_type(old)\n1643 | and self.same_type_params(old)\n1644 | and self.same_description(old)\n1645 | and self.same_label(old)\n1646 | and self.same_config(old)\n1647 | and True\n1648 | )\n1649 | \n1650 | \n1651 | # ====================================\n1652 | # Group node\n1653 | # ====================================\n1654 | \n1655 | \n1656 | @dataclass\n1657 | class Group(GroupResource, BaseNode):\n1658 | pass\n1659 | \n1660 | \n1661 | # ====================================\n1662 | # SemanticModel and related classes\n1663 | # ====================================\n1664 | \n1665 | \n1666 | @dataclass\n1667 | class NodeRelation(dbtClassMixin):\n1668 | alias: str\n1669 | schema_name: str # TODO: Could this be called simply \"schema\" so we could reuse StateRelation?\n1670 | database: Optional[str] = None\n1671 | relation_name: Optional[str] = None\n1672 | \n1673 | \n1674 | @dataclass\n1675 | class SemanticModel(GraphNode):\n1676 | model: str\n1677 | node_relation: Optional[NodeRelation]\n1678 | description: Optional[str] = None\n1679 | label: Optional[str] = None\n1680 | defaults: Optional[Defaults] = None\n1681 | entities: Sequence[Entity] = field(default_factory=list)\n1682 | measures: Sequence[Measure] = field(default_factory=list)\n1683 | dimensions: Sequence[Dimension] = field(default_factory=list)\n1684 | metadata: Optional[SourceFileMetadata] = None\n1685 | depends_on: DependsOn = field(default_factory=DependsOn)\n1686 | refs: List[RefArgs] = field(default_factory=list)\n1687 | created_at: float = field(default_factory=lambda: time.time())\n1688 | config: SemanticModelConfig = field(default_factory=SemanticModelConfig)\n1689 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1690 | primary_entity: Optional[str] = None\n1691 | group: Optional[str] = None\n1692 | \n1693 | @property\n1694 | def entity_references(self) -> List[LinkableElementReference]:\n1695 | return [entity.reference for entity in self.entities]\n1696 | \n1697 | @property\n1698 | def dimension_references(self) -> List[LinkableElementReference]:\n1699 | return [dimension.reference for dimension in self.dimensions]\n1700 | \n1701 | @property\n1702 | def measure_references(self) -> List[MeasureReference]:\n1703 | return [measure.reference for measure in self.measures]\n1704 | \n1705 | @property\n1706 | def has_validity_dimensions(self) -> bool:\n1707 | return any([dim.validity_params is not None for dim in self.dimensions])\n1708 | \n1709 | @property\n1710 | def validity_start_dimension(self) -> Optional[Dimension]:\n1711 | validity_start_dims = [\n1712 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_start\n1713 | ]\n1714 | if not validity_start_dims:\n1715 | return None\n1716 | return validity_start_dims[0]\n1717 | \n1718 | @property\n1719 | def validity_end_dimension(self) -> Optional[Dimension]:\n1720 | validity_end_dims = [\n1721 | dim for dim in self.dimensions if dim.validity_params and dim.validity_params.is_end\n1722 | ]\n1723 | if not validity_end_dims:\n1724 | return None\n1725 | return validity_end_dims[0]\n1726 | \n1727 | @property\n1728 | def partitions(self) -> List[Dimension]: # noqa: D\n1729 | return [dim for dim in self.dimensions or [] if dim.is_partition]\n1730 | \n1731 | @property\n1732 | def partition(self) -> Optional[Dimension]:\n1733 | partitions = self.partitions\n1734 | if not partitions:\n1735 | return None\n1736 | return partitions[0]\n1737 | \n1738 | @property\n1739 | def reference(self) -> SemanticModelReference:\n1740 | return SemanticModelReference(semantic_model_name=self.name)\n1741 | \n1742 | @property\n1743 | def depends_on_nodes(self):\n1744 | return self.depends_on.nodes\n1745 | \n1746 | @property\n1747 | def depends_on_macros(self):\n1748 | return self.depends_on.macros\n1749 | \n1750 | def checked_agg_time_dimension_for_measure(\n1751 | self, measure_reference: MeasureReference\n1752 | ) -> TimeDimensionReference:\n1753 | measure: Optional[Measure] = None\n1754 | for measure in self.measures:\n1755 | if measure.reference == measure_reference:\n1756 | measure = measure\n1757 | \n1758 | assert (\n1759 | measure is not None\n1760 | ), f\"No measure with name ({measure_reference.element_name}) in semantic_model with name ({self.name})\"\n1761 | \n1762 | default_agg_time_dimension = (\n1763 | self.defaults.agg_time_dimension if self.defaults is not None else None\n1764 | )\n1765 | \n1766 | agg_time_dimension_name = measure.agg_time_dimension or default_agg_time_dimension\n1767 | assert agg_time_dimension_name is not None, (\n1768 | f\"Aggregation time dimension for measure {measure.name} on semantic model {self.name} is not set! \"\n1769 | \"To fix this either specify a default `agg_time_dimension` for the semantic model or define an \"\n1770 | \"`agg_time_dimension` on the measure directly.\"\n1771 | )\n1772 | return TimeDimensionReference(element_name=agg_time_dimension_name)\n1773 | \n1774 | @property\n1775 | def primary_entity_reference(self) -> Optional[EntityReference]:\n1776 | return (\n1777 | EntityReference(element_name=self.primary_entity)\n1778 | if self.primary_entity is not None\n1779 | else None\n1780 | )\n1781 | \n1782 | def same_model(self, old: \"SemanticModel\") -> bool:\n1783 | return self.model == old.same_model\n1784 | \n1785 | def same_node_relation(self, old: \"SemanticModel\") -> bool:\n1786 | return self.node_relation == old.node_relation\n1787 | \n1788 | def same_description(self, old: \"SemanticModel\") -> bool:\n1789 | return self.description == old.description\n1790 | \n1791 | def same_defaults(self, old: \"SemanticModel\") -> bool:\n1792 | return self.defaults == old.defaults\n1793 | \n1794 | def same_entities(self, old: \"SemanticModel\") -> bool:\n1795 | return self.entities == old.entities\n1796 | \n1797 | def same_dimensions(self, old: \"SemanticModel\") -> bool:\n1798 | return self.dimensions == old.dimensions\n1799 | \n1800 | def same_measures(self, old: \"SemanticModel\") -> bool:\n1801 | return self.measures == old.measures\n1802 | \n1803 | def same_config(self, old: \"SemanticModel\") -> bool:\n1804 | return self.config == old.config\n1805 | \n1806 | def same_primary_entity(self, old: \"SemanticModel\") -> bool:\n1807 | return self.primary_entity == old.primary_entity\n1808 | \n1809 | def same_group(self, old: \"SemanticModel\") -> bool:\n1810 | return self.group == old.group\n1811 | \n1812 | def same_contents(self, old: Optional[\"SemanticModel\"]) -> bool:\n1813 | # existing when it didn't before is a change!\n1814 | # metadata/tags changes are not \"changes\"\n1815 | if old is None:\n1816 | return True\n1817 | \n1818 | return (\n1819 | self.same_model(old)\n1820 | and self.same_node_relation(old)\n1821 | and self.same_description(old)\n1822 | and self.same_defaults(old)\n1823 | and self.same_entities(old)\n1824 | and self.same_dimensions(old)\n1825 | and self.same_measures(old)\n1826 | and self.same_config(old)\n1827 | and self.same_primary_entity(old)\n1828 | and self.same_group(old)\n1829 | and True\n1830 | )\n1831 | \n1832 | \n1833 | # ====================================\n1834 | # SavedQuery and related classes\n1835 | # ====================================\n1836 | \n1837 | \n1838 | @dataclass\n1839 | class SavedQueryMandatory(GraphNode):\n1840 | query_params: QueryParams\n1841 | exports: List[Export]\n1842 | \n1843 | \n1844 | @dataclass\n1845 | class SavedQuery(NodeInfoMixin, SavedQueryMandatory):\n1846 | description: Optional[str] = None\n1847 | label: Optional[str] = None\n1848 | metadata: Optional[SourceFileMetadata] = None\n1849 | config: SavedQueryConfig = field(default_factory=SavedQueryConfig)\n1850 | unrendered_config: Dict[str, Any] = field(default_factory=dict)\n1851 | group: Optional[str] = None\n1852 | depends_on: DependsOn = field(default_factory=DependsOn)\n1853 | created_at: float = field(default_factory=lambda: time.time())\n1854 | refs: List[RefArgs] = field(default_factory=list)\n1855 | \n1856 | @property\n1857 | def metrics(self) -> List[str]:\n1858 | return self.query_params.metrics\n1859 | \n1860 | @property\n1861 | def depends_on_nodes(self):\n1862 | return self.depends_on.nodes\n1863 | \n1864 | def same_metrics(self, old: \"SavedQuery\") -> bool:\n1865 | return self.query_params.metrics == old.query_params.metrics\n1866 | \n1867 | def same_group_by(self, old: \"SavedQuery\") -> bool:\n1868 | return self.query_params.group_by == old.query_params.group_by\n1869 | \n1870 | def same_description(self, old: \"SavedQuery\") -> bool:\n1871 | return self.description == old.description\n1872 | \n1873 | def same_where(self, old: \"SavedQuery\") -> bool:\n1874 | return self.query_params.where == old.query_params.where\n1875 | \n1876 | def same_label(self, old: \"SavedQuery\") -> bool:\n1877 | return self.label == old.label\n1878 | \n1879 | def same_config(self, old: \"SavedQuery\") -> bool:\n1880 | return self.config == old.config\n1881 | \n1882 | def same_group(self, old: \"SavedQuery\") -> bool:\n1883 | return self.group == old.group\n1884 | \n1885 | def same_exports(self, old: \"SavedQuery\") -> bool:\n1886 | if len(self.exports) != len(old.exports):\n1887 | return False\n1888 | \n1889 | # exports should be in the same order, so we zip them for easy iteration\n1890 | for (old_export, new_export) in zip(old.exports, self.exports):\n1891 | if not new_export.same_contents(old_export):\n1892 | return False\n1893 | \n1894 | return True\n1895 | \n1896 | def same_contents(self, old: Optional[\"SavedQuery\"]) -> bool:\n1897 | # existing when it didn't before is a change!\n1898 | # metadata/tags changes are not \"changes\"\n1899 | if old is None:\n1900 | return True\n1901 | \n1902 | return (\n1903 | self.same_metrics(old)\n1904 | and self.same_group_by(old)\n1905 | and self.same_description(old)\n1906 | and self.same_where(old)\n1907 | and self.same_label(old)\n1908 | and self.same_config(old)\n1909 | and self.same_group(old)\n1910 | and True\n1911 | )\n1912 | \n1913 | \n1914 | # ====================================\n1915 | # Patches\n1916 | # ====================================\n1917 | \n1918 | \n1919 | @dataclass\n1920 | class ParsedPatch(HasYamlMetadata, Replaceable):\n1921 | name: str\n1922 | description: str\n1923 | meta: Dict[str, Any]\n1924 | docs: Docs\n1925 | config: Dict[str, Any]\n1926 | \n1927 | \n1928 | # The parsed node update is only the 'patch', not the test. The test became a\n1929 | # regular parsed node. Note that description and columns must be present, but\n1930 | # may be empty.\n1931 | @dataclass\n1932 | class ParsedNodePatch(ParsedPatch):\n1933 | columns: Dict[str, ColumnInfo]\n1934 | access: Optional[str]\n1935 | version: Optional[NodeVersion]\n1936 | latest_version: Optional[NodeVersion]\n1937 | constraints: List[Dict[str, Any]]\n1938 | deprecation_date: Optional[datetime]\n1939 | \n1940 | \n1941 | @dataclass\n1942 | class ParsedMacroPatch(ParsedPatch):\n1943 | arguments: List[MacroArgument] = field(default_factory=list)\n1944 | \n1945 | \n1946 | # ====================================\n1947 | # Node unions/categories\n1948 | # ====================================\n1949 | \n1950 | \n1951 | # ManifestNode without SeedNode, which doesn't have the\n1952 | # SQL related attributes\n1953 | ManifestSQLNode = Union[\n1954 | AnalysisNode,\n1955 | SingularTestNode,\n1956 | HookNode,\n1957 | ModelNode,\n1958 | RPCNode,\n1959 | SqlNode,\n1960 | GenericTestNode,\n1961 | SnapshotNode,\n1962 | UnitTestNode,\n1963 | ]\n1964 | \n1965 | # All SQL nodes plus SeedNode (csv files)\n1966 | ManifestNode = Union[\n1967 | ManifestSQLNode,\n1968 | SeedNode,\n1969 | ]\n1970 | \n1971 | ResultNode = Union[\n1972 | ManifestNode,\n1973 | SourceDefinition,\n1974 | ]\n1975 | \n1976 | # All nodes that can be in the DAG\n1977 | GraphMemberNode = Union[\n1978 | ResultNode,\n1979 | Exposure,\n1980 | Metric,\n1981 | SavedQuery,\n1982 | SemanticModel,\n1983 | UnitTestDefinition,\n1984 | ]\n1985 | \n1986 | # All \"nodes\" (or node-like objects) in this file\n1987 | Resource = Union[\n1988 | GraphMemberNode,\n1989 | Documentation,\n1990 | Macro,\n1991 | Group,\n1992 | ]\n1993 | \n1994 | TestNode = Union[SingularTestNode, GenericTestNode]\n```\n\n### File: core/dbt/task/list.py\n\n```python\n 1 | import json\n 2 | \n 3 | from dbt.contracts.graph.nodes import (\n 4 | Exposure,\n 5 | SourceDefinition,\n 6 | Metric,\n 7 | SemanticModel,\n 8 | UnitTestDefinition,\n 9 | )\n 10 | from dbt.flags import get_flags\n 11 | from dbt.graph import ResourceTypeSelector\n 12 | from dbt.task.runnable import GraphRunnableTask\n 13 | from dbt.task.test import TestSelector\n 14 | from dbt.node_types import NodeType\n 15 | from dbt_common.events.functions import (\n 16 | fire_event,\n 17 | warn_or_error,\n 18 | )\n 19 | from dbt.events.types import NoNodesSelected, ListCmdOut\n 20 | from dbt_common.exceptions import DbtRuntimeError, DbtInternalError\n 21 | from dbt_common.events.contextvars import task_contextvars\n 22 | \n 23 | \n 24 | class ListTask(GraphRunnableTask):\n 25 | DEFAULT_RESOURCE_VALUES = frozenset(\n 26 | (\n 27 | NodeType.Model,\n 28 | NodeType.Snapshot,\n 29 | NodeType.Seed,\n 30 | NodeType.Test,\n 31 | NodeType.Source,\n 32 | NodeType.Exposure,\n 33 | NodeType.Metric,\n 34 | NodeType.SemanticModel,\n 35 | NodeType.Unit,\n 36 | )\n 37 | )\n 38 | ALL_RESOURCE_VALUES = DEFAULT_RESOURCE_VALUES | frozenset((NodeType.Analysis,))\n 39 | ALLOWED_KEYS = frozenset(\n 40 | (\n 41 | \"alias\",\n 42 | \"name\",\n 43 | \"package_name\",\n 44 | \"depends_on\",\n 45 | \"tags\",\n 46 | \"config\",\n 47 | \"resource_type\",\n 48 | \"source_name\",\n 49 | \"original_file_path\",\n 50 | \"unique_id\",\n 51 | )\n 52 | )\n 53 | \n 54 | def __init__(self, args, config, manifest) -> None:\n 55 | super().__init__(args, config, manifest)\n 56 | if self.args.models:\n 57 | if self.args.select:\n 58 | raise DbtRuntimeError('\"models\" and \"select\" are mutually exclusive arguments')\n 59 | if self.args.resource_types:\n 60 | raise DbtRuntimeError(\n 61 | '\"models\" and \"resource_type\" are mutually exclusive ' \"arguments\"\n 62 | )\n 63 | \n 64 | def _iterate_selected_nodes(self):\n 65 | selector = self.get_node_selector()\n 66 | spec = self.get_selection_spec()\n 67 | unique_ids = sorted(selector.get_selected(spec))\n 68 | if not unique_ids:\n 69 | warn_or_error(NoNodesSelected())\n 70 | return\n 71 | if self.manifest is None:\n 72 | raise DbtInternalError(\"manifest is None in _iterate_selected_nodes\")\n 73 | for unique_id in unique_ids:\n 74 | if unique_id in self.manifest.nodes:\n 75 | yield self.manifest.nodes[unique_id]\n 76 | elif unique_id in self.manifest.sources:\n 77 | yield self.manifest.sources[unique_id]\n 78 | elif unique_id in self.manifest.exposures:\n 79 | yield self.manifest.exposures[unique_id]\n 80 | elif unique_id in self.manifest.metrics:\n 81 | yield self.manifest.metrics[unique_id]\n 82 | elif unique_id in self.manifest.semantic_models:\n 83 | yield self.manifest.semantic_models[unique_id]\n 84 | elif unique_id in self.manifest.unit_tests:\n 85 | yield self.manifest.unit_tests[unique_id]\n 86 | else:\n 87 | raise DbtRuntimeError(\n 88 | f'Got an unexpected result from node selection: \"{unique_id}\"'\n 89 | f\"Expected a source or a node!\"\n 90 | )\n 91 | \n 92 | def generate_selectors(self):\n 93 | for node in self._iterate_selected_nodes():\n 94 | if node.resource_type == NodeType.Source:\n 95 | assert isinstance(node, SourceDefinition)\n 96 | # sources are searched for by pkg.source_name.table_name\n 97 | source_selector = \".\".join([node.package_name, node.source_name, node.name])\n 98 | yield f\"source:{source_selector}\"\n 99 | elif node.resource_type == NodeType.Exposure:\n100 | assert isinstance(node, Exposure)\n101 | # exposures are searched for by pkg.exposure_name\n102 | exposure_selector = \".\".join([node.package_name, node.name])\n103 | yield f\"exposure:{exposure_selector}\"\n104 | elif node.resource_type == NodeType.Metric:\n105 | assert isinstance(node, Metric)\n106 | # metrics are searched for by pkg.metric_name\n107 | metric_selector = \".\".join([node.package_name, node.name])\n108 | yield f\"metric:{metric_selector}\"\n109 | elif node.resource_type == NodeType.SemanticModel:\n110 | assert isinstance(node, SemanticModel)\n111 | semantic_model_selector = \".\".join([node.package_name, node.name])\n112 | yield f\"semantic_model:{semantic_model_selector}\"\n113 | elif node.resource_type == NodeType.Unit:\n114 | assert isinstance(node, UnitTestDefinition)\n115 | unit_test_selector = \".\".join([node.package_name, node.versioned_name])\n116 | yield f\"unit_test:{unit_test_selector}\"\n117 | else:\n118 | # everything else is from `fqn`\n119 | yield \".\".join(node.fqn)\n120 | \n121 | def generate_names(self):\n122 | for node in self._iterate_selected_nodes():\n123 | yield node.search_name\n124 | \n125 | def generate_json(self):\n126 | for node in self._iterate_selected_nodes():\n127 | yield json.dumps(\n128 | {\n129 | k: v\n130 | for k, v in node.to_dict(omit_none=False).items()\n131 | if (\n132 | k in self.args.output_keys\n133 | if self.args.output_keys\n134 | else k in self.ALLOWED_KEYS\n135 | )\n136 | }\n137 | )\n138 | \n139 | def generate_paths(self):\n140 | for node in self._iterate_selected_nodes():\n141 | yield node.original_file_path\n142 | \n143 | def run(self):\n144 | # We set up a context manager here with \"task_contextvars\" because we\n145 | # we need the project_root in compile_manifest.\n146 | with task_contextvars(project_root=self.config.project_root):\n147 | self.compile_manifest()\n148 | output = self.args.output\n149 | if output == \"selector\":\n150 | generator = self.generate_selectors\n151 | elif output == \"name\":\n152 | generator = self.generate_names\n153 | elif output == \"json\":\n154 | generator = self.generate_json\n155 | elif output == \"path\":\n156 | generator = self.generate_paths\n157 | else:\n158 | raise DbtInternalError(\"Invalid output {}\".format(output))\n159 | \n160 | return self.output_results(generator())\n161 | \n162 | def output_results(self, results):\n163 | \"\"\"Log, or output a plain, newline-delimited, and ready-to-pipe list of nodes found.\"\"\"\n164 | for result in results:\n165 | self.node_results.append(result)\n166 | if get_flags().LOG_FORMAT == \"json\":\n167 | fire_event(ListCmdOut(msg=result))\n168 | else:\n169 | # Cleaner to leave as print than to mutate the logger not to print timestamps.\n170 | print(result)\n171 | return self.node_results\n172 | \n173 | @property\n174 | def resource_types(self):\n175 | if self.args.models:\n176 | return [NodeType.Model]\n177 | \n178 | if not self.args.resource_types:\n179 | return list(self.DEFAULT_RESOURCE_VALUES)\n180 | \n181 | values = set(self.args.resource_types)\n182 | if \"default\" in values:\n183 | values.remove(\"default\")\n184 | values.update(self.DEFAULT_RESOURCE_VALUES)\n185 | if \"all\" in values:\n186 | values.remove(\"all\")\n187 | values.update(self.ALL_RESOURCE_VALUES)\n188 | return list(values)\n189 | \n190 | @property\n191 | def selection_arg(self):\n192 | # for backwards compatibility, list accepts both --models and --select,\n193 | # with slightly different behavior: --models implies --resource-type model\n194 | if self.args.models:\n195 | return self.args.models\n196 | else:\n197 | return self.args.select\n198 | \n199 | def get_node_selector(self):\n200 | if self.manifest is None or self.graph is None:\n201 | raise DbtInternalError(\"manifest and graph must be set to get perform node selection\")\n202 | if self.resource_types == [NodeType.Test]:\n203 | return TestSelector(\n204 | graph=self.graph,\n205 | manifest=self.manifest,\n206 | previous_state=self.previous_state,\n207 | )\n208 | else:\n209 | return ResourceTypeSelector(\n210 | graph=self.graph,\n211 | manifest=self.manifest,\n212 | previous_state=self.previous_state,\n213 | resource_types=self.resource_types,\n214 | include_empty_nodes=True,\n215 | )\n216 | \n217 | def interpret_results(self, results):\n218 | # list command should always return 0 as exit code\n219 | return True\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/nodes.py\n+++ b/core/dbt/contracts/graph/nodes.py\n@@ -1091,6 +1091,13 @@ class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):\n tags = self.config.tags\n return [tags] if isinstance(tags, str) else tags\n \n+ @property\n+ def versioned_name(self) -> str:\n+ versioned_name = self.name\n+ if self.version is not None:\n+ versioned_name += f\"_v{self.version}\"\n+ return versioned_name\n+\n def build_unit_test_checksum(self):\n # everything except 'description'\n data = f\"{self.model}-{self.versions}-{self.given}-{self.expect}-{self.overrides}\"\ndiff --git a/core/dbt/task/list.py b/core/dbt/task/list.py\nindex 0000000..0000000 100644\n--- a/core/dbt/task/list.py\n+++ b/core/dbt/task/list.py\n@@ -1,6 +1,12 @@\n import json\n \n-from dbt.contracts.graph.nodes import Exposure, SourceDefinition, Metric, SemanticModel\n+from dbt.contracts.graph.nodes import (\n+ Exposure,\n+ SourceDefinition,\n+ Metric,\n+ SemanticModel,\n+ UnitTestDefinition,\n+)\n from dbt.flags import get_flags\n from dbt.graph import ResourceTypeSelector\n from dbt.task.runnable import GraphRunnableTask\n@@ -26,6 +32,7 @@ class ListTask(GraphRunnableTask):\n NodeType.Exposure,\n NodeType.Metric,\n NodeType.SemanticModel,\n+ NodeType.Unit,\n )\n )\n ALL_RESOURCE_VALUES = DEFAULT_RESOURCE_VALUES | frozenset((NodeType.Analysis,))\n@@ -57,26 +64,28 @@ class ListTask(GraphRunnableTask):\n def _iterate_selected_nodes(self):\n selector = self.get_node_selector()\n spec = self.get_selection_spec()\n- nodes = sorted(selector.get_selected(spec))\n- if not nodes:\n+ unique_ids = sorted(selector.get_selected(spec))\n+ if not unique_ids:\n warn_or_error(NoNodesSelected())\n return\n if self.manifest is None:\n raise DbtInternalError(\"manifest is None in _iterate_selected_nodes\")\n- for node in nodes:\n- if node in self.manifest.nodes:\n- yield self.manifest.nodes[node]\n- elif node in self.manifest.sources:\n- yield self.manifest.sources[node]\n- elif node in self.manifest.exposures:\n- yield self.manifest.exposures[node]\n- elif node in self.manifest.metrics:\n- yield self.manifest.metrics[node]\n- elif node in self.manifest.semantic_models:\n- yield self.manifest.semantic_models[node]\n+ for unique_id in unique_ids:\n+ if unique_id in self.manifest.nodes:\n+ yield self.manifest.nodes[unique_id]\n+ elif unique_id in self.manifest.sources:\n+ yield self.manifest.sources[unique_id]\n+ elif unique_id in self.manifest.exposures:\n+ yield self.manifest.exposures[unique_id]\n+ elif unique_id in self.manifest.metrics:\n+ yield self.manifest.metrics[unique_id]\n+ elif unique_id in self.manifest.semantic_models:\n+ yield self.manifest.semantic_models[unique_id]\n+ elif unique_id in self.manifest.unit_tests:\n+ yield self.manifest.unit_tests[unique_id]\n else:\n raise DbtRuntimeError(\n- f'Got an unexpected result from node selection: \"{node}\"'\n+ f'Got an unexpected result from node selection: \"{unique_id}\"'\n f\"Expected a source or a node!\"\n )\n \n@@ -101,6 +110,10 @@ class ListTask(GraphRunnableTask):\n assert isinstance(node, SemanticModel)\n semantic_model_selector = \".\".join([node.package_name, node.name])\n yield f\"semantic_model:{semantic_model_selector}\"\n+ elif node.resource_type == NodeType.Unit:\n+ assert isinstance(node, UnitTestDefinition)\n+ unit_test_selector = \".\".join([node.package_name, node.versioned_name])\n+ yield f\"unit_test:{unit_test_selector}\"\n else:\n # everything else is from `fqn`\n yield \".\".join(node.fqn)"},"prompt_input_token_count":{"kind":"number","value":54786,"string":"54,786"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9480\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"5ae8f6aad71545818a1f179abb45d5867f0e2e4f\",\n \"pull_number\": 9480,\n \"issue_numbers\": [\n \"8508\"\n ],\n \"changed_files\": [\n \"core/dbt/contracts/graph/nodes.py\",\n \"core/dbt/task/list.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32294,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9488"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 7a410ab228bda4d2ecd4ae44726a91a1030afd75\nChanged files:\n- core/dbt/artifacts/schemas/manifest/v12/manifest.py\n\n## Problem statement\n\n[Bug] Manifest `upgrade_schema_version` needs to process v11 manifests\n### Is this a new bug in dbt-core?\n\n- [X] I believe this is a new bug in dbt-core\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\n\n### Current Behavior\n\nTry running a command on dbt-core `main` using `--state` from v1.7:\r\n```\r\nmashumaro.exceptions.MissingField: Field \"unit_tests\" of type Mapping[str, UnitTestDefinition] is missing in WritableManifest instance\r\n```\n\n### Expected Behavior\n\nDon't see this error. Support backwards compatibility for v1.7-produced manifests (v11).\n\n### Steps To Reproduce\n\n1. Create a manifest using dbt-core v1.7, and stick in `state/` directory\r\n2. Switch to dbt-core v1.8.0-a1 (`main`)\r\n3. Run any command which uses state: `dbt ls -s state:modified --state state/`\r\n4. See the error\n\n### Relevant log output\n\n_No response_\n\n### Environment\n\n```markdown\n- OS: macOS 13.4.1\r\n- Python: 3.10.11\r\n- dbt: main\n```\n\n\n### Which database adapter are you using with dbt?\n\n_No response_\n\n### Additional Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/artifacts/schemas/manifest/v12/manifest.py\n\n```python\n 1 | from dataclasses import dataclass, field\n 2 | from typing import Mapping, Iterable, Tuple, Optional, Dict, List, Any\n 3 | from uuid import UUID\n 4 | \n 5 | from dbt.artifacts.schemas.base import (\n 6 | BaseArtifactMetadata,\n 7 | ArtifactMixin,\n 8 | schema_version,\n 9 | get_artifact_schema_version,\n 10 | )\n 11 | from dbt.artifacts.schemas.upgrades import upgrade_manifest_json\n 12 | from dbt.artifacts.resources import Documentation, Group, Macro\n 13 | \n 14 | # TODO: remove usage of dbt modules other than dbt.artifacts\n 15 | from dbt import tracking\n 16 | from dbt.flags import get_flags\n 17 | from dbt.contracts.graph.nodes import (\n 18 | Exposure,\n 19 | GraphMemberNode,\n 20 | ManifestNode,\n 21 | Metric,\n 22 | SavedQuery,\n 23 | SemanticModel,\n 24 | SourceDefinition,\n 25 | UnitTestDefinition,\n 26 | )\n 27 | \n 28 | \n 29 | NodeEdgeMap = Dict[str, List[str]]\n 30 | UniqueID = str\n 31 | \n 32 | \n 33 | @dataclass\n 34 | class ManifestMetadata(BaseArtifactMetadata):\n 35 | \"\"\"Metadata for the manifest.\"\"\"\n 36 | \n 37 | dbt_schema_version: str = field(\n 38 | default_factory=lambda: str(WritableManifest.dbt_schema_version)\n 39 | )\n 40 | project_name: Optional[str] = field(\n 41 | default=None,\n 42 | metadata={\n 43 | \"description\": \"Name of the root project\",\n 44 | },\n 45 | )\n 46 | project_id: Optional[str] = field(\n 47 | default=None,\n 48 | metadata={\n 49 | \"description\": \"A unique identifier for the project, hashed from the project name\",\n 50 | },\n 51 | )\n 52 | user_id: Optional[UUID] = field(\n 53 | default=None,\n 54 | metadata={\n 55 | \"description\": \"A unique identifier for the user\",\n 56 | },\n 57 | )\n 58 | send_anonymous_usage_stats: Optional[bool] = field(\n 59 | default=None,\n 60 | metadata=dict(\n 61 | description=(\"Whether dbt is configured to send anonymous usage statistics\")\n 62 | ),\n 63 | )\n 64 | adapter_type: Optional[str] = field(\n 65 | default=None,\n 66 | metadata=dict(description=\"The type name of the adapter\"),\n 67 | )\n 68 | \n 69 | def __post_init__(self):\n 70 | if tracking.active_user is None:\n 71 | return\n 72 | \n 73 | if self.user_id is None:\n 74 | self.user_id = tracking.active_user.id\n 75 | \n 76 | if self.send_anonymous_usage_stats is None:\n 77 | self.send_anonymous_usage_stats = get_flags().SEND_ANONYMOUS_USAGE_STATS\n 78 | \n 79 | @classmethod\n 80 | def default(cls):\n 81 | return cls(\n 82 | dbt_schema_version=str(WritableManifest.dbt_schema_version),\n 83 | )\n 84 | \n 85 | \n 86 | @dataclass\n 87 | @schema_version(\"manifest\", 12)\n 88 | class WritableManifest(ArtifactMixin):\n 89 | nodes: Mapping[UniqueID, ManifestNode] = field(\n 90 | metadata=dict(description=(\"The nodes defined in the dbt project and its dependencies\"))\n 91 | )\n 92 | sources: Mapping[UniqueID, SourceDefinition] = field(\n 93 | metadata=dict(description=(\"The sources defined in the dbt project and its dependencies\"))\n 94 | )\n 95 | macros: Mapping[UniqueID, Macro] = field(\n 96 | metadata=dict(description=(\"The macros defined in the dbt project and its dependencies\"))\n 97 | )\n 98 | docs: Mapping[UniqueID, Documentation] = field(\n 99 | metadata=dict(description=(\"The docs defined in the dbt project and its dependencies\"))\n100 | )\n101 | exposures: Mapping[UniqueID, Exposure] = field(\n102 | metadata=dict(\n103 | description=(\"The exposures defined in the dbt project and its dependencies\")\n104 | )\n105 | )\n106 | metrics: Mapping[UniqueID, Metric] = field(\n107 | metadata=dict(description=(\"The metrics defined in the dbt project and its dependencies\"))\n108 | )\n109 | groups: Mapping[UniqueID, Group] = field(\n110 | metadata=dict(description=(\"The groups defined in the dbt project\"))\n111 | )\n112 | selectors: Mapping[UniqueID, Any] = field(\n113 | metadata=dict(description=(\"The selectors defined in selectors.yml\"))\n114 | )\n115 | disabled: Optional[Mapping[UniqueID, List[GraphMemberNode]]] = field(\n116 | metadata=dict(description=\"A mapping of the disabled nodes in the target\")\n117 | )\n118 | parent_map: Optional[NodeEdgeMap] = field(\n119 | metadata=dict(\n120 | description=\"A mapping from child nodes to their dependencies\",\n121 | )\n122 | )\n123 | child_map: Optional[NodeEdgeMap] = field(\n124 | metadata=dict(\n125 | description=\"A mapping from parent nodes to their dependents\",\n126 | )\n127 | )\n128 | group_map: Optional[NodeEdgeMap] = field(\n129 | metadata=dict(\n130 | description=\"A mapping from group names to their nodes\",\n131 | )\n132 | )\n133 | saved_queries: Mapping[UniqueID, SavedQuery] = field(\n134 | metadata=dict(description=(\"The saved queries defined in the dbt project\"))\n135 | )\n136 | semantic_models: Mapping[UniqueID, SemanticModel] = field(\n137 | metadata=dict(description=(\"The semantic models defined in the dbt project\"))\n138 | )\n139 | metadata: ManifestMetadata = field(\n140 | metadata=dict(\n141 | description=\"Metadata about the manifest\",\n142 | )\n143 | )\n144 | unit_tests: Mapping[UniqueID, UnitTestDefinition] = field(\n145 | metadata=dict(\n146 | description=\"The unit tests defined in the project\",\n147 | )\n148 | )\n149 | \n150 | @classmethod\n151 | def compatible_previous_versions(cls) -> Iterable[Tuple[str, int]]:\n152 | return [\n153 | (\"manifest\", 4),\n154 | (\"manifest\", 5),\n155 | (\"manifest\", 6),\n156 | (\"manifest\", 7),\n157 | (\"manifest\", 8),\n158 | (\"manifest\", 9),\n159 | (\"manifest\", 10),\n160 | (\"manifest\", 11),\n161 | ]\n162 | \n163 | @classmethod\n164 | def upgrade_schema_version(cls, data):\n165 | \"\"\"This overrides the \"upgrade_schema_version\" call in VersionedSchema (via\n166 | ArtifactMixin) to modify the dictionary passed in from earlier versions of the manifest.\"\"\"\n167 | manifest_schema_version = get_artifact_schema_version(data)\n168 | if manifest_schema_version <= 10:\n169 | data = upgrade_manifest_json(data, manifest_schema_version)\n170 | return cls.from_dict(data)\n171 | \n172 | def __post_serialize__(self, dct):\n173 | for unique_id, node in dct[\"nodes\"].items():\n174 | if \"config_call_dict\" in node:\n175 | del node[\"config_call_dict\"]\n176 | if \"defer_relation\" in node:\n177 | del node[\"defer_relation\"]\n178 | return dct\n```\n\n## Files after the fix\n\n### File: core/dbt/artifacts/schemas/manifest/v12/manifest.py\n\n```python\n 1 | from dataclasses import dataclass, field\n 2 | from typing import Mapping, Iterable, Tuple, Optional, Dict, List, Any\n 3 | from uuid import UUID\n 4 | \n 5 | from dbt.artifacts.schemas.base import (\n 6 | BaseArtifactMetadata,\n 7 | ArtifactMixin,\n 8 | schema_version,\n 9 | get_artifact_schema_version,\n 10 | )\n 11 | from dbt.artifacts.schemas.upgrades import upgrade_manifest_json\n 12 | from dbt.artifacts.resources import Documentation, Group, Macro\n 13 | \n 14 | # TODO: remove usage of dbt modules other than dbt.artifacts\n 15 | from dbt import tracking\n 16 | from dbt.flags import get_flags\n 17 | from dbt.contracts.graph.nodes import (\n 18 | Exposure,\n 19 | GraphMemberNode,\n 20 | ManifestNode,\n 21 | Metric,\n 22 | SavedQuery,\n 23 | SemanticModel,\n 24 | SourceDefinition,\n 25 | UnitTestDefinition,\n 26 | )\n 27 | \n 28 | \n 29 | NodeEdgeMap = Dict[str, List[str]]\n 30 | UniqueID = str\n 31 | \n 32 | \n 33 | @dataclass\n 34 | class ManifestMetadata(BaseArtifactMetadata):\n 35 | \"\"\"Metadata for the manifest.\"\"\"\n 36 | \n 37 | dbt_schema_version: str = field(\n 38 | default_factory=lambda: str(WritableManifest.dbt_schema_version)\n 39 | )\n 40 | project_name: Optional[str] = field(\n 41 | default=None,\n 42 | metadata={\n 43 | \"description\": \"Name of the root project\",\n 44 | },\n 45 | )\n 46 | project_id: Optional[str] = field(\n 47 | default=None,\n 48 | metadata={\n 49 | \"description\": \"A unique identifier for the project, hashed from the project name\",\n 50 | },\n 51 | )\n 52 | user_id: Optional[UUID] = field(\n 53 | default=None,\n 54 | metadata={\n 55 | \"description\": \"A unique identifier for the user\",\n 56 | },\n 57 | )\n 58 | send_anonymous_usage_stats: Optional[bool] = field(\n 59 | default=None,\n 60 | metadata=dict(\n 61 | description=(\"Whether dbt is configured to send anonymous usage statistics\")\n 62 | ),\n 63 | )\n 64 | adapter_type: Optional[str] = field(\n 65 | default=None,\n 66 | metadata=dict(description=\"The type name of the adapter\"),\n 67 | )\n 68 | \n 69 | def __post_init__(self):\n 70 | if tracking.active_user is None:\n 71 | return\n 72 | \n 73 | if self.user_id is None:\n 74 | self.user_id = tracking.active_user.id\n 75 | \n 76 | if self.send_anonymous_usage_stats is None:\n 77 | self.send_anonymous_usage_stats = get_flags().SEND_ANONYMOUS_USAGE_STATS\n 78 | \n 79 | @classmethod\n 80 | def default(cls):\n 81 | return cls(\n 82 | dbt_schema_version=str(WritableManifest.dbt_schema_version),\n 83 | )\n 84 | \n 85 | \n 86 | @dataclass\n 87 | @schema_version(\"manifest\", 12)\n 88 | class WritableManifest(ArtifactMixin):\n 89 | nodes: Mapping[UniqueID, ManifestNode] = field(\n 90 | metadata=dict(description=(\"The nodes defined in the dbt project and its dependencies\"))\n 91 | )\n 92 | sources: Mapping[UniqueID, SourceDefinition] = field(\n 93 | metadata=dict(description=(\"The sources defined in the dbt project and its dependencies\"))\n 94 | )\n 95 | macros: Mapping[UniqueID, Macro] = field(\n 96 | metadata=dict(description=(\"The macros defined in the dbt project and its dependencies\"))\n 97 | )\n 98 | docs: Mapping[UniqueID, Documentation] = field(\n 99 | metadata=dict(description=(\"The docs defined in the dbt project and its dependencies\"))\n100 | )\n101 | exposures: Mapping[UniqueID, Exposure] = field(\n102 | metadata=dict(\n103 | description=(\"The exposures defined in the dbt project and its dependencies\")\n104 | )\n105 | )\n106 | metrics: Mapping[UniqueID, Metric] = field(\n107 | metadata=dict(description=(\"The metrics defined in the dbt project and its dependencies\"))\n108 | )\n109 | groups: Mapping[UniqueID, Group] = field(\n110 | metadata=dict(description=(\"The groups defined in the dbt project\"))\n111 | )\n112 | selectors: Mapping[UniqueID, Any] = field(\n113 | metadata=dict(description=(\"The selectors defined in selectors.yml\"))\n114 | )\n115 | disabled: Optional[Mapping[UniqueID, List[GraphMemberNode]]] = field(\n116 | metadata=dict(description=\"A mapping of the disabled nodes in the target\")\n117 | )\n118 | parent_map: Optional[NodeEdgeMap] = field(\n119 | metadata=dict(\n120 | description=\"A mapping from child nodes to their dependencies\",\n121 | )\n122 | )\n123 | child_map: Optional[NodeEdgeMap] = field(\n124 | metadata=dict(\n125 | description=\"A mapping from parent nodes to their dependents\",\n126 | )\n127 | )\n128 | group_map: Optional[NodeEdgeMap] = field(\n129 | metadata=dict(\n130 | description=\"A mapping from group names to their nodes\",\n131 | )\n132 | )\n133 | saved_queries: Mapping[UniqueID, SavedQuery] = field(\n134 | metadata=dict(description=(\"The saved queries defined in the dbt project\"))\n135 | )\n136 | semantic_models: Mapping[UniqueID, SemanticModel] = field(\n137 | metadata=dict(description=(\"The semantic models defined in the dbt project\"))\n138 | )\n139 | metadata: ManifestMetadata = field(\n140 | metadata=dict(\n141 | description=\"Metadata about the manifest\",\n142 | )\n143 | )\n144 | unit_tests: Mapping[UniqueID, UnitTestDefinition] = field(\n145 | metadata=dict(\n146 | description=\"The unit tests defined in the project\",\n147 | )\n148 | )\n149 | \n150 | @classmethod\n151 | def compatible_previous_versions(cls) -> Iterable[Tuple[str, int]]:\n152 | return [\n153 | (\"manifest\", 4),\n154 | (\"manifest\", 5),\n155 | (\"manifest\", 6),\n156 | (\"manifest\", 7),\n157 | (\"manifest\", 8),\n158 | (\"manifest\", 9),\n159 | (\"manifest\", 10),\n160 | (\"manifest\", 11),\n161 | ]\n162 | \n163 | @classmethod\n164 | def upgrade_schema_version(cls, data):\n165 | \"\"\"This overrides the \"upgrade_schema_version\" call in VersionedSchema (via\n166 | ArtifactMixin) to modify the dictionary passed in from earlier versions of the manifest.\"\"\"\n167 | manifest_schema_version = get_artifact_schema_version(data)\n168 | if manifest_schema_version < cls.dbt_schema_version.version:\n169 | data = upgrade_manifest_json(data, manifest_schema_version)\n170 | return cls.from_dict(data)\n171 | \n172 | def __post_serialize__(self, dct):\n173 | for unique_id, node in dct[\"nodes\"].items():\n174 | if \"config_call_dict\" in node:\n175 | del node[\"config_call_dict\"]\n176 | if \"defer_relation\" in node:\n177 | del node[\"defer_relation\"]\n178 | return dct\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/artifacts/schemas/manifest/v12/manifest.py b/core/dbt/artifacts/schemas/manifest/v12/manifest.py\nindex 0000000..0000000 100644\n--- a/core/dbt/artifacts/schemas/manifest/v12/manifest.py\n+++ b/core/dbt/artifacts/schemas/manifest/v12/manifest.py\n@@ -165,7 +165,7 @@ class WritableManifest(ArtifactMixin):\n \"\"\"This overrides the \"upgrade_schema_version\" call in VersionedSchema (via\n ArtifactMixin) to modify the dictionary passed in from earlier versions of the manifest.\"\"\"\n manifest_schema_version = get_artifact_schema_version(data)\n- if manifest_schema_version <= 10:\n+ if manifest_schema_version < cls.dbt_schema_version.version:\n data = upgrade_manifest_json(data, manifest_schema_version)\n return cls.from_dict(data)"},"prompt_input_token_count":{"kind":"number","value":4452,"string":"4,452"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9488\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"7a410ab228bda4d2ecd4ae44726a91a1030afd75\",\n \"pull_number\": 9488,\n \"issue_numbers\": [\n \"9487\"\n ],\n \"changed_files\": [\n \"core/dbt/artifacts/schemas/manifest/v12/manifest.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32295,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9495"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 9c8b28aa640382a381768904795c5e7124f9c8bc\nChanged files:\n- .github/actions/latest-wrangler/main.py\n\n## Problem statement\n\n[CT-2288] [Bug] Latest containers are not released and the wrong versions are marked `latest`\n### Current Behavior\r\n\r\nWe ran the workflow to generate the new containers for v1.4.4: [workflow output](https://github.com/dbt-labs/dbt-core/actions/runs/4308505619)\r\n\r\nThere were unexpected inputs found when trying to determine if this version is the latest (it is) in [this step](https://github.com/dbt-labs/dbt-core/actions/runs/4308505619/jobs/7514856225)\r\n\r\nWhich caused the build and publish steps to get skipped [here](https://github.com/dbt-labs/dbt-core/actions/runs/4308505619/jobs/7514867098)\r\n\r\nWe have not fully released `dbt-postgres` specifically.\r\n\r\nAdditionally the wrong package is marked as latest\r\n\r\n\r\n\r\nView all packages [here](https://github.com/orgs/dbt-labs/packages)\r\n\r\n### Expected Behavior\r\n\r\n1. everything gets released, and if it doesn't we get some kind of error\r\n2. the correct version gets marked as `latest`\r\n\r\n### Steps To Reproduce\r\n\r\nRun [release-docker.yml](https://github.com/dbt-labs/dbt-core/blob/main/.github/workflows/release-docker.yml)\r\n\r\n### Additional Context\r\n\r\nCurrent Package Versions\r\n\r\n| Package | Version Marked Latest | Most up to Date Package Version | Latest GitHub Release Version |\r\n| ----- | ----- | ----- | ----- |\r\n| dbt-core | 1.3.2 | 1.4.4 | n/a|\r\n| dbt-postgres | 1.2.3 | 1.4.1 | 1.4.4|\r\n| dbt-snowflake | 1.3.latest / 1.3.0 | 1.4.1 | 1.4.1 |\r\n| dbt-redshift | 1.3.latest / 1.3.0 | 1.4.0 | 1.4.0 |\r\n| dbt-bigquery | 1.3.latest / 1.3.0 | 1.4.1 | 1.4.1 |\r\n| dbt-spark | 1.3.latest / 1.3.0 | 1.4.1 | 1.4.1 |\n\n## Hints\n\nI am looking to add some CI to my dbt project and this is a blocker for me. I am on v1.4.6 and now need to look at reverting to v1.4.3 to get my project added to CI\nHi. Same here... Thanks\nThis issue is still partly happening, `dbt-postgres` images are not being published since 1.7.2. It might be related to the current moving of `dbt-postgres` out of `dbt-core` though.\n`dbt-postgres` is back, so not affected anymore, sorry for the noise.\n\n## Files before the fix\n\n### File: .github/actions/latest-wrangler/main.py\n\n```python\n 1 | import os\n 2 | import sys\n 3 | import requests\n 4 | from distutils.util import strtobool\n 5 | from typing import Union\n 6 | from packaging.version import parse, Version\n 7 | \n 8 | if __name__ == \"__main__\":\n 9 | \n10 | # get inputs\n11 | package = os.environ[\"INPUT_PACKAGE\"]\n12 | new_version = parse(os.environ[\"INPUT_NEW_VERSION\"])\n13 | gh_token = os.environ[\"INPUT_GH_TOKEN\"]\n14 | halt_on_missing = strtobool(os.environ.get(\"INPUT_HALT_ON_MISSING\", \"False\"))\n15 | \n16 | # get package metadata from github\n17 | package_request = requests.get(\n18 | f\"https://api.github.com/orgs/dbt-labs/packages/container/{package}/versions\",\n19 | auth=(\"\", gh_token),\n20 | )\n21 | package_meta = package_request.json()\n22 | \n23 | # Log info if we don't get a 200\n24 | if package_request.status_code != 200:\n25 | print(f\"Call to GH API failed: {package_request.status_code} {package_meta['message']}\")\n26 | \n27 | # Make an early exit if there is no matching package in github\n28 | if package_request.status_code == 404:\n29 | if halt_on_missing:\n30 | sys.exit(1)\n31 | # everything is the latest if the package doesn't exist\n32 | github_output = os.environ.get(\"GITHUB_OUTPUT\")\n33 | with open(github_output, \"at\", encoding=\"utf-8\") as gh_output:\n34 | gh_output.write(\"latest=True\")\n35 | gh_output.write(\"minor_latest=True\")\n36 | sys.exit(0)\n37 | \n38 | # TODO: verify package meta is \"correct\"\n39 | # https://github.com/dbt-labs/dbt-core/issues/4640\n40 | \n41 | # map versions and tags\n42 | version_tag_map = {\n43 | version[\"id\"]: version[\"metadata\"][\"container\"][\"tags\"] for version in package_meta\n44 | }\n45 | \n46 | # is pre-release\n47 | pre_rel = True if any(x in str(new_version) for x in [\"a\", \"b\", \"rc\"]) else False\n48 | \n49 | # semver of current latest\n50 | for version, tags in version_tag_map.items():\n51 | if \"latest\" in tags:\n52 | # N.B. This seems counterintuitive, but we expect any version tagged\n53 | # 'latest' to have exactly three associated tags:\n54 | # latest, major.minor.latest, and major.minor.patch.\n55 | # Subtracting everything that contains the string 'latest' gets us\n56 | # the major.minor.patch which is what's needed for comparison.\n57 | current_latest = parse([tag for tag in tags if \"latest\" not in tag][0])\n58 | else:\n59 | current_latest = False\n60 | \n61 | # semver of current_minor_latest\n62 | for version, tags in version_tag_map.items():\n63 | if f\"{new_version.major}.{new_version.minor}.latest\" in tags:\n64 | # Similar to above, only now we expect exactly two tags:\n65 | # major.minor.patch and major.minor.latest\n66 | current_minor_latest = parse([tag for tag in tags if \"latest\" not in tag][0])\n67 | else:\n68 | current_minor_latest = False\n69 | \n70 | def is_latest(\n71 | pre_rel: bool, new_version: Version, remote_latest: Union[bool, Version]\n72 | ) -> bool:\n73 | \"\"\"Determine if a given contaier should be tagged 'latest' based on:\n74 | - it's pre-release status\n75 | - it's version\n76 | - the version of a previously identified container tagged 'latest'\n77 | \n78 | :param pre_rel: Wether or not the version of the new container is a pre-release\n79 | :param new_version: The version of the new container\n80 | :param remote_latest: The version of the previously identified container that's\n81 | already tagged latest or False\n82 | \"\"\"\n83 | # is a pre-release = not latest\n84 | if pre_rel:\n85 | return False\n86 | # + no latest tag found = is latest\n87 | if not remote_latest:\n88 | return True\n89 | # + if remote version is lower than current = is latest, else not latest\n90 | return True if remote_latest <= new_version else False\n91 | \n92 | latest = is_latest(pre_rel, new_version, current_latest)\n93 | minor_latest = is_latest(pre_rel, new_version, current_minor_latest)\n94 | \n95 | github_output = os.environ.get(\"GITHUB_OUTPUT\")\n96 | with open(github_output, \"at\", encoding=\"utf-8\") as gh_output:\n97 | gh_output.write(f\"latest={latest}\")\n98 | gh_output.write(f\"minor_latest={minor_latest}\")\n```\n\n## Files after the fix\n\n### File: .github/actions/latest-wrangler/main.py\n\n```python\n 1 | import os\n 2 | from packaging.version import Version, parse\n 3 | import requests\n 4 | import sys\n 5 | from typing import List\n 6 | \n 7 | \n 8 | def main():\n 9 | package_name: str = os.environ[\"INPUT_PACKAGE_NAME\"]\n10 | new_version: Version = parse(os.environ[\"INPUT_NEW_VERSION\"])\n11 | github_token: str = os.environ[\"INPUT_GITHUB_TOKEN\"]\n12 | \n13 | response = _package_metadata(package_name, github_token)\n14 | published_versions = _published_versions(response)\n15 | new_version_tags = _new_version_tags(new_version, published_versions)\n16 | _register_tags(new_version_tags, package_name)\n17 | \n18 | \n19 | def _package_metadata(package_name: str, github_token: str) -> requests.Response:\n20 | url = f\"https://api.github.com/orgs/dbt-labs/packages/container/{package_name}/versions\"\n21 | return requests.get(url, auth=(\"\", github_token))\n22 | \n23 | \n24 | def _published_versions(response: requests.Response) -> List[Version]:\n25 | package_metadata = response.json()\n26 | return [\n27 | parse(tag)\n28 | for version in package_metadata\n29 | for tag in version[\"metadata\"][\"container\"][\"tags\"]\n30 | if \"latest\" not in tag\n31 | ]\n32 | \n33 | \n34 | def _new_version_tags(new_version: Version, published_versions: List[Version]) -> List[str]:\n35 | # the package version is always a tag\n36 | tags = [str(new_version)]\n37 | \n38 | # pre-releases don't get tagged with `latest`\n39 | if new_version.is_prerelease:\n40 | return tags\n41 | \n42 | if new_version > max(published_versions):\n43 | tags.append(\"latest\")\n44 | \n45 | published_patches = [\n46 | version\n47 | for version in published_versions\n48 | if version.major == new_version.major and version.minor == new_version.minor\n49 | ]\n50 | if new_version > max(published_patches):\n51 | tags.append(f\"{new_version.major}.{new_version.minor}.latest\")\n52 | \n53 | return tags\n54 | \n55 | \n56 | def _register_tags(tags: List[str], package_name: str) -> None:\n57 | fully_qualified_tags = \",\".join([f\"ghcr.io/dbt-labs/{package_name}:{tag}\" for tag in tags])\n58 | github_output = os.environ.get(\"GITHUB_OUTPUT\")\n59 | with open(github_output, \"at\", encoding=\"utf-8\") as gh_output:\n60 | gh_output.write(f\"fully_qualified_tags={fully_qualified_tags}\")\n61 | \n62 | \n63 | def _validate_response(response: requests.Response) -> None:\n64 | message = response[\"message\"]\n65 | if response.status_code != 200:\n66 | print(f\"Call to GitHub API failed: {response.status_code} - {message}\")\n67 | sys.exit(1)\n68 | \n69 | \n70 | if __name__ == \"__main__\":\n71 | main()\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/.github/actions/latest-wrangler/main.py b/.github/actions/latest-wrangler/main.py\nindex 0000000..0000000 100644\n--- a/.github/actions/latest-wrangler/main.py\n+++ b/.github/actions/latest-wrangler/main.py\n@@ -1,98 +1,71 @@\n import os\n-import sys\n+from packaging.version import Version, parse\n import requests\n-from distutils.util import strtobool\n-from typing import Union\n-from packaging.version import parse, Version\n+import sys\n+from typing import List\n+\n+\n+def main():\n+ package_name: str = os.environ[\"INPUT_PACKAGE_NAME\"]\n+ new_version: Version = parse(os.environ[\"INPUT_NEW_VERSION\"])\n+ github_token: str = os.environ[\"INPUT_GITHUB_TOKEN\"]\n+\n+ response = _package_metadata(package_name, github_token)\n+ published_versions = _published_versions(response)\n+ new_version_tags = _new_version_tags(new_version, published_versions)\n+ _register_tags(new_version_tags, package_name)\n+\n+\n+def _package_metadata(package_name: str, github_token: str) -> requests.Response:\n+ url = f\"https://api.github.com/orgs/dbt-labs/packages/container/{package_name}/versions\"\n+ return requests.get(url, auth=(\"\", github_token))\n+\n+\n+def _published_versions(response: requests.Response) -> List[Version]:\n+ package_metadata = response.json()\n+ return [\n+ parse(tag)\n+ for version in package_metadata\n+ for tag in version[\"metadata\"][\"container\"][\"tags\"]\n+ if \"latest\" not in tag\n+ ]\n \n-if __name__ == \"__main__\":\n \n- # get inputs\n- package = os.environ[\"INPUT_PACKAGE\"]\n- new_version = parse(os.environ[\"INPUT_NEW_VERSION\"])\n- gh_token = os.environ[\"INPUT_GH_TOKEN\"]\n- halt_on_missing = strtobool(os.environ.get(\"INPUT_HALT_ON_MISSING\", \"False\"))\n-\n- # get package metadata from github\n- package_request = requests.get(\n- f\"https://api.github.com/orgs/dbt-labs/packages/container/{package}/versions\",\n- auth=(\"\", gh_token),\n- )\n- package_meta = package_request.json()\n-\n- # Log info if we don't get a 200\n- if package_request.status_code != 200:\n- print(f\"Call to GH API failed: {package_request.status_code} {package_meta['message']}\")\n-\n- # Make an early exit if there is no matching package in github\n- if package_request.status_code == 404:\n- if halt_on_missing:\n- sys.exit(1)\n- # everything is the latest if the package doesn't exist\n- github_output = os.environ.get(\"GITHUB_OUTPUT\")\n- with open(github_output, \"at\", encoding=\"utf-8\") as gh_output:\n- gh_output.write(\"latest=True\")\n- gh_output.write(\"minor_latest=True\")\n- sys.exit(0)\n-\n- # TODO: verify package meta is \"correct\"\n- # https://github.com/dbt-labs/dbt-core/issues/4640\n-\n- # map versions and tags\n- version_tag_map = {\n- version[\"id\"]: version[\"metadata\"][\"container\"][\"tags\"] for version in package_meta\n- }\n-\n- # is pre-release\n- pre_rel = True if any(x in str(new_version) for x in [\"a\", \"b\", \"rc\"]) else False\n-\n- # semver of current latest\n- for version, tags in version_tag_map.items():\n- if \"latest\" in tags:\n- # N.B. This seems counterintuitive, but we expect any version tagged\n- # 'latest' to have exactly three associated tags:\n- # latest, major.minor.latest, and major.minor.patch.\n- # Subtracting everything that contains the string 'latest' gets us\n- # the major.minor.patch which is what's needed for comparison.\n- current_latest = parse([tag for tag in tags if \"latest\" not in tag][0])\n- else:\n- current_latest = False\n-\n- # semver of current_minor_latest\n- for version, tags in version_tag_map.items():\n- if f\"{new_version.major}.{new_version.minor}.latest\" in tags:\n- # Similar to above, only now we expect exactly two tags:\n- # major.minor.patch and major.minor.latest\n- current_minor_latest = parse([tag for tag in tags if \"latest\" not in tag][0])\n- else:\n- current_minor_latest = False\n-\n- def is_latest(\n- pre_rel: bool, new_version: Version, remote_latest: Union[bool, Version]\n- ) -> bool:\n- \"\"\"Determine if a given contaier should be tagged 'latest' based on:\n- - it's pre-release status\n- - it's version\n- - the version of a previously identified container tagged 'latest'\n-\n- :param pre_rel: Wether or not the version of the new container is a pre-release\n- :param new_version: The version of the new container\n- :param remote_latest: The version of the previously identified container that's\n- already tagged latest or False\n- \"\"\"\n- # is a pre-release = not latest\n- if pre_rel:\n- return False\n- # + no latest tag found = is latest\n- if not remote_latest:\n- return True\n- # + if remote version is lower than current = is latest, else not latest\n- return True if remote_latest <= new_version else False\n-\n- latest = is_latest(pre_rel, new_version, current_latest)\n- minor_latest = is_latest(pre_rel, new_version, current_minor_latest)\n+def _new_version_tags(new_version: Version, published_versions: List[Version]) -> List[str]:\n+ # the package version is always a tag\n+ tags = [str(new_version)]\n \n+ # pre-releases don't get tagged with `latest`\n+ if new_version.is_prerelease:\n+ return tags\n+\n+ if new_version > max(published_versions):\n+ tags.append(\"latest\")\n+\n+ published_patches = [\n+ version\n+ for version in published_versions\n+ if version.major == new_version.major and version.minor == new_version.minor\n+ ]\n+ if new_version > max(published_patches):\n+ tags.append(f\"{new_version.major}.{new_version.minor}.latest\")\n+\n+ return tags\n+\n+\n+def _register_tags(tags: List[str], package_name: str) -> None:\n+ fully_qualified_tags = \",\".join([f\"ghcr.io/dbt-labs/{package_name}:{tag}\" for tag in tags])\n github_output = os.environ.get(\"GITHUB_OUTPUT\")\n with open(github_output, \"at\", encoding=\"utf-8\") as gh_output:\n- gh_output.write(f\"latest={latest}\")\n- gh_output.write(f\"minor_latest={minor_latest}\")\n+ gh_output.write(f\"fully_qualified_tags={fully_qualified_tags}\")\n+\n+\n+def _validate_response(response: requests.Response) -> None:\n+ message = response[\"message\"]\n+ if response.status_code != 200:\n+ print(f\"Call to GitHub API failed: {response.status_code} - {message}\")\n+ sys.exit(1)\n+\n+\n+if __name__ == \"__main__\":\n+ main()"},"prompt_input_token_count":{"kind":"number","value":2890,"string":"2,890"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9495\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"9c8b28aa640382a381768904795c5e7124f9c8bc\",\n \"pull_number\": 9495,\n \"issue_numbers\": [\n \"7149\"\n ],\n \"changed_files\": [\n \".github/actions/latest-wrangler/main.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": false\n}"}}},{"rowIdx":32296,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9503"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 2d59a51874672e5a95ec7f2f2aa18b8a66e9e738\nChanged files:\n- core/dbt/context/providers.py\n\n## Problem statement\n\n[Bug] Update command-based logic in `compiled_code` context member, to match `sql`\n### Is this a new bug in dbt-core?\r\n\r\n- [X] I believe this is a new bug in dbt-core\r\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\r\n\r\n### Current Behavior\r\n\r\nIn https://github.com/dbt-labs/dbt-core/pull/9040, we added `defer_relation` for all tasks that perform deferral.\r\n\r\nPreviously, there was dynamic routing logic in the `sql` + `compiled_code` context members that checked for the existnece of `defer_relation` and overwrote the \"compiled code\" to use during `clone`.\r\n\r\n#9040 updated the dynamic routing logic for the `sql` context member (based on the running task), but not the `compiled_code` context member.\r\n\r\nThese need to be the same. Otherwise, I might `build` a model with deferral and, depending on whether the materialization uses `{{ sql }}` or `{{ compiled_code }}`, get a different (inconsistent) result.\r\n\r\n### Expected Behavior\r\n\r\nThere should be no difference between `{{ sql }}` and `{{ compiled_code }}` for SQL models.\r\n\r\n### Steps To Reproduce\r\n\r\n1. dbt-core `main` branch\r\n2. Use a materialization that calls `compiled_code` instead of `sql`, e.g. [dbt-snowflake's incremental materialization](https://github.com/dbt-labs/dbt-snowflake/blob/4b2d93808e1b852aec3b1c281fa0af231b0cf297/dbt/include/snowflake/macros/materializations/incremental.sql#L83)\r\n\r\n### Relevant log output\r\n\r\n```\r\n$ dbt build --debug\r\n...\r\ncreate or replace transient table ANALYTICS_DEV.dbt_jcohen.dim_certification_candidates\r\n as\r\n (select * from analytics.analytics.dim_certification_candidates\r\n );\r\n```\r\n\r\nThat ain't right!\r\n\r\n### Environment\r\n\r\n```markdown\r\ndbt: main\r\n```\r\n\r\n\r\n### Which database adapter are you using with dbt?\r\n\r\n_No response_\r\n\r\n### Additional Context\r\n\r\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/context/providers.py\n\n```python\n 1 | import abc\n 2 | from copy import deepcopy\n 3 | import os\n 4 | from typing import (\n 5 | Callable,\n 6 | Any,\n 7 | Dict,\n 8 | Optional,\n 9 | Union,\n 10 | List,\n 11 | TypeVar,\n 12 | Type,\n 13 | Iterable,\n 14 | Mapping,\n 15 | )\n 16 | from typing_extensions import Protocol\n 17 | \n 18 | from dbt.adapters.base.column import Column\n 19 | from dbt.artifacts.resources import NodeVersion, RefArgs\n 20 | from dbt_common.clients.jinja import MacroProtocol\n 21 | from dbt.adapters.factory import get_adapter, get_adapter_package_names, get_adapter_type_names\n 22 | from dbt_common.clients import agate_helper\n 23 | from dbt.clients.jinja import get_rendered, MacroGenerator, MacroStack, UnitTestMacroGenerator\n 24 | from dbt.config import RuntimeConfig, Project\n 25 | from dbt.constants import SECRET_ENV_PREFIX, DEFAULT_ENV_PLACEHOLDER\n 26 | from dbt.context.base import contextmember, contextproperty, Var\n 27 | from dbt.context.configured import FQNLookup\n 28 | from dbt.context.context_config import ContextConfig\n 29 | from dbt.context.exceptions_jinja import wrapped_exports\n 30 | from dbt.context.macro_resolver import MacroResolver, TestMacroNamespace\n 31 | from dbt.context.macros import MacroNamespaceBuilder, MacroNamespace\n 32 | from dbt.context.manifest import ManifestContext\n 33 | from dbt.adapters.contracts.connection import AdapterResponse\n 34 | from dbt.contracts.graph.manifest import Manifest, Disabled\n 35 | from dbt.contracts.graph.nodes import (\n 36 | Macro,\n 37 | Exposure,\n 38 | SeedNode,\n 39 | SourceDefinition,\n 40 | Resource,\n 41 | ManifestNode,\n 42 | AccessType,\n 43 | SemanticModel,\n 44 | UnitTestNode,\n 45 | )\n 46 | from dbt.contracts.graph.metrics import MetricReference, ResolvedMetricReference\n 47 | from dbt_common.events.functions import get_metadata_vars\n 48 | from dbt_common.exceptions import (\n 49 | DbtInternalError,\n 50 | DbtRuntimeError,\n 51 | DbtValidationError,\n 52 | MacrosSourcesUnWriteableError,\n 53 | )\n 54 | from dbt.adapters.exceptions import MissingConfigError\n 55 | from dbt.exceptions import (\n 56 | CompilationError,\n 57 | ConflictingConfigKeysError,\n 58 | SecretEnvVarLocationError,\n 59 | EnvVarMissingError,\n 60 | InlineModelConfigError,\n 61 | NumberSourceArgsError,\n 62 | PersistDocsValueTypeError,\n 63 | LoadAgateTableNotSeedError,\n 64 | LoadAgateTableValueError,\n 65 | MacroDispatchArgError,\n 66 | MacroResultAlreadyLoadedError,\n 67 | MetricArgsError,\n 68 | OperationsCannotRefEphemeralNodesError,\n 69 | ParsingError,\n 70 | RefBadContextError,\n 71 | RefArgsError,\n 72 | TargetNotFoundError,\n 73 | DbtReferenceError,\n 74 | )\n 75 | from dbt.config import IsFQNResource\n 76 | from dbt.node_types import NodeType, ModelLanguage\n 77 | \n 78 | from dbt.utils import MultiDict, args_to_dict\n 79 | from dbt_common.utils import merge, AttrDict, cast_to_str\n 80 | from dbt import selected_resources\n 81 | \n 82 | import agate\n 83 | \n 84 | \n 85 | _MISSING = object()\n 86 | \n 87 | \n 88 | # base classes\n 89 | class RelationProxy:\n 90 | def __init__(self, adapter):\n 91 | self._quoting_config = adapter.config.quoting\n 92 | self._relation_type = adapter.Relation\n 93 | \n 94 | def __getattr__(self, key):\n 95 | return getattr(self._relation_type, key)\n 96 | \n 97 | def create(self, *args, **kwargs):\n 98 | kwargs[\"quote_policy\"] = merge(self._quoting_config, kwargs.pop(\"quote_policy\", {}))\n 99 | return self._relation_type.create(*args, **kwargs)\n 100 | \n 101 | \n 102 | class BaseDatabaseWrapper:\n 103 | \"\"\"\n 104 | Wrapper for runtime database interaction. Applies the runtime quote policy\n 105 | via a relation proxy.\n 106 | \"\"\"\n 107 | \n 108 | def __init__(self, adapter, namespace: MacroNamespace):\n 109 | self._adapter = adapter\n 110 | self.Relation = RelationProxy(adapter)\n 111 | self._namespace = namespace\n 112 | \n 113 | def __getattr__(self, name):\n 114 | raise NotImplementedError(\"subclasses need to implement this\")\n 115 | \n 116 | @property\n 117 | def config(self):\n 118 | return self._adapter.config\n 119 | \n 120 | def type(self):\n 121 | return self._adapter.type()\n 122 | \n 123 | def commit(self):\n 124 | return self._adapter.commit_if_has_connection()\n 125 | \n 126 | def _get_adapter_macro_prefixes(self) -> List[str]:\n 127 | # order matters for dispatch:\n 128 | # 1. current adapter\n 129 | # 2. any parent adapters (dependencies)\n 130 | # 3. 'default'\n 131 | search_prefixes = get_adapter_type_names(self._adapter.type()) + [\"default\"]\n 132 | return search_prefixes\n 133 | \n 134 | def _get_search_packages(self, namespace: Optional[str] = None) -> List[Optional[str]]:\n 135 | search_packages: List[Optional[str]] = [None]\n 136 | \n 137 | if namespace is None:\n 138 | search_packages = [None]\n 139 | elif isinstance(namespace, str):\n 140 | macro_search_order = self._adapter.config.get_macro_search_order(namespace)\n 141 | if macro_search_order:\n 142 | search_packages = macro_search_order\n 143 | elif not macro_search_order and namespace in self._adapter.config.dependencies:\n 144 | search_packages = [self.config.project_name, namespace]\n 145 | else:\n 146 | raise CompilationError(\n 147 | f\"In adapter.dispatch, got a {type(namespace)} macro_namespace argument \"\n 148 | f'(\"{namespace}\"), but macro_namespace should be None or a string.'\n 149 | )\n 150 | \n 151 | return search_packages\n 152 | \n 153 | def dispatch(\n 154 | self,\n 155 | macro_name: str,\n 156 | macro_namespace: Optional[str] = None,\n 157 | packages: Optional[List[str]] = None, # eventually remove since it's fully deprecated\n 158 | ) -> MacroGenerator:\n 159 | search_packages: List[Optional[str]]\n 160 | \n 161 | if \".\" in macro_name:\n 162 | suggest_macro_namespace, suggest_macro_name = macro_name.split(\".\", 1)\n 163 | msg = (\n 164 | f'In adapter.dispatch, got a macro name of \"{macro_name}\", '\n 165 | f'but \".\" is not a valid macro name component. Did you mean '\n 166 | f'`adapter.dispatch(\"{suggest_macro_name}\", '\n 167 | f'macro_namespace=\"{suggest_macro_namespace}\")`?'\n 168 | )\n 169 | raise CompilationError(msg)\n 170 | \n 171 | if packages is not None:\n 172 | raise MacroDispatchArgError(macro_name)\n 173 | \n 174 | search_packages = self._get_search_packages(macro_namespace)\n 175 | \n 176 | attempts = []\n 177 | \n 178 | for package_name in search_packages:\n 179 | for prefix in self._get_adapter_macro_prefixes():\n 180 | search_name = f\"{prefix}__{macro_name}\"\n 181 | try:\n 182 | # this uses the namespace from the context\n 183 | macro = self._namespace.get_from_package(package_name, search_name)\n 184 | except CompilationError:\n 185 | # Only raise CompilationError if macro is not found in\n 186 | # any package\n 187 | macro = None\n 188 | \n 189 | if package_name is None:\n 190 | attempts.append(search_name)\n 191 | else:\n 192 | attempts.append(f\"{package_name}.{search_name}\")\n 193 | \n 194 | if macro is not None:\n 195 | return macro\n 196 | \n 197 | searched = \", \".join(repr(a) for a in attempts)\n 198 | msg = f\"In dispatch: No macro named '{macro_name}' found within namespace: '{macro_namespace}'\\n Searched for: {searched}\"\n 199 | raise CompilationError(msg)\n 200 | \n 201 | \n 202 | class BaseResolver(metaclass=abc.ABCMeta):\n 203 | def __init__(self, db_wrapper, model, config, manifest):\n 204 | self.db_wrapper = db_wrapper\n 205 | self.model = model\n 206 | self.config = config\n 207 | self.manifest = manifest\n 208 | \n 209 | @property\n 210 | def current_project(self):\n 211 | return self.config.project_name\n 212 | \n 213 | @property\n 214 | def Relation(self):\n 215 | return self.db_wrapper.Relation\n 216 | \n 217 | @property\n 218 | def resolve_limit(self) -> Optional[int]:\n 219 | return 0 if getattr(self.config.args, \"EMPTY\", False) else None\n 220 | \n 221 | @abc.abstractmethod\n 222 | def __call__(self, *args: str) -> Union[str, RelationProxy, MetricReference]:\n 223 | pass\n 224 | \n 225 | \n 226 | class BaseRefResolver(BaseResolver):\n 227 | @abc.abstractmethod\n 228 | def resolve(\n 229 | self, name: str, package: Optional[str] = None, version: Optional[NodeVersion] = None\n 230 | ) -> RelationProxy:\n 231 | ...\n 232 | \n 233 | def _repack_args(\n 234 | self, name: str, package: Optional[str], version: Optional[NodeVersion]\n 235 | ) -> RefArgs:\n 236 | return RefArgs(package=package, name=name, version=version)\n 237 | \n 238 | def validate_args(self, name: str, package: Optional[str], version: Optional[NodeVersion]):\n 239 | if not isinstance(name, str):\n 240 | raise CompilationError(\n 241 | f\"The name argument to ref() must be a string, got {type(name)}\"\n 242 | )\n 243 | \n 244 | if package is not None and not isinstance(package, str):\n 245 | raise CompilationError(\n 246 | f\"The package argument to ref() must be a string or None, got {type(package)}\"\n 247 | )\n 248 | \n 249 | if version is not None and not isinstance(version, (str, int, float)):\n 250 | raise CompilationError(\n 251 | f\"The version argument to ref() must be a string, int, float, or None - got {type(version)}\"\n 252 | )\n 253 | \n 254 | def __call__(self, *args: str, **kwargs) -> RelationProxy:\n 255 | name: str\n 256 | package: Optional[str] = None\n 257 | version: Optional[NodeVersion] = None\n 258 | \n 259 | if len(args) == 1:\n 260 | name = args[0]\n 261 | elif len(args) == 2:\n 262 | package, name = args\n 263 | else:\n 264 | raise RefArgsError(node=self.model, args=args)\n 265 | \n 266 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n 267 | self.validate_args(name, package, version)\n 268 | return self.resolve(name, package, version)\n 269 | \n 270 | \n 271 | class BaseSourceResolver(BaseResolver):\n 272 | @abc.abstractmethod\n 273 | def resolve(self, source_name: str, table_name: str):\n 274 | pass\n 275 | \n 276 | def validate_args(self, source_name: str, table_name: str):\n 277 | if not isinstance(source_name, str):\n 278 | raise CompilationError(\n 279 | f\"The source name (first) argument to source() must be a \"\n 280 | f\"string, got {type(source_name)}\"\n 281 | )\n 282 | if not isinstance(table_name, str):\n 283 | raise CompilationError(\n 284 | f\"The table name (second) argument to source() must be a \"\n 285 | f\"string, got {type(table_name)}\"\n 286 | )\n 287 | \n 288 | def __call__(self, *args: str) -> RelationProxy:\n 289 | if len(args) != 2:\n 290 | raise NumberSourceArgsError(args, node=self.model)\n 291 | self.validate_args(args[0], args[1])\n 292 | return self.resolve(args[0], args[1])\n 293 | \n 294 | \n 295 | class BaseMetricResolver(BaseResolver):\n 296 | @abc.abstractmethod\n 297 | def resolve(self, name: str, package: Optional[str] = None) -> MetricReference:\n 298 | ...\n 299 | \n 300 | def _repack_args(self, name: str, package: Optional[str]) -> List[str]:\n 301 | if package is None:\n 302 | return [name]\n 303 | else:\n 304 | return [package, name]\n 305 | \n 306 | def validate_args(self, name: str, package: Optional[str]):\n 307 | if not isinstance(name, str):\n 308 | raise CompilationError(\n 309 | f\"The name argument to metric() must be a string, got {type(name)}\"\n 310 | )\n 311 | \n 312 | if package is not None and not isinstance(package, str):\n 313 | raise CompilationError(\n 314 | f\"The package argument to metric() must be a string or None, got {type(package)}\"\n 315 | )\n 316 | \n 317 | def __call__(self, *args: str) -> MetricReference:\n 318 | name: str\n 319 | package: Optional[str] = None\n 320 | \n 321 | if len(args) == 1:\n 322 | name = args[0]\n 323 | elif len(args) == 2:\n 324 | package, name = args\n 325 | else:\n 326 | raise MetricArgsError(node=self.model, args=args)\n 327 | self.validate_args(name, package)\n 328 | return self.resolve(name, package)\n 329 | \n 330 | \n 331 | class Config(Protocol):\n 332 | def __init__(self, model, context_config: Optional[ContextConfig]):\n 333 | ...\n 334 | \n 335 | \n 336 | # Implementation of \"config(..)\" calls in models\n 337 | class ParseConfigObject(Config):\n 338 | def __init__(self, model, context_config: Optional[ContextConfig]):\n 339 | self.model = model\n 340 | self.context_config = context_config\n 341 | \n 342 | def _transform_config(self, config):\n 343 | for oldkey in (\"pre_hook\", \"post_hook\"):\n 344 | if oldkey in config:\n 345 | newkey = oldkey.replace(\"_\", \"-\")\n 346 | if newkey in config:\n 347 | raise ConflictingConfigKeysError(oldkey, newkey, node=self.model)\n 348 | config[newkey] = config.pop(oldkey)\n 349 | return config\n 350 | \n 351 | def __call__(self, *args, **kwargs):\n 352 | if len(args) == 1 and len(kwargs) == 0:\n 353 | opts = args[0]\n 354 | elif len(args) == 0 and len(kwargs) > 0:\n 355 | opts = kwargs\n 356 | else:\n 357 | raise InlineModelConfigError(node=self.model)\n 358 | \n 359 | opts = self._transform_config(opts)\n 360 | \n 361 | # it's ok to have a parse context with no context config, but you must\n 362 | # not call it!\n 363 | if self.context_config is None:\n 364 | raise DbtRuntimeError(\"At parse time, did not receive a context config\")\n 365 | self.context_config.add_config_call(opts)\n 366 | return \"\"\n 367 | \n 368 | def set(self, name, value):\n 369 | return self.__call__({name: value})\n 370 | \n 371 | def require(self, name, validator=None):\n 372 | return \"\"\n 373 | \n 374 | def get(self, name, default=None, validator=None):\n 375 | return \"\"\n 376 | \n 377 | def persist_relation_docs(self) -> bool:\n 378 | return False\n 379 | \n 380 | def persist_column_docs(self) -> bool:\n 381 | return False\n 382 | \n 383 | \n 384 | class RuntimeConfigObject(Config):\n 385 | def __init__(self, model, context_config: Optional[ContextConfig] = None):\n 386 | self.model = model\n 387 | # we never use or get a config, only the parser cares\n 388 | \n 389 | def __call__(self, *args, **kwargs):\n 390 | return \"\"\n 391 | \n 392 | def set(self, name, value):\n 393 | return self.__call__({name: value})\n 394 | \n 395 | def _validate(self, validator, value):\n 396 | validator(value)\n 397 | \n 398 | def _lookup(self, name, default=_MISSING):\n 399 | # if this is a macro, there might be no `model.config`.\n 400 | if not hasattr(self.model, \"config\"):\n 401 | result = default\n 402 | else:\n 403 | result = self.model.config.get(name, default)\n 404 | if result is _MISSING:\n 405 | raise MissingConfigError(unique_id=self.model.unique_id, name=name)\n 406 | return result\n 407 | \n 408 | def require(self, name, validator=None):\n 409 | to_return = self._lookup(name)\n 410 | \n 411 | if validator is not None:\n 412 | self._validate(validator, to_return)\n 413 | \n 414 | return to_return\n 415 | \n 416 | def get(self, name, default=None, validator=None):\n 417 | to_return = self._lookup(name, default)\n 418 | \n 419 | if validator is not None and default is not None:\n 420 | self._validate(validator, to_return)\n 421 | \n 422 | return to_return\n 423 | \n 424 | def persist_relation_docs(self) -> bool:\n 425 | persist_docs = self.get(\"persist_docs\", default={})\n 426 | if not isinstance(persist_docs, dict):\n 427 | raise PersistDocsValueTypeError(persist_docs)\n 428 | \n 429 | return persist_docs.get(\"relation\", False)\n 430 | \n 431 | def persist_column_docs(self) -> bool:\n 432 | persist_docs = self.get(\"persist_docs\", default={})\n 433 | if not isinstance(persist_docs, dict):\n 434 | raise PersistDocsValueTypeError(persist_docs)\n 435 | \n 436 | return persist_docs.get(\"columns\", False)\n 437 | \n 438 | \n 439 | # `adapter` implementations\n 440 | class ParseDatabaseWrapper(BaseDatabaseWrapper):\n 441 | \"\"\"The parser subclass of the database wrapper applies any explicit\n 442 | parse-time overrides.\n 443 | \"\"\"\n 444 | \n 445 | def __getattr__(self, name):\n 446 | override = name in self._adapter._available_ and name in self._adapter._parse_replacements_\n 447 | \n 448 | if override:\n 449 | return self._adapter._parse_replacements_[name]\n 450 | elif name in self._adapter._available_:\n 451 | return getattr(self._adapter, name)\n 452 | else:\n 453 | raise AttributeError(\n 454 | \"'{}' object has no attribute '{}'\".format(self.__class__.__name__, name)\n 455 | )\n 456 | \n 457 | \n 458 | class RuntimeDatabaseWrapper(BaseDatabaseWrapper):\n 459 | \"\"\"The runtime database wrapper exposes everything the adapter marks\n 460 | available.\n 461 | \"\"\"\n 462 | \n 463 | def __getattr__(self, name):\n 464 | if name in self._adapter._available_:\n 465 | return getattr(self._adapter, name)\n 466 | else:\n 467 | raise AttributeError(\n 468 | \"'{}' object has no attribute '{}'\".format(self.__class__.__name__, name)\n 469 | )\n 470 | \n 471 | \n 472 | # `ref` implementations\n 473 | class ParseRefResolver(BaseRefResolver):\n 474 | def resolve(\n 475 | self, name: str, package: Optional[str] = None, version: Optional[NodeVersion] = None\n 476 | ) -> RelationProxy:\n 477 | self.model.refs.append(self._repack_args(name, package, version))\n 478 | \n 479 | # This is not the ref for the \"name\" passed in, but for the current model.\n 480 | return self.Relation.create_from(self.config, self.model)\n 481 | \n 482 | \n 483 | ResolveRef = Union[Disabled, ManifestNode]\n 484 | \n 485 | \n 486 | class RuntimeRefResolver(BaseRefResolver):\n 487 | def resolve(\n 488 | self,\n 489 | target_name: str,\n 490 | target_package: Optional[str] = None,\n 491 | target_version: Optional[NodeVersion] = None,\n 492 | ) -> RelationProxy:\n 493 | target_model = self.manifest.resolve_ref(\n 494 | self.model,\n 495 | target_name,\n 496 | target_package,\n 497 | target_version,\n 498 | self.current_project,\n 499 | self.model.package_name,\n 500 | )\n 501 | \n 502 | if target_model is None or isinstance(target_model, Disabled):\n 503 | raise TargetNotFoundError(\n 504 | node=self.model,\n 505 | target_name=target_name,\n 506 | target_kind=\"node\",\n 507 | target_package=target_package,\n 508 | target_version=target_version,\n 509 | disabled=isinstance(target_model, Disabled),\n 510 | )\n 511 | elif self.manifest.is_invalid_private_ref(\n 512 | self.model, target_model, self.config.dependencies\n 513 | ):\n 514 | raise DbtReferenceError(\n 515 | unique_id=self.model.unique_id,\n 516 | ref_unique_id=target_model.unique_id,\n 517 | access=AccessType.Private,\n 518 | scope=cast_to_str(target_model.group),\n 519 | )\n 520 | elif self.manifest.is_invalid_protected_ref(\n 521 | self.model, target_model, self.config.dependencies\n 522 | ):\n 523 | raise DbtReferenceError(\n 524 | unique_id=self.model.unique_id,\n 525 | ref_unique_id=target_model.unique_id,\n 526 | access=AccessType.Protected,\n 527 | scope=target_model.package_name,\n 528 | )\n 529 | \n 530 | self.validate(target_model, target_name, target_package, target_version)\n 531 | return self.create_relation(target_model)\n 532 | \n 533 | def create_relation(self, target_model: ManifestNode) -> RelationProxy:\n 534 | if target_model.is_ephemeral_model:\n 535 | self.model.set_cte(target_model.unique_id, None)\n 536 | return self.Relation.create_ephemeral_from(target_model, limit=self.resolve_limit)\n 537 | else:\n 538 | return self.Relation.create_from(self.config, target_model, limit=self.resolve_limit)\n 539 | \n 540 | def validate(\n 541 | self,\n 542 | resolved: ManifestNode,\n 543 | target_name: str,\n 544 | target_package: Optional[str],\n 545 | target_version: Optional[NodeVersion],\n 546 | ) -> None:\n 547 | if resolved.unique_id not in self.model.depends_on.nodes:\n 548 | args = self._repack_args(target_name, target_package, target_version)\n 549 | raise RefBadContextError(node=self.model, args=args)\n 550 | \n 551 | \n 552 | class OperationRefResolver(RuntimeRefResolver):\n 553 | def validate(\n 554 | self,\n 555 | resolved: ManifestNode,\n 556 | target_name: str,\n 557 | target_package: Optional[str],\n 558 | target_version: Optional[NodeVersion],\n 559 | ) -> None:\n 560 | pass\n 561 | \n 562 | def create_relation(self, target_model: ManifestNode) -> RelationProxy:\n 563 | if target_model.is_ephemeral_model:\n 564 | # In operations, we can't ref() ephemeral nodes, because\n 565 | # Macros do not support set_cte\n 566 | raise OperationsCannotRefEphemeralNodesError(target_model.name, node=self.model)\n 567 | else:\n 568 | return super().create_relation(target_model)\n 569 | \n 570 | \n 571 | class RuntimeUnitTestRefResolver(RuntimeRefResolver):\n 572 | def resolve(\n 573 | self,\n 574 | target_name: str,\n 575 | target_package: Optional[str] = None,\n 576 | target_version: Optional[NodeVersion] = None,\n 577 | ) -> RelationProxy:\n 578 | return super().resolve(target_name, target_package, target_version)\n 579 | \n 580 | \n 581 | # `source` implementations\n 582 | class ParseSourceResolver(BaseSourceResolver):\n 583 | def resolve(self, source_name: str, table_name: str):\n 584 | # When you call source(), this is what happens at parse time\n 585 | self.model.sources.append([source_name, table_name])\n 586 | return self.Relation.create_from(self.config, self.model)\n 587 | \n 588 | \n 589 | class RuntimeSourceResolver(BaseSourceResolver):\n 590 | def resolve(self, source_name: str, table_name: str):\n 591 | target_source = self.manifest.resolve_source(\n 592 | source_name,\n 593 | table_name,\n 594 | self.current_project,\n 595 | self.model.package_name,\n 596 | )\n 597 | \n 598 | if target_source is None or isinstance(target_source, Disabled):\n 599 | raise TargetNotFoundError(\n 600 | node=self.model,\n 601 | target_name=f\"{source_name}.{table_name}\",\n 602 | target_kind=\"source\",\n 603 | disabled=(isinstance(target_source, Disabled)),\n 604 | )\n 605 | return self.Relation.create_from(self.config, target_source, limit=self.resolve_limit)\n 606 | \n 607 | \n 608 | class RuntimeUnitTestSourceResolver(BaseSourceResolver):\n 609 | def resolve(self, source_name: str, table_name: str):\n 610 | target_source = self.manifest.resolve_source(\n 611 | source_name,\n 612 | table_name,\n 613 | self.current_project,\n 614 | self.model.package_name,\n 615 | )\n 616 | if target_source is None or isinstance(target_source, Disabled):\n 617 | raise TargetNotFoundError(\n 618 | node=self.model,\n 619 | target_name=f\"{source_name}.{table_name}\",\n 620 | target_kind=\"source\",\n 621 | disabled=(isinstance(target_source, Disabled)),\n 622 | )\n 623 | # For unit tests, this isn't a \"real\" source, it's a ModelNode taking\n 624 | # the place of a source. We don't really need to return the relation here,\n 625 | # we just need to set_cte, but skipping it confuses typing. We *do* need\n 626 | # the relation in the \"this\" property.\n 627 | self.model.set_cte(target_source.unique_id, None)\n 628 | return self.Relation.create_ephemeral_from(target_source)\n 629 | \n 630 | \n 631 | # metric` implementations\n 632 | class ParseMetricResolver(BaseMetricResolver):\n 633 | def resolve(self, name: str, package: Optional[str] = None) -> MetricReference:\n 634 | self.model.metrics.append(self._repack_args(name, package))\n 635 | \n 636 | return MetricReference(name, package)\n 637 | \n 638 | \n 639 | class RuntimeMetricResolver(BaseMetricResolver):\n 640 | def resolve(self, target_name: str, target_package: Optional[str] = None) -> MetricReference:\n 641 | target_metric = self.manifest.resolve_metric(\n 642 | target_name,\n 643 | target_package,\n 644 | self.current_project,\n 645 | self.model.package_name,\n 646 | )\n 647 | \n 648 | if target_metric is None or isinstance(target_metric, Disabled):\n 649 | raise TargetNotFoundError(\n 650 | node=self.model,\n 651 | target_name=target_name,\n 652 | target_kind=\"metric\",\n 653 | target_package=target_package,\n 654 | )\n 655 | \n 656 | return ResolvedMetricReference(target_metric, self.manifest)\n 657 | \n 658 | \n 659 | # `var` implementations.\n 660 | class ModelConfiguredVar(Var):\n 661 | def __init__(\n 662 | self,\n 663 | context: Dict[str, Any],\n 664 | config: RuntimeConfig,\n 665 | node: Resource,\n 666 | ) -> None:\n 667 | self._node: Resource\n 668 | self._config: RuntimeConfig = config\n 669 | super().__init__(context, config.cli_vars, node=node)\n 670 | \n 671 | def packages_for_node(self) -> Iterable[Project]:\n 672 | dependencies = self._config.load_dependencies()\n 673 | package_name = self._node.package_name\n 674 | \n 675 | if package_name != self._config.project_name:\n 676 | if package_name in dependencies:\n 677 | yield dependencies[package_name]\n 678 | yield self._config\n 679 | \n 680 | def _generate_merged(self) -> Mapping[str, Any]:\n 681 | search_node: IsFQNResource\n 682 | if isinstance(self._node, IsFQNResource):\n 683 | search_node = self._node\n 684 | else:\n 685 | search_node = FQNLookup(self._node.package_name)\n 686 | \n 687 | adapter_type = self._config.credentials.type\n 688 | \n 689 | merged = MultiDict()\n 690 | for project in self.packages_for_node():\n 691 | merged.add(project.vars.vars_for(search_node, adapter_type))\n 692 | merged.add(self._cli_vars)\n 693 | return merged\n 694 | \n 695 | \n 696 | class ParseVar(ModelConfiguredVar):\n 697 | def get_missing_var(self, var_name):\n 698 | # in the parser, just always return None.\n 699 | return None\n 700 | \n 701 | \n 702 | class RuntimeVar(ModelConfiguredVar):\n 703 | pass\n 704 | \n 705 | \n 706 | class UnitTestVar(RuntimeVar):\n 707 | def __init__(\n 708 | self,\n 709 | context: Dict[str, Any],\n 710 | config: RuntimeConfig,\n 711 | node: Resource,\n 712 | ) -> None:\n 713 | config_copy = None\n 714 | assert isinstance(node, UnitTestNode)\n 715 | if node.overrides and node.overrides.vars:\n 716 | config_copy = deepcopy(config)\n 717 | config_copy.cli_vars.update(node.overrides.vars)\n 718 | \n 719 | super().__init__(context, config_copy or config, node=node)\n 720 | \n 721 | \n 722 | # Providers\n 723 | class Provider(Protocol):\n 724 | execute: bool\n 725 | Config: Type[Config]\n 726 | DatabaseWrapper: Type[BaseDatabaseWrapper]\n 727 | Var: Type[ModelConfiguredVar]\n 728 | ref: Type[BaseRefResolver]\n 729 | source: Type[BaseSourceResolver]\n 730 | metric: Type[BaseMetricResolver]\n 731 | \n 732 | \n 733 | class ParseProvider(Provider):\n 734 | execute = False\n 735 | Config = ParseConfigObject\n 736 | DatabaseWrapper = ParseDatabaseWrapper\n 737 | Var = ParseVar\n 738 | ref = ParseRefResolver\n 739 | source = ParseSourceResolver\n 740 | metric = ParseMetricResolver\n 741 | \n 742 | \n 743 | class GenerateNameProvider(Provider):\n 744 | execute = False\n 745 | Config = RuntimeConfigObject\n 746 | DatabaseWrapper = ParseDatabaseWrapper\n 747 | Var = RuntimeVar\n 748 | ref = ParseRefResolver\n 749 | source = ParseSourceResolver\n 750 | metric = ParseMetricResolver\n 751 | \n 752 | \n 753 | class RuntimeProvider(Provider):\n 754 | execute = True\n 755 | Config = RuntimeConfigObject\n 756 | DatabaseWrapper = RuntimeDatabaseWrapper\n 757 | Var = RuntimeVar\n 758 | ref = RuntimeRefResolver\n 759 | source = RuntimeSourceResolver\n 760 | metric = RuntimeMetricResolver\n 761 | \n 762 | \n 763 | class RuntimeUnitTestProvider(Provider):\n 764 | execute = True\n 765 | Config = RuntimeConfigObject\n 766 | DatabaseWrapper = RuntimeDatabaseWrapper\n 767 | Var = UnitTestVar\n 768 | ref = RuntimeUnitTestRefResolver\n 769 | source = RuntimeUnitTestSourceResolver\n 770 | metric = RuntimeMetricResolver\n 771 | \n 772 | \n 773 | class OperationProvider(RuntimeProvider):\n 774 | ref = OperationRefResolver\n 775 | \n 776 | \n 777 | T = TypeVar(\"T\")\n 778 | \n 779 | \n 780 | # Base context collection, used for parsing configs.\n 781 | class ProviderContext(ManifestContext):\n 782 | # subclasses are MacroContext, ModelContext, TestContext\n 783 | def __init__(\n 784 | self,\n 785 | model,\n 786 | config: RuntimeConfig,\n 787 | manifest: Manifest,\n 788 | provider: Provider,\n 789 | context_config: Optional[ContextConfig],\n 790 | ) -> None:\n 791 | if provider is None:\n 792 | raise DbtInternalError(f\"Invalid provider given to context: {provider}\")\n 793 | # mypy appeasement - we know it'll be a RuntimeConfig\n 794 | self.config: RuntimeConfig\n 795 | self.model: Union[Macro, ManifestNode] = model\n 796 | super().__init__(config, manifest, model.package_name)\n 797 | self.sql_results: Dict[str, Optional[AttrDict]] = {}\n 798 | self.context_config: Optional[ContextConfig] = context_config\n 799 | self.provider: Provider = provider\n 800 | self.adapter = get_adapter(self.config)\n 801 | # The macro namespace is used in creating the DatabaseWrapper\n 802 | self.db_wrapper = self.provider.DatabaseWrapper(self.adapter, self.namespace)\n 803 | \n 804 | # This overrides the method in ManifestContext, and provides\n 805 | # a model, which the ManifestContext builder does not\n 806 | def _get_namespace_builder(self):\n 807 | internal_packages = get_adapter_package_names(self.config.credentials.type)\n 808 | return MacroNamespaceBuilder(\n 809 | self.config.project_name,\n 810 | self.search_package,\n 811 | self.macro_stack,\n 812 | internal_packages,\n 813 | self.model,\n 814 | )\n 815 | \n 816 | @contextproperty()\n 817 | def dbt_metadata_envs(self) -> Dict[str, str]:\n 818 | return get_metadata_vars()\n 819 | \n 820 | @contextproperty()\n 821 | def invocation_args_dict(self):\n 822 | return args_to_dict(self.config.args)\n 823 | \n 824 | @contextproperty()\n 825 | def _sql_results(self) -> Dict[str, Optional[AttrDict]]:\n 826 | return self.sql_results\n 827 | \n 828 | @contextmember()\n 829 | def load_result(self, name: str) -> Optional[AttrDict]:\n 830 | if name in self.sql_results:\n 831 | # handle the special case of \"main\" macro\n 832 | # See: https://github.com/dbt-labs/dbt-core/blob/ada8860e48b32ac712d92e8b0977b2c3c9749981/core/dbt/task/run.py#L228\n 833 | if name == \"main\":\n 834 | return self.sql_results[\"main\"]\n 835 | \n 836 | # handle a None, which indicates this name was populated but has since been loaded\n 837 | elif self.sql_results[name] is None:\n 838 | raise MacroResultAlreadyLoadedError(name)\n 839 | \n 840 | # Handle the regular use case\n 841 | else:\n 842 | ret_val = self.sql_results[name]\n 843 | self.sql_results[name] = None\n 844 | return ret_val\n 845 | else:\n 846 | # Handle trying to load a result that was never stored\n 847 | return None\n 848 | \n 849 | @contextmember()\n 850 | def store_result(\n 851 | self, name: str, response: Any, agate_table: Optional[agate.Table] = None\n 852 | ) -> str:\n 853 | if agate_table is None:\n 854 | agate_table = agate_helper.empty_table()\n 855 | \n 856 | self.sql_results[name] = AttrDict(\n 857 | {\n 858 | \"response\": response,\n 859 | \"data\": agate_helper.as_matrix(agate_table),\n 860 | \"table\": agate_table,\n 861 | }\n 862 | )\n 863 | return \"\"\n 864 | \n 865 | @contextmember()\n 866 | def store_raw_result(\n 867 | self,\n 868 | name: str,\n 869 | message=Optional[str],\n 870 | code=Optional[str],\n 871 | rows_affected=Optional[str],\n 872 | agate_table: Optional[agate.Table] = None,\n 873 | ) -> str:\n 874 | response = AdapterResponse(_message=message, code=code, rows_affected=rows_affected)\n 875 | return self.store_result(name, response, agate_table)\n 876 | \n 877 | @contextproperty()\n 878 | def validation(self):\n 879 | def validate_any(*args) -> Callable[[T], None]:\n 880 | def inner(value: T) -> None:\n 881 | for arg in args:\n 882 | if isinstance(arg, type) and isinstance(value, arg):\n 883 | return\n 884 | elif value == arg:\n 885 | return\n 886 | raise DbtValidationError(\n 887 | 'Expected value \"{}\" to be one of {}'.format(value, \",\".join(map(str, args)))\n 888 | )\n 889 | \n 890 | return inner\n 891 | \n 892 | return AttrDict(\n 893 | {\n 894 | \"any\": validate_any,\n 895 | }\n 896 | )\n 897 | \n 898 | @contextmember()\n 899 | def write(self, payload: str) -> str:\n 900 | # macros/source defs aren't 'writeable'.\n 901 | if isinstance(self.model, (Macro, SourceDefinition)):\n 902 | raise MacrosSourcesUnWriteableError(node=self.model)\n 903 | self.model.build_path = self.model.get_target_write_path(self.config.target_path, \"run\")\n 904 | self.model.write_node(self.config.project_root, self.model.build_path, payload)\n 905 | return \"\"\n 906 | \n 907 | @contextmember()\n 908 | def render(self, string: str) -> str:\n 909 | return get_rendered(string, self._ctx, self.model)\n 910 | \n 911 | @contextmember()\n 912 | def try_or_compiler_error(\n 913 | self, message_if_exception: str, func: Callable, *args, **kwargs\n 914 | ) -> Any:\n 915 | try:\n 916 | return func(*args, **kwargs)\n 917 | except Exception:\n 918 | raise CompilationError(message_if_exception, self.model)\n 919 | \n 920 | @contextmember()\n 921 | def load_agate_table(self) -> agate.Table:\n 922 | if not isinstance(self.model, SeedNode):\n 923 | raise LoadAgateTableNotSeedError(self.model.resource_type, node=self.model)\n 924 | \n 925 | # include package_path for seeds defined in packages\n 926 | package_path = (\n 927 | os.path.join(self.config.packages_install_path, self.model.package_name)\n 928 | if self.model.package_name != self.config.project_name\n 929 | else \".\"\n 930 | )\n 931 | path = os.path.join(self.config.project_root, package_path, self.model.original_file_path)\n 932 | if not os.path.exists(path):\n 933 | assert self.model.root_path\n 934 | path = os.path.join(self.model.root_path, self.model.original_file_path)\n 935 | \n 936 | column_types = self.model.config.column_types\n 937 | delimiter = self.model.config.delimiter\n 938 | try:\n 939 | table = agate_helper.from_csv(path, text_columns=column_types, delimiter=delimiter)\n 940 | except ValueError as e:\n 941 | raise LoadAgateTableValueError(e, node=self.model)\n 942 | table.original_abspath = os.path.abspath(path)\n 943 | return table\n 944 | \n 945 | @contextproperty()\n 946 | def ref(self) -> Callable:\n 947 | \"\"\"The most important function in dbt is `ref()`; it's impossible to\n 948 | build even moderately complex models without it. `ref()` is how you\n 949 | reference one model within another. This is a very common behavior, as\n 950 | typically models are built to be \"stacked\" on top of one another. Here\n 951 | is how this looks in practice:\n 952 | \n 953 | > model_a.sql:\n 954 | \n 955 | select *\n 956 | from public.raw_data\n 957 | \n 958 | > model_b.sql:\n 959 | \n 960 | select *\n 961 | from {{ref('model_a')}}\n 962 | \n 963 | \n 964 | `ref()` is, under the hood, actually doing two important things. First,\n 965 | it is interpolating the schema into your model file to allow you to\n 966 | change your deployment schema via configuration. Second, it is using\n 967 | these references between models to automatically build the dependency\n 968 | graph. This will enable dbt to deploy models in the correct order when\n 969 | using dbt run.\n 970 | \n 971 | The `ref` function returns a Relation object.\n 972 | \n 973 | ## Advanced ref usage\n 974 | \n 975 | There is also a two-argument variant of the `ref` function. With this\n 976 | variant, you can pass both a package name and model name to `ref` to\n 977 | avoid ambiguity. This functionality is not commonly required for\n 978 | typical dbt usage.\n 979 | \n 980 | > model.sql:\n 981 | \n 982 | select * from {{ ref('package_name', 'model_name') }}\"\n 983 | \"\"\"\n 984 | return self.provider.ref(self.db_wrapper, self.model, self.config, self.manifest)\n 985 | \n 986 | @contextproperty()\n 987 | def source(self) -> Callable:\n 988 | return self.provider.source(self.db_wrapper, self.model, self.config, self.manifest)\n 989 | \n 990 | @contextproperty()\n 991 | def metric(self) -> Callable:\n 992 | return self.provider.metric(self.db_wrapper, self.model, self.config, self.manifest)\n 993 | \n 994 | @contextproperty(\"config\")\n 995 | def ctx_config(self) -> Config:\n 996 | \"\"\"The `config` variable exists to handle end-user configuration for\n 997 | custom materializations. Configs like `unique_key` can be implemented\n 998 | using the `config` variable in your own materializations.\n 999 | \n1000 | For example, code in the `incremental` materialization like this:\n1001 | \n1002 | {% materialization incremental, default -%}\n1003 | {%- set unique_key = config.get('unique_key') -%}\n1004 | ...\n1005 | \n1006 | is responsible for handling model code that looks like this:\n1007 | \n1008 | {{\n1009 | config(\n1010 | materialized='incremental',\n1011 | unique_key='id'\n1012 | )\n1013 | }}\n1014 | \n1015 | \n1016 | ## config.get\n1017 | \n1018 | name: The name of the configuration variable (required)\n1019 | default: The default value to use if this configuration is not provided\n1020 | (optional)\n1021 | \n1022 | The `config.get` function is used to get configurations for a model\n1023 | from the end-user. Configs defined in this way are optional, and a\n1024 | default value can be provided.\n1025 | \n1026 | Example usage:\n1027 | \n1028 | {% materialization incremental, default -%}\n1029 | -- Example w/ no default. unique_key will be None if the user does not provide this configuration\n1030 | {%- set unique_key = config.get('unique_key') -%}\n1031 | -- Example w/ default value. Default to 'id' if 'unique_key' not provided\n1032 | {%- set unique_key = config.get('unique_key', default='id') -%}\n1033 | ...\n1034 | \n1035 | ## config.require\n1036 | \n1037 | name: The name of the configuration variable (required)\n1038 | \n1039 | The `config.require` function is used to get configurations for a model\n1040 | from the end-user. Configs defined using this function are required,\n1041 | and failure to provide them will result in a compilation error.\n1042 | \n1043 | Example usage:\n1044 | \n1045 | {% materialization incremental, default -%}\n1046 | {%- set unique_key = config.require('unique_key') -%}\n1047 | ...\n1048 | \"\"\" # noqa\n1049 | return self.provider.Config(self.model, self.context_config)\n1050 | \n1051 | @contextproperty()\n1052 | def execute(self) -> bool:\n1053 | \"\"\"`execute` is a Jinja variable that returns True when dbt is in\n1054 | \"execute\" mode.\n1055 | \n1056 | When you execute a dbt compile or dbt run command, dbt:\n1057 | \n1058 | - Reads all of the files in your project and generates a \"manifest\"\n1059 | comprised of models, tests, and other graph nodes present in your\n1060 | project. During this phase, dbt uses the `ref` statements it finds\n1061 | to generate the DAG for your project. *No SQL is run during this\n1062 | phase*, and `execute == False`.\n1063 | - Compiles (and runs) each node (eg. building models, or running\n1064 | tests). SQL is run during this phase, and `execute == True`.\n1065 | \n1066 | Any Jinja that relies on a result being returned from the database will\n1067 | error during the parse phase. For example, this SQL will return an\n1068 | error:\n1069 | \n1070 | > models/order_payment_methods.sql:\n1071 | \n1072 | {% set payment_method_query %}\n1073 | select distinct\n1074 | payment_method\n1075 | from {{ ref('raw_payments') }}\n1076 | order by 1\n1077 | {% endset %}\n1078 | {% set results = run_query(relation_query) %}\n1079 | {# Return the first column #}\n1080 | {% set payment_methods = results.columns[0].values() %}\n1081 | \n1082 | The error returned by dbt will look as follows:\n1083 | \n1084 | Encountered an error:\n1085 | Compilation Error in model order_payment_methods (models/order_payment_methods.sql)\n1086 | 'None' has no attribute 'table'\n1087 | \n1088 | This is because Line #11 assumes that a table has been returned, when,\n1089 | during the parse phase, this query hasn't been run.\n1090 | \n1091 | To work around this, wrap any problematic Jinja in an\n1092 | `{% if execute %}` statement:\n1093 | \n1094 | > models/order_payment_methods.sql:\n1095 | \n1096 | {% set payment_method_query %}\n1097 | select distinct\n1098 | payment_method\n1099 | from {{ ref('raw_payments') }}\n1100 | order by 1\n1101 | {% endset %}\n1102 | {% set results = run_query(relation_query) %}\n1103 | {% if execute %}\n1104 | {# Return the first column #}\n1105 | {% set payment_methods = results.columns[0].values() %}\n1106 | {% else %}\n1107 | {% set payment_methods = [] %}\n1108 | {% endif %}\n1109 | \"\"\" # noqa\n1110 | return self.provider.execute\n1111 | \n1112 | @contextproperty()\n1113 | def exceptions(self) -> Dict[str, Any]:\n1114 | \"\"\"The exceptions namespace can be used to raise warnings and errors in\n1115 | dbt userspace.\n1116 | \n1117 | \n1118 | ## raise_compiler_error\n1119 | \n1120 | The `exceptions.raise_compiler_error` method will raise a compiler\n1121 | error with the provided message. This is typically only useful in\n1122 | macros or materializations when invalid arguments are provided by the\n1123 | calling model. Note that throwing an exception will cause a model to\n1124 | fail, so please use this variable with care!\n1125 | \n1126 | Example usage:\n1127 | \n1128 | > exceptions.sql:\n1129 | \n1130 | {% if number < 0 or number > 100 %}\n1131 | {{ exceptions.raise_compiler_error(\"Invalid `number`. Got: \" ~ number) }}\n1132 | {% endif %}\n1133 | \n1134 | ## warn\n1135 | \n1136 | The `exceptions.warn` method will raise a compiler warning with the\n1137 | provided message. If the `--warn-error` flag is provided to dbt, then\n1138 | this warning will be elevated to an exception, which is raised.\n1139 | \n1140 | Example usage:\n1141 | \n1142 | > warn.sql:\n1143 | \n1144 | {% if number < 0 or number > 100 %}\n1145 | {% do exceptions.warn(\"Invalid `number`. Got: \" ~ number) %}\n1146 | {% endif %}\n1147 | \"\"\" # noqa\n1148 | return wrapped_exports(self.model)\n1149 | \n1150 | @contextproperty()\n1151 | def database(self) -> str:\n1152 | return self.config.credentials.database\n1153 | \n1154 | @contextproperty()\n1155 | def schema(self) -> str:\n1156 | return self.config.credentials.schema\n1157 | \n1158 | @contextproperty()\n1159 | def var(self) -> ModelConfiguredVar:\n1160 | return self.provider.Var(\n1161 | context=self._ctx,\n1162 | config=self.config,\n1163 | node=self.model,\n1164 | )\n1165 | \n1166 | @contextproperty(\"adapter\")\n1167 | def ctx_adapter(self) -> BaseDatabaseWrapper:\n1168 | \"\"\"`adapter` is a wrapper around the internal database adapter used by\n1169 | dbt. It allows users to make calls to the database in their dbt models.\n1170 | The adapter methods will be translated into specific SQL statements\n1171 | depending on the type of adapter your project is using.\n1172 | \"\"\"\n1173 | return self.db_wrapper\n1174 | \n1175 | @contextproperty()\n1176 | def api(self) -> Dict[str, Any]:\n1177 | return {\n1178 | \"Relation\": self.db_wrapper.Relation,\n1179 | \"Column\": self.adapter.Column,\n1180 | }\n1181 | \n1182 | @contextproperty()\n1183 | def column(self) -> Type[Column]:\n1184 | return self.adapter.Column\n1185 | \n1186 | @contextproperty()\n1187 | def env(self) -> Dict[str, Any]:\n1188 | return self.target\n1189 | \n1190 | @contextproperty()\n1191 | def graph(self) -> Dict[str, Any]:\n1192 | \"\"\"The `graph` context variable contains information about the nodes in\n1193 | your dbt project. Models, sources, tests, and snapshots are all\n1194 | examples of nodes in dbt projects.\n1195 | \n1196 | ## The graph context variable\n1197 | \n1198 | The graph context variable is a dictionary which maps node ids onto dictionary representations of those nodes. A simplified example might look like:\n1199 | \n1200 | {\n1201 | \"model.project_name.model_name\": {\n1202 | \"config\": {\"materialzed\": \"table\", \"sort\": \"id\"},\n1203 | \"tags\": [\"abc\", \"123\"],\n1204 | \"path\": \"models/path/to/model_name.sql\",\n1205 | ...\n1206 | },\n1207 | \"source.project_name.source_name\": {\n1208 | \"path\": \"models/path/to/schema.yml\",\n1209 | \"columns\": {\n1210 | \"id\": { .... },\n1211 | \"first_name\": { .... },\n1212 | },\n1213 | ...\n1214 | }\n1215 | }\n1216 | \n1217 | The exact contract for these model and source nodes is not currently\n1218 | documented, but that will change in the future.\n1219 | \n1220 | ## Accessing models\n1221 | \n1222 | The `model` entries in the `graph` dictionary will be incomplete or\n1223 | incorrect during parsing. If accessing the models in your project via\n1224 | the `graph` variable, be sure to use the `execute` flag to ensure that\n1225 | this code only executes at run-time and not at parse-time. Do not use\n1226 | the `graph` variable to build you DAG, as the resulting dbt behavior\n1227 | will be undefined and likely incorrect.\n1228 | \n1229 | Example usage:\n1230 | \n1231 | > graph-usage.sql:\n1232 | \n1233 | /*\n1234 | Print information about all of the models in the Snowplow package\n1235 | */\n1236 | {% if execute %}\n1237 | {% for node in graph.nodes.values()\n1238 | | selectattr(\"resource_type\", \"equalto\", \"model\")\n1239 | | selectattr(\"package_name\", \"equalto\", \"snowplow\") %}\n1240 | \n1241 | {% do log(node.unique_id ~ \", materialized: \" ~ node.config.materialized, info=true) %}\n1242 | \n1243 | {% endfor %}\n1244 | {% endif %}\n1245 | /*\n1246 | Example output\n1247 | ---------------------------------------------------------------\n1248 | model.snowplow.snowplow_id_map, materialized: incremental\n1249 | model.snowplow.snowplow_page_views, materialized: incremental\n1250 | model.snowplow.snowplow_web_events, materialized: incremental\n1251 | model.snowplow.snowplow_web_page_context, materialized: table\n1252 | model.snowplow.snowplow_web_events_scroll_depth, materialized: incremental\n1253 | model.snowplow.snowplow_web_events_time, materialized: incremental\n1254 | model.snowplow.snowplow_web_events_internal_fixed, materialized: ephemeral\n1255 | model.snowplow.snowplow_base_web_page_context, materialized: ephemeral\n1256 | model.snowplow.snowplow_base_events, materialized: ephemeral\n1257 | model.snowplow.snowplow_sessions_tmp, materialized: incremental\n1258 | model.snowplow.snowplow_sessions, materialized: table\n1259 | */\n1260 | \n1261 | ## Accessing sources\n1262 | \n1263 | To access the sources in your dbt project programatically, use the \"sources\" attribute.\n1264 | \n1265 | Example usage:\n1266 | \n1267 | > models/events_unioned.sql\n1268 | \n1269 | /*\n1270 | Union all of the Snowplow sources defined in the project\n1271 | which begin with the string \"event_\"\n1272 | */\n1273 | {% set sources = [] -%}\n1274 | {% for node in graph.sources.values() -%}\n1275 | {%- if node.name.startswith('event_') and node.source_name == 'snowplow' -%}\n1276 | {%- do sources.append(source(node.source_name, node.name)) -%}\n1277 | {%- endif -%}\n1278 | {%- endfor %}\n1279 | select * from (\n1280 | {%- for source in sources %}\n1281 | {{ source }} {% if not loop.last %} union all {% endif %}\n1282 | {% endfor %}\n1283 | )\n1284 | /*\n1285 | Example compiled SQL\n1286 | ---------------------------------------------------------------\n1287 | select * from (\n1288 | select * from raw.snowplow.event_add_to_cart union all\n1289 | select * from raw.snowplow.event_remove_from_cart union all\n1290 | select * from raw.snowplow.event_checkout\n1291 | )\n1292 | */\n1293 | \n1294 | \"\"\" # noqa\n1295 | return self.manifest.flat_graph\n1296 | \n1297 | @contextproperty(\"model\")\n1298 | def ctx_model(self) -> Dict[str, Any]:\n1299 | model_dct = self.model.to_dict(omit_none=True)\n1300 | # Maintain direct use of compiled_sql\n1301 | # TODO add depreciation logic[CT-934]\n1302 | if \"compiled_code\" in model_dct:\n1303 | model_dct[\"compiled_sql\"] = model_dct[\"compiled_code\"]\n1304 | \n1305 | if (\n1306 | hasattr(self.model, \"contract\")\n1307 | and self.model.contract.alias_types is True\n1308 | and \"columns\" in model_dct\n1309 | ):\n1310 | for column in model_dct[\"columns\"].values():\n1311 | if \"data_type\" in column:\n1312 | orig_data_type = column[\"data_type\"]\n1313 | # translate data_type to value in Column.TYPE_LABELS\n1314 | new_data_type = self.adapter.Column.translate_type(orig_data_type)\n1315 | column[\"data_type\"] = new_data_type\n1316 | return model_dct\n1317 | \n1318 | @contextproperty()\n1319 | def pre_hooks(self) -> Optional[List[Dict[str, Any]]]:\n1320 | return None\n1321 | \n1322 | @contextproperty()\n1323 | def post_hooks(self) -> Optional[List[Dict[str, Any]]]:\n1324 | return None\n1325 | \n1326 | @contextproperty()\n1327 | def sql(self) -> Optional[str]:\n1328 | return None\n1329 | \n1330 | @contextproperty()\n1331 | def sql_now(self) -> str:\n1332 | return self.adapter.date_function()\n1333 | \n1334 | @contextmember()\n1335 | def adapter_macro(self, name: str, *args, **kwargs):\n1336 | \"\"\"This was deprecated in v0.18 in favor of adapter.dispatch\"\"\"\n1337 | msg = (\n1338 | 'The \"adapter_macro\" macro has been deprecated. Instead, use '\n1339 | \"the `adapter.dispatch` method to find a macro and call the \"\n1340 | \"result. For more information, see: \"\n1341 | \"https://docs.getdbt.com/reference/dbt-jinja-functions/dispatch)\"\n1342 | \" adapter_macro was called for: {macro_name}\".format(macro_name=name)\n1343 | )\n1344 | raise CompilationError(msg)\n1345 | \n1346 | @contextmember()\n1347 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1348 | \"\"\"The env_var() function. Return the environment variable named 'var'.\n1349 | If there is no such environment variable set, return the default.\n1350 | \n1351 | If the default is None, raise an exception for an undefined variable.\n1352 | \"\"\"\n1353 | return_value = None\n1354 | if var.startswith(SECRET_ENV_PREFIX):\n1355 | raise SecretEnvVarLocationError(var)\n1356 | if var in os.environ:\n1357 | return_value = os.environ[var]\n1358 | elif default is not None:\n1359 | return_value = default\n1360 | \n1361 | if return_value is not None:\n1362 | # Save the env_var value in the manifest and the var name in the source_file.\n1363 | # If this is compiling, do not save because it's irrelevant to parsing.\n1364 | compiling = (\n1365 | True\n1366 | if hasattr(self.model, \"compiled\")\n1367 | and getattr(self.model, \"compiled\", False) is True\n1368 | else False\n1369 | )\n1370 | if self.model and not compiling:\n1371 | # If the environment variable is set from a default, store a string indicating\n1372 | # that so we can skip partial parsing. Otherwise the file will be scheduled for\n1373 | # reparsing. If the default changes, the file will have been updated and therefore\n1374 | # will be scheduled for reparsing anyways.\n1375 | self.manifest.env_vars[var] = (\n1376 | return_value if var in os.environ else DEFAULT_ENV_PLACEHOLDER\n1377 | )\n1378 | \n1379 | # hooks come from dbt_project.yml which doesn't have a real file_id\n1380 | if self.model.file_id in self.manifest.files:\n1381 | source_file = self.manifest.files[self.model.file_id]\n1382 | # Schema files should never get here\n1383 | if source_file.parse_file_type != \"schema\":\n1384 | # TODO CT-211\n1385 | source_file.env_vars.append(var) # type: ignore[union-attr]\n1386 | return return_value\n1387 | else:\n1388 | raise EnvVarMissingError(var)\n1389 | \n1390 | @contextproperty()\n1391 | def selected_resources(self) -> List[str]:\n1392 | \"\"\"The `selected_resources` variable contains a list of the resources\n1393 | selected based on the parameters provided to the dbt command.\n1394 | Currently, is not populated for the command `run-operation` that\n1395 | doesn't support `--select`.\n1396 | \"\"\"\n1397 | return selected_resources.SELECTED_RESOURCES\n1398 | \n1399 | @contextmember()\n1400 | def submit_python_job(self, parsed_model: Dict, compiled_code: str) -> AdapterResponse:\n1401 | # Check macro_stack and that the unique id is for a materialization macro\n1402 | if not (\n1403 | self.context_macro_stack.depth == 2\n1404 | and self.context_macro_stack.call_stack[1] == \"macro.dbt.statement\"\n1405 | and \"materialization\" in self.context_macro_stack.call_stack[0]\n1406 | ):\n1407 | raise DbtRuntimeError(\n1408 | f\"submit_python_job is not intended to be called here, at model {parsed_model['alias']}, with macro call_stack {self.context_macro_stack.call_stack}.\"\n1409 | )\n1410 | return self.adapter.submit_python_job(parsed_model, compiled_code)\n1411 | \n1412 | \n1413 | class MacroContext(ProviderContext):\n1414 | \"\"\"Internally, macros can be executed like nodes, with some restrictions:\n1415 | \n1416 | - they don't have all values available that nodes do:\n1417 | - 'this', 'pre_hooks', 'post_hooks', and 'sql' are missing\n1418 | - 'schema' does not use any 'model' information\n1419 | - they can't be configured with config() directives\n1420 | \"\"\"\n1421 | \n1422 | def __init__(\n1423 | self,\n1424 | model: MacroProtocol,\n1425 | config: RuntimeConfig,\n1426 | manifest: Manifest,\n1427 | provider: Provider,\n1428 | search_package: Optional[str],\n1429 | ) -> None:\n1430 | super().__init__(model, config, manifest, provider, None)\n1431 | # override the model-based package with the given one\n1432 | if search_package is None:\n1433 | # if the search package name isn't specified, use the root project\n1434 | self._search_package = config.project_name\n1435 | else:\n1436 | self._search_package = search_package\n1437 | \n1438 | \n1439 | class ModelContext(ProviderContext):\n1440 | model: ManifestNode\n1441 | \n1442 | @contextproperty()\n1443 | def pre_hooks(self) -> List[Dict[str, Any]]:\n1444 | if self.model.resource_type in [NodeType.Source, NodeType.Test, NodeType.Unit]:\n1445 | return []\n1446 | # TODO CT-211\n1447 | return [\n1448 | h.to_dict(omit_none=True) for h in self.model.config.pre_hook # type: ignore[union-attr] # noqa\n1449 | ]\n1450 | \n1451 | @contextproperty()\n1452 | def post_hooks(self) -> List[Dict[str, Any]]:\n1453 | if self.model.resource_type in [NodeType.Source, NodeType.Test, NodeType.Unit]:\n1454 | return []\n1455 | # TODO CT-211\n1456 | return [\n1457 | h.to_dict(omit_none=True) for h in self.model.config.post_hook # type: ignore[union-attr] # noqa\n1458 | ]\n1459 | \n1460 | @contextproperty()\n1461 | def sql(self) -> Optional[str]:\n1462 | # only doing this in sql model for backward compatible\n1463 | if self.model.language == ModelLanguage.sql: # type: ignore[union-attr]\n1464 | # If the model is deferred and the adapter doesn't support zero-copy cloning, then select * from the prod\n1465 | # relation\n1466 | # TODO: avoid routing on args.which if possible\n1467 | if getattr(self.model, \"defer_relation\", None) and self.config.args.which == \"clone\":\n1468 | # TODO https://github.com/dbt-labs/dbt-core/issues/7976\n1469 | return f\"select * from {self.model.defer_relation.relation_name or str(self.defer_relation)}\" # type: ignore[union-attr]\n1470 | elif getattr(self.model, \"extra_ctes_injected\", None):\n1471 | # TODO CT-211\n1472 | return self.model.compiled_code # type: ignore[union-attr]\n1473 | else:\n1474 | return None\n1475 | else:\n1476 | return None\n1477 | \n1478 | @contextproperty()\n1479 | def compiled_code(self) -> Optional[str]:\n1480 | if getattr(self.model, \"defer_relation\", None):\n1481 | # TODO https://github.com/dbt-labs/dbt-core/issues/7976\n1482 | return f\"select * from {self.model.defer_relation.relation_name or str(self.defer_relation)}\" # type: ignore[union-attr]\n1483 | elif getattr(self.model, \"extra_ctes_injected\", None):\n1484 | # TODO CT-211\n1485 | return self.model.compiled_code # type: ignore[union-attr]\n1486 | else:\n1487 | return None\n1488 | \n1489 | @contextproperty()\n1490 | def database(self) -> str:\n1491 | return getattr(self.model, \"database\", self.config.credentials.database)\n1492 | \n1493 | @contextproperty()\n1494 | def schema(self) -> str:\n1495 | return getattr(self.model, \"schema\", self.config.credentials.schema)\n1496 | \n1497 | @contextproperty()\n1498 | def this(self) -> Optional[RelationProxy]:\n1499 | \"\"\"`this` makes available schema information about the currently\n1500 | executing model. It's is useful in any context in which you need to\n1501 | write code that references the current model, for example when defining\n1502 | a `sql_where` clause for an incremental model and for writing pre- and\n1503 | post-model hooks that operate on the model in some way. Developers have\n1504 | options for how to use `this`:\n1505 | \n1506 | |------------------|------------------|\n1507 | | dbt Model Syntax | Output |\n1508 | |------------------|------------------|\n1509 | | {{this}} | \"schema\".\"table\" |\n1510 | |------------------|------------------|\n1511 | | {{this.schema}} | schema |\n1512 | |------------------|------------------|\n1513 | | {{this.table}} | table |\n1514 | |------------------|------------------|\n1515 | | {{this.name}} | table |\n1516 | |------------------|------------------|\n1517 | \n1518 | Here's an example of how to use `this` in `dbt_project.yml` to grant\n1519 | select rights on a table to a different db user.\n1520 | \n1521 | > example.yml:\n1522 | \n1523 | models:\n1524 | project-name:\n1525 | post-hook:\n1526 | - \"grant select on {{ this }} to db_reader\"\n1527 | \"\"\"\n1528 | if self.model.resource_type == NodeType.Operation:\n1529 | return None\n1530 | return self.db_wrapper.Relation.create_from(self.config, self.model)\n1531 | \n1532 | @contextproperty()\n1533 | def defer_relation(self) -> Optional[RelationProxy]:\n1534 | \"\"\"\n1535 | For commands which add information about this node's corresponding\n1536 | production version (via a --state artifact), access the Relation\n1537 | object for that stateful other\n1538 | \"\"\"\n1539 | if getattr(self.model, \"defer_relation\", None):\n1540 | return self.db_wrapper.Relation.create_from(\n1541 | self.config, self.model.defer_relation # type: ignore\n1542 | )\n1543 | else:\n1544 | return None\n1545 | \n1546 | \n1547 | class UnitTestContext(ModelContext):\n1548 | model: UnitTestNode\n1549 | \n1550 | @contextmember()\n1551 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1552 | \"\"\"The env_var() function. Return the overriden unit test environment variable named 'var'.\n1553 | \n1554 | If there is no unit test override, return the environment variable named 'var'.\n1555 | \n1556 | If there is no such environment variable set, return the default.\n1557 | \n1558 | If the default is None, raise an exception for an undefined variable.\n1559 | \"\"\"\n1560 | if self.model.overrides and var in self.model.overrides.env_vars:\n1561 | return self.model.overrides.env_vars[var]\n1562 | else:\n1563 | return super().env_var(var, default)\n1564 | \n1565 | @contextproperty()\n1566 | def this(self) -> Optional[str]:\n1567 | if self.model.this_input_node_unique_id:\n1568 | this_node = self.manifest.expect(self.model.this_input_node_unique_id)\n1569 | self.model.set_cte(this_node.unique_id, None) # type: ignore\n1570 | return self.adapter.Relation.add_ephemeral_prefix(this_node.name)\n1571 | return None\n1572 | \n1573 | \n1574 | # This is called by '_context_for', used in 'render_with_context'\n1575 | def generate_parser_model_context(\n1576 | model: ManifestNode,\n1577 | config: RuntimeConfig,\n1578 | manifest: Manifest,\n1579 | context_config: ContextConfig,\n1580 | ) -> Dict[str, Any]:\n1581 | # The __init__ method of ModelContext also initializes\n1582 | # a ManifestContext object which creates a MacroNamespaceBuilder\n1583 | # which adds every macro in the Manifest.\n1584 | ctx = ModelContext(model, config, manifest, ParseProvider(), context_config)\n1585 | # The 'to_dict' method in ManifestContext moves all of the macro names\n1586 | # in the macro 'namespace' up to top level keys\n1587 | return ctx.to_dict()\n1588 | \n1589 | \n1590 | def generate_generate_name_macro_context(\n1591 | macro: Macro,\n1592 | config: RuntimeConfig,\n1593 | manifest: Manifest,\n1594 | ) -> Dict[str, Any]:\n1595 | ctx = MacroContext(macro, config, manifest, GenerateNameProvider(), None)\n1596 | return ctx.to_dict()\n1597 | \n1598 | \n1599 | def generate_runtime_model_context(\n1600 | model: ManifestNode,\n1601 | config: RuntimeConfig,\n1602 | manifest: Manifest,\n1603 | ) -> Dict[str, Any]:\n1604 | ctx = ModelContext(model, config, manifest, RuntimeProvider(), None)\n1605 | return ctx.to_dict()\n1606 | \n1607 | \n1608 | def generate_runtime_macro_context(\n1609 | macro: MacroProtocol,\n1610 | config: RuntimeConfig,\n1611 | manifest: Manifest,\n1612 | package_name: Optional[str],\n1613 | ) -> Dict[str, Any]:\n1614 | ctx = MacroContext(macro, config, manifest, OperationProvider(), package_name)\n1615 | return ctx.to_dict()\n1616 | \n1617 | \n1618 | def generate_runtime_unit_test_context(\n1619 | unit_test: UnitTestNode,\n1620 | config: RuntimeConfig,\n1621 | manifest: Manifest,\n1622 | ) -> Dict[str, Any]:\n1623 | ctx = UnitTestContext(unit_test, config, manifest, RuntimeUnitTestProvider(), None)\n1624 | ctx_dict = ctx.to_dict()\n1625 | \n1626 | if unit_test.overrides and unit_test.overrides.macros:\n1627 | for macro_name, macro_value in unit_test.overrides.macros.items():\n1628 | context_value = ctx_dict.get(macro_name)\n1629 | if isinstance(context_value, MacroGenerator):\n1630 | ctx_dict[macro_name] = UnitTestMacroGenerator(context_value, macro_value)\n1631 | else:\n1632 | ctx_dict[macro_name] = macro_value\n1633 | return ctx_dict\n1634 | \n1635 | \n1636 | class ExposureRefResolver(BaseResolver):\n1637 | def __call__(self, *args, **kwargs) -> str:\n1638 | package = None\n1639 | if len(args) == 1:\n1640 | name = args[0]\n1641 | elif len(args) == 2:\n1642 | package, name = args\n1643 | else:\n1644 | raise RefArgsError(node=self.model, args=args)\n1645 | \n1646 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n1647 | \n1648 | self.model.refs.append(RefArgs(package=package, name=name, version=version))\n1649 | return \"\"\n1650 | \n1651 | \n1652 | class ExposureSourceResolver(BaseResolver):\n1653 | def __call__(self, *args) -> str:\n1654 | if len(args) != 2:\n1655 | raise NumberSourceArgsError(args, node=self.model)\n1656 | self.model.sources.append(list(args))\n1657 | return \"\"\n1658 | \n1659 | \n1660 | class ExposureMetricResolver(BaseResolver):\n1661 | def __call__(self, *args) -> str:\n1662 | if len(args) not in (1, 2):\n1663 | raise MetricArgsError(node=self.model, args=args)\n1664 | self.model.metrics.append(list(args))\n1665 | return \"\"\n1666 | \n1667 | \n1668 | def generate_parse_exposure(\n1669 | exposure: Exposure,\n1670 | config: RuntimeConfig,\n1671 | manifest: Manifest,\n1672 | package_name: str,\n1673 | ) -> Dict[str, Any]:\n1674 | project = config.load_dependencies()[package_name]\n1675 | return {\n1676 | \"ref\": ExposureRefResolver(\n1677 | None,\n1678 | exposure,\n1679 | project,\n1680 | manifest,\n1681 | ),\n1682 | \"source\": ExposureSourceResolver(\n1683 | None,\n1684 | exposure,\n1685 | project,\n1686 | manifest,\n1687 | ),\n1688 | \"metric\": ExposureMetricResolver(\n1689 | None,\n1690 | exposure,\n1691 | project,\n1692 | manifest,\n1693 | ),\n1694 | }\n1695 | \n1696 | \n1697 | # applies to SemanticModels\n1698 | class SemanticModelRefResolver(BaseResolver):\n1699 | def __call__(self, *args, **kwargs) -> str:\n1700 | package = None\n1701 | if len(args) == 1:\n1702 | name = args[0]\n1703 | elif len(args) == 2:\n1704 | package, name = args\n1705 | else:\n1706 | raise RefArgsError(node=self.model, args=args)\n1707 | \n1708 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n1709 | self.validate_args(name, package, version)\n1710 | \n1711 | # \"model\" here is any node\n1712 | self.model.refs.append(RefArgs(package=package, name=name, version=version))\n1713 | return \"\"\n1714 | \n1715 | def validate_args(self, name, package, version):\n1716 | if not isinstance(name, str):\n1717 | raise ParsingError(\n1718 | f\"In a semantic model or metrics section in {self.model.original_file_path} \"\n1719 | \"the name argument to ref() must be a string\"\n1720 | )\n1721 | \n1722 | \n1723 | # used for semantic models\n1724 | def generate_parse_semantic_models(\n1725 | semantic_model: SemanticModel,\n1726 | config: RuntimeConfig,\n1727 | manifest: Manifest,\n1728 | package_name: str,\n1729 | ) -> Dict[str, Any]:\n1730 | project = config.load_dependencies()[package_name]\n1731 | return {\n1732 | \"ref\": SemanticModelRefResolver(\n1733 | None,\n1734 | semantic_model,\n1735 | project,\n1736 | manifest,\n1737 | ),\n1738 | }\n1739 | \n1740 | \n1741 | # This class is currently used by the schema parser in order\n1742 | # to limit the number of macros in the context by using\n1743 | # the TestMacroNamespace\n1744 | class TestContext(ProviderContext):\n1745 | def __init__(\n1746 | self,\n1747 | model,\n1748 | config: RuntimeConfig,\n1749 | manifest: Manifest,\n1750 | provider: Provider,\n1751 | context_config: Optional[ContextConfig],\n1752 | macro_resolver: MacroResolver,\n1753 | ) -> None:\n1754 | # this must be before super init so that macro_resolver exists for\n1755 | # build_namespace\n1756 | self.macro_resolver = macro_resolver\n1757 | self.thread_ctx = MacroStack()\n1758 | super().__init__(model, config, manifest, provider, context_config)\n1759 | self._build_test_namespace()\n1760 | # We need to rebuild this because it's already been built by\n1761 | # the ProviderContext with the wrong namespace.\n1762 | self.db_wrapper = self.provider.DatabaseWrapper(self.adapter, self.namespace)\n1763 | \n1764 | def _build_namespace(self):\n1765 | return {}\n1766 | \n1767 | # this overrides _build_namespace in ManifestContext which provides a\n1768 | # complete namespace of all macros to only specify macros in the depends_on\n1769 | # This only provides a namespace with macros in the test node\n1770 | # 'depends_on.macros' by using the TestMacroNamespace\n1771 | def _build_test_namespace(self):\n1772 | depends_on_macros = []\n1773 | # all generic tests use a macro named 'get_where_subquery' to wrap 'model' arg\n1774 | # see generic_test_builders.build_model_str\n1775 | get_where_subquery = self.macro_resolver.macros_by_name.get(\"get_where_subquery\")\n1776 | if get_where_subquery:\n1777 | depends_on_macros.append(get_where_subquery.unique_id)\n1778 | if self.model.depends_on and self.model.depends_on.macros:\n1779 | depends_on_macros.extend(self.model.depends_on.macros)\n1780 | lookup_macros = depends_on_macros.copy()\n1781 | for macro_unique_id in lookup_macros:\n1782 | lookup_macro = self.macro_resolver.macros.get(macro_unique_id)\n1783 | if lookup_macro:\n1784 | depends_on_macros.extend(lookup_macro.depends_on.macros)\n1785 | \n1786 | macro_namespace = TestMacroNamespace(\n1787 | self.macro_resolver, self._ctx, self.model, self.thread_ctx, depends_on_macros\n1788 | )\n1789 | self.namespace = macro_namespace\n1790 | \n1791 | @contextmember()\n1792 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1793 | return_value = None\n1794 | if var.startswith(SECRET_ENV_PREFIX):\n1795 | raise SecretEnvVarLocationError(var)\n1796 | if var in os.environ:\n1797 | return_value = os.environ[var]\n1798 | elif default is not None:\n1799 | return_value = default\n1800 | \n1801 | if return_value is not None:\n1802 | # Save the env_var value in the manifest and the var name in the source_file\n1803 | if self.model:\n1804 | # If the environment variable is set from a default, store a string indicating\n1805 | # that so we can skip partial parsing. Otherwise the file will be scheduled for\n1806 | # reparsing. If the default changes, the file will have been updated and therefore\n1807 | # will be scheduled for reparsing anyways.\n1808 | self.manifest.env_vars[var] = (\n1809 | return_value if var in os.environ else DEFAULT_ENV_PLACEHOLDER\n1810 | )\n1811 | # the \"model\" should only be test nodes, but just in case, check\n1812 | # TODO CT-211\n1813 | if self.model.resource_type == NodeType.Test and self.model.file_key_name: # type: ignore[union-attr] # noqa\n1814 | source_file = self.manifest.files[self.model.file_id]\n1815 | # TODO CT-211\n1816 | (yaml_key, name) = self.model.file_key_name.split(\".\") # type: ignore[union-attr] # noqa\n1817 | # TODO CT-211\n1818 | source_file.add_env_var(var, yaml_key, name) # type: ignore[union-attr]\n1819 | return return_value\n1820 | else:\n1821 | raise EnvVarMissingError(var)\n1822 | \n1823 | \n1824 | def generate_test_context(\n1825 | model: ManifestNode,\n1826 | config: RuntimeConfig,\n1827 | manifest: Manifest,\n1828 | context_config: ContextConfig,\n1829 | macro_resolver: MacroResolver,\n1830 | ) -> Dict[str, Any]:\n1831 | ctx = TestContext(model, config, manifest, ParseProvider(), context_config, macro_resolver)\n1832 | # The 'to_dict' method in ManifestContext moves all of the macro names\n1833 | # in the macro 'namespace' up to top level keys\n1834 | return ctx.to_dict()\n```\n\n## Files after the fix\n\n### File: core/dbt/context/providers.py\n\n```python\n 1 | import abc\n 2 | from copy import deepcopy\n 3 | import os\n 4 | from typing import (\n 5 | Callable,\n 6 | Any,\n 7 | Dict,\n 8 | Optional,\n 9 | Union,\n 10 | List,\n 11 | TypeVar,\n 12 | Type,\n 13 | Iterable,\n 14 | Mapping,\n 15 | )\n 16 | from typing_extensions import Protocol\n 17 | \n 18 | from dbt.adapters.base.column import Column\n 19 | from dbt.artifacts.resources import NodeVersion, RefArgs\n 20 | from dbt_common.clients.jinja import MacroProtocol\n 21 | from dbt.adapters.factory import get_adapter, get_adapter_package_names, get_adapter_type_names\n 22 | from dbt_common.clients import agate_helper\n 23 | from dbt.clients.jinja import get_rendered, MacroGenerator, MacroStack, UnitTestMacroGenerator\n 24 | from dbt.config import RuntimeConfig, Project\n 25 | from dbt.constants import SECRET_ENV_PREFIX, DEFAULT_ENV_PLACEHOLDER\n 26 | from dbt.context.base import contextmember, contextproperty, Var\n 27 | from dbt.context.configured import FQNLookup\n 28 | from dbt.context.context_config import ContextConfig\n 29 | from dbt.context.exceptions_jinja import wrapped_exports\n 30 | from dbt.context.macro_resolver import MacroResolver, TestMacroNamespace\n 31 | from dbt.context.macros import MacroNamespaceBuilder, MacroNamespace\n 32 | from dbt.context.manifest import ManifestContext\n 33 | from dbt.adapters.contracts.connection import AdapterResponse\n 34 | from dbt.contracts.graph.manifest import Manifest, Disabled\n 35 | from dbt.contracts.graph.nodes import (\n 36 | Macro,\n 37 | Exposure,\n 38 | SeedNode,\n 39 | SourceDefinition,\n 40 | Resource,\n 41 | ManifestNode,\n 42 | AccessType,\n 43 | SemanticModel,\n 44 | UnitTestNode,\n 45 | )\n 46 | from dbt.contracts.graph.metrics import MetricReference, ResolvedMetricReference\n 47 | from dbt_common.events.functions import get_metadata_vars\n 48 | from dbt_common.exceptions import (\n 49 | DbtInternalError,\n 50 | DbtRuntimeError,\n 51 | DbtValidationError,\n 52 | MacrosSourcesUnWriteableError,\n 53 | )\n 54 | from dbt.adapters.exceptions import MissingConfigError\n 55 | from dbt.exceptions import (\n 56 | CompilationError,\n 57 | ConflictingConfigKeysError,\n 58 | SecretEnvVarLocationError,\n 59 | EnvVarMissingError,\n 60 | InlineModelConfigError,\n 61 | NumberSourceArgsError,\n 62 | PersistDocsValueTypeError,\n 63 | LoadAgateTableNotSeedError,\n 64 | LoadAgateTableValueError,\n 65 | MacroDispatchArgError,\n 66 | MacroResultAlreadyLoadedError,\n 67 | MetricArgsError,\n 68 | OperationsCannotRefEphemeralNodesError,\n 69 | ParsingError,\n 70 | RefBadContextError,\n 71 | RefArgsError,\n 72 | TargetNotFoundError,\n 73 | DbtReferenceError,\n 74 | )\n 75 | from dbt.config import IsFQNResource\n 76 | from dbt.node_types import NodeType, ModelLanguage\n 77 | \n 78 | from dbt.utils import MultiDict, args_to_dict\n 79 | from dbt_common.utils import merge, AttrDict, cast_to_str\n 80 | from dbt import selected_resources\n 81 | \n 82 | import agate\n 83 | \n 84 | \n 85 | _MISSING = object()\n 86 | \n 87 | \n 88 | # base classes\n 89 | class RelationProxy:\n 90 | def __init__(self, adapter):\n 91 | self._quoting_config = adapter.config.quoting\n 92 | self._relation_type = adapter.Relation\n 93 | \n 94 | def __getattr__(self, key):\n 95 | return getattr(self._relation_type, key)\n 96 | \n 97 | def create(self, *args, **kwargs):\n 98 | kwargs[\"quote_policy\"] = merge(self._quoting_config, kwargs.pop(\"quote_policy\", {}))\n 99 | return self._relation_type.create(*args, **kwargs)\n 100 | \n 101 | \n 102 | class BaseDatabaseWrapper:\n 103 | \"\"\"\n 104 | Wrapper for runtime database interaction. Applies the runtime quote policy\n 105 | via a relation proxy.\n 106 | \"\"\"\n 107 | \n 108 | def __init__(self, adapter, namespace: MacroNamespace):\n 109 | self._adapter = adapter\n 110 | self.Relation = RelationProxy(adapter)\n 111 | self._namespace = namespace\n 112 | \n 113 | def __getattr__(self, name):\n 114 | raise NotImplementedError(\"subclasses need to implement this\")\n 115 | \n 116 | @property\n 117 | def config(self):\n 118 | return self._adapter.config\n 119 | \n 120 | def type(self):\n 121 | return self._adapter.type()\n 122 | \n 123 | def commit(self):\n 124 | return self._adapter.commit_if_has_connection()\n 125 | \n 126 | def _get_adapter_macro_prefixes(self) -> List[str]:\n 127 | # order matters for dispatch:\n 128 | # 1. current adapter\n 129 | # 2. any parent adapters (dependencies)\n 130 | # 3. 'default'\n 131 | search_prefixes = get_adapter_type_names(self._adapter.type()) + [\"default\"]\n 132 | return search_prefixes\n 133 | \n 134 | def _get_search_packages(self, namespace: Optional[str] = None) -> List[Optional[str]]:\n 135 | search_packages: List[Optional[str]] = [None]\n 136 | \n 137 | if namespace is None:\n 138 | search_packages = [None]\n 139 | elif isinstance(namespace, str):\n 140 | macro_search_order = self._adapter.config.get_macro_search_order(namespace)\n 141 | if macro_search_order:\n 142 | search_packages = macro_search_order\n 143 | elif not macro_search_order and namespace in self._adapter.config.dependencies:\n 144 | search_packages = [self.config.project_name, namespace]\n 145 | else:\n 146 | raise CompilationError(\n 147 | f\"In adapter.dispatch, got a {type(namespace)} macro_namespace argument \"\n 148 | f'(\"{namespace}\"), but macro_namespace should be None or a string.'\n 149 | )\n 150 | \n 151 | return search_packages\n 152 | \n 153 | def dispatch(\n 154 | self,\n 155 | macro_name: str,\n 156 | macro_namespace: Optional[str] = None,\n 157 | packages: Optional[List[str]] = None, # eventually remove since it's fully deprecated\n 158 | ) -> MacroGenerator:\n 159 | search_packages: List[Optional[str]]\n 160 | \n 161 | if \".\" in macro_name:\n 162 | suggest_macro_namespace, suggest_macro_name = macro_name.split(\".\", 1)\n 163 | msg = (\n 164 | f'In adapter.dispatch, got a macro name of \"{macro_name}\", '\n 165 | f'but \".\" is not a valid macro name component. Did you mean '\n 166 | f'`adapter.dispatch(\"{suggest_macro_name}\", '\n 167 | f'macro_namespace=\"{suggest_macro_namespace}\")`?'\n 168 | )\n 169 | raise CompilationError(msg)\n 170 | \n 171 | if packages is not None:\n 172 | raise MacroDispatchArgError(macro_name)\n 173 | \n 174 | search_packages = self._get_search_packages(macro_namespace)\n 175 | \n 176 | attempts = []\n 177 | \n 178 | for package_name in search_packages:\n 179 | for prefix in self._get_adapter_macro_prefixes():\n 180 | search_name = f\"{prefix}__{macro_name}\"\n 181 | try:\n 182 | # this uses the namespace from the context\n 183 | macro = self._namespace.get_from_package(package_name, search_name)\n 184 | except CompilationError:\n 185 | # Only raise CompilationError if macro is not found in\n 186 | # any package\n 187 | macro = None\n 188 | \n 189 | if package_name is None:\n 190 | attempts.append(search_name)\n 191 | else:\n 192 | attempts.append(f\"{package_name}.{search_name}\")\n 193 | \n 194 | if macro is not None:\n 195 | return macro\n 196 | \n 197 | searched = \", \".join(repr(a) for a in attempts)\n 198 | msg = f\"In dispatch: No macro named '{macro_name}' found within namespace: '{macro_namespace}'\\n Searched for: {searched}\"\n 199 | raise CompilationError(msg)\n 200 | \n 201 | \n 202 | class BaseResolver(metaclass=abc.ABCMeta):\n 203 | def __init__(self, db_wrapper, model, config, manifest):\n 204 | self.db_wrapper = db_wrapper\n 205 | self.model = model\n 206 | self.config = config\n 207 | self.manifest = manifest\n 208 | \n 209 | @property\n 210 | def current_project(self):\n 211 | return self.config.project_name\n 212 | \n 213 | @property\n 214 | def Relation(self):\n 215 | return self.db_wrapper.Relation\n 216 | \n 217 | @property\n 218 | def resolve_limit(self) -> Optional[int]:\n 219 | return 0 if getattr(self.config.args, \"EMPTY\", False) else None\n 220 | \n 221 | @abc.abstractmethod\n 222 | def __call__(self, *args: str) -> Union[str, RelationProxy, MetricReference]:\n 223 | pass\n 224 | \n 225 | \n 226 | class BaseRefResolver(BaseResolver):\n 227 | @abc.abstractmethod\n 228 | def resolve(\n 229 | self, name: str, package: Optional[str] = None, version: Optional[NodeVersion] = None\n 230 | ) -> RelationProxy:\n 231 | ...\n 232 | \n 233 | def _repack_args(\n 234 | self, name: str, package: Optional[str], version: Optional[NodeVersion]\n 235 | ) -> RefArgs:\n 236 | return RefArgs(package=package, name=name, version=version)\n 237 | \n 238 | def validate_args(self, name: str, package: Optional[str], version: Optional[NodeVersion]):\n 239 | if not isinstance(name, str):\n 240 | raise CompilationError(\n 241 | f\"The name argument to ref() must be a string, got {type(name)}\"\n 242 | )\n 243 | \n 244 | if package is not None and not isinstance(package, str):\n 245 | raise CompilationError(\n 246 | f\"The package argument to ref() must be a string or None, got {type(package)}\"\n 247 | )\n 248 | \n 249 | if version is not None and not isinstance(version, (str, int, float)):\n 250 | raise CompilationError(\n 251 | f\"The version argument to ref() must be a string, int, float, or None - got {type(version)}\"\n 252 | )\n 253 | \n 254 | def __call__(self, *args: str, **kwargs) -> RelationProxy:\n 255 | name: str\n 256 | package: Optional[str] = None\n 257 | version: Optional[NodeVersion] = None\n 258 | \n 259 | if len(args) == 1:\n 260 | name = args[0]\n 261 | elif len(args) == 2:\n 262 | package, name = args\n 263 | else:\n 264 | raise RefArgsError(node=self.model, args=args)\n 265 | \n 266 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n 267 | self.validate_args(name, package, version)\n 268 | return self.resolve(name, package, version)\n 269 | \n 270 | \n 271 | class BaseSourceResolver(BaseResolver):\n 272 | @abc.abstractmethod\n 273 | def resolve(self, source_name: str, table_name: str):\n 274 | pass\n 275 | \n 276 | def validate_args(self, source_name: str, table_name: str):\n 277 | if not isinstance(source_name, str):\n 278 | raise CompilationError(\n 279 | f\"The source name (first) argument to source() must be a \"\n 280 | f\"string, got {type(source_name)}\"\n 281 | )\n 282 | if not isinstance(table_name, str):\n 283 | raise CompilationError(\n 284 | f\"The table name (second) argument to source() must be a \"\n 285 | f\"string, got {type(table_name)}\"\n 286 | )\n 287 | \n 288 | def __call__(self, *args: str) -> RelationProxy:\n 289 | if len(args) != 2:\n 290 | raise NumberSourceArgsError(args, node=self.model)\n 291 | self.validate_args(args[0], args[1])\n 292 | return self.resolve(args[0], args[1])\n 293 | \n 294 | \n 295 | class BaseMetricResolver(BaseResolver):\n 296 | @abc.abstractmethod\n 297 | def resolve(self, name: str, package: Optional[str] = None) -> MetricReference:\n 298 | ...\n 299 | \n 300 | def _repack_args(self, name: str, package: Optional[str]) -> List[str]:\n 301 | if package is None:\n 302 | return [name]\n 303 | else:\n 304 | return [package, name]\n 305 | \n 306 | def validate_args(self, name: str, package: Optional[str]):\n 307 | if not isinstance(name, str):\n 308 | raise CompilationError(\n 309 | f\"The name argument to metric() must be a string, got {type(name)}\"\n 310 | )\n 311 | \n 312 | if package is not None and not isinstance(package, str):\n 313 | raise CompilationError(\n 314 | f\"The package argument to metric() must be a string or None, got {type(package)}\"\n 315 | )\n 316 | \n 317 | def __call__(self, *args: str) -> MetricReference:\n 318 | name: str\n 319 | package: Optional[str] = None\n 320 | \n 321 | if len(args) == 1:\n 322 | name = args[0]\n 323 | elif len(args) == 2:\n 324 | package, name = args\n 325 | else:\n 326 | raise MetricArgsError(node=self.model, args=args)\n 327 | self.validate_args(name, package)\n 328 | return self.resolve(name, package)\n 329 | \n 330 | \n 331 | class Config(Protocol):\n 332 | def __init__(self, model, context_config: Optional[ContextConfig]):\n 333 | ...\n 334 | \n 335 | \n 336 | # Implementation of \"config(..)\" calls in models\n 337 | class ParseConfigObject(Config):\n 338 | def __init__(self, model, context_config: Optional[ContextConfig]):\n 339 | self.model = model\n 340 | self.context_config = context_config\n 341 | \n 342 | def _transform_config(self, config):\n 343 | for oldkey in (\"pre_hook\", \"post_hook\"):\n 344 | if oldkey in config:\n 345 | newkey = oldkey.replace(\"_\", \"-\")\n 346 | if newkey in config:\n 347 | raise ConflictingConfigKeysError(oldkey, newkey, node=self.model)\n 348 | config[newkey] = config.pop(oldkey)\n 349 | return config\n 350 | \n 351 | def __call__(self, *args, **kwargs):\n 352 | if len(args) == 1 and len(kwargs) == 0:\n 353 | opts = args[0]\n 354 | elif len(args) == 0 and len(kwargs) > 0:\n 355 | opts = kwargs\n 356 | else:\n 357 | raise InlineModelConfigError(node=self.model)\n 358 | \n 359 | opts = self._transform_config(opts)\n 360 | \n 361 | # it's ok to have a parse context with no context config, but you must\n 362 | # not call it!\n 363 | if self.context_config is None:\n 364 | raise DbtRuntimeError(\"At parse time, did not receive a context config\")\n 365 | self.context_config.add_config_call(opts)\n 366 | return \"\"\n 367 | \n 368 | def set(self, name, value):\n 369 | return self.__call__({name: value})\n 370 | \n 371 | def require(self, name, validator=None):\n 372 | return \"\"\n 373 | \n 374 | def get(self, name, default=None, validator=None):\n 375 | return \"\"\n 376 | \n 377 | def persist_relation_docs(self) -> bool:\n 378 | return False\n 379 | \n 380 | def persist_column_docs(self) -> bool:\n 381 | return False\n 382 | \n 383 | \n 384 | class RuntimeConfigObject(Config):\n 385 | def __init__(self, model, context_config: Optional[ContextConfig] = None):\n 386 | self.model = model\n 387 | # we never use or get a config, only the parser cares\n 388 | \n 389 | def __call__(self, *args, **kwargs):\n 390 | return \"\"\n 391 | \n 392 | def set(self, name, value):\n 393 | return self.__call__({name: value})\n 394 | \n 395 | def _validate(self, validator, value):\n 396 | validator(value)\n 397 | \n 398 | def _lookup(self, name, default=_MISSING):\n 399 | # if this is a macro, there might be no `model.config`.\n 400 | if not hasattr(self.model, \"config\"):\n 401 | result = default\n 402 | else:\n 403 | result = self.model.config.get(name, default)\n 404 | if result is _MISSING:\n 405 | raise MissingConfigError(unique_id=self.model.unique_id, name=name)\n 406 | return result\n 407 | \n 408 | def require(self, name, validator=None):\n 409 | to_return = self._lookup(name)\n 410 | \n 411 | if validator is not None:\n 412 | self._validate(validator, to_return)\n 413 | \n 414 | return to_return\n 415 | \n 416 | def get(self, name, default=None, validator=None):\n 417 | to_return = self._lookup(name, default)\n 418 | \n 419 | if validator is not None and default is not None:\n 420 | self._validate(validator, to_return)\n 421 | \n 422 | return to_return\n 423 | \n 424 | def persist_relation_docs(self) -> bool:\n 425 | persist_docs = self.get(\"persist_docs\", default={})\n 426 | if not isinstance(persist_docs, dict):\n 427 | raise PersistDocsValueTypeError(persist_docs)\n 428 | \n 429 | return persist_docs.get(\"relation\", False)\n 430 | \n 431 | def persist_column_docs(self) -> bool:\n 432 | persist_docs = self.get(\"persist_docs\", default={})\n 433 | if not isinstance(persist_docs, dict):\n 434 | raise PersistDocsValueTypeError(persist_docs)\n 435 | \n 436 | return persist_docs.get(\"columns\", False)\n 437 | \n 438 | \n 439 | # `adapter` implementations\n 440 | class ParseDatabaseWrapper(BaseDatabaseWrapper):\n 441 | \"\"\"The parser subclass of the database wrapper applies any explicit\n 442 | parse-time overrides.\n 443 | \"\"\"\n 444 | \n 445 | def __getattr__(self, name):\n 446 | override = name in self._adapter._available_ and name in self._adapter._parse_replacements_\n 447 | \n 448 | if override:\n 449 | return self._adapter._parse_replacements_[name]\n 450 | elif name in self._adapter._available_:\n 451 | return getattr(self._adapter, name)\n 452 | else:\n 453 | raise AttributeError(\n 454 | \"'{}' object has no attribute '{}'\".format(self.__class__.__name__, name)\n 455 | )\n 456 | \n 457 | \n 458 | class RuntimeDatabaseWrapper(BaseDatabaseWrapper):\n 459 | \"\"\"The runtime database wrapper exposes everything the adapter marks\n 460 | available.\n 461 | \"\"\"\n 462 | \n 463 | def __getattr__(self, name):\n 464 | if name in self._adapter._available_:\n 465 | return getattr(self._adapter, name)\n 466 | else:\n 467 | raise AttributeError(\n 468 | \"'{}' object has no attribute '{}'\".format(self.__class__.__name__, name)\n 469 | )\n 470 | \n 471 | \n 472 | # `ref` implementations\n 473 | class ParseRefResolver(BaseRefResolver):\n 474 | def resolve(\n 475 | self, name: str, package: Optional[str] = None, version: Optional[NodeVersion] = None\n 476 | ) -> RelationProxy:\n 477 | self.model.refs.append(self._repack_args(name, package, version))\n 478 | \n 479 | # This is not the ref for the \"name\" passed in, but for the current model.\n 480 | return self.Relation.create_from(self.config, self.model)\n 481 | \n 482 | \n 483 | ResolveRef = Union[Disabled, ManifestNode]\n 484 | \n 485 | \n 486 | class RuntimeRefResolver(BaseRefResolver):\n 487 | def resolve(\n 488 | self,\n 489 | target_name: str,\n 490 | target_package: Optional[str] = None,\n 491 | target_version: Optional[NodeVersion] = None,\n 492 | ) -> RelationProxy:\n 493 | target_model = self.manifest.resolve_ref(\n 494 | self.model,\n 495 | target_name,\n 496 | target_package,\n 497 | target_version,\n 498 | self.current_project,\n 499 | self.model.package_name,\n 500 | )\n 501 | \n 502 | if target_model is None or isinstance(target_model, Disabled):\n 503 | raise TargetNotFoundError(\n 504 | node=self.model,\n 505 | target_name=target_name,\n 506 | target_kind=\"node\",\n 507 | target_package=target_package,\n 508 | target_version=target_version,\n 509 | disabled=isinstance(target_model, Disabled),\n 510 | )\n 511 | elif self.manifest.is_invalid_private_ref(\n 512 | self.model, target_model, self.config.dependencies\n 513 | ):\n 514 | raise DbtReferenceError(\n 515 | unique_id=self.model.unique_id,\n 516 | ref_unique_id=target_model.unique_id,\n 517 | access=AccessType.Private,\n 518 | scope=cast_to_str(target_model.group),\n 519 | )\n 520 | elif self.manifest.is_invalid_protected_ref(\n 521 | self.model, target_model, self.config.dependencies\n 522 | ):\n 523 | raise DbtReferenceError(\n 524 | unique_id=self.model.unique_id,\n 525 | ref_unique_id=target_model.unique_id,\n 526 | access=AccessType.Protected,\n 527 | scope=target_model.package_name,\n 528 | )\n 529 | \n 530 | self.validate(target_model, target_name, target_package, target_version)\n 531 | return self.create_relation(target_model)\n 532 | \n 533 | def create_relation(self, target_model: ManifestNode) -> RelationProxy:\n 534 | if target_model.is_ephemeral_model:\n 535 | self.model.set_cte(target_model.unique_id, None)\n 536 | return self.Relation.create_ephemeral_from(target_model, limit=self.resolve_limit)\n 537 | else:\n 538 | return self.Relation.create_from(self.config, target_model, limit=self.resolve_limit)\n 539 | \n 540 | def validate(\n 541 | self,\n 542 | resolved: ManifestNode,\n 543 | target_name: str,\n 544 | target_package: Optional[str],\n 545 | target_version: Optional[NodeVersion],\n 546 | ) -> None:\n 547 | if resolved.unique_id not in self.model.depends_on.nodes:\n 548 | args = self._repack_args(target_name, target_package, target_version)\n 549 | raise RefBadContextError(node=self.model, args=args)\n 550 | \n 551 | \n 552 | class OperationRefResolver(RuntimeRefResolver):\n 553 | def validate(\n 554 | self,\n 555 | resolved: ManifestNode,\n 556 | target_name: str,\n 557 | target_package: Optional[str],\n 558 | target_version: Optional[NodeVersion],\n 559 | ) -> None:\n 560 | pass\n 561 | \n 562 | def create_relation(self, target_model: ManifestNode) -> RelationProxy:\n 563 | if target_model.is_ephemeral_model:\n 564 | # In operations, we can't ref() ephemeral nodes, because\n 565 | # Macros do not support set_cte\n 566 | raise OperationsCannotRefEphemeralNodesError(target_model.name, node=self.model)\n 567 | else:\n 568 | return super().create_relation(target_model)\n 569 | \n 570 | \n 571 | class RuntimeUnitTestRefResolver(RuntimeRefResolver):\n 572 | def resolve(\n 573 | self,\n 574 | target_name: str,\n 575 | target_package: Optional[str] = None,\n 576 | target_version: Optional[NodeVersion] = None,\n 577 | ) -> RelationProxy:\n 578 | return super().resolve(target_name, target_package, target_version)\n 579 | \n 580 | \n 581 | # `source` implementations\n 582 | class ParseSourceResolver(BaseSourceResolver):\n 583 | def resolve(self, source_name: str, table_name: str):\n 584 | # When you call source(), this is what happens at parse time\n 585 | self.model.sources.append([source_name, table_name])\n 586 | return self.Relation.create_from(self.config, self.model)\n 587 | \n 588 | \n 589 | class RuntimeSourceResolver(BaseSourceResolver):\n 590 | def resolve(self, source_name: str, table_name: str):\n 591 | target_source = self.manifest.resolve_source(\n 592 | source_name,\n 593 | table_name,\n 594 | self.current_project,\n 595 | self.model.package_name,\n 596 | )\n 597 | \n 598 | if target_source is None or isinstance(target_source, Disabled):\n 599 | raise TargetNotFoundError(\n 600 | node=self.model,\n 601 | target_name=f\"{source_name}.{table_name}\",\n 602 | target_kind=\"source\",\n 603 | disabled=(isinstance(target_source, Disabled)),\n 604 | )\n 605 | return self.Relation.create_from(self.config, target_source, limit=self.resolve_limit)\n 606 | \n 607 | \n 608 | class RuntimeUnitTestSourceResolver(BaseSourceResolver):\n 609 | def resolve(self, source_name: str, table_name: str):\n 610 | target_source = self.manifest.resolve_source(\n 611 | source_name,\n 612 | table_name,\n 613 | self.current_project,\n 614 | self.model.package_name,\n 615 | )\n 616 | if target_source is None or isinstance(target_source, Disabled):\n 617 | raise TargetNotFoundError(\n 618 | node=self.model,\n 619 | target_name=f\"{source_name}.{table_name}\",\n 620 | target_kind=\"source\",\n 621 | disabled=(isinstance(target_source, Disabled)),\n 622 | )\n 623 | # For unit tests, this isn't a \"real\" source, it's a ModelNode taking\n 624 | # the place of a source. We don't really need to return the relation here,\n 625 | # we just need to set_cte, but skipping it confuses typing. We *do* need\n 626 | # the relation in the \"this\" property.\n 627 | self.model.set_cte(target_source.unique_id, None)\n 628 | return self.Relation.create_ephemeral_from(target_source)\n 629 | \n 630 | \n 631 | # metric` implementations\n 632 | class ParseMetricResolver(BaseMetricResolver):\n 633 | def resolve(self, name: str, package: Optional[str] = None) -> MetricReference:\n 634 | self.model.metrics.append(self._repack_args(name, package))\n 635 | \n 636 | return MetricReference(name, package)\n 637 | \n 638 | \n 639 | class RuntimeMetricResolver(BaseMetricResolver):\n 640 | def resolve(self, target_name: str, target_package: Optional[str] = None) -> MetricReference:\n 641 | target_metric = self.manifest.resolve_metric(\n 642 | target_name,\n 643 | target_package,\n 644 | self.current_project,\n 645 | self.model.package_name,\n 646 | )\n 647 | \n 648 | if target_metric is None or isinstance(target_metric, Disabled):\n 649 | raise TargetNotFoundError(\n 650 | node=self.model,\n 651 | target_name=target_name,\n 652 | target_kind=\"metric\",\n 653 | target_package=target_package,\n 654 | )\n 655 | \n 656 | return ResolvedMetricReference(target_metric, self.manifest)\n 657 | \n 658 | \n 659 | # `var` implementations.\n 660 | class ModelConfiguredVar(Var):\n 661 | def __init__(\n 662 | self,\n 663 | context: Dict[str, Any],\n 664 | config: RuntimeConfig,\n 665 | node: Resource,\n 666 | ) -> None:\n 667 | self._node: Resource\n 668 | self._config: RuntimeConfig = config\n 669 | super().__init__(context, config.cli_vars, node=node)\n 670 | \n 671 | def packages_for_node(self) -> Iterable[Project]:\n 672 | dependencies = self._config.load_dependencies()\n 673 | package_name = self._node.package_name\n 674 | \n 675 | if package_name != self._config.project_name:\n 676 | if package_name in dependencies:\n 677 | yield dependencies[package_name]\n 678 | yield self._config\n 679 | \n 680 | def _generate_merged(self) -> Mapping[str, Any]:\n 681 | search_node: IsFQNResource\n 682 | if isinstance(self._node, IsFQNResource):\n 683 | search_node = self._node\n 684 | else:\n 685 | search_node = FQNLookup(self._node.package_name)\n 686 | \n 687 | adapter_type = self._config.credentials.type\n 688 | \n 689 | merged = MultiDict()\n 690 | for project in self.packages_for_node():\n 691 | merged.add(project.vars.vars_for(search_node, adapter_type))\n 692 | merged.add(self._cli_vars)\n 693 | return merged\n 694 | \n 695 | \n 696 | class ParseVar(ModelConfiguredVar):\n 697 | def get_missing_var(self, var_name):\n 698 | # in the parser, just always return None.\n 699 | return None\n 700 | \n 701 | \n 702 | class RuntimeVar(ModelConfiguredVar):\n 703 | pass\n 704 | \n 705 | \n 706 | class UnitTestVar(RuntimeVar):\n 707 | def __init__(\n 708 | self,\n 709 | context: Dict[str, Any],\n 710 | config: RuntimeConfig,\n 711 | node: Resource,\n 712 | ) -> None:\n 713 | config_copy = None\n 714 | assert isinstance(node, UnitTestNode)\n 715 | if node.overrides and node.overrides.vars:\n 716 | config_copy = deepcopy(config)\n 717 | config_copy.cli_vars.update(node.overrides.vars)\n 718 | \n 719 | super().__init__(context, config_copy or config, node=node)\n 720 | \n 721 | \n 722 | # Providers\n 723 | class Provider(Protocol):\n 724 | execute: bool\n 725 | Config: Type[Config]\n 726 | DatabaseWrapper: Type[BaseDatabaseWrapper]\n 727 | Var: Type[ModelConfiguredVar]\n 728 | ref: Type[BaseRefResolver]\n 729 | source: Type[BaseSourceResolver]\n 730 | metric: Type[BaseMetricResolver]\n 731 | \n 732 | \n 733 | class ParseProvider(Provider):\n 734 | execute = False\n 735 | Config = ParseConfigObject\n 736 | DatabaseWrapper = ParseDatabaseWrapper\n 737 | Var = ParseVar\n 738 | ref = ParseRefResolver\n 739 | source = ParseSourceResolver\n 740 | metric = ParseMetricResolver\n 741 | \n 742 | \n 743 | class GenerateNameProvider(Provider):\n 744 | execute = False\n 745 | Config = RuntimeConfigObject\n 746 | DatabaseWrapper = ParseDatabaseWrapper\n 747 | Var = RuntimeVar\n 748 | ref = ParseRefResolver\n 749 | source = ParseSourceResolver\n 750 | metric = ParseMetricResolver\n 751 | \n 752 | \n 753 | class RuntimeProvider(Provider):\n 754 | execute = True\n 755 | Config = RuntimeConfigObject\n 756 | DatabaseWrapper = RuntimeDatabaseWrapper\n 757 | Var = RuntimeVar\n 758 | ref = RuntimeRefResolver\n 759 | source = RuntimeSourceResolver\n 760 | metric = RuntimeMetricResolver\n 761 | \n 762 | \n 763 | class RuntimeUnitTestProvider(Provider):\n 764 | execute = True\n 765 | Config = RuntimeConfigObject\n 766 | DatabaseWrapper = RuntimeDatabaseWrapper\n 767 | Var = UnitTestVar\n 768 | ref = RuntimeUnitTestRefResolver\n 769 | source = RuntimeUnitTestSourceResolver\n 770 | metric = RuntimeMetricResolver\n 771 | \n 772 | \n 773 | class OperationProvider(RuntimeProvider):\n 774 | ref = OperationRefResolver\n 775 | \n 776 | \n 777 | T = TypeVar(\"T\")\n 778 | \n 779 | \n 780 | # Base context collection, used for parsing configs.\n 781 | class ProviderContext(ManifestContext):\n 782 | # subclasses are MacroContext, ModelContext, TestContext\n 783 | def __init__(\n 784 | self,\n 785 | model,\n 786 | config: RuntimeConfig,\n 787 | manifest: Manifest,\n 788 | provider: Provider,\n 789 | context_config: Optional[ContextConfig],\n 790 | ) -> None:\n 791 | if provider is None:\n 792 | raise DbtInternalError(f\"Invalid provider given to context: {provider}\")\n 793 | # mypy appeasement - we know it'll be a RuntimeConfig\n 794 | self.config: RuntimeConfig\n 795 | self.model: Union[Macro, ManifestNode] = model\n 796 | super().__init__(config, manifest, model.package_name)\n 797 | self.sql_results: Dict[str, Optional[AttrDict]] = {}\n 798 | self.context_config: Optional[ContextConfig] = context_config\n 799 | self.provider: Provider = provider\n 800 | self.adapter = get_adapter(self.config)\n 801 | # The macro namespace is used in creating the DatabaseWrapper\n 802 | self.db_wrapper = self.provider.DatabaseWrapper(self.adapter, self.namespace)\n 803 | \n 804 | # This overrides the method in ManifestContext, and provides\n 805 | # a model, which the ManifestContext builder does not\n 806 | def _get_namespace_builder(self):\n 807 | internal_packages = get_adapter_package_names(self.config.credentials.type)\n 808 | return MacroNamespaceBuilder(\n 809 | self.config.project_name,\n 810 | self.search_package,\n 811 | self.macro_stack,\n 812 | internal_packages,\n 813 | self.model,\n 814 | )\n 815 | \n 816 | @contextproperty()\n 817 | def dbt_metadata_envs(self) -> Dict[str, str]:\n 818 | return get_metadata_vars()\n 819 | \n 820 | @contextproperty()\n 821 | def invocation_args_dict(self):\n 822 | return args_to_dict(self.config.args)\n 823 | \n 824 | @contextproperty()\n 825 | def _sql_results(self) -> Dict[str, Optional[AttrDict]]:\n 826 | return self.sql_results\n 827 | \n 828 | @contextmember()\n 829 | def load_result(self, name: str) -> Optional[AttrDict]:\n 830 | if name in self.sql_results:\n 831 | # handle the special case of \"main\" macro\n 832 | # See: https://github.com/dbt-labs/dbt-core/blob/ada8860e48b32ac712d92e8b0977b2c3c9749981/core/dbt/task/run.py#L228\n 833 | if name == \"main\":\n 834 | return self.sql_results[\"main\"]\n 835 | \n 836 | # handle a None, which indicates this name was populated but has since been loaded\n 837 | elif self.sql_results[name] is None:\n 838 | raise MacroResultAlreadyLoadedError(name)\n 839 | \n 840 | # Handle the regular use case\n 841 | else:\n 842 | ret_val = self.sql_results[name]\n 843 | self.sql_results[name] = None\n 844 | return ret_val\n 845 | else:\n 846 | # Handle trying to load a result that was never stored\n 847 | return None\n 848 | \n 849 | @contextmember()\n 850 | def store_result(\n 851 | self, name: str, response: Any, agate_table: Optional[agate.Table] = None\n 852 | ) -> str:\n 853 | if agate_table is None:\n 854 | agate_table = agate_helper.empty_table()\n 855 | \n 856 | self.sql_results[name] = AttrDict(\n 857 | {\n 858 | \"response\": response,\n 859 | \"data\": agate_helper.as_matrix(agate_table),\n 860 | \"table\": agate_table,\n 861 | }\n 862 | )\n 863 | return \"\"\n 864 | \n 865 | @contextmember()\n 866 | def store_raw_result(\n 867 | self,\n 868 | name: str,\n 869 | message=Optional[str],\n 870 | code=Optional[str],\n 871 | rows_affected=Optional[str],\n 872 | agate_table: Optional[agate.Table] = None,\n 873 | ) -> str:\n 874 | response = AdapterResponse(_message=message, code=code, rows_affected=rows_affected)\n 875 | return self.store_result(name, response, agate_table)\n 876 | \n 877 | @contextproperty()\n 878 | def validation(self):\n 879 | def validate_any(*args) -> Callable[[T], None]:\n 880 | def inner(value: T) -> None:\n 881 | for arg in args:\n 882 | if isinstance(arg, type) and isinstance(value, arg):\n 883 | return\n 884 | elif value == arg:\n 885 | return\n 886 | raise DbtValidationError(\n 887 | 'Expected value \"{}\" to be one of {}'.format(value, \",\".join(map(str, args)))\n 888 | )\n 889 | \n 890 | return inner\n 891 | \n 892 | return AttrDict(\n 893 | {\n 894 | \"any\": validate_any,\n 895 | }\n 896 | )\n 897 | \n 898 | @contextmember()\n 899 | def write(self, payload: str) -> str:\n 900 | # macros/source defs aren't 'writeable'.\n 901 | if isinstance(self.model, (Macro, SourceDefinition)):\n 902 | raise MacrosSourcesUnWriteableError(node=self.model)\n 903 | self.model.build_path = self.model.get_target_write_path(self.config.target_path, \"run\")\n 904 | self.model.write_node(self.config.project_root, self.model.build_path, payload)\n 905 | return \"\"\n 906 | \n 907 | @contextmember()\n 908 | def render(self, string: str) -> str:\n 909 | return get_rendered(string, self._ctx, self.model)\n 910 | \n 911 | @contextmember()\n 912 | def try_or_compiler_error(\n 913 | self, message_if_exception: str, func: Callable, *args, **kwargs\n 914 | ) -> Any:\n 915 | try:\n 916 | return func(*args, **kwargs)\n 917 | except Exception:\n 918 | raise CompilationError(message_if_exception, self.model)\n 919 | \n 920 | @contextmember()\n 921 | def load_agate_table(self) -> agate.Table:\n 922 | if not isinstance(self.model, SeedNode):\n 923 | raise LoadAgateTableNotSeedError(self.model.resource_type, node=self.model)\n 924 | \n 925 | # include package_path for seeds defined in packages\n 926 | package_path = (\n 927 | os.path.join(self.config.packages_install_path, self.model.package_name)\n 928 | if self.model.package_name != self.config.project_name\n 929 | else \".\"\n 930 | )\n 931 | path = os.path.join(self.config.project_root, package_path, self.model.original_file_path)\n 932 | if not os.path.exists(path):\n 933 | assert self.model.root_path\n 934 | path = os.path.join(self.model.root_path, self.model.original_file_path)\n 935 | \n 936 | column_types = self.model.config.column_types\n 937 | delimiter = self.model.config.delimiter\n 938 | try:\n 939 | table = agate_helper.from_csv(path, text_columns=column_types, delimiter=delimiter)\n 940 | except ValueError as e:\n 941 | raise LoadAgateTableValueError(e, node=self.model)\n 942 | table.original_abspath = os.path.abspath(path)\n 943 | return table\n 944 | \n 945 | @contextproperty()\n 946 | def ref(self) -> Callable:\n 947 | \"\"\"The most important function in dbt is `ref()`; it's impossible to\n 948 | build even moderately complex models without it. `ref()` is how you\n 949 | reference one model within another. This is a very common behavior, as\n 950 | typically models are built to be \"stacked\" on top of one another. Here\n 951 | is how this looks in practice:\n 952 | \n 953 | > model_a.sql:\n 954 | \n 955 | select *\n 956 | from public.raw_data\n 957 | \n 958 | > model_b.sql:\n 959 | \n 960 | select *\n 961 | from {{ref('model_a')}}\n 962 | \n 963 | \n 964 | `ref()` is, under the hood, actually doing two important things. First,\n 965 | it is interpolating the schema into your model file to allow you to\n 966 | change your deployment schema via configuration. Second, it is using\n 967 | these references between models to automatically build the dependency\n 968 | graph. This will enable dbt to deploy models in the correct order when\n 969 | using dbt run.\n 970 | \n 971 | The `ref` function returns a Relation object.\n 972 | \n 973 | ## Advanced ref usage\n 974 | \n 975 | There is also a two-argument variant of the `ref` function. With this\n 976 | variant, you can pass both a package name and model name to `ref` to\n 977 | avoid ambiguity. This functionality is not commonly required for\n 978 | typical dbt usage.\n 979 | \n 980 | > model.sql:\n 981 | \n 982 | select * from {{ ref('package_name', 'model_name') }}\"\n 983 | \"\"\"\n 984 | return self.provider.ref(self.db_wrapper, self.model, self.config, self.manifest)\n 985 | \n 986 | @contextproperty()\n 987 | def source(self) -> Callable:\n 988 | return self.provider.source(self.db_wrapper, self.model, self.config, self.manifest)\n 989 | \n 990 | @contextproperty()\n 991 | def metric(self) -> Callable:\n 992 | return self.provider.metric(self.db_wrapper, self.model, self.config, self.manifest)\n 993 | \n 994 | @contextproperty(\"config\")\n 995 | def ctx_config(self) -> Config:\n 996 | \"\"\"The `config` variable exists to handle end-user configuration for\n 997 | custom materializations. Configs like `unique_key` can be implemented\n 998 | using the `config` variable in your own materializations.\n 999 | \n1000 | For example, code in the `incremental` materialization like this:\n1001 | \n1002 | {% materialization incremental, default -%}\n1003 | {%- set unique_key = config.get('unique_key') -%}\n1004 | ...\n1005 | \n1006 | is responsible for handling model code that looks like this:\n1007 | \n1008 | {{\n1009 | config(\n1010 | materialized='incremental',\n1011 | unique_key='id'\n1012 | )\n1013 | }}\n1014 | \n1015 | \n1016 | ## config.get\n1017 | \n1018 | name: The name of the configuration variable (required)\n1019 | default: The default value to use if this configuration is not provided\n1020 | (optional)\n1021 | \n1022 | The `config.get` function is used to get configurations for a model\n1023 | from the end-user. Configs defined in this way are optional, and a\n1024 | default value can be provided.\n1025 | \n1026 | Example usage:\n1027 | \n1028 | {% materialization incremental, default -%}\n1029 | -- Example w/ no default. unique_key will be None if the user does not provide this configuration\n1030 | {%- set unique_key = config.get('unique_key') -%}\n1031 | -- Example w/ default value. Default to 'id' if 'unique_key' not provided\n1032 | {%- set unique_key = config.get('unique_key', default='id') -%}\n1033 | ...\n1034 | \n1035 | ## config.require\n1036 | \n1037 | name: The name of the configuration variable (required)\n1038 | \n1039 | The `config.require` function is used to get configurations for a model\n1040 | from the end-user. Configs defined using this function are required,\n1041 | and failure to provide them will result in a compilation error.\n1042 | \n1043 | Example usage:\n1044 | \n1045 | {% materialization incremental, default -%}\n1046 | {%- set unique_key = config.require('unique_key') -%}\n1047 | ...\n1048 | \"\"\" # noqa\n1049 | return self.provider.Config(self.model, self.context_config)\n1050 | \n1051 | @contextproperty()\n1052 | def execute(self) -> bool:\n1053 | \"\"\"`execute` is a Jinja variable that returns True when dbt is in\n1054 | \"execute\" mode.\n1055 | \n1056 | When you execute a dbt compile or dbt run command, dbt:\n1057 | \n1058 | - Reads all of the files in your project and generates a \"manifest\"\n1059 | comprised of models, tests, and other graph nodes present in your\n1060 | project. During this phase, dbt uses the `ref` statements it finds\n1061 | to generate the DAG for your project. *No SQL is run during this\n1062 | phase*, and `execute == False`.\n1063 | - Compiles (and runs) each node (eg. building models, or running\n1064 | tests). SQL is run during this phase, and `execute == True`.\n1065 | \n1066 | Any Jinja that relies on a result being returned from the database will\n1067 | error during the parse phase. For example, this SQL will return an\n1068 | error:\n1069 | \n1070 | > models/order_payment_methods.sql:\n1071 | \n1072 | {% set payment_method_query %}\n1073 | select distinct\n1074 | payment_method\n1075 | from {{ ref('raw_payments') }}\n1076 | order by 1\n1077 | {% endset %}\n1078 | {% set results = run_query(relation_query) %}\n1079 | {# Return the first column #}\n1080 | {% set payment_methods = results.columns[0].values() %}\n1081 | \n1082 | The error returned by dbt will look as follows:\n1083 | \n1084 | Encountered an error:\n1085 | Compilation Error in model order_payment_methods (models/order_payment_methods.sql)\n1086 | 'None' has no attribute 'table'\n1087 | \n1088 | This is because Line #11 assumes that a table has been returned, when,\n1089 | during the parse phase, this query hasn't been run.\n1090 | \n1091 | To work around this, wrap any problematic Jinja in an\n1092 | `{% if execute %}` statement:\n1093 | \n1094 | > models/order_payment_methods.sql:\n1095 | \n1096 | {% set payment_method_query %}\n1097 | select distinct\n1098 | payment_method\n1099 | from {{ ref('raw_payments') }}\n1100 | order by 1\n1101 | {% endset %}\n1102 | {% set results = run_query(relation_query) %}\n1103 | {% if execute %}\n1104 | {# Return the first column #}\n1105 | {% set payment_methods = results.columns[0].values() %}\n1106 | {% else %}\n1107 | {% set payment_methods = [] %}\n1108 | {% endif %}\n1109 | \"\"\" # noqa\n1110 | return self.provider.execute\n1111 | \n1112 | @contextproperty()\n1113 | def exceptions(self) -> Dict[str, Any]:\n1114 | \"\"\"The exceptions namespace can be used to raise warnings and errors in\n1115 | dbt userspace.\n1116 | \n1117 | \n1118 | ## raise_compiler_error\n1119 | \n1120 | The `exceptions.raise_compiler_error` method will raise a compiler\n1121 | error with the provided message. This is typically only useful in\n1122 | macros or materializations when invalid arguments are provided by the\n1123 | calling model. Note that throwing an exception will cause a model to\n1124 | fail, so please use this variable with care!\n1125 | \n1126 | Example usage:\n1127 | \n1128 | > exceptions.sql:\n1129 | \n1130 | {% if number < 0 or number > 100 %}\n1131 | {{ exceptions.raise_compiler_error(\"Invalid `number`. Got: \" ~ number) }}\n1132 | {% endif %}\n1133 | \n1134 | ## warn\n1135 | \n1136 | The `exceptions.warn` method will raise a compiler warning with the\n1137 | provided message. If the `--warn-error` flag is provided to dbt, then\n1138 | this warning will be elevated to an exception, which is raised.\n1139 | \n1140 | Example usage:\n1141 | \n1142 | > warn.sql:\n1143 | \n1144 | {% if number < 0 or number > 100 %}\n1145 | {% do exceptions.warn(\"Invalid `number`. Got: \" ~ number) %}\n1146 | {% endif %}\n1147 | \"\"\" # noqa\n1148 | return wrapped_exports(self.model)\n1149 | \n1150 | @contextproperty()\n1151 | def database(self) -> str:\n1152 | return self.config.credentials.database\n1153 | \n1154 | @contextproperty()\n1155 | def schema(self) -> str:\n1156 | return self.config.credentials.schema\n1157 | \n1158 | @contextproperty()\n1159 | def var(self) -> ModelConfiguredVar:\n1160 | return self.provider.Var(\n1161 | context=self._ctx,\n1162 | config=self.config,\n1163 | node=self.model,\n1164 | )\n1165 | \n1166 | @contextproperty(\"adapter\")\n1167 | def ctx_adapter(self) -> BaseDatabaseWrapper:\n1168 | \"\"\"`adapter` is a wrapper around the internal database adapter used by\n1169 | dbt. It allows users to make calls to the database in their dbt models.\n1170 | The adapter methods will be translated into specific SQL statements\n1171 | depending on the type of adapter your project is using.\n1172 | \"\"\"\n1173 | return self.db_wrapper\n1174 | \n1175 | @contextproperty()\n1176 | def api(self) -> Dict[str, Any]:\n1177 | return {\n1178 | \"Relation\": self.db_wrapper.Relation,\n1179 | \"Column\": self.adapter.Column,\n1180 | }\n1181 | \n1182 | @contextproperty()\n1183 | def column(self) -> Type[Column]:\n1184 | return self.adapter.Column\n1185 | \n1186 | @contextproperty()\n1187 | def env(self) -> Dict[str, Any]:\n1188 | return self.target\n1189 | \n1190 | @contextproperty()\n1191 | def graph(self) -> Dict[str, Any]:\n1192 | \"\"\"The `graph` context variable contains information about the nodes in\n1193 | your dbt project. Models, sources, tests, and snapshots are all\n1194 | examples of nodes in dbt projects.\n1195 | \n1196 | ## The graph context variable\n1197 | \n1198 | The graph context variable is a dictionary which maps node ids onto dictionary representations of those nodes. A simplified example might look like:\n1199 | \n1200 | {\n1201 | \"model.project_name.model_name\": {\n1202 | \"config\": {\"materialzed\": \"table\", \"sort\": \"id\"},\n1203 | \"tags\": [\"abc\", \"123\"],\n1204 | \"path\": \"models/path/to/model_name.sql\",\n1205 | ...\n1206 | },\n1207 | \"source.project_name.source_name\": {\n1208 | \"path\": \"models/path/to/schema.yml\",\n1209 | \"columns\": {\n1210 | \"id\": { .... },\n1211 | \"first_name\": { .... },\n1212 | },\n1213 | ...\n1214 | }\n1215 | }\n1216 | \n1217 | The exact contract for these model and source nodes is not currently\n1218 | documented, but that will change in the future.\n1219 | \n1220 | ## Accessing models\n1221 | \n1222 | The `model` entries in the `graph` dictionary will be incomplete or\n1223 | incorrect during parsing. If accessing the models in your project via\n1224 | the `graph` variable, be sure to use the `execute` flag to ensure that\n1225 | this code only executes at run-time and not at parse-time. Do not use\n1226 | the `graph` variable to build you DAG, as the resulting dbt behavior\n1227 | will be undefined and likely incorrect.\n1228 | \n1229 | Example usage:\n1230 | \n1231 | > graph-usage.sql:\n1232 | \n1233 | /*\n1234 | Print information about all of the models in the Snowplow package\n1235 | */\n1236 | {% if execute %}\n1237 | {% for node in graph.nodes.values()\n1238 | | selectattr(\"resource_type\", \"equalto\", \"model\")\n1239 | | selectattr(\"package_name\", \"equalto\", \"snowplow\") %}\n1240 | \n1241 | {% do log(node.unique_id ~ \", materialized: \" ~ node.config.materialized, info=true) %}\n1242 | \n1243 | {% endfor %}\n1244 | {% endif %}\n1245 | /*\n1246 | Example output\n1247 | ---------------------------------------------------------------\n1248 | model.snowplow.snowplow_id_map, materialized: incremental\n1249 | model.snowplow.snowplow_page_views, materialized: incremental\n1250 | model.snowplow.snowplow_web_events, materialized: incremental\n1251 | model.snowplow.snowplow_web_page_context, materialized: table\n1252 | model.snowplow.snowplow_web_events_scroll_depth, materialized: incremental\n1253 | model.snowplow.snowplow_web_events_time, materialized: incremental\n1254 | model.snowplow.snowplow_web_events_internal_fixed, materialized: ephemeral\n1255 | model.snowplow.snowplow_base_web_page_context, materialized: ephemeral\n1256 | model.snowplow.snowplow_base_events, materialized: ephemeral\n1257 | model.snowplow.snowplow_sessions_tmp, materialized: incremental\n1258 | model.snowplow.snowplow_sessions, materialized: table\n1259 | */\n1260 | \n1261 | ## Accessing sources\n1262 | \n1263 | To access the sources in your dbt project programatically, use the \"sources\" attribute.\n1264 | \n1265 | Example usage:\n1266 | \n1267 | > models/events_unioned.sql\n1268 | \n1269 | /*\n1270 | Union all of the Snowplow sources defined in the project\n1271 | which begin with the string \"event_\"\n1272 | */\n1273 | {% set sources = [] -%}\n1274 | {% for node in graph.sources.values() -%}\n1275 | {%- if node.name.startswith('event_') and node.source_name == 'snowplow' -%}\n1276 | {%- do sources.append(source(node.source_name, node.name)) -%}\n1277 | {%- endif -%}\n1278 | {%- endfor %}\n1279 | select * from (\n1280 | {%- for source in sources %}\n1281 | {{ source }} {% if not loop.last %} union all {% endif %}\n1282 | {% endfor %}\n1283 | )\n1284 | /*\n1285 | Example compiled SQL\n1286 | ---------------------------------------------------------------\n1287 | select * from (\n1288 | select * from raw.snowplow.event_add_to_cart union all\n1289 | select * from raw.snowplow.event_remove_from_cart union all\n1290 | select * from raw.snowplow.event_checkout\n1291 | )\n1292 | */\n1293 | \n1294 | \"\"\" # noqa\n1295 | return self.manifest.flat_graph\n1296 | \n1297 | @contextproperty(\"model\")\n1298 | def ctx_model(self) -> Dict[str, Any]:\n1299 | model_dct = self.model.to_dict(omit_none=True)\n1300 | # Maintain direct use of compiled_sql\n1301 | # TODO add depreciation logic[CT-934]\n1302 | if \"compiled_code\" in model_dct:\n1303 | model_dct[\"compiled_sql\"] = model_dct[\"compiled_code\"]\n1304 | \n1305 | if (\n1306 | hasattr(self.model, \"contract\")\n1307 | and self.model.contract.alias_types is True\n1308 | and \"columns\" in model_dct\n1309 | ):\n1310 | for column in model_dct[\"columns\"].values():\n1311 | if \"data_type\" in column:\n1312 | orig_data_type = column[\"data_type\"]\n1313 | # translate data_type to value in Column.TYPE_LABELS\n1314 | new_data_type = self.adapter.Column.translate_type(orig_data_type)\n1315 | column[\"data_type\"] = new_data_type\n1316 | return model_dct\n1317 | \n1318 | @contextproperty()\n1319 | def pre_hooks(self) -> Optional[List[Dict[str, Any]]]:\n1320 | return None\n1321 | \n1322 | @contextproperty()\n1323 | def post_hooks(self) -> Optional[List[Dict[str, Any]]]:\n1324 | return None\n1325 | \n1326 | @contextproperty()\n1327 | def sql(self) -> Optional[str]:\n1328 | return None\n1329 | \n1330 | @contextproperty()\n1331 | def sql_now(self) -> str:\n1332 | return self.adapter.date_function()\n1333 | \n1334 | @contextmember()\n1335 | def adapter_macro(self, name: str, *args, **kwargs):\n1336 | \"\"\"This was deprecated in v0.18 in favor of adapter.dispatch\"\"\"\n1337 | msg = (\n1338 | 'The \"adapter_macro\" macro has been deprecated. Instead, use '\n1339 | \"the `adapter.dispatch` method to find a macro and call the \"\n1340 | \"result. For more information, see: \"\n1341 | \"https://docs.getdbt.com/reference/dbt-jinja-functions/dispatch)\"\n1342 | \" adapter_macro was called for: {macro_name}\".format(macro_name=name)\n1343 | )\n1344 | raise CompilationError(msg)\n1345 | \n1346 | @contextmember()\n1347 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1348 | \"\"\"The env_var() function. Return the environment variable named 'var'.\n1349 | If there is no such environment variable set, return the default.\n1350 | \n1351 | If the default is None, raise an exception for an undefined variable.\n1352 | \"\"\"\n1353 | return_value = None\n1354 | if var.startswith(SECRET_ENV_PREFIX):\n1355 | raise SecretEnvVarLocationError(var)\n1356 | if var in os.environ:\n1357 | return_value = os.environ[var]\n1358 | elif default is not None:\n1359 | return_value = default\n1360 | \n1361 | if return_value is not None:\n1362 | # Save the env_var value in the manifest and the var name in the source_file.\n1363 | # If this is compiling, do not save because it's irrelevant to parsing.\n1364 | compiling = (\n1365 | True\n1366 | if hasattr(self.model, \"compiled\")\n1367 | and getattr(self.model, \"compiled\", False) is True\n1368 | else False\n1369 | )\n1370 | if self.model and not compiling:\n1371 | # If the environment variable is set from a default, store a string indicating\n1372 | # that so we can skip partial parsing. Otherwise the file will be scheduled for\n1373 | # reparsing. If the default changes, the file will have been updated and therefore\n1374 | # will be scheduled for reparsing anyways.\n1375 | self.manifest.env_vars[var] = (\n1376 | return_value if var in os.environ else DEFAULT_ENV_PLACEHOLDER\n1377 | )\n1378 | \n1379 | # hooks come from dbt_project.yml which doesn't have a real file_id\n1380 | if self.model.file_id in self.manifest.files:\n1381 | source_file = self.manifest.files[self.model.file_id]\n1382 | # Schema files should never get here\n1383 | if source_file.parse_file_type != \"schema\":\n1384 | # TODO CT-211\n1385 | source_file.env_vars.append(var) # type: ignore[union-attr]\n1386 | return return_value\n1387 | else:\n1388 | raise EnvVarMissingError(var)\n1389 | \n1390 | @contextproperty()\n1391 | def selected_resources(self) -> List[str]:\n1392 | \"\"\"The `selected_resources` variable contains a list of the resources\n1393 | selected based on the parameters provided to the dbt command.\n1394 | Currently, is not populated for the command `run-operation` that\n1395 | doesn't support `--select`.\n1396 | \"\"\"\n1397 | return selected_resources.SELECTED_RESOURCES\n1398 | \n1399 | @contextmember()\n1400 | def submit_python_job(self, parsed_model: Dict, compiled_code: str) -> AdapterResponse:\n1401 | # Check macro_stack and that the unique id is for a materialization macro\n1402 | if not (\n1403 | self.context_macro_stack.depth == 2\n1404 | and self.context_macro_stack.call_stack[1] == \"macro.dbt.statement\"\n1405 | and \"materialization\" in self.context_macro_stack.call_stack[0]\n1406 | ):\n1407 | raise DbtRuntimeError(\n1408 | f\"submit_python_job is not intended to be called here, at model {parsed_model['alias']}, with macro call_stack {self.context_macro_stack.call_stack}.\"\n1409 | )\n1410 | return self.adapter.submit_python_job(parsed_model, compiled_code)\n1411 | \n1412 | \n1413 | class MacroContext(ProviderContext):\n1414 | \"\"\"Internally, macros can be executed like nodes, with some restrictions:\n1415 | \n1416 | - they don't have all values available that nodes do:\n1417 | - 'this', 'pre_hooks', 'post_hooks', and 'sql' are missing\n1418 | - 'schema' does not use any 'model' information\n1419 | - they can't be configured with config() directives\n1420 | \"\"\"\n1421 | \n1422 | def __init__(\n1423 | self,\n1424 | model: MacroProtocol,\n1425 | config: RuntimeConfig,\n1426 | manifest: Manifest,\n1427 | provider: Provider,\n1428 | search_package: Optional[str],\n1429 | ) -> None:\n1430 | super().__init__(model, config, manifest, provider, None)\n1431 | # override the model-based package with the given one\n1432 | if search_package is None:\n1433 | # if the search package name isn't specified, use the root project\n1434 | self._search_package = config.project_name\n1435 | else:\n1436 | self._search_package = search_package\n1437 | \n1438 | \n1439 | class ModelContext(ProviderContext):\n1440 | model: ManifestNode\n1441 | \n1442 | @contextproperty()\n1443 | def pre_hooks(self) -> List[Dict[str, Any]]:\n1444 | if self.model.resource_type in [NodeType.Source, NodeType.Test, NodeType.Unit]:\n1445 | return []\n1446 | # TODO CT-211\n1447 | return [\n1448 | h.to_dict(omit_none=True) for h in self.model.config.pre_hook # type: ignore[union-attr] # noqa\n1449 | ]\n1450 | \n1451 | @contextproperty()\n1452 | def post_hooks(self) -> List[Dict[str, Any]]:\n1453 | if self.model.resource_type in [NodeType.Source, NodeType.Test, NodeType.Unit]:\n1454 | return []\n1455 | # TODO CT-211\n1456 | return [\n1457 | h.to_dict(omit_none=True) for h in self.model.config.post_hook # type: ignore[union-attr] # noqa\n1458 | ]\n1459 | \n1460 | @contextproperty()\n1461 | def compiled_code(self) -> Optional[str]:\n1462 | # TODO: avoid routing on args.which if possible\n1463 | if getattr(self.model, \"defer_relation\", None) and self.config.args.which == \"clone\":\n1464 | # TODO https://github.com/dbt-labs/dbt-core/issues/7976\n1465 | return f\"select * from {self.model.defer_relation.relation_name or str(self.defer_relation)}\" # type: ignore[union-attr]\n1466 | elif getattr(self.model, \"extra_ctes_injected\", None):\n1467 | # TODO CT-211\n1468 | return self.model.compiled_code # type: ignore[union-attr]\n1469 | else:\n1470 | return None\n1471 | \n1472 | @contextproperty()\n1473 | def sql(self) -> Optional[str]:\n1474 | # only set this for sql models, for backward compatibility\n1475 | if self.model.language == ModelLanguage.sql: # type: ignore[union-attr]\n1476 | return self.compiled_code\n1477 | else:\n1478 | return None\n1479 | \n1480 | @contextproperty()\n1481 | def database(self) -> str:\n1482 | return getattr(self.model, \"database\", self.config.credentials.database)\n1483 | \n1484 | @contextproperty()\n1485 | def schema(self) -> str:\n1486 | return getattr(self.model, \"schema\", self.config.credentials.schema)\n1487 | \n1488 | @contextproperty()\n1489 | def this(self) -> Optional[RelationProxy]:\n1490 | \"\"\"`this` makes available schema information about the currently\n1491 | executing model. It's is useful in any context in which you need to\n1492 | write code that references the current model, for example when defining\n1493 | a `sql_where` clause for an incremental model and for writing pre- and\n1494 | post-model hooks that operate on the model in some way. Developers have\n1495 | options for how to use `this`:\n1496 | \n1497 | |------------------|------------------|\n1498 | | dbt Model Syntax | Output |\n1499 | |------------------|------------------|\n1500 | | {{this}} | \"schema\".\"table\" |\n1501 | |------------------|------------------|\n1502 | | {{this.schema}} | schema |\n1503 | |------------------|------------------|\n1504 | | {{this.table}} | table |\n1505 | |------------------|------------------|\n1506 | | {{this.name}} | table |\n1507 | |------------------|------------------|\n1508 | \n1509 | Here's an example of how to use `this` in `dbt_project.yml` to grant\n1510 | select rights on a table to a different db user.\n1511 | \n1512 | > example.yml:\n1513 | \n1514 | models:\n1515 | project-name:\n1516 | post-hook:\n1517 | - \"grant select on {{ this }} to db_reader\"\n1518 | \"\"\"\n1519 | if self.model.resource_type == NodeType.Operation:\n1520 | return None\n1521 | return self.db_wrapper.Relation.create_from(self.config, self.model)\n1522 | \n1523 | @contextproperty()\n1524 | def defer_relation(self) -> Optional[RelationProxy]:\n1525 | \"\"\"\n1526 | For commands which add information about this node's corresponding\n1527 | production version (via a --state artifact), access the Relation\n1528 | object for that stateful other\n1529 | \"\"\"\n1530 | if getattr(self.model, \"defer_relation\", None):\n1531 | return self.db_wrapper.Relation.create_from(\n1532 | self.config, self.model.defer_relation # type: ignore\n1533 | )\n1534 | else:\n1535 | return None\n1536 | \n1537 | \n1538 | class UnitTestContext(ModelContext):\n1539 | model: UnitTestNode\n1540 | \n1541 | @contextmember()\n1542 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1543 | \"\"\"The env_var() function. Return the overriden unit test environment variable named 'var'.\n1544 | \n1545 | If there is no unit test override, return the environment variable named 'var'.\n1546 | \n1547 | If there is no such environment variable set, return the default.\n1548 | \n1549 | If the default is None, raise an exception for an undefined variable.\n1550 | \"\"\"\n1551 | if self.model.overrides and var in self.model.overrides.env_vars:\n1552 | return self.model.overrides.env_vars[var]\n1553 | else:\n1554 | return super().env_var(var, default)\n1555 | \n1556 | @contextproperty()\n1557 | def this(self) -> Optional[str]:\n1558 | if self.model.this_input_node_unique_id:\n1559 | this_node = self.manifest.expect(self.model.this_input_node_unique_id)\n1560 | self.model.set_cte(this_node.unique_id, None) # type: ignore\n1561 | return self.adapter.Relation.add_ephemeral_prefix(this_node.name)\n1562 | return None\n1563 | \n1564 | \n1565 | # This is called by '_context_for', used in 'render_with_context'\n1566 | def generate_parser_model_context(\n1567 | model: ManifestNode,\n1568 | config: RuntimeConfig,\n1569 | manifest: Manifest,\n1570 | context_config: ContextConfig,\n1571 | ) -> Dict[str, Any]:\n1572 | # The __init__ method of ModelContext also initializes\n1573 | # a ManifestContext object which creates a MacroNamespaceBuilder\n1574 | # which adds every macro in the Manifest.\n1575 | ctx = ModelContext(model, config, manifest, ParseProvider(), context_config)\n1576 | # The 'to_dict' method in ManifestContext moves all of the macro names\n1577 | # in the macro 'namespace' up to top level keys\n1578 | return ctx.to_dict()\n1579 | \n1580 | \n1581 | def generate_generate_name_macro_context(\n1582 | macro: Macro,\n1583 | config: RuntimeConfig,\n1584 | manifest: Manifest,\n1585 | ) -> Dict[str, Any]:\n1586 | ctx = MacroContext(macro, config, manifest, GenerateNameProvider(), None)\n1587 | return ctx.to_dict()\n1588 | \n1589 | \n1590 | def generate_runtime_model_context(\n1591 | model: ManifestNode,\n1592 | config: RuntimeConfig,\n1593 | manifest: Manifest,\n1594 | ) -> Dict[str, Any]:\n1595 | ctx = ModelContext(model, config, manifest, RuntimeProvider(), None)\n1596 | return ctx.to_dict()\n1597 | \n1598 | \n1599 | def generate_runtime_macro_context(\n1600 | macro: MacroProtocol,\n1601 | config: RuntimeConfig,\n1602 | manifest: Manifest,\n1603 | package_name: Optional[str],\n1604 | ) -> Dict[str, Any]:\n1605 | ctx = MacroContext(macro, config, manifest, OperationProvider(), package_name)\n1606 | return ctx.to_dict()\n1607 | \n1608 | \n1609 | def generate_runtime_unit_test_context(\n1610 | unit_test: UnitTestNode,\n1611 | config: RuntimeConfig,\n1612 | manifest: Manifest,\n1613 | ) -> Dict[str, Any]:\n1614 | ctx = UnitTestContext(unit_test, config, manifest, RuntimeUnitTestProvider(), None)\n1615 | ctx_dict = ctx.to_dict()\n1616 | \n1617 | if unit_test.overrides and unit_test.overrides.macros:\n1618 | for macro_name, macro_value in unit_test.overrides.macros.items():\n1619 | context_value = ctx_dict.get(macro_name)\n1620 | if isinstance(context_value, MacroGenerator):\n1621 | ctx_dict[macro_name] = UnitTestMacroGenerator(context_value, macro_value)\n1622 | else:\n1623 | ctx_dict[macro_name] = macro_value\n1624 | return ctx_dict\n1625 | \n1626 | \n1627 | class ExposureRefResolver(BaseResolver):\n1628 | def __call__(self, *args, **kwargs) -> str:\n1629 | package = None\n1630 | if len(args) == 1:\n1631 | name = args[0]\n1632 | elif len(args) == 2:\n1633 | package, name = args\n1634 | else:\n1635 | raise RefArgsError(node=self.model, args=args)\n1636 | \n1637 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n1638 | \n1639 | self.model.refs.append(RefArgs(package=package, name=name, version=version))\n1640 | return \"\"\n1641 | \n1642 | \n1643 | class ExposureSourceResolver(BaseResolver):\n1644 | def __call__(self, *args) -> str:\n1645 | if len(args) != 2:\n1646 | raise NumberSourceArgsError(args, node=self.model)\n1647 | self.model.sources.append(list(args))\n1648 | return \"\"\n1649 | \n1650 | \n1651 | class ExposureMetricResolver(BaseResolver):\n1652 | def __call__(self, *args) -> str:\n1653 | if len(args) not in (1, 2):\n1654 | raise MetricArgsError(node=self.model, args=args)\n1655 | self.model.metrics.append(list(args))\n1656 | return \"\"\n1657 | \n1658 | \n1659 | def generate_parse_exposure(\n1660 | exposure: Exposure,\n1661 | config: RuntimeConfig,\n1662 | manifest: Manifest,\n1663 | package_name: str,\n1664 | ) -> Dict[str, Any]:\n1665 | project = config.load_dependencies()[package_name]\n1666 | return {\n1667 | \"ref\": ExposureRefResolver(\n1668 | None,\n1669 | exposure,\n1670 | project,\n1671 | manifest,\n1672 | ),\n1673 | \"source\": ExposureSourceResolver(\n1674 | None,\n1675 | exposure,\n1676 | project,\n1677 | manifest,\n1678 | ),\n1679 | \"metric\": ExposureMetricResolver(\n1680 | None,\n1681 | exposure,\n1682 | project,\n1683 | manifest,\n1684 | ),\n1685 | }\n1686 | \n1687 | \n1688 | # applies to SemanticModels\n1689 | class SemanticModelRefResolver(BaseResolver):\n1690 | def __call__(self, *args, **kwargs) -> str:\n1691 | package = None\n1692 | if len(args) == 1:\n1693 | name = args[0]\n1694 | elif len(args) == 2:\n1695 | package, name = args\n1696 | else:\n1697 | raise RefArgsError(node=self.model, args=args)\n1698 | \n1699 | version = kwargs.get(\"version\") or kwargs.get(\"v\")\n1700 | self.validate_args(name, package, version)\n1701 | \n1702 | # \"model\" here is any node\n1703 | self.model.refs.append(RefArgs(package=package, name=name, version=version))\n1704 | return \"\"\n1705 | \n1706 | def validate_args(self, name, package, version):\n1707 | if not isinstance(name, str):\n1708 | raise ParsingError(\n1709 | f\"In a semantic model or metrics section in {self.model.original_file_path} \"\n1710 | \"the name argument to ref() must be a string\"\n1711 | )\n1712 | \n1713 | \n1714 | # used for semantic models\n1715 | def generate_parse_semantic_models(\n1716 | semantic_model: SemanticModel,\n1717 | config: RuntimeConfig,\n1718 | manifest: Manifest,\n1719 | package_name: str,\n1720 | ) -> Dict[str, Any]:\n1721 | project = config.load_dependencies()[package_name]\n1722 | return {\n1723 | \"ref\": SemanticModelRefResolver(\n1724 | None,\n1725 | semantic_model,\n1726 | project,\n1727 | manifest,\n1728 | ),\n1729 | }\n1730 | \n1731 | \n1732 | # This class is currently used by the schema parser in order\n1733 | # to limit the number of macros in the context by using\n1734 | # the TestMacroNamespace\n1735 | class TestContext(ProviderContext):\n1736 | def __init__(\n1737 | self,\n1738 | model,\n1739 | config: RuntimeConfig,\n1740 | manifest: Manifest,\n1741 | provider: Provider,\n1742 | context_config: Optional[ContextConfig],\n1743 | macro_resolver: MacroResolver,\n1744 | ) -> None:\n1745 | # this must be before super init so that macro_resolver exists for\n1746 | # build_namespace\n1747 | self.macro_resolver = macro_resolver\n1748 | self.thread_ctx = MacroStack()\n1749 | super().__init__(model, config, manifest, provider, context_config)\n1750 | self._build_test_namespace()\n1751 | # We need to rebuild this because it's already been built by\n1752 | # the ProviderContext with the wrong namespace.\n1753 | self.db_wrapper = self.provider.DatabaseWrapper(self.adapter, self.namespace)\n1754 | \n1755 | def _build_namespace(self):\n1756 | return {}\n1757 | \n1758 | # this overrides _build_namespace in ManifestContext which provides a\n1759 | # complete namespace of all macros to only specify macros in the depends_on\n1760 | # This only provides a namespace with macros in the test node\n1761 | # 'depends_on.macros' by using the TestMacroNamespace\n1762 | def _build_test_namespace(self):\n1763 | depends_on_macros = []\n1764 | # all generic tests use a macro named 'get_where_subquery' to wrap 'model' arg\n1765 | # see generic_test_builders.build_model_str\n1766 | get_where_subquery = self.macro_resolver.macros_by_name.get(\"get_where_subquery\")\n1767 | if get_where_subquery:\n1768 | depends_on_macros.append(get_where_subquery.unique_id)\n1769 | if self.model.depends_on and self.model.depends_on.macros:\n1770 | depends_on_macros.extend(self.model.depends_on.macros)\n1771 | lookup_macros = depends_on_macros.copy()\n1772 | for macro_unique_id in lookup_macros:\n1773 | lookup_macro = self.macro_resolver.macros.get(macro_unique_id)\n1774 | if lookup_macro:\n1775 | depends_on_macros.extend(lookup_macro.depends_on.macros)\n1776 | \n1777 | macro_namespace = TestMacroNamespace(\n1778 | self.macro_resolver, self._ctx, self.model, self.thread_ctx, depends_on_macros\n1779 | )\n1780 | self.namespace = macro_namespace\n1781 | \n1782 | @contextmember()\n1783 | def env_var(self, var: str, default: Optional[str] = None) -> str:\n1784 | return_value = None\n1785 | if var.startswith(SECRET_ENV_PREFIX):\n1786 | raise SecretEnvVarLocationError(var)\n1787 | if var in os.environ:\n1788 | return_value = os.environ[var]\n1789 | elif default is not None:\n1790 | return_value = default\n1791 | \n1792 | if return_value is not None:\n1793 | # Save the env_var value in the manifest and the var name in the source_file\n1794 | if self.model:\n1795 | # If the environment variable is set from a default, store a string indicating\n1796 | # that so we can skip partial parsing. Otherwise the file will be scheduled for\n1797 | # reparsing. If the default changes, the file will have been updated and therefore\n1798 | # will be scheduled for reparsing anyways.\n1799 | self.manifest.env_vars[var] = (\n1800 | return_value if var in os.environ else DEFAULT_ENV_PLACEHOLDER\n1801 | )\n1802 | # the \"model\" should only be test nodes, but just in case, check\n1803 | # TODO CT-211\n1804 | if self.model.resource_type == NodeType.Test and self.model.file_key_name: # type: ignore[union-attr] # noqa\n1805 | source_file = self.manifest.files[self.model.file_id]\n1806 | # TODO CT-211\n1807 | (yaml_key, name) = self.model.file_key_name.split(\".\") # type: ignore[union-attr] # noqa\n1808 | # TODO CT-211\n1809 | source_file.add_env_var(var, yaml_key, name) # type: ignore[union-attr]\n1810 | return return_value\n1811 | else:\n1812 | raise EnvVarMissingError(var)\n1813 | \n1814 | \n1815 | def generate_test_context(\n1816 | model: ManifestNode,\n1817 | config: RuntimeConfig,\n1818 | manifest: Manifest,\n1819 | context_config: ContextConfig,\n1820 | macro_resolver: MacroResolver,\n1821 | ) -> Dict[str, Any]:\n1822 | ctx = TestContext(model, config, manifest, ParseProvider(), context_config, macro_resolver)\n1823 | # The 'to_dict' method in ManifestContext moves all of the macro names\n1824 | # in the macro 'namespace' up to top level keys\n1825 | return ctx.to_dict()\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/context/providers.py b/core/dbt/context/providers.py\nindex 0000000..0000000 100644\n--- a/core/dbt/context/providers.py\n+++ b/core/dbt/context/providers.py\n@@ -1457,27 +1457,10 @@ class ModelContext(ProviderContext):\n h.to_dict(omit_none=True) for h in self.model.config.post_hook # type: ignore[union-attr] # noqa\n ]\n \n- @contextproperty()\n- def sql(self) -> Optional[str]:\n- # only doing this in sql model for backward compatible\n- if self.model.language == ModelLanguage.sql: # type: ignore[union-attr]\n- # If the model is deferred and the adapter doesn't support zero-copy cloning, then select * from the prod\n- # relation\n- # TODO: avoid routing on args.which if possible\n- if getattr(self.model, \"defer_relation\", None) and self.config.args.which == \"clone\":\n- # TODO https://github.com/dbt-labs/dbt-core/issues/7976\n- return f\"select * from {self.model.defer_relation.relation_name or str(self.defer_relation)}\" # type: ignore[union-attr]\n- elif getattr(self.model, \"extra_ctes_injected\", None):\n- # TODO CT-211\n- return self.model.compiled_code # type: ignore[union-attr]\n- else:\n- return None\n- else:\n- return None\n-\n @contextproperty()\n def compiled_code(self) -> Optional[str]:\n- if getattr(self.model, \"defer_relation\", None):\n+ # TODO: avoid routing on args.which if possible\n+ if getattr(self.model, \"defer_relation\", None) and self.config.args.which == \"clone\":\n # TODO https://github.com/dbt-labs/dbt-core/issues/7976\n return f\"select * from {self.model.defer_relation.relation_name or str(self.defer_relation)}\" # type: ignore[union-attr]\n elif getattr(self.model, \"extra_ctes_injected\", None):\n@@ -1486,6 +1469,14 @@ class ModelContext(ProviderContext):\n else:\n return None\n \n+ @contextproperty()\n+ def sql(self) -> Optional[str]:\n+ # only set this for sql models, for backward compatibility\n+ if self.model.language == ModelLanguage.sql: # type: ignore[union-attr]\n+ return self.compiled_code\n+ else:\n+ return None\n+\n @contextproperty()\n def database(self) -> str:\n return getattr(self.model, \"database\", self.config.credentials.database)"},"prompt_input_token_count":{"kind":"number","value":47083,"string":"47,083"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9503\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"2d59a51874672e5a95ec7f2f2aa18b8a66e9e738\",\n \"pull_number\": 9503,\n \"issue_numbers\": [\n \"9502\"\n ],\n \"changed_files\": [\n \"core/dbt/context/providers.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": false\n}"}}},{"rowIdx":32297,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9508"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 2411f93240a346961e6a965ad9cb5c766db275a0\nChanged files:\n- core/dbt/contracts/graph/unparsed.py\n\n## Problem statement\n\n[Bug] Semantic Layer where filter strings are parsed into lists\n### Is this a new bug in dbt-core?\n\n- [X] I believe this is a new bug in dbt-core\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\n\n### Current Behavior\n\nCurrently, if you pass a string into a filter YAML param, it will be assumed to be a list. This means your semantic manifest ends up with a list of strings for where filters. For example, this YAML:\r\n```\r\nfilter: |\r\n {{ Dimension('customer__customer_type') }} = 'new'\r\n```\r\nwould look like this in the semantic manifest:\r\n```\r\n{\"where_filters\": [{\"where_sql_template\": \"{\"}, {\"where_sql_template\": \"{\"}, {\"where_sql_template\": \" \"}, {\"where_sql_template\": \"D\"}, {\"where_sql_template\": \"i\"}, {\"where_sql_template\": \"m\"}, {\"where_sql_template\": \"e\"}, {\"where_sql_template\": \"n\"}, {\"where_sql_template\": \"s\"}, {\"where_sql_template\": \"i\"}, {\"where_sql_template\": \"o\"}, {\"where_sql_template\": \"n\"}, {\"where_sql_template\": \"(\"}, {\"where_sql_template\": \"'\"}, {\"where_sql_template\": \"c\"}, {\"where_sql_template\": \"u\"}, {\"where_sql_template\": \"s\"}, {\"where_sql_template\": \"t\"}, {\"where_sql_template\": \"o\"}, {\"where_sql_template\": \"m\"}, {\"where_sql_template\": \"e\"}, {\"where_sql_template\": \"r\"}, {\"where_sql_template\": \"_\"}, {\"where_sql_template\": \"_\"}, {\"where_sql_template\": \"c\"}, {\"where_sql_template\": \"u\"}, {\"where_sql_template\": \"s\"}, {\"where_sql_template\": \"t\"}, {\"where_sql_template\": \"o\"}, {\"where_sql_template\": \"m\"}, {\"where_sql_template\": \"e\"}, {\"where_sql_template\": \"r\"}, {\"where_sql_template\": \"_\"}, {\"where_sql_template\": \"t\"}, {\"where_sql_template\": \"y\"}, {\"where_sql_template\": \"p\"}, {\"where_sql_template\": \"e\"}, {\"where_sql_template\": \"'\"}, {\"where_sql_template\": \")\"}, {\"where_sql_template\": \" \"}, {\"where_sql_template\": \"}\"}, {\"where_sql_template\": \"}\"}, {\"where_sql_template\": \" \"}, {\"where_sql_template\": \" \"}, {\"where_sql_template\": \"=\"}, {\"where_sql_template\": \" \"}, {\"where_sql_template\": \"'\"}, {\"where_sql_template\": \"n\"}, {\"where_sql_template\": \"e\"}, {\"where_sql_template\": \"w\"}, {\"where_sql_template\": \"'\"}]}\r\n```\n\n### Expected Behavior\n\nThe semantic manifest should show this:\r\n`{\"where_filters\": [{\"where_sql_template\": \"{{ Dimension('customer__customer_type') }} = 'new'\"}]}`\n\n### Steps To Reproduce\n\nAdd a string filter to a metric or saved query and run `dbt parse`, then look at the generated semantic manifest.\n\n### Relevant log output\n\n_No response_\n\n### Environment\n\n```markdown\n- OS:\r\n- Python:\r\n- dbt:\n```\n\n\n### Which database adapter are you using with dbt?\n\n_No response_\n\n### Additional Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/contracts/graph/unparsed.py\n\n```python\n 1 | import datetime\n 2 | import re\n 3 | \n 4 | from dbt import deprecations\n 5 | from dbt.artifacts.resources import ConstantPropertyInput\n 6 | from dbt_common.contracts.config.properties import (\n 7 | AdditionalPropertiesAllowed,\n 8 | AdditionalPropertiesMixin,\n 9 | )\n 10 | from dbt_common.contracts.util import Mergeable\n 11 | from dbt_common.exceptions import DbtInternalError, CompilationError\n 12 | from dbt_common.dataclass_schema import (\n 13 | dbtClassMixin,\n 14 | StrEnum,\n 15 | ExtensibleDbtClassMixin,\n 16 | ValidationError,\n 17 | )\n 18 | from dbt.node_types import NodeType\n 19 | from dbt.artifacts.resources import (\n 20 | Defaults,\n 21 | DimensionValidityParams,\n 22 | ExposureType,\n 23 | MaturityType,\n 24 | MeasureAggregationParameters,\n 25 | )\n 26 | from dbt.contracts.util import Replaceable\n 27 | \n 28 | # trigger the PathEncoder\n 29 | import dbt_common.helper_types # noqa:F401\n 30 | from dbt.exceptions import ParsingError\n 31 | \n 32 | from dbt_semantic_interfaces.type_enums import ConversionCalculationType\n 33 | from dbt.artifacts.resources import Docs, MacroArgument, NodeVersion, Owner\n 34 | \n 35 | from dataclasses import dataclass, field\n 36 | from datetime import timedelta\n 37 | from pathlib import Path\n 38 | from typing import Optional, List, Union, Dict, Any, Sequence, Literal\n 39 | \n 40 | \n 41 | @dataclass\n 42 | class UnparsedBaseNode(dbtClassMixin, Replaceable):\n 43 | package_name: str\n 44 | path: str\n 45 | original_file_path: str\n 46 | \n 47 | @property\n 48 | def file_id(self):\n 49 | return f\"{self.package_name}://{self.original_file_path}\"\n 50 | \n 51 | \n 52 | @dataclass\n 53 | class HasCode(dbtClassMixin):\n 54 | raw_code: str\n 55 | language: str\n 56 | \n 57 | @property\n 58 | def empty(self):\n 59 | return not self.raw_code.strip()\n 60 | \n 61 | \n 62 | @dataclass\n 63 | class UnparsedMacro(UnparsedBaseNode, HasCode):\n 64 | resource_type: Literal[NodeType.Macro]\n 65 | \n 66 | \n 67 | @dataclass\n 68 | class UnparsedGenericTest(UnparsedBaseNode, HasCode):\n 69 | resource_type: Literal[NodeType.Macro]\n 70 | \n 71 | \n 72 | @dataclass\n 73 | class UnparsedNode(UnparsedBaseNode, HasCode):\n 74 | name: str\n 75 | resource_type: NodeType\n 76 | \n 77 | @property\n 78 | def search_name(self):\n 79 | return self.name\n 80 | \n 81 | \n 82 | @dataclass\n 83 | class UnparsedRunHook(UnparsedNode):\n 84 | resource_type: Literal[NodeType.Operation]\n 85 | index: Optional[int] = None\n 86 | \n 87 | \n 88 | @dataclass\n 89 | class HasColumnProps(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 90 | name: str\n 91 | description: str = \"\"\n 92 | meta: Dict[str, Any] = field(default_factory=dict)\n 93 | data_type: Optional[str] = None\n 94 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n 95 | docs: Docs = field(default_factory=Docs)\n 96 | _extra: Dict[str, Any] = field(default_factory=dict)\n 97 | \n 98 | \n 99 | TestDef = Union[Dict[str, Any], str]\n100 | \n101 | \n102 | @dataclass\n103 | class HasColumnAndTestProps(HasColumnProps):\n104 | data_tests: List[TestDef] = field(default_factory=list)\n105 | tests: List[TestDef] = field(\n106 | default_factory=list\n107 | ) # back compat for previous name of 'data_tests'\n108 | \n109 | \n110 | @dataclass\n111 | class UnparsedColumn(HasColumnAndTestProps):\n112 | quote: Optional[bool] = None\n113 | tags: List[str] = field(default_factory=list)\n114 | \n115 | \n116 | @dataclass\n117 | class HasColumnDocs(dbtClassMixin, Replaceable):\n118 | columns: Sequence[HasColumnProps] = field(default_factory=list)\n119 | \n120 | \n121 | @dataclass\n122 | class HasColumnTests(dbtClassMixin, Replaceable):\n123 | columns: Sequence[UnparsedColumn] = field(default_factory=list)\n124 | \n125 | \n126 | @dataclass\n127 | class HasYamlMetadata(dbtClassMixin):\n128 | original_file_path: str\n129 | yaml_key: str\n130 | package_name: str\n131 | \n132 | @property\n133 | def file_id(self):\n134 | return f\"{self.package_name}://{self.original_file_path}\"\n135 | \n136 | \n137 | @dataclass\n138 | class HasConfig:\n139 | config: Dict[str, Any] = field(default_factory=dict)\n140 | \n141 | \n142 | @dataclass\n143 | class UnparsedVersion(dbtClassMixin):\n144 | v: NodeVersion\n145 | defined_in: Optional[str] = None\n146 | description: str = \"\"\n147 | access: Optional[str] = None\n148 | config: Dict[str, Any] = field(default_factory=dict)\n149 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n150 | docs: Docs = field(default_factory=Docs)\n151 | data_tests: Optional[List[TestDef]] = None\n152 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n153 | columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n154 | default_factory=list\n155 | )\n156 | deprecation_date: Optional[datetime.datetime] = None\n157 | \n158 | def __lt__(self, other):\n159 | try:\n160 | return float(self.v) < float(other.v)\n161 | except ValueError:\n162 | return str(self.v) < str(other.v)\n163 | \n164 | @property\n165 | def include_exclude(self) -> dbt_common.helper_types.IncludeExclude:\n166 | return self._include_exclude\n167 | \n168 | @property\n169 | def unparsed_columns(self) -> List:\n170 | return self._unparsed_columns\n171 | \n172 | @property\n173 | def formatted_v(self) -> str:\n174 | return f\"v{self.v}\"\n175 | \n176 | def __post_init__(self):\n177 | has_include_exclude = False\n178 | self._include_exclude = dbt_common.helper_types.IncludeExclude(include=\"*\")\n179 | self._unparsed_columns = []\n180 | for column in self.columns:\n181 | if isinstance(column, dbt_common.helper_types.IncludeExclude):\n182 | if not has_include_exclude:\n183 | self._include_exclude = column\n184 | has_include_exclude = True\n185 | else:\n186 | raise ParsingError(\"version can have at most one include/exclude element\")\n187 | else:\n188 | self._unparsed_columns.append(column)\n189 | \n190 | self.deprecation_date = normalize_date(self.deprecation_date)\n191 | \n192 | \n193 | @dataclass\n194 | class UnparsedAnalysisUpdate(HasConfig, HasColumnDocs, HasColumnProps, HasYamlMetadata):\n195 | access: Optional[str] = None\n196 | \n197 | \n198 | @dataclass\n199 | class UnparsedNodeUpdate(HasConfig, HasColumnTests, HasColumnAndTestProps, HasYamlMetadata):\n200 | quote_columns: Optional[bool] = None\n201 | access: Optional[str] = None\n202 | \n203 | \n204 | @dataclass\n205 | class UnparsedModelUpdate(UnparsedNodeUpdate):\n206 | quote_columns: Optional[bool] = None\n207 | access: Optional[str] = None\n208 | latest_version: Optional[NodeVersion] = None\n209 | versions: Sequence[UnparsedVersion] = field(default_factory=list)\n210 | deprecation_date: Optional[datetime.datetime] = None\n211 | \n212 | def __post_init__(self) -> None:\n213 | if self.latest_version:\n214 | version_values = [version.v for version in self.versions]\n215 | if self.latest_version not in version_values:\n216 | raise ParsingError(\n217 | f\"latest_version: {self.latest_version} is not one of model '{self.name}' versions: {version_values} \"\n218 | )\n219 | \n220 | seen_versions = set()\n221 | for version in self.versions:\n222 | if str(version.v) in seen_versions:\n223 | raise ParsingError(\n224 | f\"Found duplicate version: '{version.v}' in versions list of model '{self.name}'\"\n225 | )\n226 | seen_versions.add(str(version.v))\n227 | \n228 | self._version_map = {version.v: version for version in self.versions}\n229 | \n230 | self.deprecation_date = normalize_date(self.deprecation_date)\n231 | \n232 | def get_columns_for_version(self, version: NodeVersion) -> List[UnparsedColumn]:\n233 | if version not in self._version_map:\n234 | raise DbtInternalError(\n235 | f\"get_columns_for_version called for version '{version}' not in version map\"\n236 | )\n237 | \n238 | version_columns = []\n239 | unparsed_version = self._version_map[version]\n240 | for base_column in self.columns:\n241 | if unparsed_version.include_exclude.includes(base_column.name):\n242 | version_columns.append(base_column)\n243 | \n244 | for column in unparsed_version.unparsed_columns:\n245 | version_columns.append(column)\n246 | \n247 | return version_columns\n248 | \n249 | def get_tests_for_version(self, version: NodeVersion) -> List[TestDef]:\n250 | if version not in self._version_map:\n251 | raise DbtInternalError(\n252 | f\"get_tests_for_version called for version '{version}' not in version map\"\n253 | )\n254 | unparsed_version = self._version_map[version]\n255 | return (\n256 | unparsed_version.data_tests\n257 | if unparsed_version.data_tests is not None\n258 | else self.data_tests\n259 | )\n260 | \n261 | \n262 | @dataclass\n263 | class UnparsedMacroUpdate(HasConfig, HasColumnProps, HasYamlMetadata):\n264 | arguments: List[MacroArgument] = field(default_factory=list)\n265 | \n266 | \n267 | class TimePeriod(StrEnum):\n268 | minute = \"minute\"\n269 | hour = \"hour\"\n270 | day = \"day\"\n271 | \n272 | def plural(self) -> str:\n273 | return str(self) + \"s\"\n274 | \n275 | \n276 | @dataclass\n277 | class Time(dbtClassMixin, Mergeable):\n278 | count: Optional[int] = None\n279 | period: Optional[TimePeriod] = None\n280 | \n281 | def exceeded(self, actual_age: float) -> bool:\n282 | if self.period is None or self.count is None:\n283 | return False\n284 | kwargs: Dict[str, int] = {self.period.plural(): self.count}\n285 | difference = timedelta(**kwargs).total_seconds()\n286 | return actual_age > difference\n287 | \n288 | def __bool__(self):\n289 | return self.count is not None and self.period is not None\n290 | \n291 | \n292 | @dataclass\n293 | class FreshnessThreshold(dbtClassMixin, Mergeable):\n294 | warn_after: Optional[Time] = field(default_factory=Time)\n295 | error_after: Optional[Time] = field(default_factory=Time)\n296 | filter: Optional[str] = None\n297 | \n298 | def status(self, age: float) -> \"dbt.artifacts.schemas.results.FreshnessStatus\": # type: ignore # noqa F821\n299 | from dbt.artifacts.schemas.results import FreshnessStatus\n300 | \n301 | if self.error_after and self.error_after.exceeded(age):\n302 | return FreshnessStatus.Error\n303 | elif self.warn_after and self.warn_after.exceeded(age):\n304 | return FreshnessStatus.Warn\n305 | else:\n306 | return FreshnessStatus.Pass\n307 | \n308 | def __bool__(self):\n309 | return bool(self.warn_after) or bool(self.error_after)\n310 | \n311 | \n312 | @dataclass\n313 | class ExternalPartition(AdditionalPropertiesAllowed, Replaceable):\n314 | name: str = \"\"\n315 | description: str = \"\"\n316 | data_type: str = \"\"\n317 | meta: Dict[str, Any] = field(default_factory=dict)\n318 | \n319 | def __post_init__(self):\n320 | if self.name == \"\" or self.data_type == \"\":\n321 | raise CompilationError(\"External partition columns must have names and data types\")\n322 | \n323 | \n324 | @dataclass\n325 | class ExternalTable(AdditionalPropertiesAllowed, Mergeable):\n326 | location: Optional[str] = None\n327 | file_format: Optional[str] = None\n328 | row_format: Optional[str] = None\n329 | tbl_properties: Optional[str] = None\n330 | partitions: Optional[Union[List[str], List[ExternalPartition]]] = None\n331 | \n332 | def __bool__(self):\n333 | return self.location is not None\n334 | \n335 | \n336 | @dataclass\n337 | class Quoting(dbtClassMixin, Mergeable):\n338 | database: Optional[bool] = None\n339 | schema: Optional[bool] = None\n340 | identifier: Optional[bool] = None\n341 | column: Optional[bool] = None\n342 | \n343 | \n344 | @dataclass\n345 | class UnparsedSourceTableDefinition(HasColumnTests, HasColumnAndTestProps):\n346 | config: Dict[str, Any] = field(default_factory=dict)\n347 | loaded_at_field: Optional[str] = None\n348 | identifier: Optional[str] = None\n349 | quoting: Quoting = field(default_factory=Quoting)\n350 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n351 | external: Optional[ExternalTable] = None\n352 | tags: List[str] = field(default_factory=list)\n353 | \n354 | def __post_serialize__(self, dct):\n355 | dct = super().__post_serialize__(dct)\n356 | if \"freshness\" not in dct and self.freshness is None:\n357 | dct[\"freshness\"] = None\n358 | return dct\n359 | \n360 | \n361 | @dataclass\n362 | class UnparsedSourceDefinition(dbtClassMixin, Replaceable):\n363 | name: str\n364 | description: str = \"\"\n365 | meta: Dict[str, Any] = field(default_factory=dict)\n366 | database: Optional[str] = None\n367 | schema: Optional[str] = None\n368 | loader: str = \"\"\n369 | quoting: Quoting = field(default_factory=Quoting)\n370 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n371 | loaded_at_field: Optional[str] = None\n372 | tables: List[UnparsedSourceTableDefinition] = field(default_factory=list)\n373 | tags: List[str] = field(default_factory=list)\n374 | config: Dict[str, Any] = field(default_factory=dict)\n375 | \n376 | @property\n377 | def yaml_key(self) -> \"str\":\n378 | return \"sources\"\n379 | \n380 | def __post_serialize__(self, dct):\n381 | dct = super().__post_serialize__(dct)\n382 | if \"freshness\" not in dct and self.freshness is None:\n383 | dct[\"freshness\"] = None\n384 | return dct\n385 | \n386 | \n387 | @dataclass\n388 | class SourceTablePatch(dbtClassMixin):\n389 | name: str\n390 | description: Optional[str] = None\n391 | meta: Optional[Dict[str, Any]] = None\n392 | data_type: Optional[str] = None\n393 | docs: Optional[Docs] = None\n394 | loaded_at_field: Optional[str] = None\n395 | identifier: Optional[str] = None\n396 | quoting: Quoting = field(default_factory=Quoting)\n397 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n398 | external: Optional[ExternalTable] = None\n399 | tags: Optional[List[str]] = None\n400 | data_tests: Optional[List[TestDef]] = None\n401 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n402 | columns: Optional[Sequence[UnparsedColumn]] = None\n403 | \n404 | def to_patch_dict(self) -> Dict[str, Any]:\n405 | dct = self.to_dict(omit_none=True)\n406 | remove_keys = \"name\"\n407 | for key in remove_keys:\n408 | if key in dct:\n409 | del dct[key]\n410 | \n411 | if self.freshness is None:\n412 | dct[\"freshness\"] = None\n413 | \n414 | return dct\n415 | \n416 | \n417 | @dataclass\n418 | class SourcePatch(dbtClassMixin, Replaceable):\n419 | name: str = field(\n420 | metadata=dict(description=\"The name of the source to override\"),\n421 | )\n422 | overrides: str = field(\n423 | metadata=dict(description=\"The package of the source to override\"),\n424 | )\n425 | path: Path = field(\n426 | metadata=dict(description=\"The path to the patch-defining yml file\"),\n427 | )\n428 | config: Dict[str, Any] = field(default_factory=dict)\n429 | description: Optional[str] = None\n430 | meta: Optional[Dict[str, Any]] = None\n431 | database: Optional[str] = None\n432 | schema: Optional[str] = None\n433 | loader: Optional[str] = None\n434 | quoting: Optional[Quoting] = None\n435 | freshness: Optional[Optional[FreshnessThreshold]] = field(default_factory=FreshnessThreshold)\n436 | loaded_at_field: Optional[str] = None\n437 | tables: Optional[List[SourceTablePatch]] = None\n438 | tags: Optional[List[str]] = None\n439 | \n440 | def to_patch_dict(self) -> Dict[str, Any]:\n441 | dct = self.to_dict(omit_none=True)\n442 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n443 | for key in remove_keys:\n444 | if key in dct:\n445 | del dct[key]\n446 | \n447 | if self.freshness is None:\n448 | dct[\"freshness\"] = None\n449 | \n450 | return dct\n451 | \n452 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n453 | if self.tables is not None:\n454 | for table in self.tables:\n455 | if table.name == name:\n456 | return table\n457 | return None\n458 | \n459 | \n460 | @dataclass\n461 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n462 | package_name: str\n463 | path: str\n464 | original_file_path: str\n465 | \n466 | @property\n467 | def file_id(self):\n468 | return f\"{self.package_name}://{self.original_file_path}\"\n469 | \n470 | @property\n471 | def resource_type(self):\n472 | return NodeType.Documentation\n473 | \n474 | \n475 | @dataclass\n476 | class UnparsedDocumentationFile(UnparsedDocumentation):\n477 | file_contents: str\n478 | \n479 | \n480 | # can't use total_ordering decorator here, as str provides an ordering already\n481 | # and it's not the one we want.\n482 | class Maturity(StrEnum):\n483 | low = \"low\"\n484 | medium = \"medium\"\n485 | high = \"high\"\n486 | \n487 | def __lt__(self, other):\n488 | if not isinstance(other, Maturity):\n489 | return NotImplemented\n490 | order = (Maturity.low, Maturity.medium, Maturity.high)\n491 | return order.index(self) < order.index(other)\n492 | \n493 | def __gt__(self, other):\n494 | if not isinstance(other, Maturity):\n495 | return NotImplemented\n496 | return self != other and not (self < other)\n497 | \n498 | def __ge__(self, other):\n499 | if not isinstance(other, Maturity):\n500 | return NotImplemented\n501 | return self == other or not (self < other)\n502 | \n503 | def __le__(self, other):\n504 | if not isinstance(other, Maturity):\n505 | return NotImplemented\n506 | return self == other or self < other\n507 | \n508 | \n509 | @dataclass\n510 | class UnparsedExposure(dbtClassMixin, Replaceable):\n511 | name: str\n512 | type: ExposureType\n513 | owner: Owner\n514 | description: str = \"\"\n515 | label: Optional[str] = None\n516 | maturity: Optional[MaturityType] = None\n517 | meta: Dict[str, Any] = field(default_factory=dict)\n518 | tags: List[str] = field(default_factory=list)\n519 | url: Optional[str] = None\n520 | depends_on: List[str] = field(default_factory=list)\n521 | config: Dict[str, Any] = field(default_factory=dict)\n522 | \n523 | @classmethod\n524 | def validate(cls, data):\n525 | super(UnparsedExposure, cls).validate(data)\n526 | if \"name\" in data:\n527 | # name can only contain alphanumeric chars and underscores\n528 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n529 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n530 | \n531 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n532 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n533 | \n534 | \n535 | @dataclass\n536 | class MetricFilter(dbtClassMixin, Replaceable):\n537 | field: str\n538 | operator: str\n539 | # TODO : Can we make this Any?\n540 | value: str\n541 | \n542 | \n543 | class MetricTimePeriod(StrEnum):\n544 | day = \"day\"\n545 | week = \"week\"\n546 | month = \"month\"\n547 | year = \"year\"\n548 | \n549 | def plural(self) -> str:\n550 | return str(self) + \"s\"\n551 | \n552 | \n553 | @dataclass\n554 | class MetricTime(dbtClassMixin, Mergeable):\n555 | count: Optional[int] = None\n556 | period: Optional[MetricTimePeriod] = None\n557 | \n558 | def __bool__(self):\n559 | return self.count is not None and self.period is not None\n560 | \n561 | \n562 | @dataclass\n563 | class UnparsedMetricInputMeasure(dbtClassMixin):\n564 | name: str\n565 | filter: Optional[Union[str, List[str]]] = None\n566 | alias: Optional[str] = None\n567 | join_to_timespine: bool = False\n568 | fill_nulls_with: Optional[int] = None\n569 | \n570 | \n571 | @dataclass\n572 | class UnparsedMetricInput(dbtClassMixin):\n573 | name: str\n574 | filter: Optional[Union[str, List[str]]] = None\n575 | alias: Optional[str] = None\n576 | offset_window: Optional[str] = None\n577 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n578 | \n579 | \n580 | @dataclass\n581 | class UnparsedConversionTypeParams(dbtClassMixin):\n582 | base_measure: Union[UnparsedMetricInputMeasure, str]\n583 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n584 | entity: str\n585 | calculation: str = (\n586 | ConversionCalculationType.CONVERSION_RATE.value\n587 | ) # ConversionCalculationType Enum\n588 | window: Optional[str] = None\n589 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n590 | \n591 | \n592 | @dataclass\n593 | class UnparsedMetricTypeParams(dbtClassMixin):\n594 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n595 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n596 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n597 | expr: Optional[Union[str, bool]] = None\n598 | window: Optional[str] = None\n599 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n600 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n601 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n602 | \n603 | \n604 | @dataclass\n605 | class UnparsedMetric(dbtClassMixin):\n606 | name: str\n607 | label: str\n608 | type: str\n609 | type_params: UnparsedMetricTypeParams\n610 | description: str = \"\"\n611 | filter: Optional[Union[str, List[str]]] = None\n612 | # metadata: Optional[Unparsedetadata] = None # TODO\n613 | meta: Dict[str, Any] = field(default_factory=dict)\n614 | tags: List[str] = field(default_factory=list)\n615 | config: Dict[str, Any] = field(default_factory=dict)\n616 | \n617 | @classmethod\n618 | def validate(cls, data):\n619 | super(UnparsedMetric, cls).validate(data)\n620 | if \"name\" in data:\n621 | errors = []\n622 | if \" \" in data[\"name\"]:\n623 | errors.append(\"cannot contain spaces\")\n624 | # This handles failing queries due to too long metric names.\n625 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n626 | if len(data[\"name\"]) > 250:\n627 | errors.append(\"cannot contain more than 250 characters\")\n628 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n629 | errors.append(\"must begin with a letter\")\n630 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n631 | errors.append(\"must contain only letters, numbers and underscores\")\n632 | \n633 | if errors:\n634 | raise ParsingError(\n635 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n636 | )\n637 | \n638 | \n639 | @dataclass\n640 | class UnparsedGroup(dbtClassMixin, Replaceable):\n641 | name: str\n642 | owner: Owner\n643 | \n644 | @classmethod\n645 | def validate(cls, data):\n646 | super(UnparsedGroup, cls).validate(data)\n647 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n648 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n649 | \n650 | \n651 | #\n652 | # semantic interfaces unparsed objects\n653 | #\n654 | \n655 | \n656 | @dataclass\n657 | class UnparsedEntity(dbtClassMixin):\n658 | name: str\n659 | type: str # EntityType enum\n660 | description: Optional[str] = None\n661 | label: Optional[str] = None\n662 | role: Optional[str] = None\n663 | expr: Optional[str] = None\n664 | \n665 | \n666 | @dataclass\n667 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n668 | name: str\n669 | window_choice: str # AggregationType enum\n670 | window_groupings: List[str] = field(default_factory=list)\n671 | \n672 | \n673 | @dataclass\n674 | class UnparsedMeasure(dbtClassMixin):\n675 | name: str\n676 | agg: str # actually an enum\n677 | description: Optional[str] = None\n678 | label: Optional[str] = None\n679 | expr: Optional[Union[str, bool, int]] = None\n680 | agg_params: Optional[MeasureAggregationParameters] = None\n681 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n682 | agg_time_dimension: Optional[str] = None\n683 | create_metric: bool = False\n684 | \n685 | \n686 | @dataclass\n687 | class UnparsedDimensionTypeParams(dbtClassMixin):\n688 | time_granularity: str # TimeGranularity enum\n689 | validity_params: Optional[DimensionValidityParams] = None\n690 | \n691 | \n692 | @dataclass\n693 | class UnparsedDimension(dbtClassMixin):\n694 | name: str\n695 | type: str # actually an enum\n696 | description: Optional[str] = None\n697 | label: Optional[str] = None\n698 | is_partition: bool = False\n699 | type_params: Optional[UnparsedDimensionTypeParams] = None\n700 | expr: Optional[str] = None\n701 | \n702 | \n703 | @dataclass\n704 | class UnparsedSemanticModel(dbtClassMixin):\n705 | name: str\n706 | model: str # looks like \"ref(...)\"\n707 | config: Dict[str, Any] = field(default_factory=dict)\n708 | description: Optional[str] = None\n709 | label: Optional[str] = None\n710 | defaults: Optional[Defaults] = None\n711 | entities: List[UnparsedEntity] = field(default_factory=list)\n712 | measures: List[UnparsedMeasure] = field(default_factory=list)\n713 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n714 | primary_entity: Optional[str] = None\n715 | \n716 | \n717 | @dataclass\n718 | class UnparsedQueryParams(dbtClassMixin):\n719 | metrics: List[str] = field(default_factory=list)\n720 | group_by: List[str] = field(default_factory=list)\n721 | where: Optional[Union[str, List[str]]] = None\n722 | \n723 | \n724 | @dataclass\n725 | class UnparsedExport(dbtClassMixin):\n726 | \"\"\"Configuration for writing query results to a table.\"\"\"\n727 | \n728 | name: str\n729 | config: Dict[str, Any] = field(default_factory=dict)\n730 | \n731 | \n732 | @dataclass\n733 | class UnparsedSavedQuery(dbtClassMixin):\n734 | name: str\n735 | query_params: UnparsedQueryParams\n736 | description: Optional[str] = None\n737 | label: Optional[str] = None\n738 | exports: List[UnparsedExport] = field(default_factory=list)\n739 | config: Dict[str, Any] = field(default_factory=dict)\n740 | \n741 | \n742 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n743 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n744 | if d is None:\n745 | return None\n746 | \n747 | # convert date to datetime\n748 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n749 | \n750 | if not dt.tzinfo:\n751 | # date is naive, re-interpret as system time zone\n752 | dt = dt.astimezone()\n753 | \n754 | return dt\n755 | \n756 | \n757 | class UnitTestFormat(StrEnum):\n758 | CSV = \"csv\"\n759 | Dict = \"dict\"\n760 | \n761 | \n762 | @dataclass\n763 | class UnitTestInputFixture(dbtClassMixin):\n764 | input: str\n765 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n766 | format: UnitTestFormat = UnitTestFormat.Dict\n767 | fixture: Optional[str] = None\n768 | \n769 | \n770 | @dataclass\n771 | class UnitTestOutputFixture(dbtClassMixin):\n772 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n773 | format: UnitTestFormat = UnitTestFormat.Dict\n774 | fixture: Optional[str] = None\n775 | \n776 | \n777 | @dataclass\n778 | class UnitTestOverrides(dbtClassMixin):\n779 | macros: Dict[str, Any] = field(default_factory=dict)\n780 | vars: Dict[str, Any] = field(default_factory=dict)\n781 | env_vars: Dict[str, Any] = field(default_factory=dict)\n782 | \n783 | \n784 | @dataclass\n785 | class UnitTestNodeVersions(dbtClassMixin):\n786 | include: Optional[List[NodeVersion]] = None\n787 | exclude: Optional[List[NodeVersion]] = None\n788 | \n789 | \n790 | @dataclass\n791 | class UnparsedUnitTest(dbtClassMixin):\n792 | name: str\n793 | model: str # name of the model being unit tested\n794 | given: Sequence[UnitTestInputFixture]\n795 | expect: UnitTestOutputFixture\n796 | description: str = \"\"\n797 | overrides: Optional[UnitTestOverrides] = None\n798 | config: Dict[str, Any] = field(default_factory=dict)\n799 | versions: Optional[UnitTestNodeVersions] = None\n800 | \n801 | @classmethod\n802 | def validate(cls, data):\n803 | super(UnparsedUnitTest, cls).validate(data)\n804 | if data.get(\"versions\", None):\n805 | if data[\"versions\"].get(\"include\") and data[\"versions\"].get(\"exclude\"):\n806 | raise ValidationError(\"Unit tests can not both include and exclude versions.\")\n```\n\n## Files after the fix\n\n### File: core/dbt/contracts/graph/unparsed.py\n\n```python\n 1 | import datetime\n 2 | import re\n 3 | \n 4 | from dbt import deprecations\n 5 | from dbt.artifacts.resources import ConstantPropertyInput\n 6 | from dbt_common.contracts.config.properties import (\n 7 | AdditionalPropertiesAllowed,\n 8 | AdditionalPropertiesMixin,\n 9 | )\n 10 | from dbt_common.contracts.util import Mergeable\n 11 | from dbt_common.exceptions import DbtInternalError, CompilationError\n 12 | from dbt_common.dataclass_schema import (\n 13 | dbtClassMixin,\n 14 | StrEnum,\n 15 | ExtensibleDbtClassMixin,\n 16 | ValidationError,\n 17 | )\n 18 | from dbt.node_types import NodeType\n 19 | from dbt.artifacts.resources import (\n 20 | Defaults,\n 21 | DimensionValidityParams,\n 22 | ExposureType,\n 23 | MaturityType,\n 24 | MeasureAggregationParameters,\n 25 | )\n 26 | from dbt.contracts.util import Replaceable\n 27 | \n 28 | # trigger the PathEncoder\n 29 | import dbt_common.helper_types # noqa:F401\n 30 | from dbt.exceptions import ParsingError\n 31 | \n 32 | from dbt_semantic_interfaces.type_enums import ConversionCalculationType\n 33 | from dbt.artifacts.resources import Docs, MacroArgument, NodeVersion, Owner\n 34 | \n 35 | from dataclasses import dataclass, field\n 36 | from datetime import timedelta\n 37 | from pathlib import Path\n 38 | from typing import Optional, List, Union, Dict, Any, Sequence, Literal\n 39 | \n 40 | \n 41 | @dataclass\n 42 | class UnparsedBaseNode(dbtClassMixin, Replaceable):\n 43 | package_name: str\n 44 | path: str\n 45 | original_file_path: str\n 46 | \n 47 | @property\n 48 | def file_id(self):\n 49 | return f\"{self.package_name}://{self.original_file_path}\"\n 50 | \n 51 | \n 52 | @dataclass\n 53 | class HasCode(dbtClassMixin):\n 54 | raw_code: str\n 55 | language: str\n 56 | \n 57 | @property\n 58 | def empty(self):\n 59 | return not self.raw_code.strip()\n 60 | \n 61 | \n 62 | @dataclass\n 63 | class UnparsedMacro(UnparsedBaseNode, HasCode):\n 64 | resource_type: Literal[NodeType.Macro]\n 65 | \n 66 | \n 67 | @dataclass\n 68 | class UnparsedGenericTest(UnparsedBaseNode, HasCode):\n 69 | resource_type: Literal[NodeType.Macro]\n 70 | \n 71 | \n 72 | @dataclass\n 73 | class UnparsedNode(UnparsedBaseNode, HasCode):\n 74 | name: str\n 75 | resource_type: NodeType\n 76 | \n 77 | @property\n 78 | def search_name(self):\n 79 | return self.name\n 80 | \n 81 | \n 82 | @dataclass\n 83 | class UnparsedRunHook(UnparsedNode):\n 84 | resource_type: Literal[NodeType.Operation]\n 85 | index: Optional[int] = None\n 86 | \n 87 | \n 88 | @dataclass\n 89 | class HasColumnProps(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 90 | name: str\n 91 | description: str = \"\"\n 92 | meta: Dict[str, Any] = field(default_factory=dict)\n 93 | data_type: Optional[str] = None\n 94 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n 95 | docs: Docs = field(default_factory=Docs)\n 96 | _extra: Dict[str, Any] = field(default_factory=dict)\n 97 | \n 98 | \n 99 | TestDef = Union[Dict[str, Any], str]\n100 | \n101 | \n102 | @dataclass\n103 | class HasColumnAndTestProps(HasColumnProps):\n104 | data_tests: List[TestDef] = field(default_factory=list)\n105 | tests: List[TestDef] = field(\n106 | default_factory=list\n107 | ) # back compat for previous name of 'data_tests'\n108 | \n109 | \n110 | @dataclass\n111 | class UnparsedColumn(HasColumnAndTestProps):\n112 | quote: Optional[bool] = None\n113 | tags: List[str] = field(default_factory=list)\n114 | \n115 | \n116 | @dataclass\n117 | class HasColumnDocs(dbtClassMixin, Replaceable):\n118 | columns: Sequence[HasColumnProps] = field(default_factory=list)\n119 | \n120 | \n121 | @dataclass\n122 | class HasColumnTests(dbtClassMixin, Replaceable):\n123 | columns: Sequence[UnparsedColumn] = field(default_factory=list)\n124 | \n125 | \n126 | @dataclass\n127 | class HasYamlMetadata(dbtClassMixin):\n128 | original_file_path: str\n129 | yaml_key: str\n130 | package_name: str\n131 | \n132 | @property\n133 | def file_id(self):\n134 | return f\"{self.package_name}://{self.original_file_path}\"\n135 | \n136 | \n137 | @dataclass\n138 | class HasConfig:\n139 | config: Dict[str, Any] = field(default_factory=dict)\n140 | \n141 | \n142 | @dataclass\n143 | class UnparsedVersion(dbtClassMixin):\n144 | v: NodeVersion\n145 | defined_in: Optional[str] = None\n146 | description: str = \"\"\n147 | access: Optional[str] = None\n148 | config: Dict[str, Any] = field(default_factory=dict)\n149 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n150 | docs: Docs = field(default_factory=Docs)\n151 | data_tests: Optional[List[TestDef]] = None\n152 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n153 | columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n154 | default_factory=list\n155 | )\n156 | deprecation_date: Optional[datetime.datetime] = None\n157 | \n158 | def __lt__(self, other):\n159 | try:\n160 | return float(self.v) < float(other.v)\n161 | except ValueError:\n162 | return str(self.v) < str(other.v)\n163 | \n164 | @property\n165 | def include_exclude(self) -> dbt_common.helper_types.IncludeExclude:\n166 | return self._include_exclude\n167 | \n168 | @property\n169 | def unparsed_columns(self) -> List:\n170 | return self._unparsed_columns\n171 | \n172 | @property\n173 | def formatted_v(self) -> str:\n174 | return f\"v{self.v}\"\n175 | \n176 | def __post_init__(self):\n177 | has_include_exclude = False\n178 | self._include_exclude = dbt_common.helper_types.IncludeExclude(include=\"*\")\n179 | self._unparsed_columns = []\n180 | for column in self.columns:\n181 | if isinstance(column, dbt_common.helper_types.IncludeExclude):\n182 | if not has_include_exclude:\n183 | self._include_exclude = column\n184 | has_include_exclude = True\n185 | else:\n186 | raise ParsingError(\"version can have at most one include/exclude element\")\n187 | else:\n188 | self._unparsed_columns.append(column)\n189 | \n190 | self.deprecation_date = normalize_date(self.deprecation_date)\n191 | \n192 | \n193 | @dataclass\n194 | class UnparsedAnalysisUpdate(HasConfig, HasColumnDocs, HasColumnProps, HasYamlMetadata):\n195 | access: Optional[str] = None\n196 | \n197 | \n198 | @dataclass\n199 | class UnparsedNodeUpdate(HasConfig, HasColumnTests, HasColumnAndTestProps, HasYamlMetadata):\n200 | quote_columns: Optional[bool] = None\n201 | access: Optional[str] = None\n202 | \n203 | \n204 | @dataclass\n205 | class UnparsedModelUpdate(UnparsedNodeUpdate):\n206 | quote_columns: Optional[bool] = None\n207 | access: Optional[str] = None\n208 | latest_version: Optional[NodeVersion] = None\n209 | versions: Sequence[UnparsedVersion] = field(default_factory=list)\n210 | deprecation_date: Optional[datetime.datetime] = None\n211 | \n212 | def __post_init__(self) -> None:\n213 | if self.latest_version:\n214 | version_values = [version.v for version in self.versions]\n215 | if self.latest_version not in version_values:\n216 | raise ParsingError(\n217 | f\"latest_version: {self.latest_version} is not one of model '{self.name}' versions: {version_values} \"\n218 | )\n219 | \n220 | seen_versions = set()\n221 | for version in self.versions:\n222 | if str(version.v) in seen_versions:\n223 | raise ParsingError(\n224 | f\"Found duplicate version: '{version.v}' in versions list of model '{self.name}'\"\n225 | )\n226 | seen_versions.add(str(version.v))\n227 | \n228 | self._version_map = {version.v: version for version in self.versions}\n229 | \n230 | self.deprecation_date = normalize_date(self.deprecation_date)\n231 | \n232 | def get_columns_for_version(self, version: NodeVersion) -> List[UnparsedColumn]:\n233 | if version not in self._version_map:\n234 | raise DbtInternalError(\n235 | f\"get_columns_for_version called for version '{version}' not in version map\"\n236 | )\n237 | \n238 | version_columns = []\n239 | unparsed_version = self._version_map[version]\n240 | for base_column in self.columns:\n241 | if unparsed_version.include_exclude.includes(base_column.name):\n242 | version_columns.append(base_column)\n243 | \n244 | for column in unparsed_version.unparsed_columns:\n245 | version_columns.append(column)\n246 | \n247 | return version_columns\n248 | \n249 | def get_tests_for_version(self, version: NodeVersion) -> List[TestDef]:\n250 | if version not in self._version_map:\n251 | raise DbtInternalError(\n252 | f\"get_tests_for_version called for version '{version}' not in version map\"\n253 | )\n254 | unparsed_version = self._version_map[version]\n255 | return (\n256 | unparsed_version.data_tests\n257 | if unparsed_version.data_tests is not None\n258 | else self.data_tests\n259 | )\n260 | \n261 | \n262 | @dataclass\n263 | class UnparsedMacroUpdate(HasConfig, HasColumnProps, HasYamlMetadata):\n264 | arguments: List[MacroArgument] = field(default_factory=list)\n265 | \n266 | \n267 | class TimePeriod(StrEnum):\n268 | minute = \"minute\"\n269 | hour = \"hour\"\n270 | day = \"day\"\n271 | \n272 | def plural(self) -> str:\n273 | return str(self) + \"s\"\n274 | \n275 | \n276 | @dataclass\n277 | class Time(dbtClassMixin, Mergeable):\n278 | count: Optional[int] = None\n279 | period: Optional[TimePeriod] = None\n280 | \n281 | def exceeded(self, actual_age: float) -> bool:\n282 | if self.period is None or self.count is None:\n283 | return False\n284 | kwargs: Dict[str, int] = {self.period.plural(): self.count}\n285 | difference = timedelta(**kwargs).total_seconds()\n286 | return actual_age > difference\n287 | \n288 | def __bool__(self):\n289 | return self.count is not None and self.period is not None\n290 | \n291 | \n292 | @dataclass\n293 | class FreshnessThreshold(dbtClassMixin, Mergeable):\n294 | warn_after: Optional[Time] = field(default_factory=Time)\n295 | error_after: Optional[Time] = field(default_factory=Time)\n296 | filter: Optional[str] = None\n297 | \n298 | def status(self, age: float) -> \"dbt.artifacts.schemas.results.FreshnessStatus\": # type: ignore # noqa F821\n299 | from dbt.artifacts.schemas.results import FreshnessStatus\n300 | \n301 | if self.error_after and self.error_after.exceeded(age):\n302 | return FreshnessStatus.Error\n303 | elif self.warn_after and self.warn_after.exceeded(age):\n304 | return FreshnessStatus.Warn\n305 | else:\n306 | return FreshnessStatus.Pass\n307 | \n308 | def __bool__(self):\n309 | return bool(self.warn_after) or bool(self.error_after)\n310 | \n311 | \n312 | @dataclass\n313 | class ExternalPartition(AdditionalPropertiesAllowed, Replaceable):\n314 | name: str = \"\"\n315 | description: str = \"\"\n316 | data_type: str = \"\"\n317 | meta: Dict[str, Any] = field(default_factory=dict)\n318 | \n319 | def __post_init__(self):\n320 | if self.name == \"\" or self.data_type == \"\":\n321 | raise CompilationError(\"External partition columns must have names and data types\")\n322 | \n323 | \n324 | @dataclass\n325 | class ExternalTable(AdditionalPropertiesAllowed, Mergeable):\n326 | location: Optional[str] = None\n327 | file_format: Optional[str] = None\n328 | row_format: Optional[str] = None\n329 | tbl_properties: Optional[str] = None\n330 | partitions: Optional[Union[List[str], List[ExternalPartition]]] = None\n331 | \n332 | def __bool__(self):\n333 | return self.location is not None\n334 | \n335 | \n336 | @dataclass\n337 | class Quoting(dbtClassMixin, Mergeable):\n338 | database: Optional[bool] = None\n339 | schema: Optional[bool] = None\n340 | identifier: Optional[bool] = None\n341 | column: Optional[bool] = None\n342 | \n343 | \n344 | @dataclass\n345 | class UnparsedSourceTableDefinition(HasColumnTests, HasColumnAndTestProps):\n346 | config: Dict[str, Any] = field(default_factory=dict)\n347 | loaded_at_field: Optional[str] = None\n348 | identifier: Optional[str] = None\n349 | quoting: Quoting = field(default_factory=Quoting)\n350 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n351 | external: Optional[ExternalTable] = None\n352 | tags: List[str] = field(default_factory=list)\n353 | \n354 | def __post_serialize__(self, dct):\n355 | dct = super().__post_serialize__(dct)\n356 | if \"freshness\" not in dct and self.freshness is None:\n357 | dct[\"freshness\"] = None\n358 | return dct\n359 | \n360 | \n361 | @dataclass\n362 | class UnparsedSourceDefinition(dbtClassMixin, Replaceable):\n363 | name: str\n364 | description: str = \"\"\n365 | meta: Dict[str, Any] = field(default_factory=dict)\n366 | database: Optional[str] = None\n367 | schema: Optional[str] = None\n368 | loader: str = \"\"\n369 | quoting: Quoting = field(default_factory=Quoting)\n370 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n371 | loaded_at_field: Optional[str] = None\n372 | tables: List[UnparsedSourceTableDefinition] = field(default_factory=list)\n373 | tags: List[str] = field(default_factory=list)\n374 | config: Dict[str, Any] = field(default_factory=dict)\n375 | \n376 | @property\n377 | def yaml_key(self) -> \"str\":\n378 | return \"sources\"\n379 | \n380 | def __post_serialize__(self, dct):\n381 | dct = super().__post_serialize__(dct)\n382 | if \"freshness\" not in dct and self.freshness is None:\n383 | dct[\"freshness\"] = None\n384 | return dct\n385 | \n386 | \n387 | @dataclass\n388 | class SourceTablePatch(dbtClassMixin):\n389 | name: str\n390 | description: Optional[str] = None\n391 | meta: Optional[Dict[str, Any]] = None\n392 | data_type: Optional[str] = None\n393 | docs: Optional[Docs] = None\n394 | loaded_at_field: Optional[str] = None\n395 | identifier: Optional[str] = None\n396 | quoting: Quoting = field(default_factory=Quoting)\n397 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n398 | external: Optional[ExternalTable] = None\n399 | tags: Optional[List[str]] = None\n400 | data_tests: Optional[List[TestDef]] = None\n401 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n402 | columns: Optional[Sequence[UnparsedColumn]] = None\n403 | \n404 | def to_patch_dict(self) -> Dict[str, Any]:\n405 | dct = self.to_dict(omit_none=True)\n406 | remove_keys = \"name\"\n407 | for key in remove_keys:\n408 | if key in dct:\n409 | del dct[key]\n410 | \n411 | if self.freshness is None:\n412 | dct[\"freshness\"] = None\n413 | \n414 | return dct\n415 | \n416 | \n417 | @dataclass\n418 | class SourcePatch(dbtClassMixin, Replaceable):\n419 | name: str = field(\n420 | metadata=dict(description=\"The name of the source to override\"),\n421 | )\n422 | overrides: str = field(\n423 | metadata=dict(description=\"The package of the source to override\"),\n424 | )\n425 | path: Path = field(\n426 | metadata=dict(description=\"The path to the patch-defining yml file\"),\n427 | )\n428 | config: Dict[str, Any] = field(default_factory=dict)\n429 | description: Optional[str] = None\n430 | meta: Optional[Dict[str, Any]] = None\n431 | database: Optional[str] = None\n432 | schema: Optional[str] = None\n433 | loader: Optional[str] = None\n434 | quoting: Optional[Quoting] = None\n435 | freshness: Optional[Optional[FreshnessThreshold]] = field(default_factory=FreshnessThreshold)\n436 | loaded_at_field: Optional[str] = None\n437 | tables: Optional[List[SourceTablePatch]] = None\n438 | tags: Optional[List[str]] = None\n439 | \n440 | def to_patch_dict(self) -> Dict[str, Any]:\n441 | dct = self.to_dict(omit_none=True)\n442 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n443 | for key in remove_keys:\n444 | if key in dct:\n445 | del dct[key]\n446 | \n447 | if self.freshness is None:\n448 | dct[\"freshness\"] = None\n449 | \n450 | return dct\n451 | \n452 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n453 | if self.tables is not None:\n454 | for table in self.tables:\n455 | if table.name == name:\n456 | return table\n457 | return None\n458 | \n459 | \n460 | @dataclass\n461 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n462 | package_name: str\n463 | path: str\n464 | original_file_path: str\n465 | \n466 | @property\n467 | def file_id(self):\n468 | return f\"{self.package_name}://{self.original_file_path}\"\n469 | \n470 | @property\n471 | def resource_type(self):\n472 | return NodeType.Documentation\n473 | \n474 | \n475 | @dataclass\n476 | class UnparsedDocumentationFile(UnparsedDocumentation):\n477 | file_contents: str\n478 | \n479 | \n480 | # can't use total_ordering decorator here, as str provides an ordering already\n481 | # and it's not the one we want.\n482 | class Maturity(StrEnum):\n483 | low = \"low\"\n484 | medium = \"medium\"\n485 | high = \"high\"\n486 | \n487 | def __lt__(self, other):\n488 | if not isinstance(other, Maturity):\n489 | return NotImplemented\n490 | order = (Maturity.low, Maturity.medium, Maturity.high)\n491 | return order.index(self) < order.index(other)\n492 | \n493 | def __gt__(self, other):\n494 | if not isinstance(other, Maturity):\n495 | return NotImplemented\n496 | return self != other and not (self < other)\n497 | \n498 | def __ge__(self, other):\n499 | if not isinstance(other, Maturity):\n500 | return NotImplemented\n501 | return self == other or not (self < other)\n502 | \n503 | def __le__(self, other):\n504 | if not isinstance(other, Maturity):\n505 | return NotImplemented\n506 | return self == other or self < other\n507 | \n508 | \n509 | @dataclass\n510 | class UnparsedExposure(dbtClassMixin, Replaceable):\n511 | name: str\n512 | type: ExposureType\n513 | owner: Owner\n514 | description: str = \"\"\n515 | label: Optional[str] = None\n516 | maturity: Optional[MaturityType] = None\n517 | meta: Dict[str, Any] = field(default_factory=dict)\n518 | tags: List[str] = field(default_factory=list)\n519 | url: Optional[str] = None\n520 | depends_on: List[str] = field(default_factory=list)\n521 | config: Dict[str, Any] = field(default_factory=dict)\n522 | \n523 | @classmethod\n524 | def validate(cls, data):\n525 | super(UnparsedExposure, cls).validate(data)\n526 | if \"name\" in data:\n527 | # name can only contain alphanumeric chars and underscores\n528 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n529 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n530 | \n531 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n532 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n533 | \n534 | \n535 | @dataclass\n536 | class MetricFilter(dbtClassMixin, Replaceable):\n537 | field: str\n538 | operator: str\n539 | # TODO : Can we make this Any?\n540 | value: str\n541 | \n542 | \n543 | class MetricTimePeriod(StrEnum):\n544 | day = \"day\"\n545 | week = \"week\"\n546 | month = \"month\"\n547 | year = \"year\"\n548 | \n549 | def plural(self) -> str:\n550 | return str(self) + \"s\"\n551 | \n552 | \n553 | @dataclass\n554 | class MetricTime(dbtClassMixin, Mergeable):\n555 | count: Optional[int] = None\n556 | period: Optional[MetricTimePeriod] = None\n557 | \n558 | def __bool__(self):\n559 | return self.count is not None and self.period is not None\n560 | \n561 | \n562 | @dataclass\n563 | class UnparsedMetricInputMeasure(dbtClassMixin):\n564 | name: str\n565 | # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n566 | filter: Union[str, List[str], None] = None\n567 | alias: Optional[str] = None\n568 | join_to_timespine: bool = False\n569 | fill_nulls_with: Optional[int] = None\n570 | \n571 | \n572 | @dataclass\n573 | class UnparsedMetricInput(dbtClassMixin):\n574 | name: str\n575 | # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n576 | filter: Union[str, List[str], None] = None\n577 | alias: Optional[str] = None\n578 | offset_window: Optional[str] = None\n579 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n580 | \n581 | \n582 | @dataclass\n583 | class UnparsedConversionTypeParams(dbtClassMixin):\n584 | base_measure: Union[UnparsedMetricInputMeasure, str]\n585 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n586 | entity: str\n587 | calculation: str = (\n588 | ConversionCalculationType.CONVERSION_RATE.value\n589 | ) # ConversionCalculationType Enum\n590 | window: Optional[str] = None\n591 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n592 | \n593 | \n594 | @dataclass\n595 | class UnparsedMetricTypeParams(dbtClassMixin):\n596 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n597 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n598 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n599 | expr: Optional[Union[str, bool]] = None\n600 | window: Optional[str] = None\n601 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n602 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n603 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n604 | \n605 | \n606 | @dataclass\n607 | class UnparsedMetric(dbtClassMixin):\n608 | name: str\n609 | label: str\n610 | type: str\n611 | type_params: UnparsedMetricTypeParams\n612 | description: str = \"\"\n613 | # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n614 | filter: Union[str, List[str], None] = None\n615 | # metadata: Optional[Unparsedetadata] = None # TODO\n616 | meta: Dict[str, Any] = field(default_factory=dict)\n617 | tags: List[str] = field(default_factory=list)\n618 | config: Dict[str, Any] = field(default_factory=dict)\n619 | \n620 | @classmethod\n621 | def validate(cls, data):\n622 | super(UnparsedMetric, cls).validate(data)\n623 | if \"name\" in data:\n624 | errors = []\n625 | if \" \" in data[\"name\"]:\n626 | errors.append(\"cannot contain spaces\")\n627 | # This handles failing queries due to too long metric names.\n628 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n629 | if len(data[\"name\"]) > 250:\n630 | errors.append(\"cannot contain more than 250 characters\")\n631 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n632 | errors.append(\"must begin with a letter\")\n633 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n634 | errors.append(\"must contain only letters, numbers and underscores\")\n635 | \n636 | if errors:\n637 | raise ParsingError(\n638 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n639 | )\n640 | \n641 | \n642 | @dataclass\n643 | class UnparsedGroup(dbtClassMixin, Replaceable):\n644 | name: str\n645 | owner: Owner\n646 | \n647 | @classmethod\n648 | def validate(cls, data):\n649 | super(UnparsedGroup, cls).validate(data)\n650 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n651 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n652 | \n653 | \n654 | #\n655 | # semantic interfaces unparsed objects\n656 | #\n657 | \n658 | \n659 | @dataclass\n660 | class UnparsedEntity(dbtClassMixin):\n661 | name: str\n662 | type: str # EntityType enum\n663 | description: Optional[str] = None\n664 | label: Optional[str] = None\n665 | role: Optional[str] = None\n666 | expr: Optional[str] = None\n667 | \n668 | \n669 | @dataclass\n670 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n671 | name: str\n672 | window_choice: str # AggregationType enum\n673 | window_groupings: List[str] = field(default_factory=list)\n674 | \n675 | \n676 | @dataclass\n677 | class UnparsedMeasure(dbtClassMixin):\n678 | name: str\n679 | agg: str # actually an enum\n680 | description: Optional[str] = None\n681 | label: Optional[str] = None\n682 | expr: Optional[Union[str, bool, int]] = None\n683 | agg_params: Optional[MeasureAggregationParameters] = None\n684 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n685 | agg_time_dimension: Optional[str] = None\n686 | create_metric: bool = False\n687 | \n688 | \n689 | @dataclass\n690 | class UnparsedDimensionTypeParams(dbtClassMixin):\n691 | time_granularity: str # TimeGranularity enum\n692 | validity_params: Optional[DimensionValidityParams] = None\n693 | \n694 | \n695 | @dataclass\n696 | class UnparsedDimension(dbtClassMixin):\n697 | name: str\n698 | type: str # actually an enum\n699 | description: Optional[str] = None\n700 | label: Optional[str] = None\n701 | is_partition: bool = False\n702 | type_params: Optional[UnparsedDimensionTypeParams] = None\n703 | expr: Optional[str] = None\n704 | \n705 | \n706 | @dataclass\n707 | class UnparsedSemanticModel(dbtClassMixin):\n708 | name: str\n709 | model: str # looks like \"ref(...)\"\n710 | config: Dict[str, Any] = field(default_factory=dict)\n711 | description: Optional[str] = None\n712 | label: Optional[str] = None\n713 | defaults: Optional[Defaults] = None\n714 | entities: List[UnparsedEntity] = field(default_factory=list)\n715 | measures: List[UnparsedMeasure] = field(default_factory=list)\n716 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n717 | primary_entity: Optional[str] = None\n718 | \n719 | \n720 | @dataclass\n721 | class UnparsedQueryParams(dbtClassMixin):\n722 | metrics: List[str] = field(default_factory=list)\n723 | group_by: List[str] = field(default_factory=list)\n724 | # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n725 | where: Union[str, List[str], None] = None\n726 | \n727 | \n728 | @dataclass\n729 | class UnparsedExport(dbtClassMixin):\n730 | \"\"\"Configuration for writing query results to a table.\"\"\"\n731 | \n732 | name: str\n733 | config: Dict[str, Any] = field(default_factory=dict)\n734 | \n735 | \n736 | @dataclass\n737 | class UnparsedSavedQuery(dbtClassMixin):\n738 | name: str\n739 | query_params: UnparsedQueryParams\n740 | description: Optional[str] = None\n741 | label: Optional[str] = None\n742 | exports: List[UnparsedExport] = field(default_factory=list)\n743 | config: Dict[str, Any] = field(default_factory=dict)\n744 | \n745 | \n746 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n747 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n748 | if d is None:\n749 | return None\n750 | \n751 | # convert date to datetime\n752 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n753 | \n754 | if not dt.tzinfo:\n755 | # date is naive, re-interpret as system time zone\n756 | dt = dt.astimezone()\n757 | \n758 | return dt\n759 | \n760 | \n761 | class UnitTestFormat(StrEnum):\n762 | CSV = \"csv\"\n763 | Dict = \"dict\"\n764 | \n765 | \n766 | @dataclass\n767 | class UnitTestInputFixture(dbtClassMixin):\n768 | input: str\n769 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n770 | format: UnitTestFormat = UnitTestFormat.Dict\n771 | fixture: Optional[str] = None\n772 | \n773 | \n774 | @dataclass\n775 | class UnitTestOutputFixture(dbtClassMixin):\n776 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n777 | format: UnitTestFormat = UnitTestFormat.Dict\n778 | fixture: Optional[str] = None\n779 | \n780 | \n781 | @dataclass\n782 | class UnitTestOverrides(dbtClassMixin):\n783 | macros: Dict[str, Any] = field(default_factory=dict)\n784 | vars: Dict[str, Any] = field(default_factory=dict)\n785 | env_vars: Dict[str, Any] = field(default_factory=dict)\n786 | \n787 | \n788 | @dataclass\n789 | class UnitTestNodeVersions(dbtClassMixin):\n790 | include: Optional[List[NodeVersion]] = None\n791 | exclude: Optional[List[NodeVersion]] = None\n792 | \n793 | \n794 | @dataclass\n795 | class UnparsedUnitTest(dbtClassMixin):\n796 | name: str\n797 | model: str # name of the model being unit tested\n798 | given: Sequence[UnitTestInputFixture]\n799 | expect: UnitTestOutputFixture\n800 | description: str = \"\"\n801 | overrides: Optional[UnitTestOverrides] = None\n802 | config: Dict[str, Any] = field(default_factory=dict)\n803 | versions: Optional[UnitTestNodeVersions] = None\n804 | \n805 | @classmethod\n806 | def validate(cls, data):\n807 | super(UnparsedUnitTest, cls).validate(data)\n808 | if data.get(\"versions\", None):\n809 | if data[\"versions\"].get(\"include\") and data[\"versions\"].get(\"exclude\"):\n810 | raise ValidationError(\"Unit tests can not both include and exclude versions.\")\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/unparsed.py\n+++ b/core/dbt/contracts/graph/unparsed.py\n@@ -562,7 +562,8 @@ class MetricTime(dbtClassMixin, Mergeable):\n @dataclass\n class UnparsedMetricInputMeasure(dbtClassMixin):\n name: str\n- filter: Optional[Union[str, List[str]]] = None\n+ # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n+ filter: Union[str, List[str], None] = None\n alias: Optional[str] = None\n join_to_timespine: bool = False\n fill_nulls_with: Optional[int] = None\n@@ -571,7 +572,8 @@ class UnparsedMetricInputMeasure(dbtClassMixin):\n @dataclass\n class UnparsedMetricInput(dbtClassMixin):\n name: str\n- filter: Optional[Union[str, List[str]]] = None\n+ # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n+ filter: Union[str, List[str], None] = None\n alias: Optional[str] = None\n offset_window: Optional[str] = None\n offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n@@ -608,7 +610,8 @@ class UnparsedMetric(dbtClassMixin):\n type: str\n type_params: UnparsedMetricTypeParams\n description: str = \"\"\n- filter: Optional[Union[str, List[str]]] = None\n+ # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n+ filter: Union[str, List[str], None] = None\n # metadata: Optional[Unparsedetadata] = None # TODO\n meta: Dict[str, Any] = field(default_factory=dict)\n tags: List[str] = field(default_factory=list)\n@@ -718,7 +721,8 @@ class UnparsedSemanticModel(dbtClassMixin):\n class UnparsedQueryParams(dbtClassMixin):\n metrics: List[str] = field(default_factory=list)\n group_by: List[str] = field(default_factory=list)\n- where: Optional[Union[str, List[str]]] = None\n+ # Note: `Union` must be the outermost part of the type annotation for serialization to work properly.\n+ where: Union[str, List[str], None] = None\n \n \n @dataclass"},"prompt_input_token_count":{"kind":"number","value":19615,"string":"19,615"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9508\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"2411f93240a346961e6a965ad9cb5c766db275a0\",\n \"pull_number\": 9508,\n \"issue_numbers\": [\n \"9507\"\n ],\n \"changed_files\": [\n \"core/dbt/contracts/graph/unparsed.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}},{"rowIdx":32298,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9509"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: db65e627cab89fb5ef6f1f8793aa2a261106a3ca\nChanged files:\n- core/dbt/contracts/graph/unparsed.py\n- core/dbt/contracts/project.py\n- core/dbt/contracts/util.py\n\n## Problem statement\n\nMigrate to using `Mergeable` from `dbt-common\n### Housekeeping\n\n- [X] I am a maintainer of dbt-core\n\n### Short description\n\nWe're currently in the process of moving the \"data resource\" portion on nodes to `dbt/artifacts`. Some of those artifacts depend on `Mergeable` which has been defined on core. In order to move the data resources to `dbt/artifacts`, we thus need to move `Mergeable` upstream of core. We moved `Mergeable` to [dbt-common](https://github.com/dbt-labs/dbt-common) in https://github.com/dbt-labs/dbt-common/pull/59, and released this change in [dbt-common 0.1.3](https://pypi.org/project/dbt-common/0.1.3/). As such as, in order to unblock some of the `dbt/artifacts` migration work, we first need to update references to `Mergeable` in core to use the `dbt-common` definition.\n\n### Acceptance criteria\n\nAll uses of `Mergeable` in core use the definition in `dbt-common`\n\n### Suggested Tests\n\nNone\n\n### Impact to Other Teams\n\nNone\n\n### Will backports be required?\n\nNo\n\n### Context\n\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/contracts/graph/unparsed.py\n\n```python\n 1 | import datetime\n 2 | import re\n 3 | \n 4 | from dbt import deprecations\n 5 | from dbt.artifacts.resources import ConstantPropertyInput\n 6 | from dbt_common.contracts.config.properties import (\n 7 | AdditionalPropertiesAllowed,\n 8 | AdditionalPropertiesMixin,\n 9 | )\n 10 | from dbt_common.exceptions import DbtInternalError, CompilationError\n 11 | from dbt_common.dataclass_schema import (\n 12 | dbtClassMixin,\n 13 | StrEnum,\n 14 | ExtensibleDbtClassMixin,\n 15 | ValidationError,\n 16 | )\n 17 | from dbt.node_types import NodeType\n 18 | from dbt.artifacts.resources import (\n 19 | Defaults,\n 20 | DimensionValidityParams,\n 21 | ExposureType,\n 22 | MaturityType,\n 23 | MeasureAggregationParameters,\n 24 | )\n 25 | from dbt.contracts.util import (\n 26 | Mergeable,\n 27 | Replaceable,\n 28 | )\n 29 | \n 30 | # trigger the PathEncoder\n 31 | import dbt_common.helper_types # noqa:F401\n 32 | from dbt.exceptions import ParsingError\n 33 | \n 34 | from dbt_semantic_interfaces.type_enums import ConversionCalculationType\n 35 | from dbt.artifacts.resources import Docs, MacroArgument, NodeVersion, Owner\n 36 | \n 37 | from dataclasses import dataclass, field\n 38 | from datetime import timedelta\n 39 | from pathlib import Path\n 40 | from typing import Optional, List, Union, Dict, Any, Sequence, Literal\n 41 | \n 42 | \n 43 | @dataclass\n 44 | class UnparsedBaseNode(dbtClassMixin, Replaceable):\n 45 | package_name: str\n 46 | path: str\n 47 | original_file_path: str\n 48 | \n 49 | @property\n 50 | def file_id(self):\n 51 | return f\"{self.package_name}://{self.original_file_path}\"\n 52 | \n 53 | \n 54 | @dataclass\n 55 | class HasCode(dbtClassMixin):\n 56 | raw_code: str\n 57 | language: str\n 58 | \n 59 | @property\n 60 | def empty(self):\n 61 | return not self.raw_code.strip()\n 62 | \n 63 | \n 64 | @dataclass\n 65 | class UnparsedMacro(UnparsedBaseNode, HasCode):\n 66 | resource_type: Literal[NodeType.Macro]\n 67 | \n 68 | \n 69 | @dataclass\n 70 | class UnparsedGenericTest(UnparsedBaseNode, HasCode):\n 71 | resource_type: Literal[NodeType.Macro]\n 72 | \n 73 | \n 74 | @dataclass\n 75 | class UnparsedNode(UnparsedBaseNode, HasCode):\n 76 | name: str\n 77 | resource_type: NodeType\n 78 | \n 79 | @property\n 80 | def search_name(self):\n 81 | return self.name\n 82 | \n 83 | \n 84 | @dataclass\n 85 | class UnparsedRunHook(UnparsedNode):\n 86 | resource_type: Literal[NodeType.Operation]\n 87 | index: Optional[int] = None\n 88 | \n 89 | \n 90 | @dataclass\n 91 | class HasColumnProps(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 92 | name: str\n 93 | description: str = \"\"\n 94 | meta: Dict[str, Any] = field(default_factory=dict)\n 95 | data_type: Optional[str] = None\n 96 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n 97 | docs: Docs = field(default_factory=Docs)\n 98 | _extra: Dict[str, Any] = field(default_factory=dict)\n 99 | \n100 | \n101 | TestDef = Union[Dict[str, Any], str]\n102 | \n103 | \n104 | @dataclass\n105 | class HasColumnAndTestProps(HasColumnProps):\n106 | data_tests: List[TestDef] = field(default_factory=list)\n107 | tests: List[TestDef] = field(\n108 | default_factory=list\n109 | ) # back compat for previous name of 'data_tests'\n110 | \n111 | \n112 | @dataclass\n113 | class UnparsedColumn(HasColumnAndTestProps):\n114 | quote: Optional[bool] = None\n115 | tags: List[str] = field(default_factory=list)\n116 | \n117 | \n118 | @dataclass\n119 | class HasColumnDocs(dbtClassMixin, Replaceable):\n120 | columns: Sequence[HasColumnProps] = field(default_factory=list)\n121 | \n122 | \n123 | @dataclass\n124 | class HasColumnTests(dbtClassMixin, Replaceable):\n125 | columns: Sequence[UnparsedColumn] = field(default_factory=list)\n126 | \n127 | \n128 | @dataclass\n129 | class HasYamlMetadata(dbtClassMixin):\n130 | original_file_path: str\n131 | yaml_key: str\n132 | package_name: str\n133 | \n134 | @property\n135 | def file_id(self):\n136 | return f\"{self.package_name}://{self.original_file_path}\"\n137 | \n138 | \n139 | @dataclass\n140 | class HasConfig:\n141 | config: Dict[str, Any] = field(default_factory=dict)\n142 | \n143 | \n144 | @dataclass\n145 | class UnparsedVersion(dbtClassMixin):\n146 | v: NodeVersion\n147 | defined_in: Optional[str] = None\n148 | description: str = \"\"\n149 | access: Optional[str] = None\n150 | config: Dict[str, Any] = field(default_factory=dict)\n151 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n152 | docs: Docs = field(default_factory=Docs)\n153 | data_tests: Optional[List[TestDef]] = None\n154 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n155 | columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n156 | default_factory=list\n157 | )\n158 | deprecation_date: Optional[datetime.datetime] = None\n159 | \n160 | def __lt__(self, other):\n161 | try:\n162 | return float(self.v) < float(other.v)\n163 | except ValueError:\n164 | return str(self.v) < str(other.v)\n165 | \n166 | @property\n167 | def include_exclude(self) -> dbt_common.helper_types.IncludeExclude:\n168 | return self._include_exclude\n169 | \n170 | @property\n171 | def unparsed_columns(self) -> List:\n172 | return self._unparsed_columns\n173 | \n174 | @property\n175 | def formatted_v(self) -> str:\n176 | return f\"v{self.v}\"\n177 | \n178 | def __post_init__(self):\n179 | has_include_exclude = False\n180 | self._include_exclude = dbt_common.helper_types.IncludeExclude(include=\"*\")\n181 | self._unparsed_columns = []\n182 | for column in self.columns:\n183 | if isinstance(column, dbt_common.helper_types.IncludeExclude):\n184 | if not has_include_exclude:\n185 | self._include_exclude = column\n186 | has_include_exclude = True\n187 | else:\n188 | raise ParsingError(\"version can have at most one include/exclude element\")\n189 | else:\n190 | self._unparsed_columns.append(column)\n191 | \n192 | self.deprecation_date = normalize_date(self.deprecation_date)\n193 | \n194 | \n195 | @dataclass\n196 | class UnparsedAnalysisUpdate(HasConfig, HasColumnDocs, HasColumnProps, HasYamlMetadata):\n197 | access: Optional[str] = None\n198 | \n199 | \n200 | @dataclass\n201 | class UnparsedNodeUpdate(HasConfig, HasColumnTests, HasColumnAndTestProps, HasYamlMetadata):\n202 | quote_columns: Optional[bool] = None\n203 | access: Optional[str] = None\n204 | \n205 | \n206 | @dataclass\n207 | class UnparsedModelUpdate(UnparsedNodeUpdate):\n208 | quote_columns: Optional[bool] = None\n209 | access: Optional[str] = None\n210 | latest_version: Optional[NodeVersion] = None\n211 | versions: Sequence[UnparsedVersion] = field(default_factory=list)\n212 | deprecation_date: Optional[datetime.datetime] = None\n213 | \n214 | def __post_init__(self) -> None:\n215 | if self.latest_version:\n216 | version_values = [version.v for version in self.versions]\n217 | if self.latest_version not in version_values:\n218 | raise ParsingError(\n219 | f\"latest_version: {self.latest_version} is not one of model '{self.name}' versions: {version_values} \"\n220 | )\n221 | \n222 | seen_versions = set()\n223 | for version in self.versions:\n224 | if str(version.v) in seen_versions:\n225 | raise ParsingError(\n226 | f\"Found duplicate version: '{version.v}' in versions list of model '{self.name}'\"\n227 | )\n228 | seen_versions.add(str(version.v))\n229 | \n230 | self._version_map = {version.v: version for version in self.versions}\n231 | \n232 | self.deprecation_date = normalize_date(self.deprecation_date)\n233 | \n234 | def get_columns_for_version(self, version: NodeVersion) -> List[UnparsedColumn]:\n235 | if version not in self._version_map:\n236 | raise DbtInternalError(\n237 | f\"get_columns_for_version called for version '{version}' not in version map\"\n238 | )\n239 | \n240 | version_columns = []\n241 | unparsed_version = self._version_map[version]\n242 | for base_column in self.columns:\n243 | if unparsed_version.include_exclude.includes(base_column.name):\n244 | version_columns.append(base_column)\n245 | \n246 | for column in unparsed_version.unparsed_columns:\n247 | version_columns.append(column)\n248 | \n249 | return version_columns\n250 | \n251 | def get_tests_for_version(self, version: NodeVersion) -> List[TestDef]:\n252 | if version not in self._version_map:\n253 | raise DbtInternalError(\n254 | f\"get_tests_for_version called for version '{version}' not in version map\"\n255 | )\n256 | unparsed_version = self._version_map[version]\n257 | return (\n258 | unparsed_version.data_tests\n259 | if unparsed_version.data_tests is not None\n260 | else self.data_tests\n261 | )\n262 | \n263 | \n264 | @dataclass\n265 | class UnparsedMacroUpdate(HasConfig, HasColumnProps, HasYamlMetadata):\n266 | arguments: List[MacroArgument] = field(default_factory=list)\n267 | \n268 | \n269 | class TimePeriod(StrEnum):\n270 | minute = \"minute\"\n271 | hour = \"hour\"\n272 | day = \"day\"\n273 | \n274 | def plural(self) -> str:\n275 | return str(self) + \"s\"\n276 | \n277 | \n278 | @dataclass\n279 | class Time(dbtClassMixin, Mergeable):\n280 | count: Optional[int] = None\n281 | period: Optional[TimePeriod] = None\n282 | \n283 | def exceeded(self, actual_age: float) -> bool:\n284 | if self.period is None or self.count is None:\n285 | return False\n286 | kwargs: Dict[str, int] = {self.period.plural(): self.count}\n287 | difference = timedelta(**kwargs).total_seconds()\n288 | return actual_age > difference\n289 | \n290 | def __bool__(self):\n291 | return self.count is not None and self.period is not None\n292 | \n293 | \n294 | @dataclass\n295 | class FreshnessThreshold(dbtClassMixin, Mergeable):\n296 | warn_after: Optional[Time] = field(default_factory=Time)\n297 | error_after: Optional[Time] = field(default_factory=Time)\n298 | filter: Optional[str] = None\n299 | \n300 | def status(self, age: float) -> \"dbt.artifacts.schemas.results.FreshnessStatus\": # type: ignore # noqa F821\n301 | from dbt.artifacts.schemas.results import FreshnessStatus\n302 | \n303 | if self.error_after and self.error_after.exceeded(age):\n304 | return FreshnessStatus.Error\n305 | elif self.warn_after and self.warn_after.exceeded(age):\n306 | return FreshnessStatus.Warn\n307 | else:\n308 | return FreshnessStatus.Pass\n309 | \n310 | def __bool__(self):\n311 | return bool(self.warn_after) or bool(self.error_after)\n312 | \n313 | \n314 | @dataclass\n315 | class ExternalPartition(AdditionalPropertiesAllowed, Replaceable):\n316 | name: str = \"\"\n317 | description: str = \"\"\n318 | data_type: str = \"\"\n319 | meta: Dict[str, Any] = field(default_factory=dict)\n320 | \n321 | def __post_init__(self):\n322 | if self.name == \"\" or self.data_type == \"\":\n323 | raise CompilationError(\"External partition columns must have names and data types\")\n324 | \n325 | \n326 | @dataclass\n327 | class ExternalTable(AdditionalPropertiesAllowed, Mergeable):\n328 | location: Optional[str] = None\n329 | file_format: Optional[str] = None\n330 | row_format: Optional[str] = None\n331 | tbl_properties: Optional[str] = None\n332 | partitions: Optional[Union[List[str], List[ExternalPartition]]] = None\n333 | \n334 | def __bool__(self):\n335 | return self.location is not None\n336 | \n337 | \n338 | @dataclass\n339 | class Quoting(dbtClassMixin, Mergeable):\n340 | database: Optional[bool] = None\n341 | schema: Optional[bool] = None\n342 | identifier: Optional[bool] = None\n343 | column: Optional[bool] = None\n344 | \n345 | \n346 | @dataclass\n347 | class UnparsedSourceTableDefinition(HasColumnTests, HasColumnAndTestProps):\n348 | config: Dict[str, Any] = field(default_factory=dict)\n349 | loaded_at_field: Optional[str] = None\n350 | identifier: Optional[str] = None\n351 | quoting: Quoting = field(default_factory=Quoting)\n352 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n353 | external: Optional[ExternalTable] = None\n354 | tags: List[str] = field(default_factory=list)\n355 | \n356 | def __post_serialize__(self, dct):\n357 | dct = super().__post_serialize__(dct)\n358 | if \"freshness\" not in dct and self.freshness is None:\n359 | dct[\"freshness\"] = None\n360 | return dct\n361 | \n362 | \n363 | @dataclass\n364 | class UnparsedSourceDefinition(dbtClassMixin, Replaceable):\n365 | name: str\n366 | description: str = \"\"\n367 | meta: Dict[str, Any] = field(default_factory=dict)\n368 | database: Optional[str] = None\n369 | schema: Optional[str] = None\n370 | loader: str = \"\"\n371 | quoting: Quoting = field(default_factory=Quoting)\n372 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n373 | loaded_at_field: Optional[str] = None\n374 | tables: List[UnparsedSourceTableDefinition] = field(default_factory=list)\n375 | tags: List[str] = field(default_factory=list)\n376 | config: Dict[str, Any] = field(default_factory=dict)\n377 | \n378 | @property\n379 | def yaml_key(self) -> \"str\":\n380 | return \"sources\"\n381 | \n382 | def __post_serialize__(self, dct):\n383 | dct = super().__post_serialize__(dct)\n384 | if \"freshness\" not in dct and self.freshness is None:\n385 | dct[\"freshness\"] = None\n386 | return dct\n387 | \n388 | \n389 | @dataclass\n390 | class SourceTablePatch(dbtClassMixin):\n391 | name: str\n392 | description: Optional[str] = None\n393 | meta: Optional[Dict[str, Any]] = None\n394 | data_type: Optional[str] = None\n395 | docs: Optional[Docs] = None\n396 | loaded_at_field: Optional[str] = None\n397 | identifier: Optional[str] = None\n398 | quoting: Quoting = field(default_factory=Quoting)\n399 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n400 | external: Optional[ExternalTable] = None\n401 | tags: Optional[List[str]] = None\n402 | data_tests: Optional[List[TestDef]] = None\n403 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n404 | columns: Optional[Sequence[UnparsedColumn]] = None\n405 | \n406 | def to_patch_dict(self) -> Dict[str, Any]:\n407 | dct = self.to_dict(omit_none=True)\n408 | remove_keys = \"name\"\n409 | for key in remove_keys:\n410 | if key in dct:\n411 | del dct[key]\n412 | \n413 | if self.freshness is None:\n414 | dct[\"freshness\"] = None\n415 | \n416 | return dct\n417 | \n418 | \n419 | @dataclass\n420 | class SourcePatch(dbtClassMixin, Replaceable):\n421 | name: str = field(\n422 | metadata=dict(description=\"The name of the source to override\"),\n423 | )\n424 | overrides: str = field(\n425 | metadata=dict(description=\"The package of the source to override\"),\n426 | )\n427 | path: Path = field(\n428 | metadata=dict(description=\"The path to the patch-defining yml file\"),\n429 | )\n430 | config: Dict[str, Any] = field(default_factory=dict)\n431 | description: Optional[str] = None\n432 | meta: Optional[Dict[str, Any]] = None\n433 | database: Optional[str] = None\n434 | schema: Optional[str] = None\n435 | loader: Optional[str] = None\n436 | quoting: Optional[Quoting] = None\n437 | freshness: Optional[Optional[FreshnessThreshold]] = field(default_factory=FreshnessThreshold)\n438 | loaded_at_field: Optional[str] = None\n439 | tables: Optional[List[SourceTablePatch]] = None\n440 | tags: Optional[List[str]] = None\n441 | \n442 | def to_patch_dict(self) -> Dict[str, Any]:\n443 | dct = self.to_dict(omit_none=True)\n444 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n445 | for key in remove_keys:\n446 | if key in dct:\n447 | del dct[key]\n448 | \n449 | if self.freshness is None:\n450 | dct[\"freshness\"] = None\n451 | \n452 | return dct\n453 | \n454 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n455 | if self.tables is not None:\n456 | for table in self.tables:\n457 | if table.name == name:\n458 | return table\n459 | return None\n460 | \n461 | \n462 | @dataclass\n463 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n464 | package_name: str\n465 | path: str\n466 | original_file_path: str\n467 | \n468 | @property\n469 | def file_id(self):\n470 | return f\"{self.package_name}://{self.original_file_path}\"\n471 | \n472 | @property\n473 | def resource_type(self):\n474 | return NodeType.Documentation\n475 | \n476 | \n477 | @dataclass\n478 | class UnparsedDocumentationFile(UnparsedDocumentation):\n479 | file_contents: str\n480 | \n481 | \n482 | # can't use total_ordering decorator here, as str provides an ordering already\n483 | # and it's not the one we want.\n484 | class Maturity(StrEnum):\n485 | low = \"low\"\n486 | medium = \"medium\"\n487 | high = \"high\"\n488 | \n489 | def __lt__(self, other):\n490 | if not isinstance(other, Maturity):\n491 | return NotImplemented\n492 | order = (Maturity.low, Maturity.medium, Maturity.high)\n493 | return order.index(self) < order.index(other)\n494 | \n495 | def __gt__(self, other):\n496 | if not isinstance(other, Maturity):\n497 | return NotImplemented\n498 | return self != other and not (self < other)\n499 | \n500 | def __ge__(self, other):\n501 | if not isinstance(other, Maturity):\n502 | return NotImplemented\n503 | return self == other or not (self < other)\n504 | \n505 | def __le__(self, other):\n506 | if not isinstance(other, Maturity):\n507 | return NotImplemented\n508 | return self == other or self < other\n509 | \n510 | \n511 | @dataclass\n512 | class UnparsedExposure(dbtClassMixin, Replaceable):\n513 | name: str\n514 | type: ExposureType\n515 | owner: Owner\n516 | description: str = \"\"\n517 | label: Optional[str] = None\n518 | maturity: Optional[MaturityType] = None\n519 | meta: Dict[str, Any] = field(default_factory=dict)\n520 | tags: List[str] = field(default_factory=list)\n521 | url: Optional[str] = None\n522 | depends_on: List[str] = field(default_factory=list)\n523 | config: Dict[str, Any] = field(default_factory=dict)\n524 | \n525 | @classmethod\n526 | def validate(cls, data):\n527 | super(UnparsedExposure, cls).validate(data)\n528 | if \"name\" in data:\n529 | # name can only contain alphanumeric chars and underscores\n530 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n531 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n532 | \n533 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n534 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n535 | \n536 | \n537 | @dataclass\n538 | class MetricFilter(dbtClassMixin, Replaceable):\n539 | field: str\n540 | operator: str\n541 | # TODO : Can we make this Any?\n542 | value: str\n543 | \n544 | \n545 | class MetricTimePeriod(StrEnum):\n546 | day = \"day\"\n547 | week = \"week\"\n548 | month = \"month\"\n549 | year = \"year\"\n550 | \n551 | def plural(self) -> str:\n552 | return str(self) + \"s\"\n553 | \n554 | \n555 | @dataclass\n556 | class MetricTime(dbtClassMixin, Mergeable):\n557 | count: Optional[int] = None\n558 | period: Optional[MetricTimePeriod] = None\n559 | \n560 | def __bool__(self):\n561 | return self.count is not None and self.period is not None\n562 | \n563 | \n564 | @dataclass\n565 | class UnparsedMetricInputMeasure(dbtClassMixin):\n566 | name: str\n567 | filter: Optional[Union[str, List[str]]] = None\n568 | alias: Optional[str] = None\n569 | join_to_timespine: bool = False\n570 | fill_nulls_with: Optional[int] = None\n571 | \n572 | \n573 | @dataclass\n574 | class UnparsedMetricInput(dbtClassMixin):\n575 | name: str\n576 | filter: Optional[Union[str, List[str]]] = None\n577 | alias: Optional[str] = None\n578 | offset_window: Optional[str] = None\n579 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n580 | \n581 | \n582 | @dataclass\n583 | class UnparsedConversionTypeParams(dbtClassMixin):\n584 | base_measure: Union[UnparsedMetricInputMeasure, str]\n585 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n586 | entity: str\n587 | calculation: str = (\n588 | ConversionCalculationType.CONVERSION_RATE.value\n589 | ) # ConversionCalculationType Enum\n590 | window: Optional[str] = None\n591 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n592 | \n593 | \n594 | @dataclass\n595 | class UnparsedMetricTypeParams(dbtClassMixin):\n596 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n597 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n598 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n599 | expr: Optional[Union[str, bool]] = None\n600 | window: Optional[str] = None\n601 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n602 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n603 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n604 | \n605 | \n606 | @dataclass\n607 | class UnparsedMetric(dbtClassMixin):\n608 | name: str\n609 | label: str\n610 | type: str\n611 | type_params: UnparsedMetricTypeParams\n612 | description: str = \"\"\n613 | filter: Optional[Union[str, List[str]]] = None\n614 | # metadata: Optional[Unparsedetadata] = None # TODO\n615 | meta: Dict[str, Any] = field(default_factory=dict)\n616 | tags: List[str] = field(default_factory=list)\n617 | config: Dict[str, Any] = field(default_factory=dict)\n618 | \n619 | @classmethod\n620 | def validate(cls, data):\n621 | super(UnparsedMetric, cls).validate(data)\n622 | if \"name\" in data:\n623 | errors = []\n624 | if \" \" in data[\"name\"]:\n625 | errors.append(\"cannot contain spaces\")\n626 | # This handles failing queries due to too long metric names.\n627 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n628 | if len(data[\"name\"]) > 250:\n629 | errors.append(\"cannot contain more than 250 characters\")\n630 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n631 | errors.append(\"must begin with a letter\")\n632 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n633 | errors.append(\"must contain only letters, numbers and underscores\")\n634 | \n635 | if errors:\n636 | raise ParsingError(\n637 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n638 | )\n639 | \n640 | \n641 | @dataclass\n642 | class UnparsedGroup(dbtClassMixin, Replaceable):\n643 | name: str\n644 | owner: Owner\n645 | \n646 | @classmethod\n647 | def validate(cls, data):\n648 | super(UnparsedGroup, cls).validate(data)\n649 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n650 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n651 | \n652 | \n653 | #\n654 | # semantic interfaces unparsed objects\n655 | #\n656 | \n657 | \n658 | @dataclass\n659 | class UnparsedEntity(dbtClassMixin):\n660 | name: str\n661 | type: str # EntityType enum\n662 | description: Optional[str] = None\n663 | label: Optional[str] = None\n664 | role: Optional[str] = None\n665 | expr: Optional[str] = None\n666 | \n667 | \n668 | @dataclass\n669 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n670 | name: str\n671 | window_choice: str # AggregationType enum\n672 | window_groupings: List[str] = field(default_factory=list)\n673 | \n674 | \n675 | @dataclass\n676 | class UnparsedMeasure(dbtClassMixin):\n677 | name: str\n678 | agg: str # actually an enum\n679 | description: Optional[str] = None\n680 | label: Optional[str] = None\n681 | expr: Optional[Union[str, bool, int]] = None\n682 | agg_params: Optional[MeasureAggregationParameters] = None\n683 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n684 | agg_time_dimension: Optional[str] = None\n685 | create_metric: bool = False\n686 | \n687 | \n688 | @dataclass\n689 | class UnparsedDimensionTypeParams(dbtClassMixin):\n690 | time_granularity: str # TimeGranularity enum\n691 | validity_params: Optional[DimensionValidityParams] = None\n692 | \n693 | \n694 | @dataclass\n695 | class UnparsedDimension(dbtClassMixin):\n696 | name: str\n697 | type: str # actually an enum\n698 | description: Optional[str] = None\n699 | label: Optional[str] = None\n700 | is_partition: bool = False\n701 | type_params: Optional[UnparsedDimensionTypeParams] = None\n702 | expr: Optional[str] = None\n703 | \n704 | \n705 | @dataclass\n706 | class UnparsedSemanticModel(dbtClassMixin):\n707 | name: str\n708 | model: str # looks like \"ref(...)\"\n709 | config: Dict[str, Any] = field(default_factory=dict)\n710 | description: Optional[str] = None\n711 | label: Optional[str] = None\n712 | defaults: Optional[Defaults] = None\n713 | entities: List[UnparsedEntity] = field(default_factory=list)\n714 | measures: List[UnparsedMeasure] = field(default_factory=list)\n715 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n716 | primary_entity: Optional[str] = None\n717 | \n718 | \n719 | @dataclass\n720 | class UnparsedQueryParams(dbtClassMixin):\n721 | metrics: List[str] = field(default_factory=list)\n722 | group_by: List[str] = field(default_factory=list)\n723 | where: Optional[Union[str, List[str]]] = None\n724 | \n725 | \n726 | @dataclass\n727 | class UnparsedExport(dbtClassMixin):\n728 | \"\"\"Configuration for writing query results to a table.\"\"\"\n729 | \n730 | name: str\n731 | config: Dict[str, Any] = field(default_factory=dict)\n732 | \n733 | \n734 | @dataclass\n735 | class UnparsedSavedQuery(dbtClassMixin):\n736 | name: str\n737 | query_params: UnparsedQueryParams\n738 | description: Optional[str] = None\n739 | label: Optional[str] = None\n740 | exports: List[UnparsedExport] = field(default_factory=list)\n741 | config: Dict[str, Any] = field(default_factory=dict)\n742 | \n743 | \n744 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n745 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n746 | if d is None:\n747 | return None\n748 | \n749 | # convert date to datetime\n750 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n751 | \n752 | if not dt.tzinfo:\n753 | # date is naive, re-interpret as system time zone\n754 | dt = dt.astimezone()\n755 | \n756 | return dt\n757 | \n758 | \n759 | class UnitTestFormat(StrEnum):\n760 | CSV = \"csv\"\n761 | Dict = \"dict\"\n762 | \n763 | \n764 | @dataclass\n765 | class UnitTestInputFixture(dbtClassMixin):\n766 | input: str\n767 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n768 | format: UnitTestFormat = UnitTestFormat.Dict\n769 | fixture: Optional[str] = None\n770 | \n771 | \n772 | @dataclass\n773 | class UnitTestOutputFixture(dbtClassMixin):\n774 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n775 | format: UnitTestFormat = UnitTestFormat.Dict\n776 | fixture: Optional[str] = None\n777 | \n778 | \n779 | @dataclass\n780 | class UnitTestOverrides(dbtClassMixin):\n781 | macros: Dict[str, Any] = field(default_factory=dict)\n782 | vars: Dict[str, Any] = field(default_factory=dict)\n783 | env_vars: Dict[str, Any] = field(default_factory=dict)\n784 | \n785 | \n786 | @dataclass\n787 | class UnitTestNodeVersions(dbtClassMixin):\n788 | include: Optional[List[NodeVersion]] = None\n789 | exclude: Optional[List[NodeVersion]] = None\n790 | \n791 | \n792 | @dataclass\n793 | class UnparsedUnitTest(dbtClassMixin):\n794 | name: str\n795 | model: str # name of the model being unit tested\n796 | given: Sequence[UnitTestInputFixture]\n797 | expect: UnitTestOutputFixture\n798 | description: str = \"\"\n799 | overrides: Optional[UnitTestOverrides] = None\n800 | config: Dict[str, Any] = field(default_factory=dict)\n801 | versions: Optional[UnitTestNodeVersions] = None\n802 | \n803 | @classmethod\n804 | def validate(cls, data):\n805 | super(UnparsedUnitTest, cls).validate(data)\n806 | if data.get(\"versions\", None):\n807 | if data[\"versions\"].get(\"include\") and data[\"versions\"].get(\"exclude\"):\n808 | raise ValidationError(\"Unit tests can not both include and exclude versions.\")\n```\n\n### File: core/dbt/contracts/project.py\n\n```python\n 1 | from dbt import deprecations\n 2 | from dbt.contracts.util import Replaceable, Mergeable, list_str, Identifier\n 3 | from dbt.adapters.contracts.connection import QueryComment\n 4 | from dbt_common.helper_types import NoValue\n 5 | from dbt_common.dataclass_schema import (\n 6 | dbtClassMixin,\n 7 | ValidationError,\n 8 | ExtensibleDbtClassMixin,\n 9 | dbtMashConfig,\n 10 | )\n 11 | from dataclasses import dataclass, field\n 12 | from typing import Optional, List, Dict, Union, Any, ClassVar\n 13 | from typing_extensions import Annotated\n 14 | from mashumaro.types import SerializableType\n 15 | from mashumaro.jsonschema.annotations import Pattern\n 16 | \n 17 | \n 18 | DEFAULT_SEND_ANONYMOUS_USAGE_STATS = True\n 19 | \n 20 | \n 21 | class SemverString(str, SerializableType):\n 22 | def _serialize(self) -> str:\n 23 | return self\n 24 | \n 25 | @classmethod\n 26 | def _deserialize(cls, value: str) -> \"SemverString\":\n 27 | return SemverString(value)\n 28 | \n 29 | \n 30 | # This supports full semver, but also allows for 2 group version numbers, (allows '1.0').\n 31 | sem_ver_pattern = r\"^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?)?$\"\n 32 | \n 33 | \n 34 | @dataclass\n 35 | class Quoting(dbtClassMixin, Mergeable):\n 36 | schema: Optional[bool] = None\n 37 | database: Optional[bool] = None\n 38 | project: Optional[bool] = None\n 39 | identifier: Optional[bool] = None\n 40 | \n 41 | \n 42 | @dataclass\n 43 | class Package(dbtClassMixin, Replaceable):\n 44 | pass\n 45 | \n 46 | \n 47 | @dataclass\n 48 | class LocalPackage(Package):\n 49 | local: str\n 50 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 51 | \n 52 | \n 53 | # `float` also allows `int`, according to PEP484 (and jsonschema!)\n 54 | RawVersion = Union[str, float]\n 55 | \n 56 | \n 57 | @dataclass\n 58 | class TarballPackage(Package):\n 59 | tarball: str\n 60 | name: str\n 61 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 62 | \n 63 | \n 64 | @dataclass\n 65 | class GitPackage(Package):\n 66 | git: str\n 67 | revision: Optional[RawVersion] = None\n 68 | warn_unpinned: Optional[bool] = field(default=None, metadata={\"alias\": \"warn-unpinned\"})\n 69 | subdirectory: Optional[str] = None\n 70 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 71 | \n 72 | def get_revisions(self) -> List[str]:\n 73 | if self.revision is None:\n 74 | return []\n 75 | else:\n 76 | return [str(self.revision)]\n 77 | \n 78 | \n 79 | @dataclass\n 80 | class RegistryPackage(Package):\n 81 | package: str\n 82 | version: Union[RawVersion, List[RawVersion]]\n 83 | install_prerelease: Optional[bool] = False\n 84 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 85 | \n 86 | def get_versions(self) -> List[str]:\n 87 | if isinstance(self.version, list):\n 88 | return [str(v) for v in self.version]\n 89 | else:\n 90 | return [str(self.version)]\n 91 | \n 92 | \n 93 | PackageSpec = Union[LocalPackage, TarballPackage, GitPackage, RegistryPackage]\n 94 | \n 95 | \n 96 | @dataclass\n 97 | class PackageConfig(dbtClassMixin, Replaceable):\n 98 | packages: List[PackageSpec]\n 99 | \n100 | @classmethod\n101 | def validate(cls, data):\n102 | for package in data.get(\"packages\", data):\n103 | if isinstance(package, dict) and package.get(\"package\"):\n104 | if not package[\"version\"]:\n105 | raise ValidationError(\n106 | f\"{package['package']} is missing the version. When installing from the Hub \"\n107 | \"package index, version is a required property\"\n108 | )\n109 | \n110 | if \"/\" not in package[\"package\"]:\n111 | raise ValidationError(\n112 | f\"{package['package']} was not found in the package index. Packages on the index \"\n113 | \"require a namespace, e.g dbt-labs/dbt_utils\"\n114 | )\n115 | super().validate(data)\n116 | \n117 | \n118 | @dataclass\n119 | class ProjectPackageMetadata:\n120 | name: str\n121 | packages: List[PackageSpec]\n122 | \n123 | @classmethod\n124 | def from_project(cls, project):\n125 | return cls(name=project.project_name, packages=project.packages.packages)\n126 | \n127 | \n128 | @dataclass\n129 | class Downloads(ExtensibleDbtClassMixin, Replaceable):\n130 | tarball: str\n131 | \n132 | \n133 | @dataclass\n134 | class RegistryPackageMetadata(\n135 | ExtensibleDbtClassMixin,\n136 | ProjectPackageMetadata,\n137 | ):\n138 | downloads: Downloads\n139 | \n140 | \n141 | # A list of all the reserved words that packages may not have as names.\n142 | BANNED_PROJECT_NAMES = {\n143 | \"_sql_results\",\n144 | \"adapter\",\n145 | \"api\",\n146 | \"column\",\n147 | \"config\",\n148 | \"context\",\n149 | \"database\",\n150 | \"env\",\n151 | \"env_var\",\n152 | \"exceptions\",\n153 | \"execute\",\n154 | \"flags\",\n155 | \"fromjson\",\n156 | \"fromyaml\",\n157 | \"graph\",\n158 | \"invocation_id\",\n159 | \"load_agate_table\",\n160 | \"load_result\",\n161 | \"log\",\n162 | \"model\",\n163 | \"modules\",\n164 | \"post_hooks\",\n165 | \"pre_hooks\",\n166 | \"ref\",\n167 | \"render\",\n168 | \"return\",\n169 | \"run_started_at\",\n170 | \"schema\",\n171 | \"source\",\n172 | \"sql\",\n173 | \"sql_now\",\n174 | \"store_result\",\n175 | \"store_raw_result\",\n176 | \"target\",\n177 | \"this\",\n178 | \"tojson\",\n179 | \"toyaml\",\n180 | \"try_or_compiler_error\",\n181 | \"var\",\n182 | \"write\",\n183 | }\n184 | \n185 | \n186 | @dataclass\n187 | class Project(dbtClassMixin, Replaceable):\n188 | _hyphenated: ClassVar[bool] = True\n189 | # Annotated is used by mashumaro for jsonschema generation\n190 | name: Annotated[Identifier, Pattern(r\"^[^\\d\\W]\\w*$\")]\n191 | config_version: Optional[int] = 2\n192 | # Annotated is used by mashumaro for jsonschema generation\n193 | version: Optional[Union[Annotated[SemverString, Pattern(sem_ver_pattern)], float]] = None\n194 | project_root: Optional[str] = None\n195 | source_paths: Optional[List[str]] = None\n196 | model_paths: Optional[List[str]] = None\n197 | macro_paths: Optional[List[str]] = None\n198 | data_paths: Optional[List[str]] = None # deprecated\n199 | seed_paths: Optional[List[str]] = None\n200 | test_paths: Optional[List[str]] = None\n201 | analysis_paths: Optional[List[str]] = None\n202 | docs_paths: Optional[List[str]] = None\n203 | asset_paths: Optional[List[str]] = None\n204 | target_path: Optional[str] = None\n205 | snapshot_paths: Optional[List[str]] = None\n206 | clean_targets: Optional[List[str]] = None\n207 | profile: Optional[str] = None\n208 | log_path: Optional[str] = None\n209 | packages_install_path: Optional[str] = None\n210 | quoting: Optional[Quoting] = None\n211 | on_run_start: Optional[List[str]] = field(default_factory=list_str)\n212 | on_run_end: Optional[List[str]] = field(default_factory=list_str)\n213 | require_dbt_version: Optional[Union[List[str], str]] = None\n214 | dispatch: List[Dict[str, Any]] = field(default_factory=list)\n215 | models: Dict[str, Any] = field(default_factory=dict)\n216 | seeds: Dict[str, Any] = field(default_factory=dict)\n217 | snapshots: Dict[str, Any] = field(default_factory=dict)\n218 | analyses: Dict[str, Any] = field(default_factory=dict)\n219 | sources: Dict[str, Any] = field(default_factory=dict)\n220 | tests: Dict[str, Any] = field(default_factory=dict) # deprecated\n221 | data_tests: Dict[str, Any] = field(default_factory=dict)\n222 | unit_tests: Dict[str, Any] = field(default_factory=dict)\n223 | metrics: Dict[str, Any] = field(default_factory=dict)\n224 | semantic_models: Dict[str, Any] = field(default_factory=dict)\n225 | saved_queries: Dict[str, Any] = field(default_factory=dict)\n226 | exposures: Dict[str, Any] = field(default_factory=dict)\n227 | vars: Optional[Dict[str, Any]] = field(\n228 | default=None,\n229 | metadata=dict(\n230 | description=\"map project names to their vars override dicts\",\n231 | ),\n232 | )\n233 | packages: List[PackageSpec] = field(default_factory=list)\n234 | query_comment: Optional[Union[QueryComment, NoValue, str]] = field(default_factory=NoValue)\n235 | restrict_access: bool = False\n236 | dbt_cloud: Optional[Dict[str, Any]] = None\n237 | \n238 | class Config(dbtMashConfig):\n239 | # These tell mashumaro to use aliases for jsonschema and for \"from_dict\"\n240 | aliases = {\n241 | \"config_version\": \"config-version\",\n242 | \"project_root\": \"project-root\",\n243 | \"source_paths\": \"source-paths\",\n244 | \"model_paths\": \"model-paths\",\n245 | \"macro_paths\": \"macro-paths\",\n246 | \"data_paths\": \"data-paths\",\n247 | \"seed_paths\": \"seed-paths\",\n248 | \"test_paths\": \"test-paths\",\n249 | \"analysis_paths\": \"analysis-paths\",\n250 | \"docs_paths\": \"docs-paths\",\n251 | \"asset_paths\": \"asset-paths\",\n252 | \"target_path\": \"target-path\",\n253 | \"snapshot_paths\": \"snapshot-paths\",\n254 | \"clean_targets\": \"clean-targets\",\n255 | \"log_path\": \"log-path\",\n256 | \"packages_install_path\": \"packages-install-path\",\n257 | \"on_run_start\": \"on-run-start\",\n258 | \"on_run_end\": \"on-run-end\",\n259 | \"require_dbt_version\": \"require-dbt-version\",\n260 | \"query_comment\": \"query-comment\",\n261 | \"restrict_access\": \"restrict-access\",\n262 | \"semantic_models\": \"semantic-models\",\n263 | \"saved_queries\": \"saved-queries\",\n264 | \"dbt_cloud\": \"dbt-cloud\",\n265 | }\n266 | \n267 | @classmethod\n268 | def validate(cls, data):\n269 | super().validate(data)\n270 | if data[\"name\"] in BANNED_PROJECT_NAMES:\n271 | raise ValidationError(f\"Invalid project name: {data['name']} is a reserved word\")\n272 | # validate dispatch config\n273 | if \"dispatch\" in data and data[\"dispatch\"]:\n274 | entries = data[\"dispatch\"]\n275 | for entry in entries:\n276 | if (\n277 | \"macro_namespace\" not in entry\n278 | or \"search_order\" not in entry\n279 | or not isinstance(entry[\"search_order\"], list)\n280 | ):\n281 | raise ValidationError(f\"Invalid project dispatch config: {entry}\")\n282 | if \"dbt_cloud\" in data and not isinstance(data[\"dbt_cloud\"], dict):\n283 | raise ValidationError(\n284 | f\"Invalid dbt_cloud config. Expected a 'dict' but got '{type(data['dbt_cloud'])}'\"\n285 | )\n286 | if data.get(\"tests\", None) and data.get(\"data_tests\", None):\n287 | raise ValidationError(\n288 | \"Invalid project config: cannot have both 'tests' and 'data_tests' defined\"\n289 | )\n290 | if \"tests\" in data:\n291 | deprecations.warn(\n292 | \"project-test-config\", deprecated_path=\"tests\", exp_path=\"data_tests\"\n293 | )\n294 | \n295 | \n296 | @dataclass\n297 | class ProjectFlags(ExtensibleDbtClassMixin, Replaceable):\n298 | cache_selected_only: Optional[bool] = None\n299 | debug: Optional[bool] = None\n300 | fail_fast: Optional[bool] = None\n301 | indirect_selection: Optional[str] = None\n302 | log_format: Optional[str] = None\n303 | log_format_file: Optional[str] = None\n304 | log_level: Optional[str] = None\n305 | log_level_file: Optional[str] = None\n306 | partial_parse: Optional[bool] = None\n307 | populate_cache: Optional[bool] = None\n308 | printer_width: Optional[int] = None\n309 | send_anonymous_usage_stats: bool = DEFAULT_SEND_ANONYMOUS_USAGE_STATS\n310 | source_freshness_run_project_hooks: bool = False\n311 | static_parser: Optional[bool] = None\n312 | use_colors: Optional[bool] = None\n313 | use_colors_file: Optional[bool] = None\n314 | use_experimental_parser: Optional[bool] = None\n315 | version_check: Optional[bool] = None\n316 | warn_error: Optional[bool] = None\n317 | warn_error_options: Optional[Dict[str, Union[str, List[str]]]] = None\n318 | write_json: Optional[bool] = None\n319 | \n320 | @property\n321 | def project_only_flags(self) -> Dict[str, Any]:\n322 | return {\"source_freshness_run_project_hooks\": self.source_freshness_run_project_hooks}\n323 | \n324 | \n325 | @dataclass\n326 | class ProfileConfig(dbtClassMixin, Replaceable):\n327 | profile_name: str\n328 | target_name: str\n329 | threads: int\n330 | # TODO: make this a dynamic union of some kind?\n331 | credentials: Optional[Dict[str, Any]]\n332 | \n333 | \n334 | @dataclass\n335 | class ConfiguredQuoting(Quoting, Replaceable):\n336 | identifier: bool = True\n337 | schema: bool = True\n338 | database: Optional[bool] = None\n339 | project: Optional[bool] = None\n340 | \n341 | \n342 | @dataclass\n343 | class Configuration(Project, ProfileConfig):\n344 | cli_vars: Dict[str, Any] = field(\n345 | default_factory=dict,\n346 | metadata={\"preserve_underscore\": True},\n347 | )\n348 | quoting: Optional[ConfiguredQuoting] = None\n349 | \n350 | \n351 | @dataclass\n352 | class ProjectList(dbtClassMixin):\n353 | projects: Dict[str, Project]\n```\n\n### File: core/dbt/contracts/util.py\n\n```python\n 1 | import dataclasses\n 2 | from typing import List, Any, Tuple\n 3 | \n 4 | from dbt_common.dataclass_schema import ValidatedStringMixin, ValidationError\n 5 | from dbt_common.contracts.util import Replaceable\n 6 | \n 7 | \n 8 | SourceKey = Tuple[str, str]\n 9 | \n10 | \n11 | def list_str() -> List[str]:\n12 | \"\"\"Mypy gets upset about stuff like:\n13 | \n14 | from dataclasses import dataclass, field\n15 | from typing import Optional, List\n16 | \n17 | @dataclass\n18 | class Foo:\n19 | x: Optional[List[str]] = field(default_factory=list)\n20 | \n21 | \n22 | Because `list` could be any kind of list, I guess\n23 | \"\"\"\n24 | return []\n25 | \n26 | \n27 | class Mergeable(Replaceable):\n28 | def merged(self, *args):\n29 | \"\"\"Perform a shallow merge, where the last non-None write wins. This is\n30 | intended to merge dataclasses that are a collection of optional values.\n31 | \"\"\"\n32 | replacements = {}\n33 | cls = type(self)\n34 | for arg in args:\n35 | for field in dataclasses.fields(cls):\n36 | value = getattr(arg, field.name)\n37 | if value is not None:\n38 | replacements[field.name] = value\n39 | \n40 | return self.replace(**replacements)\n41 | \n42 | \n43 | class Identifier(ValidatedStringMixin):\n44 | \"\"\"Our definition of a valid Identifier is the same as what's valid for an unquoted database table name.\n45 | \n46 | That is:\n47 | 1. It can contain a-z, A-Z, 0-9, and _\n48 | 1. It cannot start with a number\n49 | \"\"\"\n50 | \n51 | ValidationRegex = r\"^[^\\d\\W]\\w*$\"\n52 | \n53 | @classmethod\n54 | def is_valid(cls, value: Any) -> bool:\n55 | if not isinstance(value, str):\n56 | return False\n57 | \n58 | try:\n59 | cls.validate(value)\n60 | except ValidationError:\n61 | return False\n62 | \n63 | return True\n```\n\n## Files after the fix\n\n### File: core/dbt/contracts/graph/unparsed.py\n\n```python\n 1 | import datetime\n 2 | import re\n 3 | \n 4 | from dbt import deprecations\n 5 | from dbt.artifacts.resources import ConstantPropertyInput\n 6 | from dbt_common.contracts.config.properties import (\n 7 | AdditionalPropertiesAllowed,\n 8 | AdditionalPropertiesMixin,\n 9 | )\n 10 | from dbt_common.contracts.util import Mergeable\n 11 | from dbt_common.exceptions import DbtInternalError, CompilationError\n 12 | from dbt_common.dataclass_schema import (\n 13 | dbtClassMixin,\n 14 | StrEnum,\n 15 | ExtensibleDbtClassMixin,\n 16 | ValidationError,\n 17 | )\n 18 | from dbt.node_types import NodeType\n 19 | from dbt.artifacts.resources import (\n 20 | Defaults,\n 21 | DimensionValidityParams,\n 22 | ExposureType,\n 23 | MaturityType,\n 24 | MeasureAggregationParameters,\n 25 | )\n 26 | from dbt.contracts.util import Replaceable\n 27 | \n 28 | # trigger the PathEncoder\n 29 | import dbt_common.helper_types # noqa:F401\n 30 | from dbt.exceptions import ParsingError\n 31 | \n 32 | from dbt_semantic_interfaces.type_enums import ConversionCalculationType\n 33 | from dbt.artifacts.resources import Docs, MacroArgument, NodeVersion, Owner\n 34 | \n 35 | from dataclasses import dataclass, field\n 36 | from datetime import timedelta\n 37 | from pathlib import Path\n 38 | from typing import Optional, List, Union, Dict, Any, Sequence, Literal\n 39 | \n 40 | \n 41 | @dataclass\n 42 | class UnparsedBaseNode(dbtClassMixin, Replaceable):\n 43 | package_name: str\n 44 | path: str\n 45 | original_file_path: str\n 46 | \n 47 | @property\n 48 | def file_id(self):\n 49 | return f\"{self.package_name}://{self.original_file_path}\"\n 50 | \n 51 | \n 52 | @dataclass\n 53 | class HasCode(dbtClassMixin):\n 54 | raw_code: str\n 55 | language: str\n 56 | \n 57 | @property\n 58 | def empty(self):\n 59 | return not self.raw_code.strip()\n 60 | \n 61 | \n 62 | @dataclass\n 63 | class UnparsedMacro(UnparsedBaseNode, HasCode):\n 64 | resource_type: Literal[NodeType.Macro]\n 65 | \n 66 | \n 67 | @dataclass\n 68 | class UnparsedGenericTest(UnparsedBaseNode, HasCode):\n 69 | resource_type: Literal[NodeType.Macro]\n 70 | \n 71 | \n 72 | @dataclass\n 73 | class UnparsedNode(UnparsedBaseNode, HasCode):\n 74 | name: str\n 75 | resource_type: NodeType\n 76 | \n 77 | @property\n 78 | def search_name(self):\n 79 | return self.name\n 80 | \n 81 | \n 82 | @dataclass\n 83 | class UnparsedRunHook(UnparsedNode):\n 84 | resource_type: Literal[NodeType.Operation]\n 85 | index: Optional[int] = None\n 86 | \n 87 | \n 88 | @dataclass\n 89 | class HasColumnProps(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):\n 90 | name: str\n 91 | description: str = \"\"\n 92 | meta: Dict[str, Any] = field(default_factory=dict)\n 93 | data_type: Optional[str] = None\n 94 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n 95 | docs: Docs = field(default_factory=Docs)\n 96 | _extra: Dict[str, Any] = field(default_factory=dict)\n 97 | \n 98 | \n 99 | TestDef = Union[Dict[str, Any], str]\n100 | \n101 | \n102 | @dataclass\n103 | class HasColumnAndTestProps(HasColumnProps):\n104 | data_tests: List[TestDef] = field(default_factory=list)\n105 | tests: List[TestDef] = field(\n106 | default_factory=list\n107 | ) # back compat for previous name of 'data_tests'\n108 | \n109 | \n110 | @dataclass\n111 | class UnparsedColumn(HasColumnAndTestProps):\n112 | quote: Optional[bool] = None\n113 | tags: List[str] = field(default_factory=list)\n114 | \n115 | \n116 | @dataclass\n117 | class HasColumnDocs(dbtClassMixin, Replaceable):\n118 | columns: Sequence[HasColumnProps] = field(default_factory=list)\n119 | \n120 | \n121 | @dataclass\n122 | class HasColumnTests(dbtClassMixin, Replaceable):\n123 | columns: Sequence[UnparsedColumn] = field(default_factory=list)\n124 | \n125 | \n126 | @dataclass\n127 | class HasYamlMetadata(dbtClassMixin):\n128 | original_file_path: str\n129 | yaml_key: str\n130 | package_name: str\n131 | \n132 | @property\n133 | def file_id(self):\n134 | return f\"{self.package_name}://{self.original_file_path}\"\n135 | \n136 | \n137 | @dataclass\n138 | class HasConfig:\n139 | config: Dict[str, Any] = field(default_factory=dict)\n140 | \n141 | \n142 | @dataclass\n143 | class UnparsedVersion(dbtClassMixin):\n144 | v: NodeVersion\n145 | defined_in: Optional[str] = None\n146 | description: str = \"\"\n147 | access: Optional[str] = None\n148 | config: Dict[str, Any] = field(default_factory=dict)\n149 | constraints: List[Dict[str, Any]] = field(default_factory=list)\n150 | docs: Docs = field(default_factory=Docs)\n151 | data_tests: Optional[List[TestDef]] = None\n152 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n153 | columns: Sequence[Union[dbt_common.helper_types.IncludeExclude, UnparsedColumn]] = field(\n154 | default_factory=list\n155 | )\n156 | deprecation_date: Optional[datetime.datetime] = None\n157 | \n158 | def __lt__(self, other):\n159 | try:\n160 | return float(self.v) < float(other.v)\n161 | except ValueError:\n162 | return str(self.v) < str(other.v)\n163 | \n164 | @property\n165 | def include_exclude(self) -> dbt_common.helper_types.IncludeExclude:\n166 | return self._include_exclude\n167 | \n168 | @property\n169 | def unparsed_columns(self) -> List:\n170 | return self._unparsed_columns\n171 | \n172 | @property\n173 | def formatted_v(self) -> str:\n174 | return f\"v{self.v}\"\n175 | \n176 | def __post_init__(self):\n177 | has_include_exclude = False\n178 | self._include_exclude = dbt_common.helper_types.IncludeExclude(include=\"*\")\n179 | self._unparsed_columns = []\n180 | for column in self.columns:\n181 | if isinstance(column, dbt_common.helper_types.IncludeExclude):\n182 | if not has_include_exclude:\n183 | self._include_exclude = column\n184 | has_include_exclude = True\n185 | else:\n186 | raise ParsingError(\"version can have at most one include/exclude element\")\n187 | else:\n188 | self._unparsed_columns.append(column)\n189 | \n190 | self.deprecation_date = normalize_date(self.deprecation_date)\n191 | \n192 | \n193 | @dataclass\n194 | class UnparsedAnalysisUpdate(HasConfig, HasColumnDocs, HasColumnProps, HasYamlMetadata):\n195 | access: Optional[str] = None\n196 | \n197 | \n198 | @dataclass\n199 | class UnparsedNodeUpdate(HasConfig, HasColumnTests, HasColumnAndTestProps, HasYamlMetadata):\n200 | quote_columns: Optional[bool] = None\n201 | access: Optional[str] = None\n202 | \n203 | \n204 | @dataclass\n205 | class UnparsedModelUpdate(UnparsedNodeUpdate):\n206 | quote_columns: Optional[bool] = None\n207 | access: Optional[str] = None\n208 | latest_version: Optional[NodeVersion] = None\n209 | versions: Sequence[UnparsedVersion] = field(default_factory=list)\n210 | deprecation_date: Optional[datetime.datetime] = None\n211 | \n212 | def __post_init__(self) -> None:\n213 | if self.latest_version:\n214 | version_values = [version.v for version in self.versions]\n215 | if self.latest_version not in version_values:\n216 | raise ParsingError(\n217 | f\"latest_version: {self.latest_version} is not one of model '{self.name}' versions: {version_values} \"\n218 | )\n219 | \n220 | seen_versions = set()\n221 | for version in self.versions:\n222 | if str(version.v) in seen_versions:\n223 | raise ParsingError(\n224 | f\"Found duplicate version: '{version.v}' in versions list of model '{self.name}'\"\n225 | )\n226 | seen_versions.add(str(version.v))\n227 | \n228 | self._version_map = {version.v: version for version in self.versions}\n229 | \n230 | self.deprecation_date = normalize_date(self.deprecation_date)\n231 | \n232 | def get_columns_for_version(self, version: NodeVersion) -> List[UnparsedColumn]:\n233 | if version not in self._version_map:\n234 | raise DbtInternalError(\n235 | f\"get_columns_for_version called for version '{version}' not in version map\"\n236 | )\n237 | \n238 | version_columns = []\n239 | unparsed_version = self._version_map[version]\n240 | for base_column in self.columns:\n241 | if unparsed_version.include_exclude.includes(base_column.name):\n242 | version_columns.append(base_column)\n243 | \n244 | for column in unparsed_version.unparsed_columns:\n245 | version_columns.append(column)\n246 | \n247 | return version_columns\n248 | \n249 | def get_tests_for_version(self, version: NodeVersion) -> List[TestDef]:\n250 | if version not in self._version_map:\n251 | raise DbtInternalError(\n252 | f\"get_tests_for_version called for version '{version}' not in version map\"\n253 | )\n254 | unparsed_version = self._version_map[version]\n255 | return (\n256 | unparsed_version.data_tests\n257 | if unparsed_version.data_tests is not None\n258 | else self.data_tests\n259 | )\n260 | \n261 | \n262 | @dataclass\n263 | class UnparsedMacroUpdate(HasConfig, HasColumnProps, HasYamlMetadata):\n264 | arguments: List[MacroArgument] = field(default_factory=list)\n265 | \n266 | \n267 | class TimePeriod(StrEnum):\n268 | minute = \"minute\"\n269 | hour = \"hour\"\n270 | day = \"day\"\n271 | \n272 | def plural(self) -> str:\n273 | return str(self) + \"s\"\n274 | \n275 | \n276 | @dataclass\n277 | class Time(dbtClassMixin, Mergeable):\n278 | count: Optional[int] = None\n279 | period: Optional[TimePeriod] = None\n280 | \n281 | def exceeded(self, actual_age: float) -> bool:\n282 | if self.period is None or self.count is None:\n283 | return False\n284 | kwargs: Dict[str, int] = {self.period.plural(): self.count}\n285 | difference = timedelta(**kwargs).total_seconds()\n286 | return actual_age > difference\n287 | \n288 | def __bool__(self):\n289 | return self.count is not None and self.period is not None\n290 | \n291 | \n292 | @dataclass\n293 | class FreshnessThreshold(dbtClassMixin, Mergeable):\n294 | warn_after: Optional[Time] = field(default_factory=Time)\n295 | error_after: Optional[Time] = field(default_factory=Time)\n296 | filter: Optional[str] = None\n297 | \n298 | def status(self, age: float) -> \"dbt.artifacts.schemas.results.FreshnessStatus\": # type: ignore # noqa F821\n299 | from dbt.artifacts.schemas.results import FreshnessStatus\n300 | \n301 | if self.error_after and self.error_after.exceeded(age):\n302 | return FreshnessStatus.Error\n303 | elif self.warn_after and self.warn_after.exceeded(age):\n304 | return FreshnessStatus.Warn\n305 | else:\n306 | return FreshnessStatus.Pass\n307 | \n308 | def __bool__(self):\n309 | return bool(self.warn_after) or bool(self.error_after)\n310 | \n311 | \n312 | @dataclass\n313 | class ExternalPartition(AdditionalPropertiesAllowed, Replaceable):\n314 | name: str = \"\"\n315 | description: str = \"\"\n316 | data_type: str = \"\"\n317 | meta: Dict[str, Any] = field(default_factory=dict)\n318 | \n319 | def __post_init__(self):\n320 | if self.name == \"\" or self.data_type == \"\":\n321 | raise CompilationError(\"External partition columns must have names and data types\")\n322 | \n323 | \n324 | @dataclass\n325 | class ExternalTable(AdditionalPropertiesAllowed, Mergeable):\n326 | location: Optional[str] = None\n327 | file_format: Optional[str] = None\n328 | row_format: Optional[str] = None\n329 | tbl_properties: Optional[str] = None\n330 | partitions: Optional[Union[List[str], List[ExternalPartition]]] = None\n331 | \n332 | def __bool__(self):\n333 | return self.location is not None\n334 | \n335 | \n336 | @dataclass\n337 | class Quoting(dbtClassMixin, Mergeable):\n338 | database: Optional[bool] = None\n339 | schema: Optional[bool] = None\n340 | identifier: Optional[bool] = None\n341 | column: Optional[bool] = None\n342 | \n343 | \n344 | @dataclass\n345 | class UnparsedSourceTableDefinition(HasColumnTests, HasColumnAndTestProps):\n346 | config: Dict[str, Any] = field(default_factory=dict)\n347 | loaded_at_field: Optional[str] = None\n348 | identifier: Optional[str] = None\n349 | quoting: Quoting = field(default_factory=Quoting)\n350 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n351 | external: Optional[ExternalTable] = None\n352 | tags: List[str] = field(default_factory=list)\n353 | \n354 | def __post_serialize__(self, dct):\n355 | dct = super().__post_serialize__(dct)\n356 | if \"freshness\" not in dct and self.freshness is None:\n357 | dct[\"freshness\"] = None\n358 | return dct\n359 | \n360 | \n361 | @dataclass\n362 | class UnparsedSourceDefinition(dbtClassMixin, Replaceable):\n363 | name: str\n364 | description: str = \"\"\n365 | meta: Dict[str, Any] = field(default_factory=dict)\n366 | database: Optional[str] = None\n367 | schema: Optional[str] = None\n368 | loader: str = \"\"\n369 | quoting: Quoting = field(default_factory=Quoting)\n370 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n371 | loaded_at_field: Optional[str] = None\n372 | tables: List[UnparsedSourceTableDefinition] = field(default_factory=list)\n373 | tags: List[str] = field(default_factory=list)\n374 | config: Dict[str, Any] = field(default_factory=dict)\n375 | \n376 | @property\n377 | def yaml_key(self) -> \"str\":\n378 | return \"sources\"\n379 | \n380 | def __post_serialize__(self, dct):\n381 | dct = super().__post_serialize__(dct)\n382 | if \"freshness\" not in dct and self.freshness is None:\n383 | dct[\"freshness\"] = None\n384 | return dct\n385 | \n386 | \n387 | @dataclass\n388 | class SourceTablePatch(dbtClassMixin):\n389 | name: str\n390 | description: Optional[str] = None\n391 | meta: Optional[Dict[str, Any]] = None\n392 | data_type: Optional[str] = None\n393 | docs: Optional[Docs] = None\n394 | loaded_at_field: Optional[str] = None\n395 | identifier: Optional[str] = None\n396 | quoting: Quoting = field(default_factory=Quoting)\n397 | freshness: Optional[FreshnessThreshold] = field(default_factory=FreshnessThreshold)\n398 | external: Optional[ExternalTable] = None\n399 | tags: Optional[List[str]] = None\n400 | data_tests: Optional[List[TestDef]] = None\n401 | tests: Optional[List[TestDef]] = None # back compat for previous name of 'data_tests'\n402 | columns: Optional[Sequence[UnparsedColumn]] = None\n403 | \n404 | def to_patch_dict(self) -> Dict[str, Any]:\n405 | dct = self.to_dict(omit_none=True)\n406 | remove_keys = \"name\"\n407 | for key in remove_keys:\n408 | if key in dct:\n409 | del dct[key]\n410 | \n411 | if self.freshness is None:\n412 | dct[\"freshness\"] = None\n413 | \n414 | return dct\n415 | \n416 | \n417 | @dataclass\n418 | class SourcePatch(dbtClassMixin, Replaceable):\n419 | name: str = field(\n420 | metadata=dict(description=\"The name of the source to override\"),\n421 | )\n422 | overrides: str = field(\n423 | metadata=dict(description=\"The package of the source to override\"),\n424 | )\n425 | path: Path = field(\n426 | metadata=dict(description=\"The path to the patch-defining yml file\"),\n427 | )\n428 | config: Dict[str, Any] = field(default_factory=dict)\n429 | description: Optional[str] = None\n430 | meta: Optional[Dict[str, Any]] = None\n431 | database: Optional[str] = None\n432 | schema: Optional[str] = None\n433 | loader: Optional[str] = None\n434 | quoting: Optional[Quoting] = None\n435 | freshness: Optional[Optional[FreshnessThreshold]] = field(default_factory=FreshnessThreshold)\n436 | loaded_at_field: Optional[str] = None\n437 | tables: Optional[List[SourceTablePatch]] = None\n438 | tags: Optional[List[str]] = None\n439 | \n440 | def to_patch_dict(self) -> Dict[str, Any]:\n441 | dct = self.to_dict(omit_none=True)\n442 | remove_keys = (\"name\", \"overrides\", \"tables\", \"path\")\n443 | for key in remove_keys:\n444 | if key in dct:\n445 | del dct[key]\n446 | \n447 | if self.freshness is None:\n448 | dct[\"freshness\"] = None\n449 | \n450 | return dct\n451 | \n452 | def get_table_named(self, name: str) -> Optional[SourceTablePatch]:\n453 | if self.tables is not None:\n454 | for table in self.tables:\n455 | if table.name == name:\n456 | return table\n457 | return None\n458 | \n459 | \n460 | @dataclass\n461 | class UnparsedDocumentation(dbtClassMixin, Replaceable):\n462 | package_name: str\n463 | path: str\n464 | original_file_path: str\n465 | \n466 | @property\n467 | def file_id(self):\n468 | return f\"{self.package_name}://{self.original_file_path}\"\n469 | \n470 | @property\n471 | def resource_type(self):\n472 | return NodeType.Documentation\n473 | \n474 | \n475 | @dataclass\n476 | class UnparsedDocumentationFile(UnparsedDocumentation):\n477 | file_contents: str\n478 | \n479 | \n480 | # can't use total_ordering decorator here, as str provides an ordering already\n481 | # and it's not the one we want.\n482 | class Maturity(StrEnum):\n483 | low = \"low\"\n484 | medium = \"medium\"\n485 | high = \"high\"\n486 | \n487 | def __lt__(self, other):\n488 | if not isinstance(other, Maturity):\n489 | return NotImplemented\n490 | order = (Maturity.low, Maturity.medium, Maturity.high)\n491 | return order.index(self) < order.index(other)\n492 | \n493 | def __gt__(self, other):\n494 | if not isinstance(other, Maturity):\n495 | return NotImplemented\n496 | return self != other and not (self < other)\n497 | \n498 | def __ge__(self, other):\n499 | if not isinstance(other, Maturity):\n500 | return NotImplemented\n501 | return self == other or not (self < other)\n502 | \n503 | def __le__(self, other):\n504 | if not isinstance(other, Maturity):\n505 | return NotImplemented\n506 | return self == other or self < other\n507 | \n508 | \n509 | @dataclass\n510 | class UnparsedExposure(dbtClassMixin, Replaceable):\n511 | name: str\n512 | type: ExposureType\n513 | owner: Owner\n514 | description: str = \"\"\n515 | label: Optional[str] = None\n516 | maturity: Optional[MaturityType] = None\n517 | meta: Dict[str, Any] = field(default_factory=dict)\n518 | tags: List[str] = field(default_factory=list)\n519 | url: Optional[str] = None\n520 | depends_on: List[str] = field(default_factory=list)\n521 | config: Dict[str, Any] = field(default_factory=dict)\n522 | \n523 | @classmethod\n524 | def validate(cls, data):\n525 | super(UnparsedExposure, cls).validate(data)\n526 | if \"name\" in data:\n527 | # name can only contain alphanumeric chars and underscores\n528 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n529 | deprecations.warn(\"exposure-name\", exposure=data[\"name\"])\n530 | \n531 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n532 | raise ValidationError(\"Exposure owner must have at least one of 'name' or 'email'.\")\n533 | \n534 | \n535 | @dataclass\n536 | class MetricFilter(dbtClassMixin, Replaceable):\n537 | field: str\n538 | operator: str\n539 | # TODO : Can we make this Any?\n540 | value: str\n541 | \n542 | \n543 | class MetricTimePeriod(StrEnum):\n544 | day = \"day\"\n545 | week = \"week\"\n546 | month = \"month\"\n547 | year = \"year\"\n548 | \n549 | def plural(self) -> str:\n550 | return str(self) + \"s\"\n551 | \n552 | \n553 | @dataclass\n554 | class MetricTime(dbtClassMixin, Mergeable):\n555 | count: Optional[int] = None\n556 | period: Optional[MetricTimePeriod] = None\n557 | \n558 | def __bool__(self):\n559 | return self.count is not None and self.period is not None\n560 | \n561 | \n562 | @dataclass\n563 | class UnparsedMetricInputMeasure(dbtClassMixin):\n564 | name: str\n565 | filter: Optional[Union[str, List[str]]] = None\n566 | alias: Optional[str] = None\n567 | join_to_timespine: bool = False\n568 | fill_nulls_with: Optional[int] = None\n569 | \n570 | \n571 | @dataclass\n572 | class UnparsedMetricInput(dbtClassMixin):\n573 | name: str\n574 | filter: Optional[Union[str, List[str]]] = None\n575 | alias: Optional[str] = None\n576 | offset_window: Optional[str] = None\n577 | offset_to_grain: Optional[str] = None # str is really a TimeGranularity Enum\n578 | \n579 | \n580 | @dataclass\n581 | class UnparsedConversionTypeParams(dbtClassMixin):\n582 | base_measure: Union[UnparsedMetricInputMeasure, str]\n583 | conversion_measure: Union[UnparsedMetricInputMeasure, str]\n584 | entity: str\n585 | calculation: str = (\n586 | ConversionCalculationType.CONVERSION_RATE.value\n587 | ) # ConversionCalculationType Enum\n588 | window: Optional[str] = None\n589 | constant_properties: Optional[List[ConstantPropertyInput]] = None\n590 | \n591 | \n592 | @dataclass\n593 | class UnparsedMetricTypeParams(dbtClassMixin):\n594 | measure: Optional[Union[UnparsedMetricInputMeasure, str]] = None\n595 | numerator: Optional[Union[UnparsedMetricInput, str]] = None\n596 | denominator: Optional[Union[UnparsedMetricInput, str]] = None\n597 | expr: Optional[Union[str, bool]] = None\n598 | window: Optional[str] = None\n599 | grain_to_date: Optional[str] = None # str is really a TimeGranularity Enum\n600 | metrics: Optional[List[Union[UnparsedMetricInput, str]]] = None\n601 | conversion_type_params: Optional[UnparsedConversionTypeParams] = None\n602 | \n603 | \n604 | @dataclass\n605 | class UnparsedMetric(dbtClassMixin):\n606 | name: str\n607 | label: str\n608 | type: str\n609 | type_params: UnparsedMetricTypeParams\n610 | description: str = \"\"\n611 | filter: Optional[Union[str, List[str]]] = None\n612 | # metadata: Optional[Unparsedetadata] = None # TODO\n613 | meta: Dict[str, Any] = field(default_factory=dict)\n614 | tags: List[str] = field(default_factory=list)\n615 | config: Dict[str, Any] = field(default_factory=dict)\n616 | \n617 | @classmethod\n618 | def validate(cls, data):\n619 | super(UnparsedMetric, cls).validate(data)\n620 | if \"name\" in data:\n621 | errors = []\n622 | if \" \" in data[\"name\"]:\n623 | errors.append(\"cannot contain spaces\")\n624 | # This handles failing queries due to too long metric names.\n625 | # It only occurs in BigQuery and Snowflake (Postgres/Redshift truncate)\n626 | if len(data[\"name\"]) > 250:\n627 | errors.append(\"cannot contain more than 250 characters\")\n628 | if not (re.match(r\"^[A-Za-z]\", data[\"name\"])):\n629 | errors.append(\"must begin with a letter\")\n630 | if not (re.match(r\"[\\w-]+$\", data[\"name\"])):\n631 | errors.append(\"must contain only letters, numbers and underscores\")\n632 | \n633 | if errors:\n634 | raise ParsingError(\n635 | f\"The metric name '{data['name']}' is invalid. It {', '.join(e for e in errors)}\"\n636 | )\n637 | \n638 | \n639 | @dataclass\n640 | class UnparsedGroup(dbtClassMixin, Replaceable):\n641 | name: str\n642 | owner: Owner\n643 | \n644 | @classmethod\n645 | def validate(cls, data):\n646 | super(UnparsedGroup, cls).validate(data)\n647 | if data[\"owner\"].get(\"name\") is None and data[\"owner\"].get(\"email\") is None:\n648 | raise ValidationError(\"Group owner must have at least one of 'name' or 'email'.\")\n649 | \n650 | \n651 | #\n652 | # semantic interfaces unparsed objects\n653 | #\n654 | \n655 | \n656 | @dataclass\n657 | class UnparsedEntity(dbtClassMixin):\n658 | name: str\n659 | type: str # EntityType enum\n660 | description: Optional[str] = None\n661 | label: Optional[str] = None\n662 | role: Optional[str] = None\n663 | expr: Optional[str] = None\n664 | \n665 | \n666 | @dataclass\n667 | class UnparsedNonAdditiveDimension(dbtClassMixin):\n668 | name: str\n669 | window_choice: str # AggregationType enum\n670 | window_groupings: List[str] = field(default_factory=list)\n671 | \n672 | \n673 | @dataclass\n674 | class UnparsedMeasure(dbtClassMixin):\n675 | name: str\n676 | agg: str # actually an enum\n677 | description: Optional[str] = None\n678 | label: Optional[str] = None\n679 | expr: Optional[Union[str, bool, int]] = None\n680 | agg_params: Optional[MeasureAggregationParameters] = None\n681 | non_additive_dimension: Optional[UnparsedNonAdditiveDimension] = None\n682 | agg_time_dimension: Optional[str] = None\n683 | create_metric: bool = False\n684 | \n685 | \n686 | @dataclass\n687 | class UnparsedDimensionTypeParams(dbtClassMixin):\n688 | time_granularity: str # TimeGranularity enum\n689 | validity_params: Optional[DimensionValidityParams] = None\n690 | \n691 | \n692 | @dataclass\n693 | class UnparsedDimension(dbtClassMixin):\n694 | name: str\n695 | type: str # actually an enum\n696 | description: Optional[str] = None\n697 | label: Optional[str] = None\n698 | is_partition: bool = False\n699 | type_params: Optional[UnparsedDimensionTypeParams] = None\n700 | expr: Optional[str] = None\n701 | \n702 | \n703 | @dataclass\n704 | class UnparsedSemanticModel(dbtClassMixin):\n705 | name: str\n706 | model: str # looks like \"ref(...)\"\n707 | config: Dict[str, Any] = field(default_factory=dict)\n708 | description: Optional[str] = None\n709 | label: Optional[str] = None\n710 | defaults: Optional[Defaults] = None\n711 | entities: List[UnparsedEntity] = field(default_factory=list)\n712 | measures: List[UnparsedMeasure] = field(default_factory=list)\n713 | dimensions: List[UnparsedDimension] = field(default_factory=list)\n714 | primary_entity: Optional[str] = None\n715 | \n716 | \n717 | @dataclass\n718 | class UnparsedQueryParams(dbtClassMixin):\n719 | metrics: List[str] = field(default_factory=list)\n720 | group_by: List[str] = field(default_factory=list)\n721 | where: Optional[Union[str, List[str]]] = None\n722 | \n723 | \n724 | @dataclass\n725 | class UnparsedExport(dbtClassMixin):\n726 | \"\"\"Configuration for writing query results to a table.\"\"\"\n727 | \n728 | name: str\n729 | config: Dict[str, Any] = field(default_factory=dict)\n730 | \n731 | \n732 | @dataclass\n733 | class UnparsedSavedQuery(dbtClassMixin):\n734 | name: str\n735 | query_params: UnparsedQueryParams\n736 | description: Optional[str] = None\n737 | label: Optional[str] = None\n738 | exports: List[UnparsedExport] = field(default_factory=list)\n739 | config: Dict[str, Any] = field(default_factory=dict)\n740 | \n741 | \n742 | def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:\n743 | \"\"\"Convert date to datetime (at midnight), and add local time zone if naive\"\"\"\n744 | if d is None:\n745 | return None\n746 | \n747 | # convert date to datetime\n748 | dt = d if type(d) == datetime.datetime else datetime.datetime(d.year, d.month, d.day)\n749 | \n750 | if not dt.tzinfo:\n751 | # date is naive, re-interpret as system time zone\n752 | dt = dt.astimezone()\n753 | \n754 | return dt\n755 | \n756 | \n757 | class UnitTestFormat(StrEnum):\n758 | CSV = \"csv\"\n759 | Dict = \"dict\"\n760 | \n761 | \n762 | @dataclass\n763 | class UnitTestInputFixture(dbtClassMixin):\n764 | input: str\n765 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n766 | format: UnitTestFormat = UnitTestFormat.Dict\n767 | fixture: Optional[str] = None\n768 | \n769 | \n770 | @dataclass\n771 | class UnitTestOutputFixture(dbtClassMixin):\n772 | rows: Optional[Union[str, List[Dict[str, Any]]]] = None\n773 | format: UnitTestFormat = UnitTestFormat.Dict\n774 | fixture: Optional[str] = None\n775 | \n776 | \n777 | @dataclass\n778 | class UnitTestOverrides(dbtClassMixin):\n779 | macros: Dict[str, Any] = field(default_factory=dict)\n780 | vars: Dict[str, Any] = field(default_factory=dict)\n781 | env_vars: Dict[str, Any] = field(default_factory=dict)\n782 | \n783 | \n784 | @dataclass\n785 | class UnitTestNodeVersions(dbtClassMixin):\n786 | include: Optional[List[NodeVersion]] = None\n787 | exclude: Optional[List[NodeVersion]] = None\n788 | \n789 | \n790 | @dataclass\n791 | class UnparsedUnitTest(dbtClassMixin):\n792 | name: str\n793 | model: str # name of the model being unit tested\n794 | given: Sequence[UnitTestInputFixture]\n795 | expect: UnitTestOutputFixture\n796 | description: str = \"\"\n797 | overrides: Optional[UnitTestOverrides] = None\n798 | config: Dict[str, Any] = field(default_factory=dict)\n799 | versions: Optional[UnitTestNodeVersions] = None\n800 | \n801 | @classmethod\n802 | def validate(cls, data):\n803 | super(UnparsedUnitTest, cls).validate(data)\n804 | if data.get(\"versions\", None):\n805 | if data[\"versions\"].get(\"include\") and data[\"versions\"].get(\"exclude\"):\n806 | raise ValidationError(\"Unit tests can not both include and exclude versions.\")\n```\n\n### File: core/dbt/contracts/project.py\n\n```python\n 1 | from dbt import deprecations\n 2 | from dbt.contracts.util import Replaceable, list_str, Identifier\n 3 | from dbt.adapters.contracts.connection import QueryComment\n 4 | from dbt_common.helper_types import NoValue\n 5 | from dbt_common.contracts.util import Mergeable\n 6 | from dbt_common.dataclass_schema import (\n 7 | dbtClassMixin,\n 8 | ValidationError,\n 9 | ExtensibleDbtClassMixin,\n 10 | dbtMashConfig,\n 11 | )\n 12 | from dataclasses import dataclass, field\n 13 | from typing import Optional, List, Dict, Union, Any, ClassVar\n 14 | from typing_extensions import Annotated\n 15 | from mashumaro.types import SerializableType\n 16 | from mashumaro.jsonschema.annotations import Pattern\n 17 | \n 18 | \n 19 | DEFAULT_SEND_ANONYMOUS_USAGE_STATS = True\n 20 | \n 21 | \n 22 | class SemverString(str, SerializableType):\n 23 | def _serialize(self) -> str:\n 24 | return self\n 25 | \n 26 | @classmethod\n 27 | def _deserialize(cls, value: str) -> \"SemverString\":\n 28 | return SemverString(value)\n 29 | \n 30 | \n 31 | # This supports full semver, but also allows for 2 group version numbers, (allows '1.0').\n 32 | sem_ver_pattern = r\"^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?)?$\"\n 33 | \n 34 | \n 35 | @dataclass\n 36 | class Quoting(dbtClassMixin, Mergeable):\n 37 | schema: Optional[bool] = None\n 38 | database: Optional[bool] = None\n 39 | project: Optional[bool] = None\n 40 | identifier: Optional[bool] = None\n 41 | \n 42 | \n 43 | @dataclass\n 44 | class Package(dbtClassMixin, Replaceable):\n 45 | pass\n 46 | \n 47 | \n 48 | @dataclass\n 49 | class LocalPackage(Package):\n 50 | local: str\n 51 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 52 | \n 53 | \n 54 | # `float` also allows `int`, according to PEP484 (and jsonschema!)\n 55 | RawVersion = Union[str, float]\n 56 | \n 57 | \n 58 | @dataclass\n 59 | class TarballPackage(Package):\n 60 | tarball: str\n 61 | name: str\n 62 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 63 | \n 64 | \n 65 | @dataclass\n 66 | class GitPackage(Package):\n 67 | git: str\n 68 | revision: Optional[RawVersion] = None\n 69 | warn_unpinned: Optional[bool] = field(default=None, metadata={\"alias\": \"warn-unpinned\"})\n 70 | subdirectory: Optional[str] = None\n 71 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 72 | \n 73 | def get_revisions(self) -> List[str]:\n 74 | if self.revision is None:\n 75 | return []\n 76 | else:\n 77 | return [str(self.revision)]\n 78 | \n 79 | \n 80 | @dataclass\n 81 | class RegistryPackage(Package):\n 82 | package: str\n 83 | version: Union[RawVersion, List[RawVersion]]\n 84 | install_prerelease: Optional[bool] = False\n 85 | unrendered: Dict[str, Any] = field(default_factory=dict)\n 86 | \n 87 | def get_versions(self) -> List[str]:\n 88 | if isinstance(self.version, list):\n 89 | return [str(v) for v in self.version]\n 90 | else:\n 91 | return [str(self.version)]\n 92 | \n 93 | \n 94 | PackageSpec = Union[LocalPackage, TarballPackage, GitPackage, RegistryPackage]\n 95 | \n 96 | \n 97 | @dataclass\n 98 | class PackageConfig(dbtClassMixin, Replaceable):\n 99 | packages: List[PackageSpec]\n100 | \n101 | @classmethod\n102 | def validate(cls, data):\n103 | for package in data.get(\"packages\", data):\n104 | if isinstance(package, dict) and package.get(\"package\"):\n105 | if not package[\"version\"]:\n106 | raise ValidationError(\n107 | f\"{package['package']} is missing the version. When installing from the Hub \"\n108 | \"package index, version is a required property\"\n109 | )\n110 | \n111 | if \"/\" not in package[\"package\"]:\n112 | raise ValidationError(\n113 | f\"{package['package']} was not found in the package index. Packages on the index \"\n114 | \"require a namespace, e.g dbt-labs/dbt_utils\"\n115 | )\n116 | super().validate(data)\n117 | \n118 | \n119 | @dataclass\n120 | class ProjectPackageMetadata:\n121 | name: str\n122 | packages: List[PackageSpec]\n123 | \n124 | @classmethod\n125 | def from_project(cls, project):\n126 | return cls(name=project.project_name, packages=project.packages.packages)\n127 | \n128 | \n129 | @dataclass\n130 | class Downloads(ExtensibleDbtClassMixin, Replaceable):\n131 | tarball: str\n132 | \n133 | \n134 | @dataclass\n135 | class RegistryPackageMetadata(\n136 | ExtensibleDbtClassMixin,\n137 | ProjectPackageMetadata,\n138 | ):\n139 | downloads: Downloads\n140 | \n141 | \n142 | # A list of all the reserved words that packages may not have as names.\n143 | BANNED_PROJECT_NAMES = {\n144 | \"_sql_results\",\n145 | \"adapter\",\n146 | \"api\",\n147 | \"column\",\n148 | \"config\",\n149 | \"context\",\n150 | \"database\",\n151 | \"env\",\n152 | \"env_var\",\n153 | \"exceptions\",\n154 | \"execute\",\n155 | \"flags\",\n156 | \"fromjson\",\n157 | \"fromyaml\",\n158 | \"graph\",\n159 | \"invocation_id\",\n160 | \"load_agate_table\",\n161 | \"load_result\",\n162 | \"log\",\n163 | \"model\",\n164 | \"modules\",\n165 | \"post_hooks\",\n166 | \"pre_hooks\",\n167 | \"ref\",\n168 | \"render\",\n169 | \"return\",\n170 | \"run_started_at\",\n171 | \"schema\",\n172 | \"source\",\n173 | \"sql\",\n174 | \"sql_now\",\n175 | \"store_result\",\n176 | \"store_raw_result\",\n177 | \"target\",\n178 | \"this\",\n179 | \"tojson\",\n180 | \"toyaml\",\n181 | \"try_or_compiler_error\",\n182 | \"var\",\n183 | \"write\",\n184 | }\n185 | \n186 | \n187 | @dataclass\n188 | class Project(dbtClassMixin, Replaceable):\n189 | _hyphenated: ClassVar[bool] = True\n190 | # Annotated is used by mashumaro for jsonschema generation\n191 | name: Annotated[Identifier, Pattern(r\"^[^\\d\\W]\\w*$\")]\n192 | config_version: Optional[int] = 2\n193 | # Annotated is used by mashumaro for jsonschema generation\n194 | version: Optional[Union[Annotated[SemverString, Pattern(sem_ver_pattern)], float]] = None\n195 | project_root: Optional[str] = None\n196 | source_paths: Optional[List[str]] = None\n197 | model_paths: Optional[List[str]] = None\n198 | macro_paths: Optional[List[str]] = None\n199 | data_paths: Optional[List[str]] = None # deprecated\n200 | seed_paths: Optional[List[str]] = None\n201 | test_paths: Optional[List[str]] = None\n202 | analysis_paths: Optional[List[str]] = None\n203 | docs_paths: Optional[List[str]] = None\n204 | asset_paths: Optional[List[str]] = None\n205 | target_path: Optional[str] = None\n206 | snapshot_paths: Optional[List[str]] = None\n207 | clean_targets: Optional[List[str]] = None\n208 | profile: Optional[str] = None\n209 | log_path: Optional[str] = None\n210 | packages_install_path: Optional[str] = None\n211 | quoting: Optional[Quoting] = None\n212 | on_run_start: Optional[List[str]] = field(default_factory=list_str)\n213 | on_run_end: Optional[List[str]] = field(default_factory=list_str)\n214 | require_dbt_version: Optional[Union[List[str], str]] = None\n215 | dispatch: List[Dict[str, Any]] = field(default_factory=list)\n216 | models: Dict[str, Any] = field(default_factory=dict)\n217 | seeds: Dict[str, Any] = field(default_factory=dict)\n218 | snapshots: Dict[str, Any] = field(default_factory=dict)\n219 | analyses: Dict[str, Any] = field(default_factory=dict)\n220 | sources: Dict[str, Any] = field(default_factory=dict)\n221 | tests: Dict[str, Any] = field(default_factory=dict) # deprecated\n222 | data_tests: Dict[str, Any] = field(default_factory=dict)\n223 | unit_tests: Dict[str, Any] = field(default_factory=dict)\n224 | metrics: Dict[str, Any] = field(default_factory=dict)\n225 | semantic_models: Dict[str, Any] = field(default_factory=dict)\n226 | saved_queries: Dict[str, Any] = field(default_factory=dict)\n227 | exposures: Dict[str, Any] = field(default_factory=dict)\n228 | vars: Optional[Dict[str, Any]] = field(\n229 | default=None,\n230 | metadata=dict(\n231 | description=\"map project names to their vars override dicts\",\n232 | ),\n233 | )\n234 | packages: List[PackageSpec] = field(default_factory=list)\n235 | query_comment: Optional[Union[QueryComment, NoValue, str]] = field(default_factory=NoValue)\n236 | restrict_access: bool = False\n237 | dbt_cloud: Optional[Dict[str, Any]] = None\n238 | \n239 | class Config(dbtMashConfig):\n240 | # These tell mashumaro to use aliases for jsonschema and for \"from_dict\"\n241 | aliases = {\n242 | \"config_version\": \"config-version\",\n243 | \"project_root\": \"project-root\",\n244 | \"source_paths\": \"source-paths\",\n245 | \"model_paths\": \"model-paths\",\n246 | \"macro_paths\": \"macro-paths\",\n247 | \"data_paths\": \"data-paths\",\n248 | \"seed_paths\": \"seed-paths\",\n249 | \"test_paths\": \"test-paths\",\n250 | \"analysis_paths\": \"analysis-paths\",\n251 | \"docs_paths\": \"docs-paths\",\n252 | \"asset_paths\": \"asset-paths\",\n253 | \"target_path\": \"target-path\",\n254 | \"snapshot_paths\": \"snapshot-paths\",\n255 | \"clean_targets\": \"clean-targets\",\n256 | \"log_path\": \"log-path\",\n257 | \"packages_install_path\": \"packages-install-path\",\n258 | \"on_run_start\": \"on-run-start\",\n259 | \"on_run_end\": \"on-run-end\",\n260 | \"require_dbt_version\": \"require-dbt-version\",\n261 | \"query_comment\": \"query-comment\",\n262 | \"restrict_access\": \"restrict-access\",\n263 | \"semantic_models\": \"semantic-models\",\n264 | \"saved_queries\": \"saved-queries\",\n265 | \"dbt_cloud\": \"dbt-cloud\",\n266 | }\n267 | \n268 | @classmethod\n269 | def validate(cls, data):\n270 | super().validate(data)\n271 | if data[\"name\"] in BANNED_PROJECT_NAMES:\n272 | raise ValidationError(f\"Invalid project name: {data['name']} is a reserved word\")\n273 | # validate dispatch config\n274 | if \"dispatch\" in data and data[\"dispatch\"]:\n275 | entries = data[\"dispatch\"]\n276 | for entry in entries:\n277 | if (\n278 | \"macro_namespace\" not in entry\n279 | or \"search_order\" not in entry\n280 | or not isinstance(entry[\"search_order\"], list)\n281 | ):\n282 | raise ValidationError(f\"Invalid project dispatch config: {entry}\")\n283 | if \"dbt_cloud\" in data and not isinstance(data[\"dbt_cloud\"], dict):\n284 | raise ValidationError(\n285 | f\"Invalid dbt_cloud config. Expected a 'dict' but got '{type(data['dbt_cloud'])}'\"\n286 | )\n287 | if data.get(\"tests\", None) and data.get(\"data_tests\", None):\n288 | raise ValidationError(\n289 | \"Invalid project config: cannot have both 'tests' and 'data_tests' defined\"\n290 | )\n291 | if \"tests\" in data:\n292 | deprecations.warn(\n293 | \"project-test-config\", deprecated_path=\"tests\", exp_path=\"data_tests\"\n294 | )\n295 | \n296 | \n297 | @dataclass\n298 | class ProjectFlags(ExtensibleDbtClassMixin, Replaceable):\n299 | cache_selected_only: Optional[bool] = None\n300 | debug: Optional[bool] = None\n301 | fail_fast: Optional[bool] = None\n302 | indirect_selection: Optional[str] = None\n303 | log_format: Optional[str] = None\n304 | log_format_file: Optional[str] = None\n305 | log_level: Optional[str] = None\n306 | log_level_file: Optional[str] = None\n307 | partial_parse: Optional[bool] = None\n308 | populate_cache: Optional[bool] = None\n309 | printer_width: Optional[int] = None\n310 | send_anonymous_usage_stats: bool = DEFAULT_SEND_ANONYMOUS_USAGE_STATS\n311 | source_freshness_run_project_hooks: bool = False\n312 | static_parser: Optional[bool] = None\n313 | use_colors: Optional[bool] = None\n314 | use_colors_file: Optional[bool] = None\n315 | use_experimental_parser: Optional[bool] = None\n316 | version_check: Optional[bool] = None\n317 | warn_error: Optional[bool] = None\n318 | warn_error_options: Optional[Dict[str, Union[str, List[str]]]] = None\n319 | write_json: Optional[bool] = None\n320 | \n321 | @property\n322 | def project_only_flags(self) -> Dict[str, Any]:\n323 | return {\"source_freshness_run_project_hooks\": self.source_freshness_run_project_hooks}\n324 | \n325 | \n326 | @dataclass\n327 | class ProfileConfig(dbtClassMixin, Replaceable):\n328 | profile_name: str\n329 | target_name: str\n330 | threads: int\n331 | # TODO: make this a dynamic union of some kind?\n332 | credentials: Optional[Dict[str, Any]]\n333 | \n334 | \n335 | @dataclass\n336 | class ConfiguredQuoting(Quoting, Replaceable):\n337 | identifier: bool = True\n338 | schema: bool = True\n339 | database: Optional[bool] = None\n340 | project: Optional[bool] = None\n341 | \n342 | \n343 | @dataclass\n344 | class Configuration(Project, ProfileConfig):\n345 | cli_vars: Dict[str, Any] = field(\n346 | default_factory=dict,\n347 | metadata={\"preserve_underscore\": True},\n348 | )\n349 | quoting: Optional[ConfiguredQuoting] = None\n350 | \n351 | \n352 | @dataclass\n353 | class ProjectList(dbtClassMixin):\n354 | projects: Dict[str, Project]\n```\n\n### File: core/dbt/contracts/util.py\n\n```python\n 1 | from typing import List, Any, Tuple\n 2 | \n 3 | from dbt_common.dataclass_schema import ValidatedStringMixin, ValidationError\n 4 | \n 5 | # Leave imports of `Mergeable` and `Replaceable` to preserve import paths\n 6 | from dbt_common.contracts.util import Mergeable, Replaceable # noqa:F401\n 7 | \n 8 | \n 9 | SourceKey = Tuple[str, str]\n10 | \n11 | \n12 | def list_str() -> List[str]:\n13 | \"\"\"Mypy gets upset about stuff like:\n14 | \n15 | from dataclasses import dataclass, field\n16 | from typing import Optional, List\n17 | \n18 | @dataclass\n19 | class Foo:\n20 | x: Optional[List[str]] = field(default_factory=list)\n21 | \n22 | \n23 | Because `list` could be any kind of list, I guess\n24 | \"\"\"\n25 | return []\n26 | \n27 | \n28 | class Identifier(ValidatedStringMixin):\n29 | \"\"\"Our definition of a valid Identifier is the same as what's valid for an unquoted database table name.\n30 | \n31 | That is:\n32 | 1. It can contain a-z, A-Z, 0-9, and _\n33 | 1. It cannot start with a number\n34 | \"\"\"\n35 | \n36 | ValidationRegex = r\"^[^\\d\\W]\\w*$\"\n37 | \n38 | @classmethod\n39 | def is_valid(cls, value: Any) -> bool:\n40 | if not isinstance(value, str):\n41 | return False\n42 | \n43 | try:\n44 | cls.validate(value)\n45 | except ValidationError:\n46 | return False\n47 | \n48 | return True\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/graph/unparsed.py\n+++ b/core/dbt/contracts/graph/unparsed.py\n@@ -7,6 +7,7 @@ from dbt_common.contracts.config.properties import (\n AdditionalPropertiesAllowed,\n AdditionalPropertiesMixin,\n )\n+from dbt_common.contracts.util import Mergeable\n from dbt_common.exceptions import DbtInternalError, CompilationError\n from dbt_common.dataclass_schema import (\n dbtClassMixin,\n@@ -22,10 +23,7 @@ from dbt.artifacts.resources import (\n MaturityType,\n MeasureAggregationParameters,\n )\n-from dbt.contracts.util import (\n- Mergeable,\n- Replaceable,\n-)\n+from dbt.contracts.util import Replaceable\n \n # trigger the PathEncoder\n import dbt_common.helper_types # noqa:F401\ndiff --git a/core/dbt/contracts/project.py b/core/dbt/contracts/project.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/project.py\n+++ b/core/dbt/contracts/project.py\n@@ -1,7 +1,8 @@\n from dbt import deprecations\n-from dbt.contracts.util import Replaceable, Mergeable, list_str, Identifier\n+from dbt.contracts.util import Replaceable, list_str, Identifier\n from dbt.adapters.contracts.connection import QueryComment\n from dbt_common.helper_types import NoValue\n+from dbt_common.contracts.util import Mergeable\n from dbt_common.dataclass_schema import (\n dbtClassMixin,\n ValidationError,\ndiff --git a/core/dbt/contracts/util.py b/core/dbt/contracts/util.py\nindex 0000000..0000000 100644\n--- a/core/dbt/contracts/util.py\n+++ b/core/dbt/contracts/util.py\n@@ -1,8 +1,9 @@\n-import dataclasses\n from typing import List, Any, Tuple\n \n from dbt_common.dataclass_schema import ValidatedStringMixin, ValidationError\n-from dbt_common.contracts.util import Replaceable\n+\n+# Leave imports of `Mergeable` and `Replaceable` to preserve import paths\n+from dbt_common.contracts.util import Mergeable, Replaceable # noqa:F401\n \n \n SourceKey = Tuple[str, str]\n@@ -24,22 +25,6 @@ def list_str() -> List[str]:\n return []\n \n \n-class Mergeable(Replaceable):\n- def merged(self, *args):\n- \"\"\"Perform a shallow merge, where the last non-None write wins. This is\n- intended to merge dataclasses that are a collection of optional values.\n- \"\"\"\n- replacements = {}\n- cls = type(self)\n- for arg in args:\n- for field in dataclasses.fields(cls):\n- value = getattr(arg, field.name)\n- if value is not None:\n- replacements[field.name] = value\n-\n- return self.replace(**replacements)\n-\n-\n class Identifier(ValidatedStringMixin):\n \"\"\"Our definition of a valid Identifier is the same as what's valid for an unquoted database table name."},"prompt_input_token_count":{"kind":"number","value":28854,"string":"28,854"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9509\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"db65e627cab89fb5ef6f1f8793aa2a261106a3ca\",\n \"pull_number\": 9509,\n \"issue_numbers\": [\n \"9505\"\n ],\n \"changed_files\": [\n \"core/dbt/contracts/graph/unparsed.py\",\n \"core/dbt/contracts/project.py\",\n \"core/dbt/contracts/util.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": false\n}"}}},{"rowIdx":32299,"cells":{"id":{"kind":"string","value":"dbt-labs__dbt-core-9539"},"prompt":{"kind":"string","value":"You are given a GitHub issue and the relevant repository files before and after the fix.\n\nYour task is to synthesize the unified git diff that transforms the before files into the after files.\n\nRepository: dbt-labs/dbt-core\nBase commit: 1220fdfdd62b0f7ece97bbea52d08f86ac09bf73\nChanged files:\n- core/dbt/parser/schemas.py\n\n## Problem statement\n\n[CT-3544] [Bug] Model level constraints aren't being applied to versioned models\n### Is this a new bug in dbt-core?\r\n\r\n- [X] I believe this is a new bug in dbt-core\r\n- [X] I have searched the existing issues, and I could not find an existing issue for this bug\r\n\r\n### Current Behavior\r\n\r\nIf you're using model versions (https://docs.getdbt.com/docs/collaborate/govern/model-versions), model level constraints (https://docs.getdbt.com/reference/resource-properties/constraints#defining-constraints) don't seem to be applied to the model.\r\n\r\n### Expected Behavior\r\n\r\nModel level constraints should be applied as expected.\r\n\r\n### Steps To Reproduce\r\n\r\nFirst let's look at a well behaved model level constraints example (without model versioning).\r\n\r\n```yaml\r\n# dbt_project.yml\r\nname: my_dbt_project\r\nprofile: all\r\nconfig-version: 2\r\nversion: \"1.0.0\"\r\n\r\nmodels:\r\n my_dbt_project:\r\n +materialized: table\r\n\r\n# models/schema.yml\r\nversion: 2\r\nmodels:\r\n - name: foo\r\n config:\r\n contract:\r\n enforced: true\r\n constraints:\r\n - type: primary_key\r\n columns: [id, user_name]\r\n columns:\r\n - name: id\r\n data_type: int\r\n constraints:\r\n - type: not_null\r\n - name: user_name\r\n data_type: text\r\n```\r\n\r\n```sql\r\n-- models/foo.sql\r\nselect 1 as id, 'alice' as user_name\r\n```\r\n\r\nDo a run:\r\n\r\n```sh\r\n$ dbt --debug run -s foo\r\n...\r\n23:06:58 On model.my_dbt_project.foo: /* {\"app\": \"dbt\", \"dbt_version\": \"1.7.4\", \"profile_name\": \"all\", \"target_name\": \"pg-local\", \"node_id\": \"model.my_dbt_project.foo\"} */\r\n\r\n \r\n \r\n\r\n create table \"postgres\".\"public\".\"foo__dbt_tmp\"\r\n \r\n \r\n \r\n \r\n (\r\n id int not null,\r\n user_name text,\r\n \r\n primary key (id, user_name)\r\n )\r\n ;\r\n insert into \"postgres\".\"public\".\"foo__dbt_tmp\" (\r\n id, user_name\r\n )\r\n \r\n (\r\n \r\n select id, user_name\r\n from (\r\n select 1 as id, 'alice' as user_name\r\n ) as model_subq\r\n );\r\n \r\n23:06:58 SQL status: INSERT 0 1 in 0.0 seconds\r\n...\r\n```\r\n\r\nWe see the constraint `primary key (id, user_name)` is applied.\r\n\r\nNow let's rename the file `foo.sql` > `foo_v1.sql` and edit the `schema.yml` files contents:\r\n\r\n```yaml\r\n# models/schema.yml\r\nversion: 2\r\nmodels:\r\n - name: foo\r\n latest_version: 1\r\n config:\r\n contract:\r\n enforced: true\r\n constraints:\r\n - type: primary_key\r\n columns: [id, user_name]\r\n columns:\r\n - name: id\r\n data_type: int\r\n constraints:\r\n - type: not_null\r\n - name: user_name\r\n data_type: text\r\n versions:\r\n - v: 1\r\n```\r\n\r\n```sql\r\n-- models/foo_v1.sql\r\nselect 1 as id, 'alice' as user_name\r\n```\r\n\r\nDo a run:\r\n\r\n```sh\r\n$ dbt clean && dbt --debug run -s foo\r\n...\r\n23:09:56 On model.my_dbt_project.foo.v1: /* {\"app\": \"dbt\", \"dbt_version\": \"1.7.4\", \"profile_name\": \"all\", \"target_name\": \"pg-local\", \"node_id\": \"model.my_dbt_project.foo.v1\"} */\r\n\r\n \r\n \r\n\r\n create table \"postgres\".\"public\".\"foo_v1__dbt_tmp\"\r\n \r\n \r\n \r\n \r\n (\r\n id int not null,\r\n user_name text\r\n \r\n )\r\n ;\r\n insert into \"postgres\".\"public\".\"foo_v1__dbt_tmp\" (\r\n id, user_name\r\n )\r\n \r\n (\r\n \r\n select id, user_name\r\n from (\r\n select 1 as id, 'alice' as user_name\r\n ) as model_subq\r\n );\r\n \r\n23:09:56 SQL status: INSERT 0 1 in 0.0 seconds\r\n...\r\n```\r\n\r\nA versioned model of `foo` is created (`foo_v1`) and column level contraints are applied but the model level constraint is not applied.\r\n\r\n\r\n### Relevant log output\r\n\r\n_No response_\r\n\r\n### Environment\r\n\r\n```markdown\r\n- OS: macOS\r\n- Python: 3.11.2\r\n- dbt: \r\nCore:\r\n - installed: 1.7.4\r\n - latest: 1.7.4 - Up to date!\r\n\r\nPlugins:\r\n - bigquery: 1.7.2 - Up to date!\r\n - snowflake: 1.7.1 - Up to date!\r\n - postgres: 1.7.4 - Up to date!\r\n```\r\n\r\n\r\n### Which database adapter are you using with dbt?\r\n\r\npostgres\r\n\r\n### Additional Context\r\n\r\n_No response_\n\n## Files before the fix\n\n### File: core/dbt/parser/schemas.py\n\n```python\n 1 | import datetime\n 2 | import time\n 3 | \n 4 | from abc import ABCMeta, abstractmethod\n 5 | from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Type, TypeVar\n 6 | from dataclasses import dataclass, field\n 7 | \n 8 | from dbt import deprecations\n 9 | from dbt_common.contracts.constraints import ConstraintType, ModelLevelConstraint\n 10 | from dbt_common.dataclass_schema import ValidationError, dbtClassMixin\n 11 | \n 12 | from dbt.clients.yaml_helper import load_yaml_text\n 13 | from dbt.parser.schema_renderer import SchemaYamlRenderer\n 14 | from dbt.parser.schema_generic_tests import SchemaGenericTestParser\n 15 | from dbt.context.context_config import ContextConfig\n 16 | from dbt.context.configured import generate_schema_yml_context, SchemaYamlVars\n 17 | from dbt.contracts.files import SchemaSourceFile\n 18 | from dbt.contracts.graph.nodes import (\n 19 | ParsedNodePatch,\n 20 | ParsedMacroPatch,\n 21 | UnpatchedSourceDefinition,\n 22 | ModelNode,\n 23 | )\n 24 | from dbt.contracts.graph.unparsed import (\n 25 | HasColumnDocs,\n 26 | HasColumnTests,\n 27 | SourcePatch,\n 28 | UnparsedAnalysisUpdate,\n 29 | UnparsedMacroUpdate,\n 30 | UnparsedNodeUpdate,\n 31 | UnparsedModelUpdate,\n 32 | UnparsedSourceDefinition,\n 33 | )\n 34 | from dbt.exceptions import (\n 35 | DuplicateMacroPatchNameError,\n 36 | DuplicatePatchPathError,\n 37 | DuplicateSourcePatchNameError,\n 38 | JSONValidationError,\n 39 | DbtInternalError,\n 40 | ParsingError,\n 41 | YamlLoadError,\n 42 | YamlParseDictError,\n 43 | YamlParseListError,\n 44 | InvalidAccessTypeError,\n 45 | )\n 46 | from dbt_common.exceptions import DbtValidationError\n 47 | from dbt_common.events.functions import warn_or_error\n 48 | from dbt.events.types import (\n 49 | MacroNotFoundForPatch,\n 50 | NoNodeForYamlKey,\n 51 | ValidationWarning,\n 52 | UnsupportedConstraintMaterialization,\n 53 | WrongResourceSchemaFile,\n 54 | )\n 55 | from dbt.node_types import NodeType, AccessType\n 56 | from dbt.parser.base import SimpleParser\n 57 | from dbt.parser.search import FileBlock\n 58 | from dbt.parser.common import (\n 59 | YamlBlock,\n 60 | TargetBlock,\n 61 | TestBlock,\n 62 | VersionedTestBlock,\n 63 | ParserRef,\n 64 | trimmed,\n 65 | )\n 66 | from dbt.utils import coerce_dict_str\n 67 | from dbt_common.utils import deep_merge\n 68 | \n 69 | \n 70 | schema_file_keys = (\n 71 | \"models\",\n 72 | \"seeds\",\n 73 | \"snapshots\",\n 74 | \"sources\",\n 75 | \"macros\",\n 76 | \"analyses\",\n 77 | \"exposures\",\n 78 | \"metrics\",\n 79 | \"semantic_models\",\n 80 | \"saved_queries\",\n 81 | )\n 82 | \n 83 | \n 84 | # ===============================================================================\n 85 | # Schema Parser classes\n 86 | #\n 87 | # The SchemaParser is a subclass of the SimpleParser from base.py, as is\n 88 | # the SchemaGenericTestParser. The schema sub-parsers are all subclasses of\n 89 | # the YamlReader parsing class. Most of the action in creating SourceDefinition\n 90 | # nodes actually happens in the SourcePatcher class, in sources.py, which is\n 91 | # called as a late-stage parsing step in manifest.py.\n 92 | #\n 93 | # The \"patch\" parsers read yaml config and properties and apply them to\n 94 | # nodes that were already created from sql files.\n 95 | #\n 96 | # The SchemaParser and SourcePatcher both use the SchemaGenericTestParser\n 97 | # (in schema_generic_tests.py) to create generic test nodes.\n 98 | #\n 99 | # YamlReader\n100 | # MetricParser (metrics) [schema_yaml_readers.py]\n101 | # ExposureParser (exposures) [schema_yaml_readers.py]\n102 | # GroupParser (groups) [schema_yaml_readers.py]\n103 | # SourceParser (sources)\n104 | # PatchParser\n105 | # MacroPatchParser (macros)\n106 | # NodePatchParser\n107 | # ModelPatchParser (models)\n108 | # AnalysisPatchParser (analyses)\n109 | # TestablePatchParser (seeds, snapshots)\n110 | #\n111 | # ===============================================================================\n112 | \n113 | \n114 | def yaml_from_file(source_file: SchemaSourceFile) -> Dict[str, Any]:\n115 | \"\"\"If loading the yaml fails, raise an exception.\"\"\"\n116 | try:\n117 | # source_file.contents can sometimes be None\n118 | return load_yaml_text(source_file.contents or \"\", source_file.path)\n119 | except DbtValidationError as e:\n120 | raise YamlLoadError(\n121 | project_name=source_file.project_name, path=source_file.path.relative_path, exc=e\n122 | )\n123 | \n124 | \n125 | # This is the main schema file parser, but almost everything happens in the\n126 | # the schema sub-parsers.\n127 | class SchemaParser(SimpleParser[YamlBlock, ModelNode]):\n128 | def __init__(\n129 | self,\n130 | project,\n131 | manifest,\n132 | root_project,\n133 | ) -> None:\n134 | super().__init__(project, manifest, root_project)\n135 | \n136 | self.generic_test_parser = SchemaGenericTestParser(project, manifest, root_project)\n137 | \n138 | self.schema_yaml_vars = SchemaYamlVars()\n139 | self.render_ctx = generate_schema_yml_context(\n140 | self.root_project, self.project.project_name, self.schema_yaml_vars\n141 | )\n142 | \n143 | # This is unnecessary, but mypy was requiring it. Clean up parser code so\n144 | # we don't have to do this.\n145 | def parse_from_dict(self, dct):\n146 | pass\n147 | \n148 | @classmethod\n149 | def get_compiled_path(cls, block: FileBlock) -> str:\n150 | # should this raise an error?\n151 | return block.path.relative_path\n152 | \n153 | @property\n154 | def resource_type(self) -> NodeType:\n155 | return NodeType.Test\n156 | \n157 | def parse_file(self, block: FileBlock, dct: Optional[Dict] = None) -> None:\n158 | assert isinstance(block.file, SchemaSourceFile)\n159 | \n160 | # If partially parsing, dct should be from pp_dict, otherwise\n161 | # dict_from_yaml\n162 | if dct:\n163 | # contains the FileBlock and the data (dictionary)\n164 | yaml_block = YamlBlock.from_file_block(block, dct)\n165 | \n166 | parser: YamlReader\n167 | \n168 | # There are 9 different yaml lists which are parsed by different parsers:\n169 | # Model, Seed, Snapshot, Source, Macro, Analysis, Exposure, Metric, Group\n170 | \n171 | # ModelPatchParser.parse()\n172 | if \"models\" in dct:\n173 | # the models are already in the manifest as nodes when we reach this code,\n174 | # even if they are disabled in the schema file\n175 | model_parse_result = ModelPatchParser(self, yaml_block, \"models\").parse()\n176 | for versioned_test_block in model_parse_result.versioned_test_blocks:\n177 | self.generic_test_parser.parse_versioned_tests(versioned_test_block)\n178 | \n179 | # PatchParser.parse()\n180 | if \"seeds\" in dct:\n181 | seed_parse_result = TestablePatchParser(self, yaml_block, \"seeds\").parse()\n182 | for test_block in seed_parse_result.test_blocks:\n183 | self.generic_test_parser.parse_tests(test_block)\n184 | \n185 | # PatchParser.parse()\n186 | if \"snapshots\" in dct:\n187 | snapshot_parse_result = TestablePatchParser(self, yaml_block, \"snapshots\").parse()\n188 | for test_block in snapshot_parse_result.test_blocks:\n189 | self.generic_test_parser.parse_tests(test_block)\n190 | \n191 | # This parser uses SourceParser.parse() which doesn't return\n192 | # any test blocks. Source tests are handled at a later point\n193 | # in the process.\n194 | if \"sources\" in dct:\n195 | parser = SourceParser(self, yaml_block, \"sources\")\n196 | parser.parse()\n197 | \n198 | # PatchParser.parse() (but never test_blocks)\n199 | if \"macros\" in dct:\n200 | parser = MacroPatchParser(self, yaml_block, \"macros\")\n201 | parser.parse()\n202 | \n203 | # PatchParser.parse() (but never test_blocks)\n204 | if \"analyses\" in dct:\n205 | parser = AnalysisPatchParser(self, yaml_block, \"analyses\")\n206 | parser.parse()\n207 | \n208 | # ExposureParser.parse()\n209 | if \"exposures\" in dct:\n210 | from dbt.parser.schema_yaml_readers import ExposureParser\n211 | \n212 | exp_parser = ExposureParser(self, yaml_block)\n213 | exp_parser.parse()\n214 | \n215 | # MetricParser.parse()\n216 | if \"metrics\" in dct:\n217 | from dbt.parser.schema_yaml_readers import MetricParser\n218 | \n219 | metric_parser = MetricParser(self, yaml_block)\n220 | metric_parser.parse()\n221 | \n222 | # GroupParser.parse()\n223 | if \"groups\" in dct:\n224 | from dbt.parser.schema_yaml_readers import GroupParser\n225 | \n226 | group_parser = GroupParser(self, yaml_block)\n227 | group_parser.parse()\n228 | \n229 | if \"semantic_models\" in dct:\n230 | from dbt.parser.schema_yaml_readers import SemanticModelParser\n231 | \n232 | semantic_model_parser = SemanticModelParser(self, yaml_block)\n233 | semantic_model_parser.parse()\n234 | \n235 | if \"unit_tests\" in dct:\n236 | from dbt.parser.unit_tests import UnitTestParser\n237 | \n238 | unit_test_parser = UnitTestParser(self, yaml_block)\n239 | unit_test_parser.parse()\n240 | \n241 | if \"saved_queries\" in dct:\n242 | from dbt.parser.schema_yaml_readers import SavedQueryParser\n243 | \n244 | saved_query_parser = SavedQueryParser(self, yaml_block)\n245 | saved_query_parser.parse()\n246 | \n247 | \n248 | Parsed = TypeVar(\"Parsed\", UnpatchedSourceDefinition, ParsedNodePatch, ParsedMacroPatch)\n249 | NodeTarget = TypeVar(\"NodeTarget\", UnparsedNodeUpdate, UnparsedAnalysisUpdate, UnparsedModelUpdate)\n250 | NonSourceTarget = TypeVar(\n251 | \"NonSourceTarget\",\n252 | UnparsedNodeUpdate,\n253 | UnparsedAnalysisUpdate,\n254 | UnparsedMacroUpdate,\n255 | UnparsedModelUpdate,\n256 | )\n257 | \n258 | \n259 | @dataclass\n260 | class ParseResult:\n261 | test_blocks: List[TestBlock] = field(default_factory=list)\n262 | versioned_test_blocks: List[VersionedTestBlock] = field(default_factory=list)\n263 | \n264 | \n265 | # abstract base class (ABCMeta)\n266 | # Many subclasses: MetricParser, ExposureParser, GroupParser, SourceParser,\n267 | # PatchParser, SemanticModelParser, SavedQueryParser, UnitTestParser\n268 | class YamlReader(metaclass=ABCMeta):\n269 | def __init__(self, schema_parser: SchemaParser, yaml: YamlBlock, key: str) -> None:\n270 | self.schema_parser = schema_parser\n271 | # key: models, seeds, snapshots, sources, macros,\n272 | # analyses, exposures, unit_tests\n273 | self.key = key\n274 | self.yaml = yaml\n275 | self.schema_yaml_vars = SchemaYamlVars()\n276 | self.render_ctx = generate_schema_yml_context(\n277 | self.schema_parser.root_project,\n278 | self.schema_parser.project.project_name,\n279 | self.schema_yaml_vars,\n280 | )\n281 | self.renderer = SchemaYamlRenderer(self.render_ctx, self.key)\n282 | \n283 | @property\n284 | def manifest(self):\n285 | return self.schema_parser.manifest\n286 | \n287 | @property\n288 | def project(self):\n289 | return self.schema_parser.project\n290 | \n291 | @property\n292 | def default_database(self):\n293 | return self.schema_parser.default_database\n294 | \n295 | @property\n296 | def root_project(self):\n297 | return self.schema_parser.root_project\n298 | \n299 | # for the different schema subparsers ('models', 'source', etc)\n300 | # get the list of dicts pointed to by the key in the yaml config,\n301 | # ensure that the dicts have string keys\n302 | def get_key_dicts(self) -> Iterable[Dict[str, Any]]:\n303 | data = self.yaml.data.get(self.key, [])\n304 | if not isinstance(data, list):\n305 | raise ParsingError(\n306 | \"{} must be a list, got {} instead: ({})\".format(\n307 | self.key, type(data), trimmed(str(data))\n308 | )\n309 | )\n310 | path = self.yaml.path.original_file_path\n311 | \n312 | # for each dict in the data (which is a list of dicts)\n313 | for entry in data:\n314 | \n315 | # check that entry is a dict and that all dict values\n316 | # are strings\n317 | if coerce_dict_str(entry) is None:\n318 | raise YamlParseListError(path, self.key, data, \"expected a dict with string keys\")\n319 | \n320 | if \"name\" not in entry and \"model\" not in entry:\n321 | raise ParsingError(\"Entry did not contain a name\")\n322 | \n323 | # Render the data (except for tests, data_tests and descriptions).\n324 | # See the SchemaYamlRenderer\n325 | entry = self.render_entry(entry)\n326 | if self.schema_yaml_vars.env_vars:\n327 | self.schema_parser.manifest.env_vars.update(self.schema_yaml_vars.env_vars)\n328 | schema_file = self.yaml.file\n329 | assert isinstance(schema_file, SchemaSourceFile)\n330 | for var in self.schema_yaml_vars.env_vars.keys():\n331 | schema_file.add_env_var(var, self.key, entry[\"name\"])\n332 | self.schema_yaml_vars.env_vars = {}\n333 | \n334 | yield entry\n335 | \n336 | def render_entry(self, dct):\n337 | try:\n338 | # This does a deep_map which will fail if there are circular references\n339 | dct = self.renderer.render_data(dct)\n340 | except ParsingError as exc:\n341 | raise ParsingError(\n342 | f\"Failed to render {self.yaml.file.path.original_file_path} from \"\n343 | f\"project {self.project.project_name}: {exc}\"\n344 | ) from exc\n345 | return dct\n346 | \n347 | @abstractmethod\n348 | def parse(self) -> ParseResult:\n349 | raise NotImplementedError(\"parse is abstract\")\n350 | \n351 | \n352 | T = TypeVar(\"T\", bound=dbtClassMixin)\n353 | \n354 | \n355 | # This parses the 'sources' keys in yaml files.\n356 | class SourceParser(YamlReader):\n357 | def _target_from_dict(self, cls: Type[T], data: Dict[str, Any]) -> T:\n358 | path = self.yaml.path.original_file_path\n359 | try:\n360 | cls.validate(data)\n361 | return cls.from_dict(data)\n362 | except (ValidationError, JSONValidationError) as exc:\n363 | raise YamlParseDictError(path, self.key, data, exc)\n364 | \n365 | # This parse method takes the yaml dictionaries in 'sources' keys and uses them\n366 | # to create UnparsedSourceDefinition objects. They are then turned\n367 | # into UnpatchedSourceDefinition objects in 'add_source_definitions'\n368 | # or SourcePatch objects in 'add_source_patch'\n369 | def parse(self) -> ParseResult:\n370 | # get a verified list of dicts for the key handled by this parser\n371 | for data in self.get_key_dicts():\n372 | data = self.project.credentials.translate_aliases(data, recurse=True)\n373 | \n374 | is_override = \"overrides\" in data\n375 | if is_override:\n376 | data[\"path\"] = self.yaml.path.original_file_path\n377 | patch = self._target_from_dict(SourcePatch, data)\n378 | assert isinstance(self.yaml.file, SchemaSourceFile)\n379 | source_file = self.yaml.file\n380 | # source patches must be unique\n381 | key = (patch.overrides, patch.name)\n382 | if key in self.manifest.source_patches:\n383 | raise DuplicateSourcePatchNameError(patch, self.manifest.source_patches[key])\n384 | self.manifest.source_patches[key] = patch\n385 | source_file.source_patches.append(key)\n386 | else:\n387 | source = self._target_from_dict(UnparsedSourceDefinition, data)\n388 | self.add_source_definitions(source)\n389 | return ParseResult()\n390 | \n391 | def add_source_definitions(self, source: UnparsedSourceDefinition) -> None:\n392 | package_name = self.project.project_name\n393 | original_file_path = self.yaml.path.original_file_path\n394 | fqn_path = self.yaml.path.relative_path\n395 | for table in source.tables:\n396 | unique_id = \".\".join([NodeType.Source, package_name, source.name, table.name])\n397 | \n398 | # the FQN is project name / path elements /source_name /table_name\n399 | fqn = self.schema_parser.get_fqn_prefix(fqn_path)\n400 | fqn.extend([source.name, table.name])\n401 | \n402 | source_def = UnpatchedSourceDefinition(\n403 | source=source,\n404 | table=table,\n405 | path=original_file_path,\n406 | original_file_path=original_file_path,\n407 | package_name=package_name,\n408 | unique_id=unique_id,\n409 | resource_type=NodeType.Source,\n410 | fqn=fqn,\n411 | name=f\"{source.name}_{table.name}\",\n412 | )\n413 | self.manifest.add_source(self.yaml.file, source_def)\n414 | \n415 | \n416 | # This class has two subclasses: NodePatchParser and MacroPatchParser\n417 | class PatchParser(YamlReader, Generic[NonSourceTarget, Parsed]):\n418 | @abstractmethod\n419 | def _target_type(self) -> Type[NonSourceTarget]:\n420 | raise NotImplementedError(\"_target_type not implemented\")\n421 | \n422 | @abstractmethod\n423 | def get_block(self, node: NonSourceTarget) -> TargetBlock:\n424 | raise NotImplementedError(\"get_block is abstract\")\n425 | \n426 | @abstractmethod\n427 | def parse_patch(self, block: TargetBlock[NonSourceTarget], refs: ParserRef) -> None:\n428 | raise NotImplementedError(\"parse_patch is abstract\")\n429 | \n430 | def parse(self) -> ParseResult:\n431 | node: NonSourceTarget\n432 | # This will always be empty if the node a macro or analysis\n433 | test_blocks: List[TestBlock] = []\n434 | # This will always be empty if the node is _not_ a model\n435 | versioned_test_blocks: List[VersionedTestBlock] = []\n436 | \n437 | # get list of 'node' objects\n438 | # UnparsedNodeUpdate (TestablePatchParser, models, seeds, snapshots)\n439 | # = HasColumnTests, HasTests\n440 | # UnparsedAnalysisUpdate (UnparsedAnalysisParser, analyses)\n441 | # = HasColumnDocs, HasDocs\n442 | # UnparsedMacroUpdate (MacroPatchParser, 'macros')\n443 | # = HasDocs\n444 | # correspond to this parser's 'key'\n445 | for node in self.get_unparsed_target():\n446 | # node_block is a TargetBlock (Macro or Analysis)\n447 | # or a TestBlock (all of the others)\n448 | node_block = self.get_block(node)\n449 | if isinstance(node_block, TestBlock):\n450 | # TestablePatchParser = seeds, snapshots\n451 | test_blocks.append(node_block)\n452 | if isinstance(node_block, VersionedTestBlock):\n453 | # models\n454 | versioned_test_blocks.append(node_block)\n455 | if isinstance(node, (HasColumnDocs, HasColumnTests)):\n456 | # UnparsedNodeUpdate and UnparsedAnalysisUpdate\n457 | refs: ParserRef = ParserRef.from_target(node)\n458 | else:\n459 | refs = ParserRef()\n460 | \n461 | # There's no unique_id on the node yet so cannot add to disabled dict\n462 | self.parse_patch(node_block, refs)\n463 | \n464 | return ParseResult(test_blocks, versioned_test_blocks)\n465 | \n466 | def get_unparsed_target(self) -> Iterable[NonSourceTarget]:\n467 | path = self.yaml.path.original_file_path\n468 | \n469 | # get verified list of dicts for the 'key' that this\n470 | # parser handles\n471 | key_dicts = self.get_key_dicts()\n472 | for data in key_dicts:\n473 | # add extra data to each dict. This updates the dicts\n474 | # in the parser yaml\n475 | data.update(\n476 | {\n477 | \"original_file_path\": path,\n478 | \"yaml_key\": self.key,\n479 | \"package_name\": self.project.project_name,\n480 | }\n481 | )\n482 | try:\n483 | # target_type: UnparsedNodeUpdate, UnparsedAnalysisUpdate,\n484 | # or UnparsedMacroUpdate\n485 | self._target_type().validate(data)\n486 | if self.key != \"macros\":\n487 | # macros don't have the 'config' key support yet\n488 | self.normalize_meta_attribute(data, path)\n489 | self.normalize_docs_attribute(data, path)\n490 | self.normalize_group_attribute(data, path)\n491 | self.normalize_contract_attribute(data, path)\n492 | self.normalize_access_attribute(data, path)\n493 | # `tests` has been deprecated, convert to `data_tests` here if present\n494 | self.validate_data_tests(data)\n495 | node = self._target_type().from_dict(data)\n496 | except (ValidationError, JSONValidationError) as exc:\n497 | raise YamlParseDictError(path, self.key, data, exc)\n498 | else:\n499 | yield node\n500 | \n501 | # We want to raise an error if some attributes are in two places, and move them\n502 | # from toplevel to config if necessary\n503 | def normalize_attribute(self, data, path, attribute):\n504 | if attribute in data:\n505 | if \"config\" in data and attribute in data[\"config\"]:\n506 | raise ParsingError(\n507 | f\"\"\"\n508 | In {path}: found {attribute} dictionary in 'config' dictionary and as top-level key.\n509 | Remove the top-level key and define it under 'config' dictionary only.\n510 | \"\"\".strip()\n511 | )\n512 | else:\n513 | if \"config\" not in data:\n514 | data[\"config\"] = {}\n515 | data[\"config\"][attribute] = data.pop(attribute)\n516 | \n517 | def normalize_meta_attribute(self, data, path):\n518 | return self.normalize_attribute(data, path, \"meta\")\n519 | \n520 | def normalize_docs_attribute(self, data, path):\n521 | return self.normalize_attribute(data, path, \"docs\")\n522 | \n523 | def normalize_group_attribute(self, data, path):\n524 | return self.normalize_attribute(data, path, \"group\")\n525 | \n526 | def normalize_contract_attribute(self, data, path):\n527 | return self.normalize_attribute(data, path, \"contract\")\n528 | \n529 | def normalize_access_attribute(self, data, path):\n530 | return self.normalize_attribute(data, path, \"access\")\n531 | \n532 | def validate_data_tests(self, data):\n533 | # Rename 'tests' -> 'data_tests' at both model-level and column-level\n534 | # Raise a validation error if the user has defined both names\n535 | def validate_and_rename(data):\n536 | if data.get(\"tests\"):\n537 | if \"tests\" in data and \"data_tests\" in data:\n538 | raise ValidationError(\n539 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n540 | )\n541 | deprecations.warn(\n542 | \"project-test-config\",\n543 | deprecated_path=\"tests\",\n544 | exp_path=\"data_tests\",\n545 | )\n546 | data[\"data_tests\"] = data.pop(\"tests\")\n547 | \n548 | # model-level tests\n549 | validate_and_rename(data)\n550 | \n551 | # column-level tests\n552 | if data.get(\"columns\"):\n553 | for column in data[\"columns\"]:\n554 | validate_and_rename(column)\n555 | \n556 | # versioned models\n557 | if data.get(\"versions\"):\n558 | for version in data[\"versions\"]:\n559 | validate_and_rename(version)\n560 | if version.get(\"columns\"):\n561 | for column in version[\"columns\"]:\n562 | validate_and_rename(column)\n563 | \n564 | def patch_node_config(self, node, patch):\n565 | # Get the ContextConfig that's used in calculating the config\n566 | # This must match the model resource_type that's being patched\n567 | config = ContextConfig(\n568 | self.schema_parser.root_project,\n569 | node.fqn,\n570 | node.resource_type,\n571 | self.schema_parser.project.project_name,\n572 | )\n573 | # We need to re-apply the config_call_dict after the patch config\n574 | config._config_call_dict = node.config_call_dict\n575 | self.schema_parser.update_parsed_node_config(node, config, patch_config_dict=patch.config)\n576 | \n577 | \n578 | # Subclasses of NodePatchParser: TestablePatchParser, ModelPatchParser, AnalysisPatchParser,\n579 | # so models, seeds, snapshots, analyses\n580 | class NodePatchParser(PatchParser[NodeTarget, ParsedNodePatch], Generic[NodeTarget]):\n581 | def parse_patch(self, block: TargetBlock[NodeTarget], refs: ParserRef) -> None:\n582 | # We're not passing the ParsedNodePatch around anymore, so we\n583 | # could possibly skip creating one. Leaving here for now for\n584 | # code consistency.\n585 | deprecation_date: Optional[datetime.datetime] = None\n586 | if isinstance(block.target, UnparsedModelUpdate):\n587 | deprecation_date = block.target.deprecation_date\n588 | \n589 | patch = ParsedNodePatch(\n590 | name=block.target.name,\n591 | original_file_path=block.target.original_file_path,\n592 | yaml_key=block.target.yaml_key,\n593 | package_name=block.target.package_name,\n594 | description=block.target.description,\n595 | columns=refs.column_info,\n596 | meta=block.target.meta,\n597 | docs=block.target.docs,\n598 | config=block.target.config,\n599 | access=block.target.access,\n600 | version=None,\n601 | latest_version=None,\n602 | constraints=block.target.constraints,\n603 | deprecation_date=deprecation_date,\n604 | )\n605 | assert isinstance(self.yaml.file, SchemaSourceFile)\n606 | source_file: SchemaSourceFile = self.yaml.file\n607 | if patch.yaml_key in [\"models\", \"seeds\", \"snapshots\"]:\n608 | unique_id = self.manifest.ref_lookup.get_unique_id(\n609 | patch.name, self.project.project_name, None\n610 | ) or self.manifest.ref_lookup.get_unique_id(patch.name, None, None)\n611 | \n612 | if unique_id:\n613 | resource_type = NodeType(unique_id.split(\".\")[0])\n614 | if resource_type.pluralize() != patch.yaml_key:\n615 | warn_or_error(\n616 | WrongResourceSchemaFile(\n617 | patch_name=patch.name,\n618 | resource_type=resource_type,\n619 | plural_resource_type=resource_type.pluralize(),\n620 | yaml_key=patch.yaml_key,\n621 | file_path=patch.original_file_path,\n622 | )\n623 | )\n624 | return\n625 | \n626 | elif patch.yaml_key == \"analyses\":\n627 | unique_id = self.manifest.analysis_lookup.get_unique_id(patch.name, None, None)\n628 | else:\n629 | raise DbtInternalError(\n630 | f\"Unexpected yaml_key {patch.yaml_key} for patch in \"\n631 | f\"file {source_file.path.original_file_path}\"\n632 | )\n633 | # handle disabled nodes\n634 | if unique_id is None:\n635 | # Node might be disabled. Following call returns list of matching disabled nodes\n636 | found_nodes = self.manifest.disabled_lookup.find(patch.name, patch.package_name)\n637 | if found_nodes:\n638 | if len(found_nodes) > 1 and patch.config.get(\"enabled\"):\n639 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n640 | # We have no way to know which one to enable.\n641 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n642 | msg = (\n643 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n644 | f\"{resource_type} '{patch.name}'. Multiple nodes for the same \"\n645 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n646 | \"in `dbt_project.yml` or in the sql files.\"\n647 | )\n648 | raise ParsingError(msg)\n649 | \n650 | # all nodes in the disabled dict have the same unique_id so just grab the first one\n651 | # to append with the unique id\n652 | source_file.append_patch(patch.yaml_key, found_nodes[0].unique_id)\n653 | for node in found_nodes:\n654 | node.patch_path = source_file.file_id\n655 | # re-calculate the node config with the patch config. Always do this\n656 | # for the case when no config is set to ensure the default of true gets captured\n657 | if patch.config:\n658 | self.patch_node_config(node, patch)\n659 | \n660 | self.patch_node_properties(node, patch)\n661 | else:\n662 | warn_or_error(\n663 | NoNodeForYamlKey(\n664 | patch_name=patch.name,\n665 | yaml_key=patch.yaml_key,\n666 | file_path=source_file.path.original_file_path,\n667 | )\n668 | )\n669 | return\n670 | \n671 | # patches can't be overwritten\n672 | node = self.manifest.nodes.get(unique_id)\n673 | if node:\n674 | if node.patch_path:\n675 | package_name, existing_file_path = node.patch_path.split(\"://\")\n676 | raise DuplicatePatchPathError(patch, existing_file_path)\n677 | \n678 | source_file.append_patch(patch.yaml_key, node.unique_id)\n679 | # re-calculate the node config with the patch config. Always do this\n680 | # for the case when no config is set to ensure the default of true gets captured\n681 | if patch.config:\n682 | self.patch_node_config(node, patch)\n683 | \n684 | self.patch_node_properties(node, patch)\n685 | \n686 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n687 | \"\"\"Given a ParsedNodePatch, add the new information to the node.\"\"\"\n688 | # explicitly pick out the parts to update so we don't inadvertently\n689 | # step on the model name or anything\n690 | # Note: config should already be updated\n691 | node.patch_path = patch.file_id\n692 | # update created_at so process_docs will run in partial parsing\n693 | node.created_at = time.time()\n694 | node.description = patch.description\n695 | node.columns = patch.columns\n696 | node.name = patch.name\n697 | \n698 | if not isinstance(node, ModelNode):\n699 | for attr in [\"latest_version\", \"access\", \"version\", \"constraints\"]:\n700 | if getattr(patch, attr):\n701 | warn_or_error(\n702 | ValidationWarning(\n703 | field_name=attr,\n704 | resource_type=node.resource_type.value,\n705 | node_name=patch.name,\n706 | )\n707 | )\n708 | \n709 | \n710 | # TestablePatchParser = seeds, snapshots\n711 | class TestablePatchParser(NodePatchParser[UnparsedNodeUpdate]):\n712 | __test__ = False\n713 | \n714 | def get_block(self, node: UnparsedNodeUpdate) -> TestBlock:\n715 | return TestBlock.from_yaml_block(self.yaml, node)\n716 | \n717 | def _target_type(self) -> Type[UnparsedNodeUpdate]:\n718 | return UnparsedNodeUpdate\n719 | \n720 | \n721 | class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n722 | def get_block(self, node: UnparsedModelUpdate) -> VersionedTestBlock:\n723 | return VersionedTestBlock.from_yaml_block(self.yaml, node)\n724 | \n725 | def parse_patch(self, block: TargetBlock[UnparsedModelUpdate], refs: ParserRef) -> None:\n726 | target = block.target\n727 | if NodeType.Model.pluralize() != target.yaml_key:\n728 | warn_or_error(\n729 | WrongResourceSchemaFile(\n730 | patch_name=target.name,\n731 | resource_type=NodeType.Model,\n732 | plural_resource_type=NodeType.Model.pluralize(),\n733 | yaml_key=target.yaml_key,\n734 | file_path=target.original_file_path,\n735 | )\n736 | )\n737 | return\n738 | \n739 | versions = target.versions\n740 | if not versions:\n741 | super().parse_patch(block, refs)\n742 | else:\n743 | assert isinstance(self.yaml.file, SchemaSourceFile)\n744 | source_file: SchemaSourceFile = self.yaml.file\n745 | latest_version = (\n746 | target.latest_version if target.latest_version is not None else max(versions).v\n747 | )\n748 | for unparsed_version in versions:\n749 | versioned_model_name = (\n750 | unparsed_version.defined_in or f\"{block.name}_{unparsed_version.formatted_v}\"\n751 | )\n752 | # ref lookup without version - version is not set yet\n753 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n754 | versioned_model_name, target.package_name, None\n755 | )\n756 | \n757 | versioned_model_node = None\n758 | add_node_nofile_fn: Callable\n759 | \n760 | # If this is the latest version, it's allowed to define itself in a model file name that doesn't have a suffix\n761 | if versioned_model_unique_id is None and unparsed_version.v == latest_version:\n762 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n763 | block.name, target.package_name, None\n764 | )\n765 | \n766 | if versioned_model_unique_id is None:\n767 | # Node might be disabled. Following call returns list of matching disabled nodes\n768 | found_nodes = self.manifest.disabled_lookup.find(versioned_model_name, None)\n769 | if found_nodes:\n770 | if len(found_nodes) > 1 and target.config.get(\"enabled\"):\n771 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n772 | # We have no way to know which one to enable.\n773 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n774 | msg = (\n775 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n776 | f\"{resource_type} '{target.name}'. Multiple nodes for the same \"\n777 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n778 | \"in `dbt_project.yml` or in the sql files.\"\n779 | )\n780 | raise ParsingError(msg)\n781 | versioned_model_node = self.manifest.disabled.pop(\n782 | found_nodes[0].unique_id\n783 | )[0]\n784 | add_node_nofile_fn = self.manifest.add_disabled_nofile\n785 | else:\n786 | versioned_model_node = self.manifest.nodes.pop(versioned_model_unique_id)\n787 | add_node_nofile_fn = self.manifest.add_node_nofile\n788 | \n789 | if versioned_model_node is None:\n790 | warn_or_error(\n791 | NoNodeForYamlKey(\n792 | patch_name=versioned_model_name,\n793 | yaml_key=target.yaml_key,\n794 | file_path=source_file.path.original_file_path,\n795 | )\n796 | )\n797 | continue\n798 | \n799 | # update versioned node unique_id\n800 | versioned_model_node_unique_id_old = versioned_model_node.unique_id\n801 | versioned_model_node.unique_id = (\n802 | f\"model.{target.package_name}.{target.name}.{unparsed_version.formatted_v}\"\n803 | )\n804 | # update source file.nodes with new unique_id\n805 | self.manifest.files[versioned_model_node.file_id].nodes.remove(\n806 | versioned_model_node_unique_id_old\n807 | )\n808 | self.manifest.files[versioned_model_node.file_id].nodes.append(\n809 | versioned_model_node.unique_id\n810 | )\n811 | \n812 | # update versioned node fqn\n813 | versioned_model_node.fqn[-1] = target.name\n814 | versioned_model_node.fqn.append(unparsed_version.formatted_v)\n815 | \n816 | # add versioned node back to nodes/disabled\n817 | add_node_nofile_fn(versioned_model_node)\n818 | \n819 | # flatten columns based on include/exclude\n820 | version_refs: ParserRef = ParserRef.from_versioned_target(\n821 | block.target, unparsed_version.v\n822 | )\n823 | \n824 | versioned_model_patch = ParsedNodePatch(\n825 | name=target.name,\n826 | original_file_path=target.original_file_path,\n827 | yaml_key=target.yaml_key,\n828 | package_name=target.package_name,\n829 | description=unparsed_version.description or target.description,\n830 | columns=version_refs.column_info,\n831 | meta=target.meta,\n832 | docs=unparsed_version.docs or target.docs,\n833 | config=deep_merge(target.config, unparsed_version.config),\n834 | access=unparsed_version.access or target.access,\n835 | version=unparsed_version.v,\n836 | latest_version=latest_version,\n837 | constraints=unparsed_version.constraints or target.constraints,\n838 | deprecation_date=unparsed_version.deprecation_date,\n839 | )\n840 | # Node patched before config because config patching depends on model name,\n841 | # which may have been updated in the version patch\n842 | # versioned_model_node.patch(versioned_model_patch)\n843 | self.patch_node_properties(versioned_model_node, versioned_model_patch)\n844 | \n845 | # Includes alias recomputation\n846 | self.patch_node_config(versioned_model_node, versioned_model_patch)\n847 | \n848 | # Need to reapply this here, in the case that 'contract: {enforced: true}' was during config-setting\n849 | versioned_model_node.build_contract_checksum()\n850 | source_file.append_patch(\n851 | versioned_model_patch.yaml_key, versioned_model_node.unique_id\n852 | )\n853 | self.manifest.rebuild_ref_lookup()\n854 | self.manifest.rebuild_disabled_lookup()\n855 | \n856 | def _target_type(self) -> Type[UnparsedModelUpdate]:\n857 | return UnparsedModelUpdate\n858 | \n859 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n860 | super().patch_node_properties(node, patch)\n861 | node.version = patch.version\n862 | node.latest_version = patch.latest_version\n863 | node.deprecation_date = patch.deprecation_date\n864 | if patch.access:\n865 | if AccessType.is_valid(patch.access):\n866 | node.access = AccessType(patch.access)\n867 | else:\n868 | raise InvalidAccessTypeError(\n869 | unique_id=node.unique_id,\n870 | field_value=patch.access,\n871 | )\n872 | self.patch_constraints(node, patch.constraints)\n873 | node.build_contract_checksum()\n874 | \n875 | def patch_constraints(self, node, constraints):\n876 | contract_config = node.config.get(\"contract\")\n877 | if contract_config.enforced is True:\n878 | self._validate_constraint_prerequisites(node)\n879 | \n880 | if any(\n881 | c for c in constraints if \"type\" not in c or not ConstraintType.is_valid(c[\"type\"])\n882 | ):\n883 | raise ParsingError(\n884 | f\"Invalid constraint type on model {node.name}: \"\n885 | f\"Type must be one of {[ct.value for ct in ConstraintType]}\"\n886 | )\n887 | \n888 | node.constraints = [ModelLevelConstraint.from_dict(c) for c in constraints]\n889 | \n890 | def _validate_constraint_prerequisites(self, model_node: ModelNode):\n891 | \n892 | column_warn_unsupported = [\n893 | constraint.warn_unsupported\n894 | for column in model_node.columns.values()\n895 | for constraint in column.constraints\n896 | ]\n897 | model_warn_unsupported = [\n898 | constraint.warn_unsupported for constraint in model_node.constraints\n899 | ]\n900 | warn_unsupported = column_warn_unsupported + model_warn_unsupported\n901 | \n902 | # if any constraint has `warn_unsupported` as True then send the warning\n903 | if any(warn_unsupported) and not model_node.materialization_enforces_constraints:\n904 | warn_or_error(\n905 | UnsupportedConstraintMaterialization(materialized=model_node.config.materialized),\n906 | node=model_node,\n907 | )\n908 | \n909 | errors = []\n910 | if not model_node.columns:\n911 | errors.append(\n912 | \"Constraints must be defined in a `yml` schema configuration file like `schema.yml`.\"\n913 | )\n914 | \n915 | if str(model_node.language) != \"sql\":\n916 | errors.append(f\"Language Error: Expected 'sql' but found '{model_node.language}'\")\n917 | \n918 | if errors:\n919 | raise ParsingError(\n920 | f\"Contract enforcement failed for: ({model_node.original_file_path})\\n\"\n921 | + \"\\n\".join(errors)\n922 | )\n923 | \n924 | \n925 | class AnalysisPatchParser(NodePatchParser[UnparsedAnalysisUpdate]):\n926 | def get_block(self, node: UnparsedAnalysisUpdate) -> TargetBlock:\n927 | return TargetBlock.from_yaml_block(self.yaml, node)\n928 | \n929 | def _target_type(self) -> Type[UnparsedAnalysisUpdate]:\n930 | return UnparsedAnalysisUpdate\n931 | \n932 | \n933 | class MacroPatchParser(PatchParser[UnparsedMacroUpdate, ParsedMacroPatch]):\n934 | def get_block(self, node: UnparsedMacroUpdate) -> TargetBlock:\n935 | return TargetBlock.from_yaml_block(self.yaml, node)\n936 | \n937 | def _target_type(self) -> Type[UnparsedMacroUpdate]:\n938 | return UnparsedMacroUpdate\n939 | \n940 | def parse_patch(self, block: TargetBlock[UnparsedMacroUpdate], refs: ParserRef) -> None:\n941 | patch = ParsedMacroPatch(\n942 | name=block.target.name,\n943 | original_file_path=block.target.original_file_path,\n944 | yaml_key=block.target.yaml_key,\n945 | package_name=block.target.package_name,\n946 | arguments=block.target.arguments,\n947 | description=block.target.description,\n948 | meta=block.target.meta,\n949 | docs=block.target.docs,\n950 | config=block.target.config,\n951 | )\n952 | assert isinstance(self.yaml.file, SchemaSourceFile)\n953 | source_file = self.yaml.file\n954 | # macros are fully namespaced\n955 | unique_id = f\"macro.{patch.package_name}.{patch.name}\"\n956 | macro = self.manifest.macros.get(unique_id)\n957 | if not macro:\n958 | warn_or_error(MacroNotFoundForPatch(patch_name=patch.name))\n959 | return\n960 | if macro.patch_path:\n961 | package_name, existing_file_path = macro.patch_path.split(\"://\")\n962 | raise DuplicateMacroPatchNameError(patch, existing_file_path)\n963 | source_file.macro_patches[patch.name] = unique_id\n964 | \n965 | # former macro.patch code\n966 | macro.patch_path = patch.file_id\n967 | macro.description = patch.description\n968 | macro.created_at = time.time()\n969 | macro.meta = patch.meta\n970 | macro.docs = patch.docs\n971 | macro.arguments = patch.arguments\n```\n\n## Files after the fix\n\n### File: core/dbt/parser/schemas.py\n\n```python\n 1 | import datetime\n 2 | import time\n 3 | \n 4 | from abc import ABCMeta, abstractmethod\n 5 | from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Type, TypeVar\n 6 | from dataclasses import dataclass, field\n 7 | \n 8 | from dbt import deprecations\n 9 | from dbt_common.contracts.constraints import ConstraintType, ModelLevelConstraint\n 10 | from dbt_common.dataclass_schema import ValidationError, dbtClassMixin\n 11 | \n 12 | from dbt.clients.yaml_helper import load_yaml_text\n 13 | from dbt.parser.schema_renderer import SchemaYamlRenderer\n 14 | from dbt.parser.schema_generic_tests import SchemaGenericTestParser\n 15 | from dbt.context.context_config import ContextConfig\n 16 | from dbt.context.configured import generate_schema_yml_context, SchemaYamlVars\n 17 | from dbt.contracts.files import SchemaSourceFile\n 18 | from dbt.contracts.graph.nodes import (\n 19 | ParsedNodePatch,\n 20 | ParsedMacroPatch,\n 21 | UnpatchedSourceDefinition,\n 22 | ModelNode,\n 23 | )\n 24 | from dbt.contracts.graph.unparsed import (\n 25 | HasColumnDocs,\n 26 | HasColumnTests,\n 27 | SourcePatch,\n 28 | UnparsedAnalysisUpdate,\n 29 | UnparsedMacroUpdate,\n 30 | UnparsedNodeUpdate,\n 31 | UnparsedModelUpdate,\n 32 | UnparsedSourceDefinition,\n 33 | )\n 34 | from dbt.exceptions import (\n 35 | DuplicateMacroPatchNameError,\n 36 | DuplicatePatchPathError,\n 37 | DuplicateSourcePatchNameError,\n 38 | JSONValidationError,\n 39 | DbtInternalError,\n 40 | ParsingError,\n 41 | YamlLoadError,\n 42 | YamlParseDictError,\n 43 | YamlParseListError,\n 44 | InvalidAccessTypeError,\n 45 | )\n 46 | from dbt_common.exceptions import DbtValidationError\n 47 | from dbt_common.events.functions import warn_or_error\n 48 | from dbt.events.types import (\n 49 | MacroNotFoundForPatch,\n 50 | NoNodeForYamlKey,\n 51 | ValidationWarning,\n 52 | UnsupportedConstraintMaterialization,\n 53 | WrongResourceSchemaFile,\n 54 | )\n 55 | from dbt.node_types import NodeType, AccessType\n 56 | from dbt.parser.base import SimpleParser\n 57 | from dbt.parser.search import FileBlock\n 58 | from dbt.parser.common import (\n 59 | YamlBlock,\n 60 | TargetBlock,\n 61 | TestBlock,\n 62 | VersionedTestBlock,\n 63 | ParserRef,\n 64 | trimmed,\n 65 | )\n 66 | from dbt.utils import coerce_dict_str\n 67 | from dbt_common.utils import deep_merge\n 68 | \n 69 | \n 70 | schema_file_keys = (\n 71 | \"models\",\n 72 | \"seeds\",\n 73 | \"snapshots\",\n 74 | \"sources\",\n 75 | \"macros\",\n 76 | \"analyses\",\n 77 | \"exposures\",\n 78 | \"metrics\",\n 79 | \"semantic_models\",\n 80 | \"saved_queries\",\n 81 | )\n 82 | \n 83 | \n 84 | # ===============================================================================\n 85 | # Schema Parser classes\n 86 | #\n 87 | # The SchemaParser is a subclass of the SimpleParser from base.py, as is\n 88 | # the SchemaGenericTestParser. The schema sub-parsers are all subclasses of\n 89 | # the YamlReader parsing class. Most of the action in creating SourceDefinition\n 90 | # nodes actually happens in the SourcePatcher class, in sources.py, which is\n 91 | # called as a late-stage parsing step in manifest.py.\n 92 | #\n 93 | # The \"patch\" parsers read yaml config and properties and apply them to\n 94 | # nodes that were already created from sql files.\n 95 | #\n 96 | # The SchemaParser and SourcePatcher both use the SchemaGenericTestParser\n 97 | # (in schema_generic_tests.py) to create generic test nodes.\n 98 | #\n 99 | # YamlReader\n100 | # MetricParser (metrics) [schema_yaml_readers.py]\n101 | # ExposureParser (exposures) [schema_yaml_readers.py]\n102 | # GroupParser (groups) [schema_yaml_readers.py]\n103 | # SourceParser (sources)\n104 | # PatchParser\n105 | # MacroPatchParser (macros)\n106 | # NodePatchParser\n107 | # ModelPatchParser (models)\n108 | # AnalysisPatchParser (analyses)\n109 | # TestablePatchParser (seeds, snapshots)\n110 | #\n111 | # ===============================================================================\n112 | \n113 | \n114 | def yaml_from_file(source_file: SchemaSourceFile) -> Dict[str, Any]:\n115 | \"\"\"If loading the yaml fails, raise an exception.\"\"\"\n116 | try:\n117 | # source_file.contents can sometimes be None\n118 | return load_yaml_text(source_file.contents or \"\", source_file.path)\n119 | except DbtValidationError as e:\n120 | raise YamlLoadError(\n121 | project_name=source_file.project_name, path=source_file.path.relative_path, exc=e\n122 | )\n123 | \n124 | \n125 | # This is the main schema file parser, but almost everything happens in the\n126 | # the schema sub-parsers.\n127 | class SchemaParser(SimpleParser[YamlBlock, ModelNode]):\n128 | def __init__(\n129 | self,\n130 | project,\n131 | manifest,\n132 | root_project,\n133 | ) -> None:\n134 | super().__init__(project, manifest, root_project)\n135 | \n136 | self.generic_test_parser = SchemaGenericTestParser(project, manifest, root_project)\n137 | \n138 | self.schema_yaml_vars = SchemaYamlVars()\n139 | self.render_ctx = generate_schema_yml_context(\n140 | self.root_project, self.project.project_name, self.schema_yaml_vars\n141 | )\n142 | \n143 | # This is unnecessary, but mypy was requiring it. Clean up parser code so\n144 | # we don't have to do this.\n145 | def parse_from_dict(self, dct):\n146 | pass\n147 | \n148 | @classmethod\n149 | def get_compiled_path(cls, block: FileBlock) -> str:\n150 | # should this raise an error?\n151 | return block.path.relative_path\n152 | \n153 | @property\n154 | def resource_type(self) -> NodeType:\n155 | return NodeType.Test\n156 | \n157 | def parse_file(self, block: FileBlock, dct: Optional[Dict] = None) -> None:\n158 | assert isinstance(block.file, SchemaSourceFile)\n159 | \n160 | # If partially parsing, dct should be from pp_dict, otherwise\n161 | # dict_from_yaml\n162 | if dct:\n163 | # contains the FileBlock and the data (dictionary)\n164 | yaml_block = YamlBlock.from_file_block(block, dct)\n165 | \n166 | parser: YamlReader\n167 | \n168 | # There are 9 different yaml lists which are parsed by different parsers:\n169 | # Model, Seed, Snapshot, Source, Macro, Analysis, Exposure, Metric, Group\n170 | \n171 | # ModelPatchParser.parse()\n172 | if \"models\" in dct:\n173 | # the models are already in the manifest as nodes when we reach this code,\n174 | # even if they are disabled in the schema file\n175 | model_parse_result = ModelPatchParser(self, yaml_block, \"models\").parse()\n176 | for versioned_test_block in model_parse_result.versioned_test_blocks:\n177 | self.generic_test_parser.parse_versioned_tests(versioned_test_block)\n178 | \n179 | # PatchParser.parse()\n180 | if \"seeds\" in dct:\n181 | seed_parse_result = TestablePatchParser(self, yaml_block, \"seeds\").parse()\n182 | for test_block in seed_parse_result.test_blocks:\n183 | self.generic_test_parser.parse_tests(test_block)\n184 | \n185 | # PatchParser.parse()\n186 | if \"snapshots\" in dct:\n187 | snapshot_parse_result = TestablePatchParser(self, yaml_block, \"snapshots\").parse()\n188 | for test_block in snapshot_parse_result.test_blocks:\n189 | self.generic_test_parser.parse_tests(test_block)\n190 | \n191 | # This parser uses SourceParser.parse() which doesn't return\n192 | # any test blocks. Source tests are handled at a later point\n193 | # in the process.\n194 | if \"sources\" in dct:\n195 | parser = SourceParser(self, yaml_block, \"sources\")\n196 | parser.parse()\n197 | \n198 | # PatchParser.parse() (but never test_blocks)\n199 | if \"macros\" in dct:\n200 | parser = MacroPatchParser(self, yaml_block, \"macros\")\n201 | parser.parse()\n202 | \n203 | # PatchParser.parse() (but never test_blocks)\n204 | if \"analyses\" in dct:\n205 | parser = AnalysisPatchParser(self, yaml_block, \"analyses\")\n206 | parser.parse()\n207 | \n208 | # ExposureParser.parse()\n209 | if \"exposures\" in dct:\n210 | from dbt.parser.schema_yaml_readers import ExposureParser\n211 | \n212 | exp_parser = ExposureParser(self, yaml_block)\n213 | exp_parser.parse()\n214 | \n215 | # MetricParser.parse()\n216 | if \"metrics\" in dct:\n217 | from dbt.parser.schema_yaml_readers import MetricParser\n218 | \n219 | metric_parser = MetricParser(self, yaml_block)\n220 | metric_parser.parse()\n221 | \n222 | # GroupParser.parse()\n223 | if \"groups\" in dct:\n224 | from dbt.parser.schema_yaml_readers import GroupParser\n225 | \n226 | group_parser = GroupParser(self, yaml_block)\n227 | group_parser.parse()\n228 | \n229 | if \"semantic_models\" in dct:\n230 | from dbt.parser.schema_yaml_readers import SemanticModelParser\n231 | \n232 | semantic_model_parser = SemanticModelParser(self, yaml_block)\n233 | semantic_model_parser.parse()\n234 | \n235 | if \"unit_tests\" in dct:\n236 | from dbt.parser.unit_tests import UnitTestParser\n237 | \n238 | unit_test_parser = UnitTestParser(self, yaml_block)\n239 | unit_test_parser.parse()\n240 | \n241 | if \"saved_queries\" in dct:\n242 | from dbt.parser.schema_yaml_readers import SavedQueryParser\n243 | \n244 | saved_query_parser = SavedQueryParser(self, yaml_block)\n245 | saved_query_parser.parse()\n246 | \n247 | \n248 | Parsed = TypeVar(\"Parsed\", UnpatchedSourceDefinition, ParsedNodePatch, ParsedMacroPatch)\n249 | NodeTarget = TypeVar(\"NodeTarget\", UnparsedNodeUpdate, UnparsedAnalysisUpdate, UnparsedModelUpdate)\n250 | NonSourceTarget = TypeVar(\n251 | \"NonSourceTarget\",\n252 | UnparsedNodeUpdate,\n253 | UnparsedAnalysisUpdate,\n254 | UnparsedMacroUpdate,\n255 | UnparsedModelUpdate,\n256 | )\n257 | \n258 | \n259 | @dataclass\n260 | class ParseResult:\n261 | test_blocks: List[TestBlock] = field(default_factory=list)\n262 | versioned_test_blocks: List[VersionedTestBlock] = field(default_factory=list)\n263 | \n264 | \n265 | # abstract base class (ABCMeta)\n266 | # Many subclasses: MetricParser, ExposureParser, GroupParser, SourceParser,\n267 | # PatchParser, SemanticModelParser, SavedQueryParser, UnitTestParser\n268 | class YamlReader(metaclass=ABCMeta):\n269 | def __init__(self, schema_parser: SchemaParser, yaml: YamlBlock, key: str) -> None:\n270 | self.schema_parser = schema_parser\n271 | # key: models, seeds, snapshots, sources, macros,\n272 | # analyses, exposures, unit_tests\n273 | self.key = key\n274 | self.yaml = yaml\n275 | self.schema_yaml_vars = SchemaYamlVars()\n276 | self.render_ctx = generate_schema_yml_context(\n277 | self.schema_parser.root_project,\n278 | self.schema_parser.project.project_name,\n279 | self.schema_yaml_vars,\n280 | )\n281 | self.renderer = SchemaYamlRenderer(self.render_ctx, self.key)\n282 | \n283 | @property\n284 | def manifest(self):\n285 | return self.schema_parser.manifest\n286 | \n287 | @property\n288 | def project(self):\n289 | return self.schema_parser.project\n290 | \n291 | @property\n292 | def default_database(self):\n293 | return self.schema_parser.default_database\n294 | \n295 | @property\n296 | def root_project(self):\n297 | return self.schema_parser.root_project\n298 | \n299 | # for the different schema subparsers ('models', 'source', etc)\n300 | # get the list of dicts pointed to by the key in the yaml config,\n301 | # ensure that the dicts have string keys\n302 | def get_key_dicts(self) -> Iterable[Dict[str, Any]]:\n303 | data = self.yaml.data.get(self.key, [])\n304 | if not isinstance(data, list):\n305 | raise ParsingError(\n306 | \"{} must be a list, got {} instead: ({})\".format(\n307 | self.key, type(data), trimmed(str(data))\n308 | )\n309 | )\n310 | path = self.yaml.path.original_file_path\n311 | \n312 | # for each dict in the data (which is a list of dicts)\n313 | for entry in data:\n314 | \n315 | # check that entry is a dict and that all dict values\n316 | # are strings\n317 | if coerce_dict_str(entry) is None:\n318 | raise YamlParseListError(path, self.key, data, \"expected a dict with string keys\")\n319 | \n320 | if \"name\" not in entry and \"model\" not in entry:\n321 | raise ParsingError(\"Entry did not contain a name\")\n322 | \n323 | # Render the data (except for tests, data_tests and descriptions).\n324 | # See the SchemaYamlRenderer\n325 | entry = self.render_entry(entry)\n326 | if self.schema_yaml_vars.env_vars:\n327 | self.schema_parser.manifest.env_vars.update(self.schema_yaml_vars.env_vars)\n328 | schema_file = self.yaml.file\n329 | assert isinstance(schema_file, SchemaSourceFile)\n330 | for var in self.schema_yaml_vars.env_vars.keys():\n331 | schema_file.add_env_var(var, self.key, entry[\"name\"])\n332 | self.schema_yaml_vars.env_vars = {}\n333 | \n334 | yield entry\n335 | \n336 | def render_entry(self, dct):\n337 | try:\n338 | # This does a deep_map which will fail if there are circular references\n339 | dct = self.renderer.render_data(dct)\n340 | except ParsingError as exc:\n341 | raise ParsingError(\n342 | f\"Failed to render {self.yaml.file.path.original_file_path} from \"\n343 | f\"project {self.project.project_name}: {exc}\"\n344 | ) from exc\n345 | return dct\n346 | \n347 | @abstractmethod\n348 | def parse(self) -> ParseResult:\n349 | raise NotImplementedError(\"parse is abstract\")\n350 | \n351 | \n352 | T = TypeVar(\"T\", bound=dbtClassMixin)\n353 | \n354 | \n355 | # This parses the 'sources' keys in yaml files.\n356 | class SourceParser(YamlReader):\n357 | def _target_from_dict(self, cls: Type[T], data: Dict[str, Any]) -> T:\n358 | path = self.yaml.path.original_file_path\n359 | try:\n360 | cls.validate(data)\n361 | return cls.from_dict(data)\n362 | except (ValidationError, JSONValidationError) as exc:\n363 | raise YamlParseDictError(path, self.key, data, exc)\n364 | \n365 | # This parse method takes the yaml dictionaries in 'sources' keys and uses them\n366 | # to create UnparsedSourceDefinition objects. They are then turned\n367 | # into UnpatchedSourceDefinition objects in 'add_source_definitions'\n368 | # or SourcePatch objects in 'add_source_patch'\n369 | def parse(self) -> ParseResult:\n370 | # get a verified list of dicts for the key handled by this parser\n371 | for data in self.get_key_dicts():\n372 | data = self.project.credentials.translate_aliases(data, recurse=True)\n373 | \n374 | is_override = \"overrides\" in data\n375 | if is_override:\n376 | data[\"path\"] = self.yaml.path.original_file_path\n377 | patch = self._target_from_dict(SourcePatch, data)\n378 | assert isinstance(self.yaml.file, SchemaSourceFile)\n379 | source_file = self.yaml.file\n380 | # source patches must be unique\n381 | key = (patch.overrides, patch.name)\n382 | if key in self.manifest.source_patches:\n383 | raise DuplicateSourcePatchNameError(patch, self.manifest.source_patches[key])\n384 | self.manifest.source_patches[key] = patch\n385 | source_file.source_patches.append(key)\n386 | else:\n387 | source = self._target_from_dict(UnparsedSourceDefinition, data)\n388 | self.add_source_definitions(source)\n389 | return ParseResult()\n390 | \n391 | def add_source_definitions(self, source: UnparsedSourceDefinition) -> None:\n392 | package_name = self.project.project_name\n393 | original_file_path = self.yaml.path.original_file_path\n394 | fqn_path = self.yaml.path.relative_path\n395 | for table in source.tables:\n396 | unique_id = \".\".join([NodeType.Source, package_name, source.name, table.name])\n397 | \n398 | # the FQN is project name / path elements /source_name /table_name\n399 | fqn = self.schema_parser.get_fqn_prefix(fqn_path)\n400 | fqn.extend([source.name, table.name])\n401 | \n402 | source_def = UnpatchedSourceDefinition(\n403 | source=source,\n404 | table=table,\n405 | path=original_file_path,\n406 | original_file_path=original_file_path,\n407 | package_name=package_name,\n408 | unique_id=unique_id,\n409 | resource_type=NodeType.Source,\n410 | fqn=fqn,\n411 | name=f\"{source.name}_{table.name}\",\n412 | )\n413 | self.manifest.add_source(self.yaml.file, source_def)\n414 | \n415 | \n416 | # This class has two subclasses: NodePatchParser and MacroPatchParser\n417 | class PatchParser(YamlReader, Generic[NonSourceTarget, Parsed]):\n418 | @abstractmethod\n419 | def _target_type(self) -> Type[NonSourceTarget]:\n420 | raise NotImplementedError(\"_target_type not implemented\")\n421 | \n422 | @abstractmethod\n423 | def get_block(self, node: NonSourceTarget) -> TargetBlock:\n424 | raise NotImplementedError(\"get_block is abstract\")\n425 | \n426 | @abstractmethod\n427 | def parse_patch(self, block: TargetBlock[NonSourceTarget], refs: ParserRef) -> None:\n428 | raise NotImplementedError(\"parse_patch is abstract\")\n429 | \n430 | def parse(self) -> ParseResult:\n431 | node: NonSourceTarget\n432 | # This will always be empty if the node a macro or analysis\n433 | test_blocks: List[TestBlock] = []\n434 | # This will always be empty if the node is _not_ a model\n435 | versioned_test_blocks: List[VersionedTestBlock] = []\n436 | \n437 | # get list of 'node' objects\n438 | # UnparsedNodeUpdate (TestablePatchParser, models, seeds, snapshots)\n439 | # = HasColumnTests, HasTests\n440 | # UnparsedAnalysisUpdate (UnparsedAnalysisParser, analyses)\n441 | # = HasColumnDocs, HasDocs\n442 | # UnparsedMacroUpdate (MacroPatchParser, 'macros')\n443 | # = HasDocs\n444 | # correspond to this parser's 'key'\n445 | for node in self.get_unparsed_target():\n446 | # node_block is a TargetBlock (Macro or Analysis)\n447 | # or a TestBlock (all of the others)\n448 | node_block = self.get_block(node)\n449 | if isinstance(node_block, TestBlock):\n450 | # TestablePatchParser = seeds, snapshots\n451 | test_blocks.append(node_block)\n452 | if isinstance(node_block, VersionedTestBlock):\n453 | # models\n454 | versioned_test_blocks.append(node_block)\n455 | if isinstance(node, (HasColumnDocs, HasColumnTests)):\n456 | # UnparsedNodeUpdate and UnparsedAnalysisUpdate\n457 | refs: ParserRef = ParserRef.from_target(node)\n458 | else:\n459 | refs = ParserRef()\n460 | \n461 | # There's no unique_id on the node yet so cannot add to disabled dict\n462 | self.parse_patch(node_block, refs)\n463 | \n464 | return ParseResult(test_blocks, versioned_test_blocks)\n465 | \n466 | def get_unparsed_target(self) -> Iterable[NonSourceTarget]:\n467 | path = self.yaml.path.original_file_path\n468 | \n469 | # get verified list of dicts for the 'key' that this\n470 | # parser handles\n471 | key_dicts = self.get_key_dicts()\n472 | for data in key_dicts:\n473 | # add extra data to each dict. This updates the dicts\n474 | # in the parser yaml\n475 | data.update(\n476 | {\n477 | \"original_file_path\": path,\n478 | \"yaml_key\": self.key,\n479 | \"package_name\": self.project.project_name,\n480 | }\n481 | )\n482 | try:\n483 | # target_type: UnparsedNodeUpdate, UnparsedAnalysisUpdate,\n484 | # or UnparsedMacroUpdate\n485 | self._target_type().validate(data)\n486 | if self.key != \"macros\":\n487 | # macros don't have the 'config' key support yet\n488 | self.normalize_meta_attribute(data, path)\n489 | self.normalize_docs_attribute(data, path)\n490 | self.normalize_group_attribute(data, path)\n491 | self.normalize_contract_attribute(data, path)\n492 | self.normalize_access_attribute(data, path)\n493 | # `tests` has been deprecated, convert to `data_tests` here if present\n494 | self.validate_data_tests(data)\n495 | node = self._target_type().from_dict(data)\n496 | except (ValidationError, JSONValidationError) as exc:\n497 | raise YamlParseDictError(path, self.key, data, exc)\n498 | else:\n499 | yield node\n500 | \n501 | # We want to raise an error if some attributes are in two places, and move them\n502 | # from toplevel to config if necessary\n503 | def normalize_attribute(self, data, path, attribute):\n504 | if attribute in data:\n505 | if \"config\" in data and attribute in data[\"config\"]:\n506 | raise ParsingError(\n507 | f\"\"\"\n508 | In {path}: found {attribute} dictionary in 'config' dictionary and as top-level key.\n509 | Remove the top-level key and define it under 'config' dictionary only.\n510 | \"\"\".strip()\n511 | )\n512 | else:\n513 | if \"config\" not in data:\n514 | data[\"config\"] = {}\n515 | data[\"config\"][attribute] = data.pop(attribute)\n516 | \n517 | def normalize_meta_attribute(self, data, path):\n518 | return self.normalize_attribute(data, path, \"meta\")\n519 | \n520 | def normalize_docs_attribute(self, data, path):\n521 | return self.normalize_attribute(data, path, \"docs\")\n522 | \n523 | def normalize_group_attribute(self, data, path):\n524 | return self.normalize_attribute(data, path, \"group\")\n525 | \n526 | def normalize_contract_attribute(self, data, path):\n527 | return self.normalize_attribute(data, path, \"contract\")\n528 | \n529 | def normalize_access_attribute(self, data, path):\n530 | return self.normalize_attribute(data, path, \"access\")\n531 | \n532 | def validate_data_tests(self, data):\n533 | # Rename 'tests' -> 'data_tests' at both model-level and column-level\n534 | # Raise a validation error if the user has defined both names\n535 | def validate_and_rename(data):\n536 | if data.get(\"tests\"):\n537 | if \"tests\" in data and \"data_tests\" in data:\n538 | raise ValidationError(\n539 | \"Invalid test config: cannot have both 'tests' and 'data_tests' defined\"\n540 | )\n541 | deprecations.warn(\n542 | \"project-test-config\",\n543 | deprecated_path=\"tests\",\n544 | exp_path=\"data_tests\",\n545 | )\n546 | data[\"data_tests\"] = data.pop(\"tests\")\n547 | \n548 | # model-level tests\n549 | validate_and_rename(data)\n550 | \n551 | # column-level tests\n552 | if data.get(\"columns\"):\n553 | for column in data[\"columns\"]:\n554 | validate_and_rename(column)\n555 | \n556 | # versioned models\n557 | if data.get(\"versions\"):\n558 | for version in data[\"versions\"]:\n559 | validate_and_rename(version)\n560 | if version.get(\"columns\"):\n561 | for column in version[\"columns\"]:\n562 | validate_and_rename(column)\n563 | \n564 | def patch_node_config(self, node, patch):\n565 | # Get the ContextConfig that's used in calculating the config\n566 | # This must match the model resource_type that's being patched\n567 | config = ContextConfig(\n568 | self.schema_parser.root_project,\n569 | node.fqn,\n570 | node.resource_type,\n571 | self.schema_parser.project.project_name,\n572 | )\n573 | # We need to re-apply the config_call_dict after the patch config\n574 | config._config_call_dict = node.config_call_dict\n575 | self.schema_parser.update_parsed_node_config(node, config, patch_config_dict=patch.config)\n576 | \n577 | \n578 | # Subclasses of NodePatchParser: TestablePatchParser, ModelPatchParser, AnalysisPatchParser,\n579 | # so models, seeds, snapshots, analyses\n580 | class NodePatchParser(PatchParser[NodeTarget, ParsedNodePatch], Generic[NodeTarget]):\n581 | def parse_patch(self, block: TargetBlock[NodeTarget], refs: ParserRef) -> None:\n582 | # We're not passing the ParsedNodePatch around anymore, so we\n583 | # could possibly skip creating one. Leaving here for now for\n584 | # code consistency.\n585 | deprecation_date: Optional[datetime.datetime] = None\n586 | if isinstance(block.target, UnparsedModelUpdate):\n587 | deprecation_date = block.target.deprecation_date\n588 | \n589 | patch = ParsedNodePatch(\n590 | name=block.target.name,\n591 | original_file_path=block.target.original_file_path,\n592 | yaml_key=block.target.yaml_key,\n593 | package_name=block.target.package_name,\n594 | description=block.target.description,\n595 | columns=refs.column_info,\n596 | meta=block.target.meta,\n597 | docs=block.target.docs,\n598 | config=block.target.config,\n599 | access=block.target.access,\n600 | version=None,\n601 | latest_version=None,\n602 | constraints=block.target.constraints,\n603 | deprecation_date=deprecation_date,\n604 | )\n605 | assert isinstance(self.yaml.file, SchemaSourceFile)\n606 | source_file: SchemaSourceFile = self.yaml.file\n607 | if patch.yaml_key in [\"models\", \"seeds\", \"snapshots\"]:\n608 | unique_id = self.manifest.ref_lookup.get_unique_id(\n609 | patch.name, self.project.project_name, None\n610 | ) or self.manifest.ref_lookup.get_unique_id(patch.name, None, None)\n611 | \n612 | if unique_id:\n613 | resource_type = NodeType(unique_id.split(\".\")[0])\n614 | if resource_type.pluralize() != patch.yaml_key:\n615 | warn_or_error(\n616 | WrongResourceSchemaFile(\n617 | patch_name=patch.name,\n618 | resource_type=resource_type,\n619 | plural_resource_type=resource_type.pluralize(),\n620 | yaml_key=patch.yaml_key,\n621 | file_path=patch.original_file_path,\n622 | )\n623 | )\n624 | return\n625 | \n626 | elif patch.yaml_key == \"analyses\":\n627 | unique_id = self.manifest.analysis_lookup.get_unique_id(patch.name, None, None)\n628 | else:\n629 | raise DbtInternalError(\n630 | f\"Unexpected yaml_key {patch.yaml_key} for patch in \"\n631 | f\"file {source_file.path.original_file_path}\"\n632 | )\n633 | # handle disabled nodes\n634 | if unique_id is None:\n635 | # Node might be disabled. Following call returns list of matching disabled nodes\n636 | found_nodes = self.manifest.disabled_lookup.find(patch.name, patch.package_name)\n637 | if found_nodes:\n638 | if len(found_nodes) > 1 and patch.config.get(\"enabled\"):\n639 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n640 | # We have no way to know which one to enable.\n641 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n642 | msg = (\n643 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n644 | f\"{resource_type} '{patch.name}'. Multiple nodes for the same \"\n645 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n646 | \"in `dbt_project.yml` or in the sql files.\"\n647 | )\n648 | raise ParsingError(msg)\n649 | \n650 | # all nodes in the disabled dict have the same unique_id so just grab the first one\n651 | # to append with the unique id\n652 | source_file.append_patch(patch.yaml_key, found_nodes[0].unique_id)\n653 | for node in found_nodes:\n654 | node.patch_path = source_file.file_id\n655 | # re-calculate the node config with the patch config. Always do this\n656 | # for the case when no config is set to ensure the default of true gets captured\n657 | if patch.config:\n658 | self.patch_node_config(node, patch)\n659 | \n660 | self.patch_node_properties(node, patch)\n661 | else:\n662 | warn_or_error(\n663 | NoNodeForYamlKey(\n664 | patch_name=patch.name,\n665 | yaml_key=patch.yaml_key,\n666 | file_path=source_file.path.original_file_path,\n667 | )\n668 | )\n669 | return\n670 | \n671 | # patches can't be overwritten\n672 | node = self.manifest.nodes.get(unique_id)\n673 | if node:\n674 | if node.patch_path:\n675 | package_name, existing_file_path = node.patch_path.split(\"://\")\n676 | raise DuplicatePatchPathError(patch, existing_file_path)\n677 | \n678 | source_file.append_patch(patch.yaml_key, node.unique_id)\n679 | # re-calculate the node config with the patch config. Always do this\n680 | # for the case when no config is set to ensure the default of true gets captured\n681 | if patch.config:\n682 | self.patch_node_config(node, patch)\n683 | \n684 | self.patch_node_properties(node, patch)\n685 | \n686 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n687 | \"\"\"Given a ParsedNodePatch, add the new information to the node.\"\"\"\n688 | # explicitly pick out the parts to update so we don't inadvertently\n689 | # step on the model name or anything\n690 | # Note: config should already be updated\n691 | node.patch_path = patch.file_id\n692 | # update created_at so process_docs will run in partial parsing\n693 | node.created_at = time.time()\n694 | node.description = patch.description\n695 | node.columns = patch.columns\n696 | node.name = patch.name\n697 | \n698 | if not isinstance(node, ModelNode):\n699 | for attr in [\"latest_version\", \"access\", \"version\", \"constraints\"]:\n700 | if getattr(patch, attr):\n701 | warn_or_error(\n702 | ValidationWarning(\n703 | field_name=attr,\n704 | resource_type=node.resource_type.value,\n705 | node_name=patch.name,\n706 | )\n707 | )\n708 | \n709 | \n710 | # TestablePatchParser = seeds, snapshots\n711 | class TestablePatchParser(NodePatchParser[UnparsedNodeUpdate]):\n712 | __test__ = False\n713 | \n714 | def get_block(self, node: UnparsedNodeUpdate) -> TestBlock:\n715 | return TestBlock.from_yaml_block(self.yaml, node)\n716 | \n717 | def _target_type(self) -> Type[UnparsedNodeUpdate]:\n718 | return UnparsedNodeUpdate\n719 | \n720 | \n721 | class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n722 | def get_block(self, node: UnparsedModelUpdate) -> VersionedTestBlock:\n723 | return VersionedTestBlock.from_yaml_block(self.yaml, node)\n724 | \n725 | def parse_patch(self, block: TargetBlock[UnparsedModelUpdate], refs: ParserRef) -> None:\n726 | target = block.target\n727 | if NodeType.Model.pluralize() != target.yaml_key:\n728 | warn_or_error(\n729 | WrongResourceSchemaFile(\n730 | patch_name=target.name,\n731 | resource_type=NodeType.Model,\n732 | plural_resource_type=NodeType.Model.pluralize(),\n733 | yaml_key=target.yaml_key,\n734 | file_path=target.original_file_path,\n735 | )\n736 | )\n737 | return\n738 | \n739 | versions = target.versions\n740 | if not versions:\n741 | super().parse_patch(block, refs)\n742 | else:\n743 | assert isinstance(self.yaml.file, SchemaSourceFile)\n744 | source_file: SchemaSourceFile = self.yaml.file\n745 | latest_version = (\n746 | target.latest_version if target.latest_version is not None else max(versions).v\n747 | )\n748 | for unparsed_version in versions:\n749 | versioned_model_name = (\n750 | unparsed_version.defined_in or f\"{block.name}_{unparsed_version.formatted_v}\"\n751 | )\n752 | # ref lookup without version - version is not set yet\n753 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n754 | versioned_model_name, target.package_name, None\n755 | )\n756 | \n757 | versioned_model_node = None\n758 | add_node_nofile_fn: Callable\n759 | \n760 | # If this is the latest version, it's allowed to define itself in a model file name that doesn't have a suffix\n761 | if versioned_model_unique_id is None and unparsed_version.v == latest_version:\n762 | versioned_model_unique_id = self.manifest.ref_lookup.get_unique_id(\n763 | block.name, target.package_name, None\n764 | )\n765 | \n766 | if versioned_model_unique_id is None:\n767 | # Node might be disabled. Following call returns list of matching disabled nodes\n768 | found_nodes = self.manifest.disabled_lookup.find(versioned_model_name, None)\n769 | if found_nodes:\n770 | if len(found_nodes) > 1 and target.config.get(\"enabled\"):\n771 | # There are multiple disabled nodes for this model and the schema file wants to enable one.\n772 | # We have no way to know which one to enable.\n773 | resource_type = found_nodes[0].unique_id.split(\".\")[0]\n774 | msg = (\n775 | f\"Found {len(found_nodes)} matching disabled nodes for \"\n776 | f\"{resource_type} '{target.name}'. Multiple nodes for the same \"\n777 | \"unique id cannot be enabled in the schema file. They must be enabled \"\n778 | \"in `dbt_project.yml` or in the sql files.\"\n779 | )\n780 | raise ParsingError(msg)\n781 | versioned_model_node = self.manifest.disabled.pop(\n782 | found_nodes[0].unique_id\n783 | )[0]\n784 | add_node_nofile_fn = self.manifest.add_disabled_nofile\n785 | else:\n786 | versioned_model_node = self.manifest.nodes.pop(versioned_model_unique_id)\n787 | add_node_nofile_fn = self.manifest.add_node_nofile\n788 | \n789 | if versioned_model_node is None:\n790 | warn_or_error(\n791 | NoNodeForYamlKey(\n792 | patch_name=versioned_model_name,\n793 | yaml_key=target.yaml_key,\n794 | file_path=source_file.path.original_file_path,\n795 | )\n796 | )\n797 | continue\n798 | \n799 | # update versioned node unique_id\n800 | versioned_model_node_unique_id_old = versioned_model_node.unique_id\n801 | versioned_model_node.unique_id = (\n802 | f\"model.{target.package_name}.{target.name}.{unparsed_version.formatted_v}\"\n803 | )\n804 | # update source file.nodes with new unique_id\n805 | self.manifest.files[versioned_model_node.file_id].nodes.remove(\n806 | versioned_model_node_unique_id_old\n807 | )\n808 | self.manifest.files[versioned_model_node.file_id].nodes.append(\n809 | versioned_model_node.unique_id\n810 | )\n811 | \n812 | # update versioned node fqn\n813 | versioned_model_node.fqn[-1] = target.name\n814 | versioned_model_node.fqn.append(unparsed_version.formatted_v)\n815 | \n816 | # add versioned node back to nodes/disabled\n817 | add_node_nofile_fn(versioned_model_node)\n818 | \n819 | # flatten columns based on include/exclude\n820 | version_refs: ParserRef = ParserRef.from_versioned_target(\n821 | block.target, unparsed_version.v\n822 | )\n823 | \n824 | versioned_model_patch = ParsedNodePatch(\n825 | name=target.name,\n826 | original_file_path=target.original_file_path,\n827 | yaml_key=target.yaml_key,\n828 | package_name=target.package_name,\n829 | description=unparsed_version.description or target.description,\n830 | columns=version_refs.column_info,\n831 | meta=target.meta,\n832 | docs=unparsed_version.docs or target.docs,\n833 | config=deep_merge(target.config, unparsed_version.config),\n834 | access=unparsed_version.access or target.access,\n835 | version=unparsed_version.v,\n836 | latest_version=latest_version,\n837 | constraints=unparsed_version.constraints or target.constraints,\n838 | deprecation_date=unparsed_version.deprecation_date,\n839 | )\n840 | # Node patched before config because config patching depends on model name,\n841 | # which may have been updated in the version patch\n842 | # versioned_model_node.patch(versioned_model_patch)\n843 | self.patch_node_properties(versioned_model_node, versioned_model_patch)\n844 | \n845 | # Includes alias recomputation\n846 | self.patch_node_config(versioned_model_node, versioned_model_patch)\n847 | \n848 | # Need to reapply setting constraints and contract checksum here, because\n849 | # they depend on node.contract.enabled, which wouldn't be set when\n850 | # patch_node_properties was called if it wasn't set in the model file.\n851 | self.patch_constraints(versioned_model_node, versioned_model_patch.constraints)\n852 | versioned_model_node.build_contract_checksum()\n853 | source_file.append_patch(\n854 | versioned_model_patch.yaml_key, versioned_model_node.unique_id\n855 | )\n856 | self.manifest.rebuild_ref_lookup()\n857 | self.manifest.rebuild_disabled_lookup()\n858 | \n859 | def _target_type(self) -> Type[UnparsedModelUpdate]:\n860 | return UnparsedModelUpdate\n861 | \n862 | def patch_node_properties(self, node, patch: \"ParsedNodePatch\"):\n863 | super().patch_node_properties(node, patch)\n864 | node.version = patch.version\n865 | node.latest_version = patch.latest_version\n866 | node.deprecation_date = patch.deprecation_date\n867 | if patch.access:\n868 | if AccessType.is_valid(patch.access):\n869 | node.access = AccessType(patch.access)\n870 | else:\n871 | raise InvalidAccessTypeError(\n872 | unique_id=node.unique_id,\n873 | field_value=patch.access,\n874 | )\n875 | # These two will have to be reapplied after config is built for versioned models\n876 | self.patch_constraints(node, patch.constraints)\n877 | node.build_contract_checksum()\n878 | \n879 | def patch_constraints(self, node, constraints):\n880 | contract_config = node.config.get(\"contract\")\n881 | if contract_config.enforced is True:\n882 | self._validate_constraint_prerequisites(node)\n883 | \n884 | if any(\n885 | c for c in constraints if \"type\" not in c or not ConstraintType.is_valid(c[\"type\"])\n886 | ):\n887 | raise ParsingError(\n888 | f\"Invalid constraint type on model {node.name}: \"\n889 | f\"Type must be one of {[ct.value for ct in ConstraintType]}\"\n890 | )\n891 | \n892 | node.constraints = [ModelLevelConstraint.from_dict(c) for c in constraints]\n893 | \n894 | def _validate_constraint_prerequisites(self, model_node: ModelNode):\n895 | \n896 | column_warn_unsupported = [\n897 | constraint.warn_unsupported\n898 | for column in model_node.columns.values()\n899 | for constraint in column.constraints\n900 | ]\n901 | model_warn_unsupported = [\n902 | constraint.warn_unsupported for constraint in model_node.constraints\n903 | ]\n904 | warn_unsupported = column_warn_unsupported + model_warn_unsupported\n905 | \n906 | # if any constraint has `warn_unsupported` as True then send the warning\n907 | if any(warn_unsupported) and not model_node.materialization_enforces_constraints:\n908 | warn_or_error(\n909 | UnsupportedConstraintMaterialization(materialized=model_node.config.materialized),\n910 | node=model_node,\n911 | )\n912 | \n913 | errors = []\n914 | if not model_node.columns:\n915 | errors.append(\n916 | \"Constraints must be defined in a `yml` schema configuration file like `schema.yml`.\"\n917 | )\n918 | \n919 | if str(model_node.language) != \"sql\":\n920 | errors.append(f\"Language Error: Expected 'sql' but found '{model_node.language}'\")\n921 | \n922 | if errors:\n923 | raise ParsingError(\n924 | f\"Contract enforcement failed for: ({model_node.original_file_path})\\n\"\n925 | + \"\\n\".join(errors)\n926 | )\n927 | \n928 | \n929 | class AnalysisPatchParser(NodePatchParser[UnparsedAnalysisUpdate]):\n930 | def get_block(self, node: UnparsedAnalysisUpdate) -> TargetBlock:\n931 | return TargetBlock.from_yaml_block(self.yaml, node)\n932 | \n933 | def _target_type(self) -> Type[UnparsedAnalysisUpdate]:\n934 | return UnparsedAnalysisUpdate\n935 | \n936 | \n937 | class MacroPatchParser(PatchParser[UnparsedMacroUpdate, ParsedMacroPatch]):\n938 | def get_block(self, node: UnparsedMacroUpdate) -> TargetBlock:\n939 | return TargetBlock.from_yaml_block(self.yaml, node)\n940 | \n941 | def _target_type(self) -> Type[UnparsedMacroUpdate]:\n942 | return UnparsedMacroUpdate\n943 | \n944 | def parse_patch(self, block: TargetBlock[UnparsedMacroUpdate], refs: ParserRef) -> None:\n945 | patch = ParsedMacroPatch(\n946 | name=block.target.name,\n947 | original_file_path=block.target.original_file_path,\n948 | yaml_key=block.target.yaml_key,\n949 | package_name=block.target.package_name,\n950 | arguments=block.target.arguments,\n951 | description=block.target.description,\n952 | meta=block.target.meta,\n953 | docs=block.target.docs,\n954 | config=block.target.config,\n955 | )\n956 | assert isinstance(self.yaml.file, SchemaSourceFile)\n957 | source_file = self.yaml.file\n958 | # macros are fully namespaced\n959 | unique_id = f\"macro.{patch.package_name}.{patch.name}\"\n960 | macro = self.manifest.macros.get(unique_id)\n961 | if not macro:\n962 | warn_or_error(MacroNotFoundForPatch(patch_name=patch.name))\n963 | return\n964 | if macro.patch_path:\n965 | package_name, existing_file_path = macro.patch_path.split(\"://\")\n966 | raise DuplicateMacroPatchNameError(patch, existing_file_path)\n967 | source_file.macro_patches[patch.name] = unique_id\n968 | \n969 | # former macro.patch code\n970 | macro.patch_path = patch.file_id\n971 | macro.description = patch.description\n972 | macro.created_at = time.time()\n973 | macro.meta = patch.meta\n974 | macro.docs = patch.docs\n975 | macro.arguments = patch.arguments\n```\n\n## Output format\n\nOutput only a unified git diff.\n"},"answer":{"kind":"string","value":"diff --git a/core/dbt/parser/schemas.py b/core/dbt/parser/schemas.py\nindex 0000000..0000000 100644\n--- a/core/dbt/parser/schemas.py\n+++ b/core/dbt/parser/schemas.py\n@@ -845,7 +845,10 @@ class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n # Includes alias recomputation\n self.patch_node_config(versioned_model_node, versioned_model_patch)\n \n- # Need to reapply this here, in the case that 'contract: {enforced: true}' was during config-setting\n+ # Need to reapply setting constraints and contract checksum here, because\n+ # they depend on node.contract.enabled, which wouldn't be set when\n+ # patch_node_properties was called if it wasn't set in the model file.\n+ self.patch_constraints(versioned_model_node, versioned_model_patch.constraints)\n versioned_model_node.build_contract_checksum()\n source_file.append_patch(\n versioned_model_patch.yaml_key, versioned_model_node.unique_id\n@@ -869,6 +872,7 @@ class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):\n unique_id=node.unique_id,\n field_value=patch.access,\n )\n+ # These two will have to be reapplied after config is built for versioned models\n self.patch_constraints(node, patch.constraints)\n node.build_contract_checksum()"},"prompt_input_token_count":{"kind":"number","value":25309,"string":"25,309"},"metadata":{"kind":"string","value":"{\n \"dataset\": \"internlm/SWE-Fixer-Train-110K-diff\",\n \"source_dataset\": \"internlm/SWE-Fixer-Train-110K\",\n \"task\": \"before_after_to_diff\",\n \"instance_id\": \"dbt-labs__dbt-core-9539\",\n \"repo\": \"dbt-labs/dbt-core\",\n \"base_commit\": \"1220fdfdd62b0f7ece97bbea52d08f86ac09bf73\",\n \"pull_number\": 9539,\n \"issue_numbers\": [\n \"9364\"\n ],\n \"changed_files\": [\n \"core/dbt/parser/schemas.py\"\n ],\n \"truncated_files\": [],\n \"marker_files\": {},\n \"has_test_patch\": true\n}"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":322,"numItemsPerPage":100,"numTotalItems":33387,"offset":32200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMzOTI0MywianRpIjoiMWRhM2RlOTAtZjU4Mi00ZmI4LWI3NGEtMDIxNTFjNDkzYmM0Iiwic3ViIjoiL2RhdGFzZXRzL2Q0bmllbGRldi9zd2UtZml4ZXItZGlmZiIsImV4cCI6MTc4NjM0Mjg0MywiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.5OxfMoN-TcQKAb3lql1bJrYGQsjsPXGWc-8rXpm3iN25-SPwCvfp_bI8sTmtQcz8wiXmJpY1-XyGCtoKiNTzAw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":33387,"numBytesParquet":1431108823},{"config":"default","split":"dev","numRows":4778,"numBytesParquet":195694703},{"config":"default","split":"test","numRows":9534,"numBytesParquet":403458829}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
id stringlengths 13 54 | prompt stringlengths 708 2.91M | answer stringlengths 110 352k | prompt_input_token_count int64 206 1.14M | metadata dict |
|---|---|---|---|---|
dbt-labs__dbt-core-8482 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 4d3c6d9c7c6bb7de35dda71074650e57c12a5a3b
Changed files:
- core/dbt/cli/main.py
- co... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -330,6 +330,7 @@ def docs_serve(ctx, **kwargs):
@p.state
@p.defer_state
@p.deprecated_state
+@p.compile_inject_ephemeral_ctes
@p.target
@p.target_path
@p.threads
diff --g... | 46,407 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8482",
"repo": "dbt-labs/dbt-core",
"base_commit": "4d3c6d9c7c6bb7de35dda71074650e57c12a5a3b",
"pull_number": 8482,
"issue_numbers": [
... |
dbt-labs__dbt-core-8485 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 4d3c6d9c7c6bb7de35dda71074650e57c12a5a3b
Changed files:
- core/dbt/adapters/base/co... | diff --git a/core/dbt/adapters/base/connections.py b/core/dbt/adapters/base/connections.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/connections.py
+++ b/core/dbt/adapters/base/connections.py
@@ -400,7 +400,7 @@ class BaseConnectionManager(metaclass=abc.ABCMeta):
@abc.abstractmethod
def exe... | 54,192 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8485",
"repo": "dbt-labs/dbt-core",
"base_commit": "4d3c6d9c7c6bb7de35dda71074650e57c12a5a3b",
"pull_number": 8485,
"issue_numbers": [
... |
dbt-labs__dbt-core-8492 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: f063e4e01c3faeba9ba559fcf153c2dd6148c8dd
Changed files:
- core/dbt/contracts/result... | diff --git a/core/dbt/contracts/results.py b/core/dbt/contracts/results.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/results.py
+++ b/core/dbt/contracts/results.py
@@ -1,7 +1,7 @@
import threading
from dbt.contracts.graph.unparsed import FreshnessThreshold
-from dbt.contracts.graph.nodes import SourceD... | 11,000 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8492",
"repo": "dbt-labs/dbt-core",
"base_commit": "f063e4e01c3faeba9ba559fcf153c2dd6148c8dd",
"pull_number": 8492,
"issue_numbers": [
... |
dbt-labs__dbt-core-8523 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 07372db90666ab27b22d561469423d0ea091f4b3
Changed files:
- core/dbt/adapters/base/me... | diff --git a/core/dbt/adapters/base/meta.py b/core/dbt/adapters/base/meta.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/meta.py
+++ b/core/dbt/adapters/base/meta.py
@@ -93,7 +93,7 @@ class AdapterMeta(abc.ABCMeta):
_available_: FrozenSet[str]
_parse_replacements_: Dict[str, Callable]
- de... | 9,133 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8523",
"repo": "dbt-labs/dbt-core",
"base_commit": "07372db90666ab27b22d561469423d0ea091f4b3",
"pull_number": 8523,
"issue_numbers": [
... |
dbt-labs__dbt-core-8524 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: f063e4e01c3faeba9ba559fcf153c2dd6148c8dd
Changed files:
- core/dbt/events/types.py
... | diff --git a/core/dbt/events/types.py b/core/dbt/events/types.py
index 0000000..0000000 100644
--- a/core/dbt/events/types.py
+++ b/core/dbt/events/types.py
@@ -1628,7 +1628,7 @@ class LogSnapshotResult(DynamicLevel):
status = red(self.status.upper())
else:
info = "OK snapshotted"
- ... | 160,127 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8524",
"repo": "dbt-labs/dbt-core",
"base_commit": "f063e4e01c3faeba9ba559fcf153c2dd6148c8dd",
"pull_number": 8524,
"issue_numbers": [
... |
dbt-labs__dbt-core-8527 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7ae3de1fa011b231b397073bac7dadb67a56ed87
Changed files:
- core/dbt/config/project.p... | diff --git a/core/dbt/config/project.py b/core/dbt/config/project.py
index 0000000..0000000 100644
--- a/core/dbt/config/project.py
+++ b/core/dbt/config/project.py
@@ -429,6 +429,7 @@ class PartialProject(RenderComponents):
semantic_models: Dict[str, Any]
exposures: Dict[str, Any]
vars_value... | 36,956 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8527",
"repo": "dbt-labs/dbt-core",
"base_commit": "7ae3de1fa011b231b397073bac7dadb67a56ed87",
"pull_number": 8527,
"issue_numbers": [
... |
dbt-labs__dbt-core-8551 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 9aff3ca27478846b58d1a9766787ba65497ff6df
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -1528,7 +1528,15 @@ def get_manifest_schema_version(dct: dict) -> int:
schema_version = dct.get("metadata",... | 41,697 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8551",
"repo": "dbt-labs/dbt-core",
"base_commit": "9aff3ca27478846b58d1a9766787ba65497ff6df",
"pull_number": 8551,
"issue_numbers": [
... |
dbt-labs__dbt-core-8561 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22
Changed files:
- core/dbt/clients/agate_he... | diff --git a/core/dbt/clients/agate_helper.py b/core/dbt/clients/agate_helper.py
index 0000000..0000000 100644
--- a/core/dbt/clients/agate_helper.py
+++ b/core/dbt/clients/agate_helper.py
@@ -12,6 +12,20 @@ from dbt.exceptions import DbtRuntimeError
BOM = BOM_UTF8.decode("utf-8") # '\ufeff'
+class Integer(agate.... | 9,618 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8561",
"repo": "dbt-labs/dbt-core",
"base_commit": "7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22",
"pull_number": 8561,
"issue_numbers": [
... |
dbt-labs__dbt-core-8568 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22
Changed files:
- core/dbt/task/base.py
##... | diff --git a/core/dbt/task/base.py b/core/dbt/task/base.py
index 0000000..0000000 100644
--- a/core/dbt/task/base.py
+++ b/core/dbt/task/base.py
@@ -193,7 +193,7 @@ class ExecutionContext:
class BaseRunner(metaclass=ABCMeta):
- def __init__(self, config, adapter, node, node_index, num_nodes):
+ def __init__(... | 10,924 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8568",
"repo": "dbt-labs/dbt-core",
"base_commit": "7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22",
"pull_number": 8568,
"issue_numbers": [
... |
dbt-labs__dbt-core-8569 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22
Changed files:
- core/dbt/task/runnable.py... | diff --git a/core/dbt/task/runnable.py b/core/dbt/task/runnable.py
index 0000000..0000000 100644
--- a/core/dbt/task/runnable.py
+++ b/core/dbt/task/runnable.py
@@ -20,6 +20,7 @@ from dbt.contracts.results import (
RunningStatus,
RunResult,
RunStatus,
+ BaseResult,
)
from dbt.contracts.state import ... | 14,901 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8569",
"repo": "dbt-labs/dbt-core",
"base_commit": "7e2a08f3a5a873d37d7e9de1ada935a5d78c3b22",
"pull_number": 8569,
"issue_numbers": [
... |
dbt-labs__dbt-core-8578 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 75781503b8e75c5684bffbb946e528b39a21525b
Changed files:
- core/dbt/context/provider... | diff --git a/core/dbt/context/providers.py b/core/dbt/context/providers.py
index 0000000..0000000 100644
--- a/core/dbt/context/providers.py
+++ b/core/dbt/context/providers.py
@@ -618,7 +618,7 @@ class RuntimeMetricResolver(BaseMetricResolver):
target_package=target_package,
)
- ... | 45,736 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8578",
"repo": "dbt-labs/dbt-core",
"base_commit": "75781503b8e75c5684bffbb946e528b39a21525b",
"pull_number": 8578,
"issue_numbers": [
... |
dbt-labs__dbt-core-8587 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bfb054082f9c7759ce2e95851de554ec1e75650e
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -1510,7 +1510,15 @@ def get_manifest_schema_version(dct: dict) -> int:
schema_version = dct.get("metadata",... | 40,256 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8587",
"repo": "dbt-labs/dbt-core",
"base_commit": "bfb054082f9c7759ce2e95851de554ec1e75650e",
"pull_number": 8587,
"issue_numbers": [
... |
dbt-labs__dbt-core-8604 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 845aeb697d75d6440ae03624d8574ce37c2850ac
Changed files:
- core/dbt/config/renderer.... | diff --git a/core/dbt/config/renderer.py b/core/dbt/config/renderer.py
index 0000000..0000000 100644
--- a/core/dbt/config/renderer.py
+++ b/core/dbt/config/renderer.py
@@ -182,7 +182,17 @@ class SecretRenderer(BaseRenderer):
# First, standard Jinja rendering, with special handling for 'secret' environment var... | 5,413 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8604",
"repo": "dbt-labs/dbt-core",
"base_commit": "845aeb697d75d6440ae03624d8574ce37c2850ac",
"pull_number": 8604,
"issue_numbers": [
... |
dbt-labs__dbt-core-8605 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 84860e59914ff54b97362c18c2eaf07a47b8d6e6
Changed files:
- core/dbt/config/renderer.... | diff --git a/core/dbt/config/renderer.py b/core/dbt/config/renderer.py
index 0000000..0000000 100644
--- a/core/dbt/config/renderer.py
+++ b/core/dbt/config/renderer.py
@@ -181,7 +181,17 @@ class SecretRenderer(BaseRenderer):
# First, standard Jinja rendering, with special handling for 'secret' environment var... | 5,379 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8605",
"repo": "dbt-labs/dbt-core",
"base_commit": "84860e59914ff54b97362c18c2eaf07a47b8d6e6",
"pull_number": 8605,
"issue_numbers": [
... |
dbt-labs__dbt-core-8615 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: b39eeb328c9a245f21b54fb48f2761ad03d4d6ad
Changed files:
- core/dbt/cli/main.py
- co... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -254,6 +254,7 @@ def docs(ctx, **kwargs):
@p.select
@p.selector
@p.empty_catalog
+@p.static
@p.state
@p.defer_state
@p.deprecated_state
diff --git a/core/dbt/cli/params.p... | 38,015 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8615",
"repo": "dbt-labs/dbt-core",
"base_commit": "b39eeb328c9a245f21b54fb48f2761ad03d4d6ad",
"pull_number": 8615,
"issue_numbers": [
... |
dbt-labs__dbt-core-8619 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: e0f811222e3702ddc3280cda1375797a6702adb3
Changed files:
- core/dbt/clients/agate_he... | diff --git a/core/dbt/clients/agate_helper.py b/core/dbt/clients/agate_helper.py
index 0000000..0000000 100644
--- a/core/dbt/clients/agate_helper.py
+++ b/core/dbt/clients/agate_helper.py
@@ -12,6 +12,20 @@ from dbt.exceptions import DbtRuntimeError
BOM = BOM_UTF8.decode("utf-8") # '\ufeff'
+class Integer(agate.... | 5,957 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8619",
"repo": "dbt-labs/dbt-core",
"base_commit": "e0f811222e3702ddc3280cda1375797a6702adb3",
"pull_number": 8619,
"issue_numbers": [
... |
dbt-labs__dbt-core-8638 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3cc7044fb3f085e20ef71a9807f0ef1415fb7cd0
Changed files:
- core/dbt/contracts/state.... | diff --git a/core/dbt/contracts/state.py b/core/dbt/contracts/state.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/state.py
+++ b/core/dbt/contracts/state.py
@@ -1,8 +1,11 @@
from pathlib import Path
-from .graph.manifest import WritableManifest
-from .results import RunResultsArtifact
-from .results import... | 164,919 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8638",
"repo": "dbt-labs/dbt-core",
"base_commit": "3cc7044fb3f085e20ef71a9807f0ef1415fb7cd0",
"pull_number": 8638,
"issue_numbers": [
... |
dbt-labs__dbt-core-8641 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: d597b80486ebb409685fafb23d972f5361ddf7fc
Changed files:
- core/dbt/task/show.py
##... | diff --git a/core/dbt/task/show.py b/core/dbt/task/show.py
index 0000000..0000000 100644
--- a/core/dbt/task/show.py
+++ b/core/dbt/task/show.py
@@ -2,6 +2,7 @@ import io
import threading
import time
+from dbt.context.providers import generate_runtime_model_context
from dbt.contracts.graph.nodes import SeedNode
f... | 4,715 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8641",
"repo": "dbt-labs/dbt-core",
"base_commit": "d597b80486ebb409685fafb23d972f5361ddf7fc",
"pull_number": 8641,
"issue_numbers": [
... |
dbt-labs__dbt-core-8643 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3f5ebe81b9039b33a57b9aa8b1f5cb1edcd8790f
Changed files:
- core/dbt/events/adapter_e... | diff --git a/core/dbt/events/adapter_endpoint.py b/core/dbt/events/adapter_endpoint.py
index 0000000..0000000 100644
--- a/core/dbt/events/adapter_endpoint.py
+++ b/core/dbt/events/adapter_endpoint.py
@@ -1,7 +1,8 @@
import traceback
from dataclasses import dataclass
-from dbt.events.functions import fire_event
+from... | 9,469 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8643",
"repo": "dbt-labs/dbt-core",
"base_commit": "3f5ebe81b9039b33a57b9aa8b1f5cb1edcd8790f",
"pull_number": 8643,
"issue_numbers": [
... |
dbt-labs__dbt-core-8648 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: f17c1f3fe730947f554b55e4e5471bb9cb45fd95
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -74,6 +74,7 @@ from dbt.adapters.cache import RelationsCache, _make_ref_key_dict
from dbt import deprecations
GET_CATALOG_MACRO_NAME... | 54,780 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8648",
"repo": "dbt-labs/dbt-core",
"base_commit": "f17c1f3fe730947f554b55e4e5471bb9cb45fd95",
"pull_number": 8648,
"issue_numbers": [
... |
dbt-labs__dbt-core-8653 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 46ee3f3d9c1383e97cde32ed363e6357b5a10314
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/model_config.py b/core/dbt/contracts/graph/model_config.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/model_config.py
+++ b/core/dbt/contracts/graph/model_config.py
@@ -216,7 +216,6 @@ T = TypeVar("T", bound="BaseConfig")
@dataclass
class BaseConfig(Additional... | 20,379 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8653",
"repo": "dbt-labs/dbt-core",
"base_commit": "46ee3f3d9c1383e97cde32ed363e6357b5a10314",
"pull_number": 8653,
"issue_numbers": [
... |
dbt-labs__dbt-core-8665 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: d597b80486ebb409685fafb23d972f5361ddf7fc
Changed files:
- core/dbt/cli/flags.py
- c... | diff --git a/core/dbt/cli/flags.py b/core/dbt/cli/flags.py
index 0000000..0000000 100644
--- a/core/dbt/cli/flags.py
+++ b/core/dbt/cli/flags.py
@@ -57,7 +57,7 @@ def args_to_context(args: List[str]) -> Context:
from dbt.cli.main import cli
cli_ctx = cli.make_context(cli.name, args)
- # Split args if the... | 15,332 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8665",
"repo": "dbt-labs/dbt-core",
"base_commit": "d597b80486ebb409685fafb23d972f5361ddf7fc",
"pull_number": 8665,
"issue_numbers": [
... |
dbt-labs__dbt-core-8670 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: aa86fdfe71690e76873facba89c49c3284398855
Changed files:
- core/dbt/cli/main.py
## ... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -1,3 +1,4 @@
+import functools
from copy import copy
from dataclasses import dataclass
from typing import Callable, List, Optional, Union
@@ -118,6 +119,44 @@ class dbtRunne... | 18,259 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8670",
"repo": "dbt-labs/dbt-core",
"base_commit": "aa86fdfe71690e76873facba89c49c3284398855",
"pull_number": 8670,
"issue_numbers": [
... |
dbt-labs__dbt-core-8684 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: d91265411061463b42d6f4d6d94e094a42a96d2b
Changed files:
- core/setup.py
## Problem... | diff --git a/core/setup.py b/core/setup.py
index 0000000..0000000 100644
--- a/core/setup.py
+++ b/core/setup.py
@@ -59,7 +59,7 @@ setup(
# ----
# dbt-core uses these packages in standard ways. Pin to the major version, and check compatibility
# with major versions in each new minor version o... | 4,049 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8684",
"repo": "dbt-labs/dbt-core",
"base_commit": "d91265411061463b42d6f4d6d94e094a42a96d2b",
"pull_number": 8684,
"issue_numbers": [
... |
dbt-labs__dbt-core-8696 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: aa86fdfe71690e76873facba89c49c3284398855
Changed files:
- core/dbt/graph/graph.py
... | diff --git a/core/dbt/graph/graph.py b/core/dbt/graph/graph.py
index 0000000..0000000 100644
--- a/core/dbt/graph/graph.py
+++ b/core/dbt/graph/graph.py
@@ -1,6 +1,7 @@
from typing import Set, Iterable, Iterator, Optional, NewType
from itertools import product
import networkx as nx # type: ignore
+from functools im... | 8,136 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8696",
"repo": "dbt-labs/dbt-core",
"base_commit": "aa86fdfe71690e76873facba89c49c3284398855",
"pull_number": 8696,
"issue_numbers": [
... |
dbt-labs__dbt-core-8700 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 417fc2a73587df8532a241c083f34fb832f73426
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -1411,6 +1411,8 @@ class MetricInputMeasure(dbtClassMixin):
name: str
filter: Optional[WhereFilter] = None
al... | 74,982 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8700",
"repo": "dbt-labs/dbt-core",
"base_commit": "417fc2a73587df8532a241c083f34fb832f73426",
"pull_number": 8700,
"issue_numbers": [
... |
dbt-labs__dbt-core-8709 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: aa86fdfe71690e76873facba89c49c3284398855
Changed files:
- core/dbt/parser/manifest.... | diff --git a/core/dbt/parser/manifest.py b/core/dbt/parser/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/parser/manifest.py
+++ b/core/dbt/parser/manifest.py
@@ -1172,6 +1172,16 @@ class ManifestLoader:
config.project_name,
)
_process_docs_for_metrics(ctx, metric)
+... | 48,727 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8709",
"repo": "dbt-labs/dbt-core",
"base_commit": "aa86fdfe71690e76873facba89c49c3284398855",
"pull_number": 8709,
"issue_numbers": [
... |
dbt-labs__dbt-core-8716 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: f2ef4a62491d77fe68f079074be056f95bc84445
Changed files:
- core/dbt/graph/graph.py
... | diff --git a/core/dbt/graph/graph.py b/core/dbt/graph/graph.py
index 0000000..0000000 100644
--- a/core/dbt/graph/graph.py
+++ b/core/dbt/graph/graph.py
@@ -1,6 +1,7 @@
from typing import Set, Iterable, Iterator, Optional, NewType
from itertools import product
import networkx as nx # type: ignore
+from functools im... | 9,284 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8716",
"repo": "dbt-labs/dbt-core",
"base_commit": "f2ef4a62491d77fe68f079074be056f95bc84445",
"pull_number": 8716,
"issue_numbers": [
... |
dbt-labs__dbt-core-8718 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 5010e87d4aad32e1fb9c5e4d8f14f2abc98d98cf
Changed files:
- core/dbt/parser/manifest.... | diff --git a/core/dbt/parser/manifest.py b/core/dbt/parser/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/parser/manifest.py
+++ b/core/dbt/parser/manifest.py
@@ -98,6 +98,7 @@ from dbt.contracts.graph.nodes import (
ResultNode,
ModelNode,
NodeRelation,
+ SemanticModel,
)
from dbt.contract... | 47,580 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8718",
"repo": "dbt-labs/dbt-core",
"base_commit": "5010e87d4aad32e1fb9c5e4d8f14f2abc98d98cf",
"pull_number": 8718,
"issue_numbers": [
... |
dbt-labs__dbt-core-8732 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: de6b75b3bc320a50bf3ae173d2d21e559bd2ed89
Changed files:
- core/dbt/cli/main.py
## ... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -1,3 +1,4 @@
+import functools
from copy import copy
from dataclasses import dataclass
from typing import Callable, List, Optional, Union
@@ -118,6 +119,44 @@ class dbtRunne... | 17,495 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8732",
"repo": "dbt-labs/dbt-core",
"base_commit": "de6b75b3bc320a50bf3ae173d2d21e559bd2ed89",
"pull_number": 8732,
"issue_numbers": [
... |
dbt-labs__dbt-core-8734 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3c8cf858a2b71dc80fd84691b2d1ba84cad90f65
Changed files:
- core/dbt/cli/main.py
## ... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -1,3 +1,4 @@
+import functools
from copy import copy
from dataclasses import dataclass
from typing import Callable, List, Optional, Union
@@ -118,6 +119,42 @@ class dbtRunne... | 15,932 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8734",
"repo": "dbt-labs/dbt-core",
"base_commit": "3c8cf858a2b71dc80fd84691b2d1ba84cad90f65",
"pull_number": 8734,
"issue_numbers": [
... |
dbt-labs__dbt-core-8743 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bb6fd3029b5bf2fcdbb540528f0ff7ccebc50a41
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/model_config.py b/core/dbt/contracts/graph/model_config.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/model_config.py
+++ b/core/dbt/contracts/graph/model_config.py
@@ -526,6 +526,11 @@ class ModelConfig(NodeConfig):
)
+@dataclass
+class UnitTestNodeConfi... | 79,269 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8743",
"repo": "dbt-labs/dbt-core",
"base_commit": "bb6fd3029b5bf2fcdbb540528f0ff7ccebc50a41",
"pull_number": 8743,
"issue_numbers": [
... |
dbt-labs__dbt-core-8750 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 416bc845ad77d9a692f20b8aae4e8bd2f9dc9a09
Changed files:
- core/dbt/graph/selector_m... | diff --git a/core/dbt/graph/selector_methods.py b/core/dbt/graph/selector_methods.py
index 0000000..0000000 100644
--- a/core/dbt/graph/selector_methods.py
+++ b/core/dbt/graph/selector_methods.py
@@ -234,7 +234,9 @@ class TagSelectorMethod(SelectorMethod):
def search(self, included_nodes: Set[UniqueId], selector:... | 20,285 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8750",
"repo": "dbt-labs/dbt-core",
"base_commit": "416bc845ad77d9a692f20b8aae4e8bd2f9dc9a09",
"pull_number": 8750,
"issue_numbers": [
... |
dbt-labs__dbt-core-8771 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c6ff3abecd390788f2d29fd7d5d2338fa1ab8bb2
Changed files:
- core/dbt/parser/manifest.... | diff --git a/core/dbt/parser/manifest.py b/core/dbt/parser/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/parser/manifest.py
+++ b/core/dbt/parser/manifest.py
@@ -1117,10 +1117,12 @@ class ManifestLoader:
database=refd_node.database,
)
- # nodes: node and column descriptions... | 48,205 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8771",
"repo": "dbt-labs/dbt-core",
"base_commit": "c6ff3abecd390788f2d29fd7d5d2338fa1ab8bb2",
"pull_number": 8771,
"issue_numbers": [
... |
dbt-labs__dbt-core-8772 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c6ff3abecd390788f2d29fd7d5d2338fa1ab8bb2
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -434,9 +434,8 @@ class BaseAdapter(metaclass=AdapterMeta):
return info_schema_name_map
def _get_catalog_relations_by_inf... | 48,782 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8772",
"repo": "dbt-labs/dbt-core",
"base_commit": "c6ff3abecd390788f2d29fd7d5d2338fa1ab8bb2",
"pull_number": 8772,
"issue_numbers": [
... |
dbt-labs__dbt-core-8773 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 6946a206a8145848d57e696cf72044b18cec4604
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -1342,6 +1342,8 @@ class MetricInputMeasure(dbtClassMixin):
name: str
filter: Optional[WhereFilter] = None
al... | 73,140 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8773",
"repo": "dbt-labs/dbt-core",
"base_commit": "6946a206a8145848d57e696cf72044b18cec4604",
"pull_number": 8773,
"issue_numbers": [
... |
dbt-labs__dbt-core-8792 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bb249d612cc34e3830e60a501ec0df23e77ddf94
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -945,7 +945,14 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
group_map = {... | 42,305 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8792",
"repo": "dbt-labs/dbt-core",
"base_commit": "bb249d612cc34e3830e60a501ec0df23e77ddf94",
"pull_number": 8792,
"issue_numbers": [
... |
dbt-labs__dbt-core-8802 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 0e4a6e670da291ee05d8ad564043a2b811ecc22d
Changed files:
- core/dbt/task/debug.py
#... | diff --git a/core/dbt/task/debug.py b/core/dbt/task/debug.py
index 0000000..0000000 100644
--- a/core/dbt/task/debug.py
+++ b/core/dbt/task/debug.py
@@ -149,13 +149,14 @@ class DebugTask(BaseTask):
dependencies_statuses = self.test_dependencies()
# Test connection
- self.test_connection()... | 12,819 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8802",
"repo": "dbt-labs/dbt-core",
"base_commit": "0e4a6e670da291ee05d8ad564043a2b811ecc22d",
"pull_number": 8802,
"issue_numbers": [
... |
dbt-labs__dbt-core-8803 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 339957b42c25b6b8833b25d9d274bd493246fc4c
Changed files:
- core/dbt/task/retry.py
#... | diff --git a/core/dbt/task/retry.py b/core/dbt/task/retry.py
index 0000000..0000000 100644
--- a/core/dbt/task/retry.py
+++ b/core/dbt/task/retry.py
@@ -19,6 +19,16 @@ from dbt.task.snapshot import SnapshotTask
from dbt.task.test import TestTask
RETRYABLE_STATUSES = {NodeStatus.Error, NodeStatus.Fail, NodeStatus.Sk... | 7,277 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8803",
"repo": "dbt-labs/dbt-core",
"base_commit": "339957b42c25b6b8833b25d9d274bd493246fc4c",
"pull_number": 8803,
"issue_numbers": [
... |
dbt-labs__dbt-core-8811 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1852191686290f180c62d73a4b96ebb229afe4bb
Changed files:
- core/dbt/task/retry.py
#... | diff --git a/core/dbt/task/retry.py b/core/dbt/task/retry.py
index 0000000..0000000 100644
--- a/core/dbt/task/retry.py
+++ b/core/dbt/task/retry.py
@@ -19,6 +19,16 @@ from dbt.task.snapshot import SnapshotTask
from dbt.task.test import TestTask
RETRYABLE_STATUSES = {NodeStatus.Error, NodeStatus.Fail, NodeStatus.Sk... | 5,088 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8811",
"repo": "dbt-labs/dbt-core",
"base_commit": "1852191686290f180c62d73a4b96ebb229afe4bb",
"pull_number": 8811,
"issue_numbers": [
... |
dbt-labs__dbt-core-8817 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3d27483658f517946506f65969c47d1979688de9
Changed files:
- core/dbt/parser/partial.p... | diff --git a/core/dbt/parser/partial.py b/core/dbt/parser/partial.py
index 0000000..0000000 100644
--- a/core/dbt/parser/partial.py
+++ b/core/dbt/parser/partial.py
@@ -338,7 +338,10 @@ class PartialParsing:
file_id = node.patch_path
# it might be changed... then what?
if file_id... | 30,074 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8817",
"repo": "dbt-labs/dbt-core",
"base_commit": "3d27483658f517946506f65969c47d1979688de9",
"pull_number": 8817,
"issue_numbers": [
... |
dbt-labs__dbt-core-8820 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: af0cbcb6a58c44991a09da978a9edd2fc65eb6de
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest_upgrade.py b/core/dbt/contracts/graph/manifest_upgrade.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest_upgrade.py
+++ b/core/dbt/contracts/graph/manifest_upgrade.py
@@ -62,10 +62,72 @@ def drop_v9_and_prior_metrics(manifest: dict) -> None:
man... | 3,990 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8820",
"repo": "dbt-labs/dbt-core",
"base_commit": "af0cbcb6a58c44991a09da978a9edd2fc65eb6de",
"pull_number": 8820,
"issue_numbers": [
... |
dbt-labs__dbt-core-8828 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3d27483658f517946506f65969c47d1979688de9
Changed files:
- core/dbt/events/types.py
... | diff --git a/core/dbt/events/types.py b/core/dbt/events/types.py
index 0000000..0000000 100644
--- a/core/dbt/events/types.py
+++ b/core/dbt/events/types.py
@@ -1239,12 +1239,14 @@ class UnversionedBreakingChange(WarnLevel):
def message(self) -> str:
reasons = "\n - ".join(self.breaking_changes)
- ... | 57,228 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8828",
"repo": "dbt-labs/dbt-core",
"base_commit": "3d27483658f517946506f65969c47d1979688de9",
"pull_number": 8828,
"issue_numbers": [
... |
dbt-labs__dbt-core-8842 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1baebb423c82a9c645e59b390fc3a69089623600
Changed files:
- core/dbt/adapters/capabil... | diff --git a/core/dbt/adapters/capability.py b/core/dbt/adapters/capability.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/capability.py
+++ b/core/dbt/adapters/capability.py
@@ -4,7 +4,7 @@ from typing import Optional, DefaultDict, Mapping
class Capability(str, Enum):
- """Enumeration of optional ada... | 1,375 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8842",
"repo": "dbt-labs/dbt-core",
"base_commit": "1baebb423c82a9c645e59b390fc3a69089623600",
"pull_number": 8842,
"issue_numbers": [
... |
dbt-labs__dbt-core-8855 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6
Changed files:
- core/dbt/deps/tarball.py
... | diff --git a/core/dbt/deps/tarball.py b/core/dbt/deps/tarball.py
index 0000000..0000000 100644
--- a/core/dbt/deps/tarball.py
+++ b/core/dbt/deps/tarball.py
@@ -1,7 +1,14 @@
+import functools
+import os
+from pathlib import Path
from typing import Dict
-from dbt.contracts.project import RegistryPackageMetadata, Tarb... | 3,836 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8855",
"repo": "dbt-labs/dbt-core",
"base_commit": "e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6",
"pull_number": 8855,
"issue_numbers": [
... |
dbt-labs__dbt-core-8856 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: ef9d6a870f3cc864ba3240d393a1a9a5b1de529d
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -455,30 +455,16 @@ class BaseAdapter(metaclass=AdapterMeta):
return relations_by_info_schema
- def _get_catalog_relation... | 51,472 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8856",
"repo": "dbt-labs/dbt-core",
"base_commit": "ef9d6a870f3cc864ba3240d393a1a9a5b1de529d",
"pull_number": 8856,
"issue_numbers": [
... |
dbt-labs__dbt-core-8865 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: efa6339e1804e07f7f47aebccb46492fd897f7f5
Changed files:
- core/dbt/parser/partial.p... | diff --git a/core/dbt/parser/partial.py b/core/dbt/parser/partial.py
index 0000000..0000000 100644
--- a/core/dbt/parser/partial.py
+++ b/core/dbt/parser/partial.py
@@ -922,6 +922,9 @@ class PartialParsing:
if unique_id in self.saved_manifest.semantic_models:
semantic_model = self.saved_ma... | 32,907 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8865",
"repo": "dbt-labs/dbt-core",
"base_commit": "efa6339e1804e07f7f47aebccb46492fd897f7f5",
"pull_number": 8865,
"issue_numbers": [
... |
dbt-labs__dbt-core-8909 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: dbd02e54c26f806d7ccc724e5708a00efc95253c
Changed files:
- core/dbt/adapters/base/pl... | diff --git a/core/dbt/adapters/base/plugin.py b/core/dbt/adapters/base/plugin.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/plugin.py
+++ b/core/dbt/adapters/base/plugin.py
@@ -1,20 +1,10 @@
from typing import List, Optional, Type
+from pathlib import Path
from dbt.adapters.base import Credentials
-... | 915 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8909",
"repo": "dbt-labs/dbt-core",
"base_commit": "dbd02e54c26f806d7ccc724e5708a00efc95253c",
"pull_number": 8909,
"issue_numbers": [
... |
dbt-labs__dbt-core-8915 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 6aeebc4c76fbbf1ae9cdbf25e2ef6ee86e1aea3a
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/node_args.py b/core/dbt/contracts/graph/node_args.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/node_args.py
+++ b/core/dbt/contracts/graph/node_args.py
@@ -33,7 +33,8 @@ class ModelNodeArgs:
@property
def fqn(self) -> List[str]:
fqn = [self.pac... | 5,057 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8915",
"repo": "dbt-labs/dbt-core",
"base_commit": "6aeebc4c76fbbf1ae9cdbf25e2ef6ee86e1aea3a",
"pull_number": 8915,
"issue_numbers": [
... |
dbt-labs__dbt-core-8921 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 10ca8ab6512607cbb05ff8699b5f827e2e0336ef
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/node_args.py b/core/dbt/contracts/graph/node_args.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/node_args.py
+++ b/core/dbt/contracts/graph/node_args.py
@@ -33,7 +33,8 @@ class ModelNodeArgs:
@property
def fqn(self) -> List[str]:
fqn = [self.pac... | 3,137 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8921",
"repo": "dbt-labs/dbt-core",
"base_commit": "10ca8ab6512607cbb05ff8699b5f827e2e0336ef",
"pull_number": 8921,
"issue_numbers": [
... |
dbt-labs__dbt-core-8922 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 12c1cbbc641785c03a3bf451ba32355ac1b5bcbf
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/node_args.py b/core/dbt/contracts/graph/node_args.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/node_args.py
+++ b/core/dbt/contracts/graph/node_args.py
@@ -33,7 +33,8 @@ class ModelNodeArgs:
@property
def fqn(self) -> List[str]:
fqn = [self.pac... | 3,136 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8922",
"repo": "dbt-labs/dbt-core",
"base_commit": "12c1cbbc641785c03a3bf451ba32355ac1b5bcbf",
"pull_number": 8922,
"issue_numbers": [
... |
dbt-labs__dbt-core-8940 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: a2a7b7d795eb40f743063601375e44a5b72f1b9a
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -1179,9 +1179,9 @@ class BaseAdapter(metaclass=AdapterMeta):
}
def in_map(row: agate.Row):
- ... | 43,322 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8940",
"repo": "dbt-labs/dbt-core",
"base_commit": "a2a7b7d795eb40f743063601375e44a5b72f1b9a",
"pull_number": 8940,
"issue_numbers": [
... |
dbt-labs__dbt-core-8953 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 5e13698b2b6ff2db537da634aa7e356d87a79506
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -455,30 +455,16 @@ class BaseAdapter(metaclass=AdapterMeta):
return relations_by_info_schema
- def _get_catalog_relation... | 50,839 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8953",
"repo": "dbt-labs/dbt-core",
"base_commit": "5e13698b2b6ff2db537da634aa7e356d87a79506",
"pull_number": 8953,
"issue_numbers": [
... |
dbt-labs__dbt-core-8966 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 02a3dc5be367e5291b9778fef70c341aacefe90d
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/unparsed.py
+++ b/core/dbt/contracts/graph/unparsed.py
@@ -830,16 +830,11 @@ class UnitTestOverrides(dbtClassMixin):
@dataclass
-class UnparsedUnitTestDefinition(dbt... | 50,702 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8966",
"repo": "dbt-labs/dbt-core",
"base_commit": "02a3dc5be367e5291b9778fef70c341aacefe90d",
"pull_number": 8966,
"issue_numbers": [
... |
dbt-labs__dbt-core-8975 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bb21403c9e906097c4913edcf7a013d404e93d80
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -1179,9 +1179,12 @@ class BaseAdapter(metaclass=AdapterMeta):
}
def in_map(row: agate.Row):
- ... | 43,464 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8975",
"repo": "dbt-labs/dbt-core",
"base_commit": "bb21403c9e906097c4913edcf7a013d404e93d80",
"pull_number": 8975,
"issue_numbers": [
... |
dbt-labs__dbt-core-8978 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: eeaaec4de9cfe8c5fbec22e5f063e79b9417f954
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -1179,9 +1179,12 @@ class BaseAdapter(metaclass=AdapterMeta):
}
def in_map(row: agate.Row):
- ... | 44,604 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8978",
"repo": "dbt-labs/dbt-core",
"base_commit": "eeaaec4de9cfe8c5fbec22e5f063e79b9417f954",
"pull_number": 8978,
"issue_numbers": [
... |
dbt-labs__dbt-core-8984 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 436dae6bb3e142aa7d0773ff7cbba7a8c2cb72f8
Changed files:
- core/dbt/clients/agate_he... | diff --git a/core/dbt/clients/agate_helper.py b/core/dbt/clients/agate_helper.py
index 0000000..0000000 100644
--- a/core/dbt/clients/agate_helper.py
+++ b/core/dbt/clients/agate_helper.py
@@ -3,6 +3,7 @@ from codecs import BOM_UTF8
import agate
import datetime
import isodate
+import io
import json
import dbt.util... | 10,374 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-8984",
"repo": "dbt-labs/dbt-core",
"base_commit": "436dae6bb3e142aa7d0773ff7cbba7a8c2cb72f8",
"pull_number": 8984,
"issue_numbers": [
... |
dbt-labs__dbt-core-9004 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7fddd6e448d9873da282b2ff7835ab39738d9663
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -51,6 +51,7 @@ from dbt.clients.agate_helper import (
get_column_value_uncased,
merge_tables,
table_from_rows,
+ Integ... | 52,683 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9004",
"repo": "dbt-labs/dbt-core",
"base_commit": "7fddd6e448d9873da282b2ff7835ab39738d9663",
"pull_number": 9004,
"issue_numbers": [
... |
dbt-labs__dbt-core-9008 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c7c3ac872cc59c861dad041153d7ab0fa54d9b2f
Changed files:
- core/dbt/node_types.py
#... | diff --git a/core/dbt/node_types.py b/core/dbt/node_types.py
index 0000000..0000000 100644
--- a/core/dbt/node_types.py
+++ b/core/dbt/node_types.py
@@ -64,19 +64,6 @@ class NodeType(StrEnum):
cls.Model,
]
- @classmethod
- def documentable(cls) -> List["NodeType"]:
- return [
- ... | 1,768 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9008",
"repo": "dbt-labs/dbt-core",
"base_commit": "c7c3ac872cc59c861dad041153d7ab0fa54d9b2f",
"pull_number": 9008,
"issue_numbers": [
... |
dbt-labs__dbt-core-9009 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c7c3ac872cc59c861dad041153d7ab0fa54d9b2f
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -20,6 +20,7 @@ from typing import (
Generic,
AbstractSet,
ClassVar,
+ Iterable,
)
from typin... | 60,850 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9009",
"repo": "dbt-labs/dbt-core",
"base_commit": "c7c3ac872cc59c861dad041153d7ab0fa54d9b2f",
"pull_number": 9009,
"issue_numbers": [
... |
dbt-labs__dbt-core-9012 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c7c3ac872cc59c861dad041153d7ab0fa54d9b2f
Changed files:
- core/setup.py
## Problem... | diff --git a/core/setup.py b/core/setup.py
index 0000000..0000000 100644
--- a/core/setup.py
+++ b/core/setup.py
@@ -73,7 +73,6 @@ setup(
# These are major-version-0 packages also maintained by dbt-labs. Accept patches.
"dbt-extractor~=0.5.0",
"minimal-snowplow-tracker~=0.0.2",
- # DSI... | 20,701 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9012",
"repo": "dbt-labs/dbt-core",
"base_commit": "c7c3ac872cc59c861dad041153d7ab0fa54d9b2f",
"pull_number": 9012,
"issue_numbers": [
... |
dbt-labs__dbt-core-9017 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 2401600e57048dd56818f7293abed96ffd510ac9
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -20,6 +20,7 @@ from typing import (
Generic,
AbstractSet,
ClassVar,
+ Iterable,
)
from typin... | 60,851 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9017",
"repo": "dbt-labs/dbt-core",
"base_commit": "2401600e57048dd56818f7293abed96ffd510ac9",
"pull_number": 9017,
"issue_numbers": [
... |
dbt-labs__dbt-core-9021 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 6c1822f1869869df301795c0b0b1e72f393540fe
Changed files:
- plugins/postgres/setup.py... | diff --git a/plugins/postgres/setup.py b/plugins/postgres/setup.py
index 0000000..0000000 100644
--- a/plugins/postgres/setup.py
+++ b/plugins/postgres/setup.py
@@ -60,14 +60,7 @@ setup(
author_email="info@dbtlabs.com",
url="https://github.com/dbt-labs/dbt-core",
packages=find_namespace_packages(include=... | 2,761 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9021",
"repo": "dbt-labs/dbt-core",
"base_commit": "6c1822f1869869df301795c0b0b1e72f393540fe",
"pull_number": 9021,
"issue_numbers": [
... |
dbt-labs__dbt-core-9031 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1c9cec17878ca0fec537a4cc13812f91ee97b29b
Changed files:
- core/dbt/plugins/manager.... | diff --git a/core/dbt/plugins/manager.py b/core/dbt/plugins/manager.py
index 0000000..0000000 100644
--- a/core/dbt/plugins/manager.py
+++ b/core/dbt/plugins/manager.py
@@ -1,6 +1,8 @@
+import functools
import importlib
import pkgutil
-from typing import Dict, List, Callable
+from types import ModuleType
+from typing... | 3,582 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9031",
"repo": "dbt-labs/dbt-core",
"base_commit": "1c9cec17878ca0fec537a4cc13812f91ee97b29b",
"pull_number": 9031,
"issue_numbers": [
... |
dbt-labs__dbt-core-9032 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 3b033ac108b2b7a7ca902ce1a1ac6719db776552
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -1080,6 +1080,7 @@ class UnitTestDefinition(GraphNode):
overrides: Optional[UnitTestOverrides] = None
depends_on: ... | 69,067 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9032",
"repo": "dbt-labs/dbt-core",
"base_commit": "3b033ac108b2b7a7ca902ce1a1ac6719db776552",
"pull_number": 9032,
"issue_numbers": [
... |
dbt-labs__dbt-core-9044 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 2792e0c2ced324f2376337ab9b329c61d055bae0
Changed files:
- core/dbt/config/project.p... | diff --git a/core/dbt/config/project.py b/core/dbt/config/project.py
index 0000000..0000000 100644
--- a/core/dbt/config/project.py
+++ b/core/dbt/config/project.py
@@ -652,6 +652,13 @@ class Project:
generic_test_paths.append(os.path.join(test_path, "generic"))
return generic_test_paths
+ @p... | 39,805 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9044",
"repo": "dbt-labs/dbt-core",
"base_commit": "2792e0c2ced324f2376337ab9b329c61d055bae0",
"pull_number": 9044,
"issue_numbers": [
... |
dbt-labs__dbt-core-9059 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 436dae6bb3e142aa7d0773ff7cbba7a8c2cb72f8
Changed files:
- core/dbt/adapters/base/re... | diff --git a/core/dbt/adapters/base/relation.py b/core/dbt/adapters/base/relation.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/relation.py
+++ b/core/dbt/adapters/base/relation.py
@@ -2,7 +2,13 @@ from collections.abc import Hashable
from dataclasses import dataclass, field
from typing import Optiona... | 105,313 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9059",
"repo": "dbt-labs/dbt-core",
"base_commit": "436dae6bb3e142aa7d0773ff7cbba7a8c2cb72f8",
"pull_number": 9059,
"issue_numbers": [
... |
dbt-labs__dbt-core-9065 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/model_config.py b/core/dbt/contracts/graph/model_config.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/model_config.py
+++ b/core/dbt/contracts/graph/model_config.py
@@ -15,6 +15,7 @@ from dbt.contracts.util import Replaceable, list_str
from dbt.exceptions import ... | 53,108 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9065",
"repo": "dbt-labs/dbt-core",
"base_commit": "e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6",
"pull_number": 9065,
"issue_numbers": [
... |
dbt-labs__dbt-core-9068 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6
Changed files:
- core/dbt/deps/tarball.py
... | diff --git a/core/dbt/deps/tarball.py b/core/dbt/deps/tarball.py
index 0000000..0000000 100644
--- a/core/dbt/deps/tarball.py
+++ b/core/dbt/deps/tarball.py
@@ -31,8 +31,7 @@ class TarballPinnedPackage(TarballPackageMixin, PinnedPackage):
def to_dict(self) -> Dict[str, str]:
return {
"tarball... | 2,448 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9068",
"repo": "dbt-labs/dbt-core",
"base_commit": "e24f9b3da722328e24ee10a06fa2e8d2ca73b3e6",
"pull_number": 9068,
"issue_numbers": [
... |
dbt-labs__dbt-core-9081 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 2c1926cee9edad86dcc0e435677789e8e93925bb
Changed files:
- core/dbt/cli/main.py
- co... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -127,12 +127,14 @@ def global_flags(func):
@p.populate_cache
@p.print
@p.printer_width
+ @p.profile
@p.quiet
@p.record_timing_info
@p.send_anon... | 37,265 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9081",
"repo": "dbt-labs/dbt-core",
"base_commit": "2c1926cee9edad86dcc0e435677789e8e93925bb",
"pull_number": 9081,
"issue_numbers": [
... |
dbt-labs__dbt-core-9106 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: b5885da54eb7427c9d7e2fc0b147ee4835e94333
Changed files:
- core/setup.py
## Problem... | diff --git a/core/setup.py b/core/setup.py
index 0000000..0000000 100644
--- a/core/setup.py
+++ b/core/setup.py
@@ -49,7 +49,7 @@ setup(
# ----
# dbt-core uses these packages deeply, throughout the codebase, and there have been breaking changes in past patch releases (even though these are major-vers... | 3,316 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9106",
"repo": "dbt-labs/dbt-core",
"base_commit": "b5885da54eb7427c9d7e2fc0b147ee4835e94333",
"pull_number": 9106,
"issue_numbers": [
... |
dbt-labs__dbt-core-9155 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 5488dfb9926c3f81e6a80bd0d8b01fe7f0ac7a60
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/manifest.py b/core/dbt/contracts/graph/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -1550,7 +1550,7 @@ AnyManifest = Union[Manifest, MacroManifest]
@dataclass
-@schema_version("manifest", 11)... | 62,619 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9155",
"repo": "dbt-labs/dbt-core",
"base_commit": "5488dfb9926c3f81e6a80bd0d8b01fe7f0ac7a60",
"pull_number": 9155,
"issue_numbers": [
... |
dbt-labs__dbt-core-9159 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 32fde755043134dd8a2f5835db9c50e2f4383cb8
Changed files:
- core/dbt/task/generate.py... | diff --git a/core/dbt/task/generate.py b/core/dbt/task/generate.py
index 0000000..0000000 100644
--- a/core/dbt/task/generate.py
+++ b/core/dbt/task/generate.py
@@ -247,6 +247,12 @@ class GenerateTask(CompileTask):
if self.job_queue is not None:
selected_node_ids = self.job_queue.g... | 51,042 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9159",
"repo": "dbt-labs/dbt-core",
"base_commit": "32fde755043134dd8a2f5835db9c50e2f4383cb8",
"pull_number": 9159,
"issue_numbers": [
... |
dbt-labs__dbt-core-9163 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 09f5bb3dcffeda7a60ad2b22c2891f237628ecd1
Changed files:
- core/dbt/task/generate.py... | diff --git a/core/dbt/task/generate.py b/core/dbt/task/generate.py
index 0000000..0000000 100644
--- a/core/dbt/task/generate.py
+++ b/core/dbt/task/generate.py
@@ -247,6 +247,12 @@ class GenerateTask(CompileTask):
if self.job_queue is not None:
selected_node_ids = self.job_queue.g... | 29,649 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9163",
"repo": "dbt-labs/dbt-core",
"base_commit": "09f5bb3dcffeda7a60ad2b22c2891f237628ecd1",
"pull_number": 9163,
"issue_numbers": [
... |
dbt-labs__dbt-core-9169 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1740df534bae3e0a639eb97df17bbb8f6ba4e704
Changed files:
- core/dbt/cli/main.py
- co... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -457,7 +457,6 @@ def debug(ctx, **kwargs):
@p.target
@p.vars
@p.source
-@p.dry_run
@p.lock
@p.upgrade
@p.add_package
@@ -483,12 +482,6 @@ def deps(ctx, **kwargs):
... | 40,129 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9169",
"repo": "dbt-labs/dbt-core",
"base_commit": "1740df534bae3e0a639eb97df17bbb8f6ba4e704",
"pull_number": 9169,
"issue_numbers": [
... |
dbt-labs__dbt-core-9184 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bf6bffad94790683a0d2d57ee2f9cc807ab08c22
Changed files:
- core/dbt/adapters/base/re... | diff --git a/core/dbt/adapters/base/relation.py b/core/dbt/adapters/base/relation.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/relation.py
+++ b/core/dbt/adapters/base/relation.py
@@ -245,7 +245,7 @@ class BaseRelation(FakeAPIObject, Hashable):
cls: Type[Self],
config: HasQuoting,
... | 11,646 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9184",
"repo": "dbt-labs/dbt-core",
"base_commit": "bf6bffad94790683a0d2d57ee2f9cc807ab08c22",
"pull_number": 9184,
"issue_numbers": [
... |
dbt-labs__dbt-core-9229 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: fc2d16fd34de41f6b7f966193d42fc76b8a9eedd
Changed files:
- core/dbt/contracts/util.p... | diff --git a/core/dbt/contracts/util.py b/core/dbt/contracts/util.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/util.py
+++ b/core/dbt/contracts/util.py
@@ -18,6 +18,7 @@ from dbt.dataclass_schema import (
ValidationError,
)
from mashumaro.jsonschema import build_json_schema
+from mashumaro.jsonschem... | 9,029 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9229",
"repo": "dbt-labs/dbt-core",
"base_commit": "fc2d16fd34de41f6b7f966193d42fc76b8a9eedd",
"pull_number": 9229,
"issue_numbers": [
... |
dbt-labs__dbt-core-9242 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: f1c2f06d1e903d65df4e709911e2be434f99b6e5
Changed files:
- core/dbt/adapters/base/im... | diff --git a/core/dbt/adapters/base/impl.py b/core/dbt/adapters/base/impl.py
index 0000000..0000000 100644
--- a/core/dbt/adapters/base/impl.py
+++ b/core/dbt/adapters/base/impl.py
@@ -4,7 +4,6 @@ from contextlib import contextmanager
from datetime import datetime
from enum import Enum
import time
-from itertools im... | 66,689 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9242",
"repo": "dbt-labs/dbt-core",
"base_commit": "f1c2f06d1e903d65df4e709911e2be434f99b6e5",
"pull_number": 9242,
"issue_numbers": [
... |
dbt-labs__dbt-core-9270 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bcbde3ac4204f00d964a3ea60896b6af1df18c71
Changed files:
- core/dbt/graph/selector_m... | diff --git a/core/dbt/graph/selector_methods.py b/core/dbt/graph/selector_methods.py
index 0000000..0000000 100644
--- a/core/dbt/graph/selector_methods.py
+++ b/core/dbt/graph/selector_methods.py
@@ -455,6 +455,10 @@ class FileSelectorMethod(SelectorMethod):
class PackageSelectorMethod(SelectorMethod):
def searc... | 26,047 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9270",
"repo": "dbt-labs/dbt-core",
"base_commit": "bcbde3ac4204f00d964a3ea60896b6af1df18c71",
"pull_number": 9270,
"issue_numbers": [
... |
dbt-labs__dbt-core-9291 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 4bb1d4bce32cbb3c485d15bdd65fe0c47c508fd3
Changed files:
- plugins/postgres/dbt/adap... | diff --git a/plugins/postgres/dbt/adapters/postgres/impl.py b/plugins/postgres/dbt/adapters/postgres/impl.py
index 0000000..0000000 100644
--- a/plugins/postgres/dbt/adapters/postgres/impl.py
+++ b/plugins/postgres/dbt/adapters/postgres/impl.py
@@ -18,7 +18,7 @@ from dbt.adapters.exceptions import (
IndexConfigErr... | 9,062 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9291",
"repo": "dbt-labs/dbt-core",
"base_commit": "4bb1d4bce32cbb3c485d15bdd65fe0c47c508fd3",
"pull_number": 9291,
"issue_numbers": [
... |
dbt-labs__dbt-core-9335 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: e42b7ca214684e147d9141e71159faf3d79a229f
Changed files:
- core/dbt/common/contracts... | diff --git a/core/dbt/common/contracts/config/base.py b/core/dbt/common/contracts/config/base.py
index 0000000..0000000 100644
--- a/core/dbt/common/contracts/config/base.py
+++ b/core/dbt/common/contracts/config/base.py
@@ -1,7 +1,10 @@
+# necessary for annotating constructors
+from __future__ import annotations
+
fr... | 14,909 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9335",
"repo": "dbt-labs/dbt-core",
"base_commit": "e42b7ca214684e147d9141e71159faf3d79a229f",
"pull_number": 9335,
"issue_numbers": [
... |
dbt-labs__dbt-core-9341 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 65b366bca904ef741bedae255dfdbc3837f4d2e9
Changed files:
- core/dbt/task/deps.py
##... | diff --git a/core/dbt/task/deps.py b/core/dbt/task/deps.py
index 0000000..0000000 100644
--- a/core/dbt/task/deps.py
+++ b/core/dbt/task/deps.py
@@ -201,7 +201,7 @@ class DepsTask(BaseTask):
)
with open(lock_filepath, "w") as lock_obj:
- yaml.safe_dump(packages_installed, lock_obj)
+ ... | 7,711 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9341",
"repo": "dbt-labs/dbt-core",
"base_commit": "65b366bca904ef741bedae255dfdbc3837f4d2e9",
"pull_number": 9341,
"issue_numbers": [
... |
dbt-labs__dbt-core-9343 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 0da5dfecbb45632d52ecdb07ad2c5b4726c246ca
Changed files:
- core/dbt/context/provider... | diff --git a/core/dbt/context/providers.py b/core/dbt/context/providers.py
index 0000000..0000000 100644
--- a/core/dbt/context/providers.py
+++ b/core/dbt/context/providers.py
@@ -67,7 +67,6 @@ from dbt.exceptions import (
MacroResultAlreadyLoadedError,
MetricArgsError,
OperationsCannotRefEphemeralNodes... | 47,375 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9343",
"repo": "dbt-labs/dbt-core",
"base_commit": "0da5dfecbb45632d52ecdb07ad2c5b4726c246ca",
"pull_number": 9343,
"issue_numbers": [
... |
dbt-labs__dbt-core-9366 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c547aace361ea12c3de90a811e612481fefe766b
Changed files:
- core/dbt/cli/flags.py
- c... | diff --git a/core/dbt/cli/flags.py b/core/dbt/cli/flags.py
index 0000000..0000000 100644
--- a/core/dbt/cli/flags.py
+++ b/core/dbt/cli/flags.py
@@ -236,8 +236,8 @@ class Flags:
# Add entire invocation command to flags
object.__setattr__(self, "INVOCATION_COMMAND", "dbt " + " ".join(sys.argv[1:]))
-... | 26,947 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9366",
"repo": "dbt-labs/dbt-core",
"base_commit": "c547aace361ea12c3de90a811e612481fefe766b",
"pull_number": 9366,
"issue_numbers": [
... |
dbt-labs__dbt-core-9373 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 6fd0a947297056e4a92d796111a2be578b774b47
Changed files:
- core/setup.py
## Problem... | diff --git a/core/setup.py b/core/setup.py
index 0000000..0000000 100644
--- a/core/setup.py
+++ b/core/setup.py
@@ -65,7 +65,7 @@ setup(
# ----
# These packages are major-version-0. Keep upper bounds on upcoming minor versions (which could have breaking changes)
# and check compatibility / b... | 3,486 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9373",
"repo": "dbt-labs/dbt-core",
"base_commit": "6fd0a947297056e4a92d796111a2be578b774b47",
"pull_number": 9373,
"issue_numbers": [
... |
dbt-labs__dbt-core-9396 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 321031cb472a728cf8be2de5a91d7e81b43cbb29
Changed files:
- core/dbt/context/provider... | diff --git a/core/dbt/context/providers.py b/core/dbt/context/providers.py
index 0000000..0000000 100644
--- a/core/dbt/context/providers.py
+++ b/core/dbt/context/providers.py
@@ -577,7 +577,6 @@ class RuntimeUnitTestRefResolver(RuntimeRefResolver):
target_package: Optional[str] = None,
target_versio... | 47,623 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9396",
"repo": "dbt-labs/dbt-core",
"base_commit": "321031cb472a728cf8be2de5a91d7e81b43cbb29",
"pull_number": 9396,
"issue_numbers": [
... |
dbt-labs__dbt-core-9412 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 0da5dfecbb45632d52ecdb07ad2c5b4726c246ca
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -1225,6 +1225,21 @@ class UnpatchedSourceDefinition(BaseNode):
sources parse tests differently than models, so we n... | 92,220 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9412",
"repo": "dbt-labs/dbt-core",
"base_commit": "0da5dfecbb45632d52ecdb07ad2c5b4726c246ca",
"pull_number": 9412,
"issue_numbers": [
... |
dbt-labs__dbt-core-9423 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: c547aace361ea12c3de90a811e612481fefe766b
Changed files:
- core/dbt/context/macros.p... | diff --git a/core/dbt/context/macros.py b/core/dbt/context/macros.py
index 0000000..0000000 100644
--- a/core/dbt/context/macros.py
+++ b/core/dbt/context/macros.py
@@ -67,7 +67,6 @@ class MacroNamespace(Mapping):
raise KeyError(key)
def get_from_package(self, package_name: Optional[str], name: str) -> ... | 50,997 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9423",
"repo": "dbt-labs/dbt-core",
"base_commit": "c547aace361ea12c3de90a811e612481fefe766b",
"pull_number": 9423,
"issue_numbers": [
... |
dbt-labs__dbt-core-9427 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: af188624d5967ed996f40f1c1e20082878b8cc8a
Changed files:
- core/dbt/cli/main.py
## ... | diff --git a/core/dbt/cli/main.py b/core/dbt/cli/main.py
index 0000000..0000000 100644
--- a/core/dbt/cli/main.py
+++ b/core/dbt/cli/main.py
@@ -602,6 +602,7 @@ def run(ctx, **kwargs):
@requires.profile
@requires.project
@requires.runtime_config
+@requires.manifest
def retry(ctx, **kwargs):
"""Retry the nodes ... | 16,624 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9427",
"repo": "dbt-labs/dbt-core",
"base_commit": "af188624d5967ed996f40f1c1e20082878b8cc8a",
"pull_number": 9427,
"issue_numbers": [
... |
dbt-labs__dbt-core-9452 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: bdcf2649632139296dc7c24fc50cbf9c8325df87
Changed files:
- core/setup.py
## Problem... | diff --git a/core/setup.py b/core/setup.py
index 0000000..0000000 100644
--- a/core/setup.py
+++ b/core/setup.py
@@ -61,6 +61,7 @@ setup(
# with major versions in each new minor version of dbt-core.
"click>=8.0.2,<9",
"networkx>=2.3,<4",
+ "requests<3.0.0", # should match dbt-common
... | 2,979 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9452",
"repo": "dbt-labs/dbt-core",
"base_commit": "bdcf2649632139296dc7c24fc50cbf9c8325df87",
"pull_number": 9452,
"issue_numbers": [
... |
dbt-labs__dbt-core-9454 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 98bbbc126b48326a3acadeee96886202a744ed11
Changed files:
- core/dbt/task/docs/genera... | diff --git a/core/dbt/task/docs/generate.py b/core/dbt/task/docs/generate.py
index 0000000..0000000 100644
--- a/core/dbt/task/docs/generate.py
+++ b/core/dbt/task/docs/generate.py
@@ -13,6 +13,8 @@ from dbt.task.docs import DOCS_INDEX_FILE_PATH
from dbt.task.compile import CompileTask
from dbt.adapters.factory imp... | 9,486 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9454",
"repo": "dbt-labs/dbt-core",
"base_commit": "98bbbc126b48326a3acadeee96886202a744ed11",
"pull_number": 9454,
"issue_numbers": [
... |
dbt-labs__dbt-core-9456 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 6663846026aba5d9b8e4abb47b58af2ff0462e40
Changed files:
- core/dbt/task/docs/genera... | diff --git a/core/dbt/task/docs/generate.py b/core/dbt/task/docs/generate.py
index 0000000..0000000 100644
--- a/core/dbt/task/docs/generate.py
+++ b/core/dbt/task/docs/generate.py
@@ -343,6 +343,7 @@ class GenerateTask(CompileTask):
manifest=self.manifest,
previous_state=self.previous_state,
... | 8,918 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9456",
"repo": "dbt-labs/dbt-core",
"base_commit": "6663846026aba5d9b8e4abb47b58af2ff0462e40",
"pull_number": 9456,
"issue_numbers": [
... |
dbt-labs__dbt-core-9465 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1cbc6d333d79f4408ed620c5aef18b18a216e6c3
Changed files:
- core/dbt/artifacts/resour... | diff --git a/core/dbt/artifacts/resources/types.py b/core/dbt/artifacts/resources/types.py
index 0000000..0000000 100644
--- a/core/dbt/artifacts/resources/types.py
+++ b/core/dbt/artifacts/resources/types.py
@@ -18,7 +18,7 @@ class AccessType(StrEnum):
class NodeType(StrEnum):
Model = "model"
Analysis = "an... | 17,096 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9465",
"repo": "dbt-labs/dbt-core",
"base_commit": "1cbc6d333d79f4408ed620c5aef18b18a216e6c3",
"pull_number": 9465,
"issue_numbers": [
... |
dbt-labs__dbt-core-9480 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 5ae8f6aad71545818a1f179abb45d5867f0e2e4f
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/nodes.py b/core/dbt/contracts/graph/nodes.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -1091,6 +1091,13 @@ class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):
tags = self.co... | 54,786 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9480",
"repo": "dbt-labs/dbt-core",
"base_commit": "5ae8f6aad71545818a1f179abb45d5867f0e2e4f",
"pull_number": 9480,
"issue_numbers": [
... |
dbt-labs__dbt-core-9488 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 7a410ab228bda4d2ecd4ae44726a91a1030afd75
Changed files:
- core/dbt/artifacts/schema... | diff --git a/core/dbt/artifacts/schemas/manifest/v12/manifest.py b/core/dbt/artifacts/schemas/manifest/v12/manifest.py
index 0000000..0000000 100644
--- a/core/dbt/artifacts/schemas/manifest/v12/manifest.py
+++ b/core/dbt/artifacts/schemas/manifest/v12/manifest.py
@@ -165,7 +165,7 @@ class WritableManifest(ArtifactMixi... | 4,452 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9488",
"repo": "dbt-labs/dbt-core",
"base_commit": "7a410ab228bda4d2ecd4ae44726a91a1030afd75",
"pull_number": 9488,
"issue_numbers": [
... |
dbt-labs__dbt-core-9495 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 9c8b28aa640382a381768904795c5e7124f9c8bc
Changed files:
- .github/actions/latest-wr... | diff --git a/.github/actions/latest-wrangler/main.py b/.github/actions/latest-wrangler/main.py
index 0000000..0000000 100644
--- a/.github/actions/latest-wrangler/main.py
+++ b/.github/actions/latest-wrangler/main.py
@@ -1,98 +1,71 @@
import os
-import sys
+from packaging.version import Version, parse
import requests... | 2,890 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9495",
"repo": "dbt-labs/dbt-core",
"base_commit": "9c8b28aa640382a381768904795c5e7124f9c8bc",
"pull_number": 9495,
"issue_numbers": [
... |
dbt-labs__dbt-core-9503 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 2d59a51874672e5a95ec7f2f2aa18b8a66e9e738
Changed files:
- core/dbt/context/provider... | diff --git a/core/dbt/context/providers.py b/core/dbt/context/providers.py
index 0000000..0000000 100644
--- a/core/dbt/context/providers.py
+++ b/core/dbt/context/providers.py
@@ -1457,27 +1457,10 @@ class ModelContext(ProviderContext):
h.to_dict(omit_none=True) for h in self.model.config.post_hook # typ... | 47,083 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9503",
"repo": "dbt-labs/dbt-core",
"base_commit": "2d59a51874672e5a95ec7f2f2aa18b8a66e9e738",
"pull_number": 9503,
"issue_numbers": [
... |
dbt-labs__dbt-core-9508 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 2411f93240a346961e6a965ad9cb5c766db275a0
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/unparsed.py
+++ b/core/dbt/contracts/graph/unparsed.py
@@ -562,7 +562,8 @@ class MetricTime(dbtClassMixin, Mergeable):
@dataclass
class UnparsedMetricInputMeasure(dbtCl... | 19,615 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9508",
"repo": "dbt-labs/dbt-core",
"base_commit": "2411f93240a346961e6a965ad9cb5c766db275a0",
"pull_number": 9508,
"issue_numbers": [
... |
dbt-labs__dbt-core-9509 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: db65e627cab89fb5ef6f1f8793aa2a261106a3ca
Changed files:
- core/dbt/contracts/graph/... | diff --git a/core/dbt/contracts/graph/unparsed.py b/core/dbt/contracts/graph/unparsed.py
index 0000000..0000000 100644
--- a/core/dbt/contracts/graph/unparsed.py
+++ b/core/dbt/contracts/graph/unparsed.py
@@ -7,6 +7,7 @@ from dbt_common.contracts.config.properties import (
AdditionalPropertiesAllowed,
Additio... | 28,854 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9509",
"repo": "dbt-labs/dbt-core",
"base_commit": "db65e627cab89fb5ef6f1f8793aa2a261106a3ca",
"pull_number": 9509,
"issue_numbers": [
... |
dbt-labs__dbt-core-9539 | You are given a GitHub issue and the relevant repository files before and after the fix.
Your task is to synthesize the unified git diff that transforms the before files into the after files.
Repository: dbt-labs/dbt-core
Base commit: 1220fdfdd62b0f7ece97bbea52d08f86ac09bf73
Changed files:
- core/dbt/parser/schemas.p... | diff --git a/core/dbt/parser/schemas.py b/core/dbt/parser/schemas.py
index 0000000..0000000 100644
--- a/core/dbt/parser/schemas.py
+++ b/core/dbt/parser/schemas.py
@@ -845,7 +845,10 @@ class ModelPatchParser(NodePatchParser[UnparsedModelUpdate]):
# Includes alias recomputation
self.pa... | 25,309 | {
"dataset": "internlm/SWE-Fixer-Train-110K-diff",
"source_dataset": "internlm/SWE-Fixer-Train-110K",
"task": "before_after_to_diff",
"instance_id": "dbt-labs__dbt-core-9539",
"repo": "dbt-labs/dbt-core",
"base_commit": "1220fdfdd62b0f7ece97bbea52d08f86ac09bf73",
"pull_number": 9539,
"issue_numbers": [
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.