Refactor from_resource to no longer use generics

In the next commit we're gonna add a `to_resource` method. As we don't
want to have to pass a resource into `to_resource`, the class itself
needs to expose what resource class should be built. Thus a type annotation
is no longer enough. To solve this we've added a class method to BaseNode
which returns the associated resource class. The method on BaseNode will
raise a NotImplementedError unless the the inheriting class has overridden
the `resouce_class` method to return the a resource class.

You may be thinking "Why not a class property"? And that is absolutely a
valid question. We used to be able to chain `@classmethod` with
`@property` to create a class property. However, this was deprecated in
python 3.11 and removed in 3.13 (details on why this happened can be found
[here](python/cpython#89519)). There is an
[alternate way to setup a class property](python/cpython#89519 (comment)),
however this seems a bit convoluted if a class method easily gets the job
done. The draw back is that we must do `.resource_class()` instead of
`.resource_class` and on classes implementing `BaseNode` we have to
override it with a method instead of a property specification.

Additionally, making it a class _instance_ property won't work because
we don't want to require an _instance_ of the class to get the
`resource_class` as we might not have an instance at our dispossal.

Author: QMalcolm

core/dbt/contracts/graph/nodes.py

@@ -4,7 +4,6 @@
 from dataclasses import dataclass, field
 import hashlib
 
-from abc import ABC
 from mashumaro.types import SerializableType
 from typing import (
     Optional,
@@ -14,10 +13,9 @@
     Any,
     Sequence,
     Tuple,
+    Type,
     Iterator,
     Literal,
-    Generic,
-    TypeVar,
 )
 
 from dbt import deprecations
@@ -116,13 +114,19 @@
 # ==================================================
 
 
-ResourceTypeT = TypeVar("ResourceTypeT", bound="BaseResource")
-
-
 @dataclass
-class BaseNode(ABC, Generic[ResourceTypeT], BaseResource):
+class BaseNode(BaseResource):
     """All nodes or node-like objects in this file should have this as a base class"""
 
+    # In an ideal world this would be a class property. However, chaining @classmethod and
+    # @property was deprecated in python 3.11 and removed in 3.13. There are more
+    # complicated ways of making a class property, however a class method suits our
+    # purposes well enough
+    @classmethod
+    def resource_class(cls) -> Type[BaseResource]:
+        """Should be overriden by any class inheriting BaseNode"""
+        raise NotImplementedError
+
     @property
     def search_name(self):
         return self.name
@@ -160,12 +164,13 @@ def get_materialization(self):
         return self.config.materialized
 
     @classmethod
-    def from_resource(cls, resource_instance: ResourceTypeT):
+    def from_resource(cls, resource_instance: BaseResource):
+        assert isinstance(resource_instance, cls.resource_class())
         return cls.from_dict(resource_instance.to_dict())
 
 
 @dataclass
-class GraphNode(GraphResource, BaseNode[ResourceTypeT], Generic[ResourceTypeT]):
+class GraphNode(GraphResource, BaseNode):
     """Nodes in the DAG. Macro and Documentation don't have fqn."""
 
     def same_fqn(self, other) -> bool:
@@ -190,7 +195,7 @@ def identifier(self):
 
 
 @dataclass
-class ParsedNodeMandatory(GraphNode[GraphResource], HasRelationMetadata, Replaceable):
+class ParsedNodeMandatory(GraphNode, HasRelationMetadata, Replaceable):
     alias: str
     checksum: FileHash
     config: NodeConfig = field(default_factory=NodeConfig)
@@ -985,7 +990,7 @@ class UnitTestDefinitionMandatory:
 
 
 @dataclass
-class UnitTestDefinition(NodeInfoMixin, GraphNode[GraphResource], UnitTestDefinitionMandatory):
+class UnitTestDefinition(NodeInfoMixin, GraphNode, UnitTestDefinitionMandatory):
     description: str = ""
     overrides: Optional[UnitTestOverrides] = None
     depends_on: DependsOn = field(default_factory=DependsOn)
@@ -1211,13 +1216,17 @@ def tests(self) -> List[TestDef]:
 @dataclass
 class SourceDefinition(
     NodeInfoMixin,
-    GraphNode[SourceDefinitionResource],
+    GraphNode,
     SourceDefinitionResource,
     HasRelationMetadata,
 ):
     # Overriding the `freshness` property to use the `FreshnessThreshold` instead of the `FreshnessThresholdResource`
     freshness: Optional[FreshnessThreshold] = None
 
+    @classmethod
+    def resource_class(cls) -> Type[SourceDefinitionResource]:
+        return SourceDefinitionResource
+
     def __post_serialize__(self, dct):
         if "_event_status" in dct:
             del dct["_event_status"]
@@ -1326,7 +1335,7 @@ def group(self):
 
 
 @dataclass
-class Exposure(GraphNode[ExposureResource], ExposureResource):
+class Exposure(GraphNode, ExposureResource):
     @property
     def depends_on_nodes(self):
         return self.depends_on.nodes
@@ -1335,6 +1344,10 @@ def depends_on_nodes(self):
     def search_name(self):
         return self.name
 
+    @classmethod
+    def resource_class(cls) -> Type[ExposureResource]:
+        return ExposureResource
+
     def same_depends_on(self, old: "Exposure") -> bool:
         return set(self.depends_on.nodes) == set(old.depends_on.nodes)
 
@@ -1392,7 +1405,7 @@ def group(self):
 
 
 @dataclass
-class Metric(GraphNode[MetricResource], MetricResource):
+class Metric(GraphNode, MetricResource):
     @property
     def depends_on_nodes(self):
         return self.depends_on.nodes
@@ -1401,6 +1414,10 @@ def depends_on_nodes(self):
     def search_name(self):
         return self.name
 
+    @classmethod
+    def resource_class(cls) -> Type[MetricResource]:
+        return MetricResource
+
     def same_description(self, old: "Metric") -> bool:
         return self.description == old.description
 
@@ -1459,7 +1476,7 @@ class Group(GroupResource, BaseNode):
 
 
 @dataclass
-class SemanticModel(GraphNode[SemanticModelResource], SemanticModelResource):
+class SemanticModel(GraphNode, SemanticModelResource):
     @property
     def depends_on_nodes(self):
         return self.depends_on.nodes
@@ -1468,6 +1485,10 @@ def depends_on_nodes(self):
     def depends_on_macros(self):
         return self.depends_on.macros
 
+    @classmethod
+    def resource_class(cls) -> Type[SemanticModelResource]:
+        return SemanticModelResource
+
     def same_model(self, old: "SemanticModel") -> bool:
         return self.model == old.same_model
 
@@ -1525,7 +1546,11 @@ def same_contents(self, old: Optional["SemanticModel"]) -> bool:
 
 
 @dataclass
-class SavedQuery(NodeInfoMixin, GraphNode[SavedQueryResource], SavedQueryResource):
+class SavedQuery(NodeInfoMixin, GraphNode, SavedQueryResource):
+    @classmethod
+    def resource_class(cls) -> Type[SavedQueryResource]:
+        return SavedQueryResource
+
     def same_metrics(self, old: "SavedQuery") -> bool:
         return self.query_params.metrics == old.query_params.metrics