Decouple LoadMode.AUTOMATIC from load() method in DbtGraph

[dwreeves]

This PR is an offshoot of #895. I'm introducing it here as it is something that can be implemented reasonably well in Cosmos 1.x.

Overview

TLDR-- DbtGraph.load() actually is two things:

• It loads the dbt graph by dispatching the load implementation
• It implements the LoadMode.AUTOMATIC implementation

My proposal is that it should actually only do one of these things, i.e. loads the dbt graph. This means that automatic should be its own separate implementation.

See the proposed code for DbtGraph inside #895 for a full implementation of the 2.x proposal. Note that some of the suggestions for DbtGraph in #895 are proposed deprecations that are out of scope for this issue, but we'd certainly want to move in this direction. Here it is a little slimmed down:

class DbtGraph:

    load_method_mapping: dict[LoadMode, Callable[[], None]] = {}

    def __init__(
        ...
    ):
        default_load_method_mapping = {
            LoadMode.AUTOMATIC: self.load_with_automatic_method,
            LoadMode.CUSTOM: self.load_via_custom_parser,
            LoadMode.DBT_LS: self.load_via_dbt_ls,
            LoadMode.DBT_LS_FILE: self.load_via_dbt_ls_file,
            LoadMode.DBT_MANIFEST: self.load_from_dbt_manifest,
        }
        # It looks like this in case load methods are set at the class level,
        # i.e. `default_load_method_mapping` sets defaults, but does not override
        # anything a user might set at the class level.
        default_load_method_mapping.update(self.load_method_mapping)
        self.load_method_mapping = default_load_method_mapping

        self.is_loaded: bool = False

        self.nodes: dict[str, DbtNode] = {}
        self.filtered_nodes: dict[str, DbtNode] = {

    def load(
            self,
            method: LoadMode | None = None,
            reload: bool = False
    ) -> dict[str, DbtNode]:
        if not reload and self.is_loaded:
            return self.filtered_nodes
        # Load only dispatches;
        # does not implicitly have the automatic load mode inside.
        if method is None:
            method = self.render_config.load_method
        callback = self.load_method_mapping[method]
        # Before the load() method only mutated DbtGraph's state.
        # It's possible that DbtGraph should not rely on mutated state.
        return callback()

    def load_with_automatic_method(self) -> None: ...
    def load_via_custom_parser(self) -> None: ...
    def load_via_dbt_ls(self) -> None: ...
    def load_via_dbt_ls_file(self) -> None: ...
    def load_from_dbt_manifest(self) -> None: ...