Fix code to work with mashumaro 3.15

.changes/unreleased/Under the Hood-20241202-115445.yaml

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: Support upgrading mashumaro to 3.15
+time: 2024-12-02T11:54:45.103325-05:00
+custom:
+  Author: gshank
+  Issue: "11044"

core/dbt/artifacts/resources/v1/components.py

@@ -12,7 +12,7 @@
 from dbt_common.dataclass_schema import ExtensibleDbtClassMixin, dbtClassMixin
 from dbt_semantic_interfaces.type_enums import TimeGranularity
 
-NodeVersion = Union[str, float]
+NodeVersion = Union[int, float, str]
 
 
 @dataclass

core/dbt/artifacts/resources/v1/snapshot.py

@@ -71,12 +71,6 @@ def final_validate(self):
         if self.materialized and self.materialized != "snapshot":
             raise ValidationError("A snapshot must have a materialized value of 'snapshot'")
 
-    # Called by "calculate_node_config_dict" in ContextConfigGenerator
-    def finalize_and_validate(self):
-        data = self.to_dict(omit_none=True)
-        self.validate(data)
-        return self.from_dict(data)
-
 
 @dataclass
 class Snapshot(CompiledResource):

core/dbt/artifacts/resources/v1/source_definition.py

@@ -40,7 +40,7 @@ class ExternalTable(AdditionalPropertiesAllowed, Mergeable):
     file_format: Optional[str] = None
     row_format: Optional[str] = None
     tbl_properties: Optional[str] = None
-    partitions: Optional[Union[List[str], List[ExternalPartition]]] = None
+    partitions: Optional[Union[List[ExternalPartition], List[str]]] = None
 
     def __bool__(self):
         return self.location is not None

core/dbt/context/providers.py

@@ -40,7 +40,7 @@
 from dbt.constants import DEFAULT_ENV_PLACEHOLDER
 from dbt.context.base import Var, contextmember, contextproperty
 from dbt.context.configured import FQNLookup
-from dbt.context.context_config import ContextConfig
+from dbt.context.context_config import ConfigBuilder
 from dbt.context.exceptions_jinja import wrapped_exports
 from dbt.context.macro_resolver import MacroResolver, TestMacroNamespace
 from dbt.context.macros import MacroNamespace, MacroNamespaceBuilder
@@ -367,14 +367,14 @@
 
 
 class Config(Protocol):
-    def __init__(self, model, context_config: Optional[ContextConfig]): ...
+    def __init__(self, model, config_builder: Optional[ConfigBuilder]): ...
 
 
 # Implementation of "config(..)" calls in models
 class ParseConfigObject(Config):
-    def __init__(self, model, context_config: Optional[ContextConfig]):
+    def __init__(self, model, config_builder: Optional[ConfigBuilder]):
         self.model = model
-        self.context_config = context_config
+        self.config_builder = config_builder
 
     def _transform_config(self, config):
         for oldkey in ("pre_hook", "post_hook"):
@@ -395,19 +395,19 @@
 
         opts = self._transform_config(opts)
 
-        # it's ok to have a parse context with no context config, but you must
+        # it's ok to have a parse context with no config builder, but you must
         # not call it!
-        if self.context_config is None:
-            raise DbtRuntimeError("At parse time, did not receive a context config")
+        if self.config_builder is None:
+            raise DbtRuntimeError("At parse time, did not receive a config builder")
 
         # Track unrendered opts to build parsed node unrendered_config later on
         if get_flags().state_modified_compare_more_unrendered_values:
             unrendered_config = statically_parse_unrendered_config(self.model.raw_code)
             if unrendered_config:
-                self.context_config.add_unrendered_config_call(unrendered_config)
+                self.config_builder.add_unrendered_config_call(unrendered_config)
 
-        # Use rendered opts to populate context_config
-        self.context_config.add_config_call(opts)
+        # Use rendered opts to populate config builder
+        self.config_builder.add_config_call(opts)
         return ""
 
     def set(self, name, value):
@@ -427,7 +427,7 @@
 
 
 class RuntimeConfigObject(Config):
-    def __init__(self, model, context_config: Optional[ContextConfig] = None):
+    def __init__(self, model, config_builder: Optional[ConfigBuilder] = None):
         self.model = model
         # we never use or get a config, only the parser cares
 
@@ -887,7 +887,7 @@
         config: RuntimeConfig,
         manifest: Manifest,
         provider: Provider,
-        context_config: Optional[ContextConfig],
+        config_builder: Optional[ConfigBuilder],
     ) -> None:
         if provider is None:
             raise DbtInternalError(f"Invalid provider given to context: {provider}")
@@ -896,7 +896,7 @@
         self.model: Union[Macro, ManifestNode] = model
         super().__init__(config, manifest, model.package_name)
         self.sql_results: Dict[str, Optional[AttrDict]] = {}
-        self.context_config: Optional[ContextConfig] = context_config
+        self.config_builder: Optional[ConfigBuilder] = config_builder
         self.provider: Provider = provider
         self.adapter = get_adapter(self.config)
         # The macro namespace is used in creating the DatabaseWrapper
@@ -1165,7 +1165,7 @@
               {%- set unique_key = config.require('unique_key') -%}
               ...
         """  # noqa
-        return self.provider.Config(self.model, self.context_config)
+        return self.provider.Config(self.model, self.config_builder)
 
     @contextproperty()
     def execute(self) -> bool:
@@ -1689,12 +1689,12 @@
     model: ManifestNode,
     config: RuntimeConfig,
     manifest: Manifest,
-    context_config: ContextConfig,
+    config_builder: ConfigBuilder,
 ) -> Dict[str, Any]:
     # The __init__ method of ModelContext also initializes
     # a ManifestContext object which creates a MacroNamespaceBuilder
     # which adds every macro in the Manifest.
-    ctx = ModelContext(model, config, manifest, ParseProvider(), context_config)
+    ctx = ModelContext(model, config, manifest, ParseProvider(), config_builder)
     # The 'to_dict' method in ManifestContext moves all of the macro names
     # in the macro 'namespace' up to top level keys
     return ctx.to_dict()
@@ -1896,14 +1896,14 @@
         config: RuntimeConfig,
         manifest: Manifest,
         provider: Provider,
-        context_config: Optional[ContextConfig],
+        config_builder: Optional[ConfigBuilder],
         macro_resolver: MacroResolver,
     ) -> None:
         # this must be before super init so that macro_resolver exists for
         # build_namespace
         self.macro_resolver = macro_resolver
         self.thread_ctx = MacroStack()
-        super().__init__(model, config, manifest, provider, context_config)
+        super().__init__(model, config, manifest, provider, config_builder)
         self._build_test_namespace()
         # We need to rebuild this because it's already been built by
         # the ProviderContext with the wrong namespace.
@@ -1975,10 +1975,10 @@
     model: ManifestNode,
     config: RuntimeConfig,
     manifest: Manifest,
-    context_config: ContextConfig,
+    config_builder: ConfigBuilder,
     macro_resolver: MacroResolver,
 ) -> Dict[str, Any]:
-    ctx = TestContext(model, config, manifest, ParseProvider(), context_config, macro_resolver)
+    ctx = TestContext(model, config, manifest, ParseProvider(), config_builder, macro_resolver)
     # The 'to_dict' method in ManifestContext moves all of the macro names
     # in the macro 'namespace' up to top level keys
     return ctx.to_dict()

core/dbt/contracts/graph/model_config.py

@@ -53,14 +53,5 @@ class UnitTestNodeConfig(NodeConfig):
 }
 
 
-# base resource types are like resource types, except nothing has mandatory
-# configs.
-BASE_RESOURCE_TYPES: Dict[NodeType, Type[BaseConfig]] = RESOURCE_TYPES.copy()
-
-
 def get_config_for(resource_type: NodeType, base=False) -> Type[BaseConfig]:
-    if base:
-        lookup = BASE_RESOURCE_TYPES
-    else:
-        lookup = RESOURCE_TYPES
-    return lookup.get(resource_type, NodeConfig)
+    return RESOURCE_TYPES.get(resource_type, NodeConfig)