recce-nightly 1.3.0.20250507__py3-none-any.whl → 1.4.0.20250514__py3-none-any.whl

recce/adapter/dbt_adapter/__init__.py

@@ -8,14 +8,27 @@ from dataclasses import dataclass, fields
 from errno import ENOENT
 from functools import lru_cache
 from pathlib import Path
-from typing import Callable, Dict, List, Optional, Tuple, Iterator, Any, Set, Union, Literal, Type
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 
 from recce.event import log_performance
 from recce.exceptions import RecceException
-from recce.util.cll import cll, CLLPerformanceTracking
-from recce.util.lineage import find_upstream, find_downstream
+from recce.util.cll import CLLPerformanceTracking, cll
+from recce.util.lineage import find_downstream, find_upstream
+
 from ...tasks.profile import ProfileTask
-from ...util.breaking import parse_change_category, BreakingPerformanceTracking
+from ...util.breaking import BreakingPerformanceTracking, parse_change_category
 
 try:
     import agate
@@ -30,11 +43,23 @@ from watchdog.observers import Observer
 
 from recce.adapter.base import BaseAdapter
 from recce.state import ArtifactsRoot
-from .dbt_version import DbtVersion
+
 from ...models import RunType
-from ...models.types import LineageDiff, NodeDiff, NodeChange
-from ...tasks import Task, QueryTask, QueryBaseTask, QueryDiffTask, ValueDiffTask, ValueDiffDetailTask, ProfileDiffTask, \
-    RowCountTask, RowCountDiffTask, TopKDiffTask, HistogramDiffTask
+from ...models.types import LineageDiff, NodeChange, NodeDiff
+from ...tasks import (
+    HistogramDiffTask,
+    ProfileDiffTask,
+    QueryBaseTask,
+    QueryDiffTask,
+    QueryTask,
+    RowCountDiffTask,
+    RowCountTask,
+    Task,
+    TopKDiffTask,
+    ValueDiffDetailTask,
+    ValueDiffTask,
+)
+from .dbt_version import DbtVersion
 
 dbt_supported_registry: Dict[RunType, Type[Task]] = {
     RunType.QUERY: QueryTask,
@@ -56,7 +81,7 @@ get_adapter_orig = dbt.adapters.factory.get_adapter
 
 
 def get_adapter(config):
-    if hasattr(config, 'adapter'):
+    if hasattr(config, "adapter"):
         return config.adapter
     else:
         return get_adapter_orig(config)
@@ -69,7 +94,11 @@ from dbt.adapters.base import Column  # noqa: E402
 from dbt.adapters.factory import get_adapter_class_by_name  # noqa: E402
 from dbt.adapters.sql import SQLAdapter  # noqa: E402
 from dbt.config.runtime import RuntimeConfig  # noqa: E402
-from dbt.contracts.graph.manifest import Manifest, WritableManifest, MacroManifest  # noqa: E402
+from dbt.contracts.graph.manifest import (  # noqa: E402
+    MacroManifest,
+    Manifest,
+    WritableManifest,
+)
 from dbt.contracts.graph.nodes import ManifestNode  # noqa: E402
 from dbt.contracts.results import CatalogArtifact  # noqa: E402
 from dbt.flags import set_from_args  # noqa: E402
@@ -78,7 +107,7 @@ from dbt.parser.sql import SqlBlockParser  # noqa: E402
 
 dbt_version = DbtVersion()
 
-if dbt_version < 'v1.8':
+if dbt_version < "v1.8":
     from dbt.contracts.connection import Connection
 else:
     from dbt.adapters.contracts.connection import Connection
@@ -86,19 +115,21 @@ else:
 
 @contextmanager
 def silence_no_nodes_warning():
-    if dbt_version >= 'v1.8':
+    if dbt_version >= "v1.8":
         from dbt.events.types import NoNodesForSelectionCriteria
         from dbt_common.events.functions import WARN_ERROR_OPTIONS
+
         WARN_ERROR_OPTIONS.silence.append(NoNodesForSelectionCriteria.__name__)
     try:
         yield
     finally:
-        if dbt_version >= 'v1.8':
+        if dbt_version >= "v1.8":
             from dbt_common.events.functions import WARN_ERROR_OPTIONS
+
             WARN_ERROR_OPTIONS.silence.pop()
 
 
-logger = logging.getLogger('uvicorn')
+logger = logging.getLogger("uvicorn")
 
 
 class ArtifactsEventHandler(FileSystemEventHandler):
@@ -147,16 +178,18 @@ class EnvironmentEventHandler(FileSystemEventHandler):
 
 
 def merge_tables(tables: List[agate.Table]) -> agate.Table:
-    if dbt_version < 'v1.8':
+    if dbt_version < "v1.8":
         from dbt.clients.agate_helper import merge_tables
+
         return merge_tables(tables)
     else:
         from dbt_common.clients.agate_helper import merge_tables
+
         return merge_tables(tables)
 
 
 def as_manifest(m: WritableManifest) -> Manifest:
-    if dbt_version < 'v1.8':
+    if dbt_version < "v1.8":
         data = m.__dict__
         all_fields = set([x.name for x in fields(Manifest)])
         new_data = {k: v for k, v in data.items() if k in all_fields}
@@ -184,12 +217,13 @@ def load_catalog(path: str = None, data: dict = None):
 
 
 def previous_state(state_path: Path, target_path: Path, project_root: Path) -> PreviousState:
-    if dbt_version < 'v1.5.2':
+    if dbt_version < "v1.5.2":
         return PreviousState(state_path, target_path)
     else:
         try:
             # Overwrite the level_tag method temporarily to avoid the warning message
-            from dbt.events.types import WarnStateTargetEqual, EventLevel
+            from dbt.events.types import EventLevel, WarnStateTargetEqual
+
             original_level_tag_func = WarnStateTargetEqual.level_tag
             WarnStateTargetEqual.level_tag = lambda x: EventLevel.DEBUG
         except ImportError:
@@ -209,12 +243,12 @@ def previous_state(state_path: Path, target_path: Path, project_root: Path) -> P
 def default_profiles_dir():
     # Precedence: DBT_PROFILES_DIR > current working directory > ~/.dbt/
     # https://docs.getdbt.com/docs/core/connect-data-platform/connection-profiles#advanced-customizing-a-profile-directory
-    if os.getenv('DBT_PROFILES_DIR'):
-        return os.getenv('DBT_PROFILES_DIR')
-    elif os.path.exists(os.path.join(os.getcwd(), 'profiles.yml')):
+    if os.getenv("DBT_PROFILES_DIR"):
+        return os.getenv("DBT_PROFILES_DIR")
+    elif os.path.exists(os.path.join(os.getcwd(), "profiles.yml")):
         return os.getcwd()
     else:
-        return os.path.expanduser('~/.dbt/')
+        return os.path.expanduser("~/.dbt/")
 
 
 @dataclass()
@@ -222,12 +256,13 @@ class DbtArgs:
     """
     Used for RuntimeConfig.from_args
     """
-    threads: Optional[int] = 1,
-    target: Optional[str] = None,
-    profiles_dir: Optional[str] = None,
-    project_dir: Optional[str] = None,
-    profile: Optional[str] = None,
-    target_path: Optional[str] = None,
+
+    threads: Optional[int] = (1,)
+    target: Optional[str] = (None,)
+    profiles_dir: Optional[str] = (None,)
+    project_dir: Optional[str] = (None,)
+    profile: Optional[str] = (None,)
+    target_path: Optional[str] = (None,)
     project_only_flags: Optional[Dict[str, Any]] = None
     which: Optional[str] = None
     state_modified_compare_more_unrendered_values: Optional[bool] = False  # new flag added since dbt v1.9
@@ -258,32 +293,18 @@ class DbtAdapter(BaseAdapter):
 
     def support_tasks(self):
         support_map = {run_type.value: True for run_type in dbt_supported_registry}
-        supported_dbt_packages = set([package.package_name for package in self.manifest.macros.values()])
-
-        if 'dbt_profiler' not in supported_dbt_packages:
-            support_map[RunType.PROFILE_DIFF.value] = False
-            support_map[RunType.PROFILE.value] = False
-
-        if 'audit_helper' not in supported_dbt_packages:
-            support_map[RunType.VALUE_DIFF.value] = False
-            support_map[RunType.VALUE_DIFF_DETAIL.value] = False
-            support_map['query_diff_with_primary_key'] = False
 
         return support_map
 
     @classmethod
-    def load(cls,
-             no_artifacts=False,
-             review=False,
-             **kwargs):
+    def load(cls, no_artifacts=False, review=False, **kwargs):
+        target = kwargs.get("target")
+        target_path = kwargs.get("target_path", "target")
+        target_base_path = kwargs.get("target_base_path", "target-base")
 
-        target = kwargs.get('target')
-        target_path = kwargs.get('target_path', 'target')
-        target_base_path = kwargs.get('target_base_path', 'target-base')
-
-        profile_name = kwargs.get('profile')
-        project_dir = kwargs.get('project_dir')
-        profiles_dir = kwargs.get('profiles_dir')
+        profile_name = kwargs.get("profile")
+        project_dir = kwargs.get("project_dir")
+        profiles_dir = kwargs.get("profiles_dir")
 
         if profiles_dir is None:
             profiles_dir = default_profiles_dir()
@@ -297,21 +318,25 @@ class DbtAdapter(BaseAdapter):
             profiles_dir=profiles_dir,
             profile=profile_name,
             project_only_flags={},
-            which='list'
+            which="list",
         )
         set_from_args(args, args)
 
         from dbt.exceptions import DbtProjectError
+
         try:
             # adapter
-            if dbt_version < 'v1.8':
+            if dbt_version < "v1.8":
                 runtime_config = RuntimeConfig.from_args(args)
                 adapter_name = runtime_config.credentials.type
                 adapter_cls = get_adapter_class_by_name(adapter_name)
                 adapter: SQLAdapter = adapter_cls(runtime_config)
             else:
-                from dbt_common.context import set_invocation_context, get_invocation_context
                 from dbt.mp_context import get_mp_context
+                from dbt_common.context import (
+                    get_invocation_context,
+                    set_invocation_context,
+                )
 
                 set_invocation_context({})
                 get_invocation_context()._env = dict(os.environ)
@@ -320,6 +345,7 @@ class DbtAdapter(BaseAdapter):
                 adapter_cls = get_adapter_class_by_name(adapter_name)
                 adapter: SQLAdapter = adapter_cls(runtime_config, get_mp_context())
                 from dbt.adapters.factory import FACTORY
+
                 FACTORY.adapters[adapter_name] = adapter
 
             adapter.connections.set_connection_name()
@@ -329,7 +355,7 @@ class DbtAdapter(BaseAdapter):
                 runtime_config=runtime_config,
                 adapter=adapter,
                 review_mode=review,
-                base_path=target_base_path
+                base_path=target_base_path,
             )
         except DbtProjectError as e:
             raise e
@@ -350,27 +376,26 @@ class DbtAdapter(BaseAdapter):
 
     def get_columns(self, model: str, base=False) -> List[Column]:
         relation = self.create_relation(model, base)
-        get_columns_macro = 'get_columns_in_relation'
-        if self.adapter.connections.TYPE == 'databricks':
-            get_columns_macro = 'get_columns_comments'
+        get_columns_macro = "get_columns_in_relation"
+        if self.adapter.connections.TYPE == "databricks":
+            get_columns_macro = "get_columns_comments"
 
-        if dbt_version < 'v1.8':
+        if dbt_version < "v1.8":
             columns = self.adapter.execute_macro(
-                get_columns_macro,
-                kwargs={"relation": relation},
-                manifest=self.manifest)
+                get_columns_macro, kwargs={"relation": relation}, manifest=self.manifest
+            )
         else:
             from dbt.context.providers import generate_runtime_macro_context
+
             macro_manifest = MacroManifest(self.manifest.macros)
             self.adapter.set_macro_resolver(macro_manifest)
             self.adapter.set_macro_context_generator(generate_runtime_macro_context)
-            columns = self.adapter.execute_macro(
-                get_columns_macro,
-                kwargs={"relation": relation})
+            columns = self.adapter.execute_macro(get_columns_macro, kwargs={"relation": relation})
 
-        if self.adapter.connections.TYPE == 'databricks':
+        if self.adapter.connections.TYPE == "databricks":
             # reference: get_columns_in_relation (dbt/adapters/databricks/impl.py)
             from dbt.adapters.databricks import DatabricksColumn
+
             rows = columns
             columns = []
             for row in rows:
@@ -378,7 +403,9 @@ class DbtAdapter(BaseAdapter):
                     break
                 columns.append(
                     DatabricksColumn(
-                        column=row["col_name"], dtype=row["data_type"], comment=row["comment"]
+                        column=row["col_name"],
+                        dtype=row["data_type"],
+                        comment=row["comment"],
                     )
                 )
             return columns
@@ -389,29 +416,29 @@ class DbtAdapter(BaseAdapter):
         manifest = self.curr_manifest if base is False else self.base_manifest
         manifest_dict = manifest.to_dict()
 
-        node = manifest_dict['nodes'].get(model_id)
+        node = manifest_dict["nodes"].get(model_id)
         if node is None:
             return {}
 
-        node_name = node['name']
-        with self.adapter.connection_named('model'):
+        node_name = node["name"]
+        with self.adapter.connection_named("model"):
             columns = [column for column in self.get_columns(node_name, base=base)]
 
-        child_map: List[str] = manifest_dict['child_map'][model_id]
+        child_map: List[str] = manifest_dict["child_map"][model_id]
         cols_not_null = []
         cols_unique = []
 
         for child in child_map:
-            comps = child.split('.')
+            comps = child.split(".")
             child_type = comps[0]
             child_name = comps[2]
 
-            not_null_prefix = f'not_null_{node_name}_'
-            if child_type == 'test' and child_name.startswith(not_null_prefix):
-                cols_not_null.append(child_name[len(not_null_prefix):])
-            unique_prefix = f'unique_{node_name}_'
-            if child_type == 'test' and child_name.startswith(unique_prefix):
-                cols_unique.append(child_name[len(unique_prefix):])
+            not_null_prefix = f"not_null_{node_name}_"
+            if child_type == "test" and child_name.startswith(not_null_prefix):
+                cols_not_null.append(child_name[len(not_null_prefix) :])
+            unique_prefix = f"unique_{node_name}_"
+            if child_type == "test" and child_name.startswith(unique_prefix):
+                cols_unique.append(child_name[len(unique_prefix) :])
 
         columns_info = {}
         primary_key = None
@@ -419,16 +446,16 @@ class DbtAdapter(BaseAdapter):
             col_name = c.column
             col = dict(name=col_name, type=c.dtype)
             if col_name in cols_not_null:
-                col['not_null'] = True
+                col["not_null"] = True
             if col_name in cols_unique:
-                col['unique'] = True
+                col["unique"] = True
                 if not primary_key:
                     primary_key = col_name
             columns_info[col_name] = col
 
         result = dict(columns=columns_info)
         if primary_key:
-            result['primary_key'] = primary_key
+            result["primary_key"] = primary_key
 
         return result
 
@@ -437,7 +464,7 @@ class DbtAdapter(BaseAdapter):
         Load the artifacts from the 'target' and 'target-base' directory
         """
         if self.runtime_config is None:
-            raise Exception('Cannot find the dbt project configuration')
+            raise Exception("Cannot find the dbt project configuration")
 
         project_root = self.runtime_config.project_root
         target_path = self.runtime_config.target_path
@@ -446,17 +473,17 @@ class DbtAdapter(BaseAdapter):
         self.base_path = os.path.join(project_root, target_base_path)
 
         # load the artifacts
-        path = os.path.join(project_root, target_path, 'manifest.json')
+        path = os.path.join(project_root, target_path, "manifest.json")
         curr_manifest = load_manifest(path=path)
         if curr_manifest is None:
             raise FileNotFoundError(ENOENT, os.strerror(ENOENT), path)
-        path = os.path.join(project_root, target_base_path, 'manifest.json')
+        path = os.path.join(project_root, target_base_path, "manifest.json")
         base_manifest = load_manifest(path=path)
         if base_manifest is None:
             raise FileNotFoundError(ENOENT, os.strerror(ENOENT), path)
 
-        curr_catalog = load_catalog(path=os.path.join(project_root, target_path, 'catalog.json'))
-        base_catalog = load_catalog(path=os.path.join(project_root, target_base_path, 'catalog.json'))
+        curr_catalog = load_catalog(path=os.path.join(project_root, target_path, "catalog.json"))
+        base_catalog = load_catalog(path=os.path.join(project_root, target_base_path, "catalog.json"))
 
         # set the value if all the artifacts are loaded successfully
         self.curr_manifest = curr_manifest
@@ -474,22 +501,21 @@ class DbtAdapter(BaseAdapter):
 
         # set the file paths to watch
         self.artifacts_files = [
-            os.path.join(project_root, target_path, 'manifest.json'),
-            os.path.join(project_root, target_path, 'catalog.json'),
-            os.path.join(project_root, target_base_path, 'manifest.json'),
-            os.path.join(project_root, target_base_path, 'catalog.json'),
+            os.path.join(project_root, target_path, "manifest.json"),
+            os.path.join(project_root, target_path, "catalog.json"),
+            os.path.join(project_root, target_base_path, "manifest.json"),
+            os.path.join(project_root, target_base_path, "catalog.json"),
         ]
 
     def is_python_model(self, node_id: str, base: Optional[bool] = False):
         manifest = self.curr_manifest if base is False else self.base_manifest
         model = manifest.nodes.get(node_id)
-        if hasattr(model, 'language'):
-            return model.language == 'python'
+        if hasattr(model, "language"):
+            return model.language == "python"
 
         return False
 
     def find_node_by_name(self, node_name, base=False) -> Optional[ManifestNode]:
-
         manifest = self.curr_manifest if base is False else self.base_manifest
 
         for key, node in manifest.nodes.items():
@@ -499,22 +525,22 @@ class DbtAdapter(BaseAdapter):
         return None
 
     def get_node_name_by_id(self, unique_id):
-        if unique_id.startswith('source.'):
+        if unique_id.startswith("source."):
             if unique_id in self.curr_manifest.sources:
                 return self.curr_manifest.sources[unique_id].name
             elif unique_id in self.base_manifest.sources:
                 return self.base_manifest.sources[unique_id].name
-        elif unique_id.startswith('metric.'):
+        elif unique_id.startswith("metric."):
             if unique_id in self.curr_manifest.metrics:
                 return self.curr_manifest.metrics[unique_id].name
             elif unique_id in self.base_manifest.metrics:
                 return self.base_manifest.metrics[unique_id].name
-        elif unique_id.startswith('exposure.'):
+        elif unique_id.startswith("exposure."):
             if unique_id in self.curr_manifest.exposures:
                 return self.curr_manifest.exposures[unique_id].name
             elif unique_id in self.base_manifest.exposures:
                 return self.base_manifest.exposures[unique_id].name
-        elif unique_id.startswith('semantic_model.'):
+        elif unique_id.startswith("semantic_model."):
             if unique_id in self.curr_manifest.semantic_models:
                 return self.curr_manifest.semantic_models[unique_id].name
             elif unique_id in self.base_manifest.semantic_models:
@@ -529,14 +555,24 @@ class DbtAdapter(BaseAdapter):
     def get_manifest(self, base: bool):
         return self.curr_manifest if base is False else self.base_manifest
 
-    def generate_sql(self, sql_template: str, base: bool = False, context=None, provided_manifest=None):
+    def generate_sql(
+        self,
+        sql_template: str,
+        base: bool = False,
+        context=None,
+        provided_manifest=None,
+    ):
         if context is None:
             context = {}
         manifest = provided_manifest if provided_manifest is not None else as_manifest(self.get_manifest(base))
         parser = SqlBlockParser(self.runtime_config, manifest, self.runtime_config)
 
-        if dbt_version >= dbt_version.parse('v1.8'):
-            from dbt_common.context import set_invocation_context, get_invocation_context
+        if dbt_version >= dbt_version.parse("v1.8"):
+            from dbt_common.context import (
+                get_invocation_context,
+                set_invocation_context,
+            )
+
             set_invocation_context({})
             get_invocation_context()._env = dict(os.environ)
 
@@ -544,21 +580,27 @@ class DbtAdapter(BaseAdapter):
         node = parser.parse_remote(sql_template, node_id)
         process_node(self.runtime_config, manifest, node)
 
-        if dbt_version < dbt_version.parse('v1.8'):
+        if dbt_version < dbt_version.parse("v1.8"):
             compiler = self.adapter.get_compiler()
             compiler.compile_node(node, manifest, context)
             return node.compiled_code
         else:
-            from dbt.context.providers import generate_runtime_model_context
             from dbt.clients import jinja
+            from dbt.context.providers import generate_runtime_model_context
+
             jinja_ctx = generate_runtime_model_context(node, self.runtime_config, manifest)
             jinja_ctx.update(context)
             compiled_code = jinja.get_rendered(sql_template, jinja_ctx, node)
             return compiled_code
 
-    def execute(self, sql: str, auto_begin: bool = False, fetch: bool = False, limit: Optional[int] = None) -> Tuple[
-        any, agate.Table]:
-        if dbt_version < dbt_version.parse('v1.6'):
+    def execute(
+        self,
+        sql: str,
+        auto_begin: bool = False,
+        fetch: bool = False,
+        limit: Optional[int] = None,
+    ) -> Tuple[any, agate.Table]:
+        if dbt_version < dbt_version.parse("v1.6"):
             return self.adapter.execute(sql, auto_begin=auto_begin, fetch=fetch)
 
         return self.adapter.execute(sql, auto_begin=auto_begin, fetch=fetch, limit=limit)
@@ -569,7 +611,7 @@ class DbtAdapter(BaseAdapter):
 
         node_ids = nodes.keys()
         parent_map = {}
-        for k, parents in manifest_dict['parent_map'].items():
+        for k, parents in manifest_dict["parent_map"].items():
             if k not in node_ids:
                 continue
             parent_map[k] = [parent for parent in parents if parent in node_ids]
@@ -580,8 +622,8 @@ class DbtAdapter(BaseAdapter):
         manifest = self.curr_manifest if base is False else self.base_manifest
         manifest_dict = manifest.to_dict()
 
-        if node_id in manifest_dict['parent_map']:
-            return manifest_dict['parent_map'][node_id]
+        if node_id in manifest_dict["parent_map"]:
+            return manifest_dict["parent_map"][node_id]
 
     def get_lineage(self, base: Optional[bool] = False):
         manifest = self.curr_manifest if base is False else self.base_manifest
@@ -590,12 +632,14 @@ class DbtAdapter(BaseAdapter):
         return self.get_lineage_cached(base, cache_key)
 
     def get_lineage_diff(self) -> LineageDiff:
-        cache_key = hash((
-            id(self.base_manifest),
-            id(self.base_catalog),
-            id(self.curr_manifest),
-            id(self.curr_catalog),
-        ))
+        cache_key = hash(
+            (
+                id(self.base_manifest),
+                id(self.base_catalog),
+                id(self.curr_manifest),
+                id(self.curr_catalog),
+            )
+        )
         return self._get_lineage_diff_cached(cache_key)
 
     @lru_cache(maxsize=2)
@@ -614,35 +658,35 @@ class DbtAdapter(BaseAdapter):
 
         nodes = {}
 
-        for node in manifest_dict['nodes'].values():
-            unique_id = node['unique_id']
-            resource_type = node['resource_type']
+        for node in manifest_dict["nodes"].values():
+            unique_id = node["unique_id"]
+            resource_type = node["resource_type"]
 
-            if resource_type not in ['model', 'seed', 'exposure', 'snapshot']:
+            if resource_type not in ["model", "seed", "exposure", "snapshot"]:
                 continue
 
             nodes[unique_id] = {
-                'id': node['unique_id'],
-                'name': node['name'],
-                'resource_type': node['resource_type'],
-                'package_name': node['package_name'],
-                'schema': node['schema'],
-                'config': node['config'],
-                'checksum': node['checksum'],
-                'raw_code': node['raw_code'],
+                "id": node["unique_id"],
+                "name": node["name"],
+                "resource_type": node["resource_type"],
+                "package_name": node["package_name"],
+                "schema": node["schema"],
+                "config": node["config"],
+                "checksum": node["checksum"],
+                "raw_code": node["raw_code"],
             }
 
             # List of <type>.<package_name>.<node_name>.<hash>
             # model.jaffle_shop.customer_segments
             # test.jaffle_shop.not_null_customers_customer_id.5c9bf9911d
             # test.jaffle_shop.unique_customers_customer_id.c5af1ff4b1
-            child_map: List[str] = manifest_dict['child_map'][unique_id]
+            child_map: List[str] = manifest_dict["child_map"][unique_id]
             cols_not_null = []
             cols_unique = []
 
             for child in child_map:
-                node_name = node['name']
-                comps = child.split('.')
+                node_name = node["name"]
+                comps = child.split(".")
                 if len(comps) < 2:
                     # only happens in unittest
                     continue
@@ -650,12 +694,12 @@ class DbtAdapter(BaseAdapter):
                 child_type = comps[0]
                 child_name = comps[2]
 
-                not_null_prefix = f'not_null_{node_name}_'
-                if child_type == 'test' and child_name.startswith(not_null_prefix):
-                    cols_not_null.append(child_name[len(not_null_prefix):])
-                unique_prefix = f'unique_{node_name}_'
-                if child_type == 'test' and child_name.startswith(unique_prefix):
-                    cols_unique.append(child_name[len(unique_prefix):])
+                not_null_prefix = f"not_null_{node_name}_"
+                if child_type == "test" and child_name.startswith(not_null_prefix):
+                    cols_not_null.append(child_name[len(not_null_prefix) :])
+                unique_prefix = f"unique_{node_name}_"
+                if child_type == "test" and child_name.startswith(unique_prefix):
+                    cols_unique.append(child_name[len(unique_prefix) :])
 
             if catalog is not None and unique_id in catalog.nodes:
                 columns = {}
@@ -663,61 +707,58 @@ class DbtAdapter(BaseAdapter):
                 for col_name, col_metadata in catalog.nodes[unique_id].columns.items():
                     col = dict(name=col_name, type=col_metadata.type)
                     if col_name in cols_not_null:
-                        col['not_null'] = True
+                        col["not_null"] = True
                     if col_name in cols_unique:
-                        col['unique'] = True
+                        col["unique"] = True
                         if not primary_key:
                             primary_key = col_name
                     columns[col_name] = col
-                nodes[unique_id]['columns'] = columns
+                nodes[unique_id]["columns"] = columns
                 if primary_key:
-                    nodes[unique_id]['primary_key'] = primary_key
+                    nodes[unique_id]["primary_key"] = primary_key
 
-        for source in manifest_dict['sources'].values():
-            unique_id = source['unique_id']
+        for source in manifest_dict["sources"].values():
+            unique_id = source["unique_id"]
 
             nodes[unique_id] = {
-                'id': source['unique_id'],
-                'name': source['name'],
-                'resource_type': source['resource_type'],
-                'package_name': source['package_name'],
-                'config': source['config'],
+                "id": source["unique_id"],
+                "name": source["name"],
+                "resource_type": source["resource_type"],
+                "package_name": source["package_name"],
+                "config": source["config"],
             }
 
             if catalog is not None and unique_id in catalog.sources:
-                nodes[unique_id]['columns'] = {
-                    col_name: {
-                        'name': col_name,
-                        'type': col_metadata.type
-                    }
+                nodes[unique_id]["columns"] = {
+                    col_name: {"name": col_name, "type": col_metadata.type}
                     for col_name, col_metadata in catalog.sources[unique_id].columns.items()
                 }
 
-        for exposure in manifest_dict['exposures'].values():
-            nodes[exposure['unique_id']] = {
-                'id': exposure['unique_id'],
-                'name': exposure['name'],
-                'resource_type': exposure['resource_type'],
-                'package_name': exposure['package_name'],
-                'config': exposure['config'],
+        for exposure in manifest_dict["exposures"].values():
+            nodes[exposure["unique_id"]] = {
+                "id": exposure["unique_id"],
+                "name": exposure["name"],
+                "resource_type": exposure["resource_type"],
+                "package_name": exposure["package_name"],
+                "config": exposure["config"],
             }
-        for metric in manifest_dict['metrics'].values():
-            nodes[metric['unique_id']] = {
-                'id': metric['unique_id'],
-                'name': metric['name'],
-                'resource_type': metric['resource_type'],
-                'package_name': metric['package_name'],
-                'config': metric['config'],
+        for metric in manifest_dict["metrics"].values():
+            nodes[metric["unique_id"]] = {
+                "id": metric["unique_id"],
+                "name": metric["name"],
+                "resource_type": metric["resource_type"],
+                "package_name": metric["package_name"],
+                "config": metric["config"],
             }
 
-        if 'semantic_models' in manifest_dict:
-            for semantic_models in manifest_dict['semantic_models'].values():
-                nodes[semantic_models['unique_id']] = {
-                    'id': semantic_models['unique_id'],
-                    'name': semantic_models['name'],
-                    'resource_type': semantic_models['resource_type'],
-                    'package_name': semantic_models['package_name'],
-                    'config': semantic_models['config'],
+        if "semantic_models" in manifest_dict:
+            for semantic_models in manifest_dict["semantic_models"].values():
+                nodes[semantic_models["unique_id"]] = {
+                    "id": semantic_models["unique_id"],
+                    "name": semantic_models["name"],
+                    "resource_type": semantic_models["resource_type"],
+                    "package_name": semantic_models["package_name"],
+                    "config": semantic_models["config"],
                 }
 
         parent_map = self.build_parent_map(nodes, base)
@@ -725,7 +766,7 @@ class DbtAdapter(BaseAdapter):
         if base is False:
             cll_tracker.end_lineage()
             cll_tracker.set_total_nodes(len(nodes))
-            log_performance('model lineage', cll_tracker.to_dict())
+            log_performance("model lineage", cll_tracker.to_dict())
             cll_tracker.reset()
 
         return dict(
@@ -739,10 +780,7 @@ class DbtAdapter(BaseAdapter):
     def _get_lineage_diff_cached(self, cache_key) -> LineageDiff:
         base = self.get_lineage(base=True)
         current = self.get_lineage(base=False)
-        keys = {
-            *base.get('nodes', {}).keys(),
-            *current.get('nodes', {}).keys()
-        }
+        keys = {*base.get("nodes", {}).keys(), *current.get("nodes", {}).keys()}
 
         # Start to diff
         perf_tracking = BreakingPerformanceTracking()
@@ -750,7 +788,7 @@ class DbtAdapter(BaseAdapter):
 
         base_manifest = as_manifest(self.get_manifest(True))
         curr_manifest = as_manifest(self.get_manifest(False))
-        perf_tracking.record_checkpoint('manifest')
+        perf_tracking.record_checkpoint("manifest")
 
         def ref_func(*args):
             if len(args) == 1:
@@ -762,7 +800,7 @@ class DbtAdapter(BaseAdapter):
             return node
 
         def source_func(source_name, table_name):
-            source_name = source_name.replace('-', '_')
+            source_name = source_name.replace("-", "_")
             return f"__{source_name}__{table_name}"
 
         jinja_context = dict(
@@ -773,49 +811,47 @@ class DbtAdapter(BaseAdapter):
         # for each node, compare the base and current lineage
         diff = {}
         for key in keys:
-            base_node = base.get('nodes', {}).get(key)
-            curr_node = current.get('nodes', {}).get(key)
+            base_node = base.get("nodes", {}).get(key)
+            curr_node = current.get("nodes", {}).get(key)
             if base_node and curr_node:
-                base_checksum = base_node.get('checksum', {}).get('checksum')
-                curr_checksum = curr_node.get('checksum', {}).get('checksum')
+                base_checksum = base_node.get("checksum", {}).get("checksum")
+                curr_checksum = curr_node.get("checksum", {}).get("checksum")
                 change = None
                 if base_checksum is None or curr_checksum is None or base_checksum == curr_checksum:
                     continue
 
-                if curr_node.get('resource_type') == 'model':
+                if curr_node.get("resource_type") == "model":
                     try:
                         perf_tracking.increment_modified_nodes()
 
                         def _get_schema(lineage):
                             schema = {}
-                            nodes = lineage['nodes']
-                            parent_list = lineage['parent_map'].get(key, [])
+                            nodes = lineage["nodes"]
+                            parent_list = lineage["parent_map"].get(key, [])
                             for parent_id in parent_list:
                                 parent_node = nodes.get(parent_id)
                                 if parent_node is None:
                                     continue
-                                columns = parent_node.get('columns') or {}
-                                name = parent_node.get('name')
-                                if parent_node.get('resource_type') == 'source':
-                                    parts = parent_id.split('.')
+                                columns = parent_node.get("columns") or {}
+                                name = parent_node.get("name")
+                                if parent_node.get("resource_type") == "source":
+                                    parts = parent_id.split(".")
                                     source = parts[2]
                                     table = parts[3]
-                                    source = source.replace('-', '_')
+                                    source = source.replace("-", "_")
                                     name = f"__{source}__{table}"
-                                schema[name] = {
-                                    name: column.get('type') for name, column in columns.items()
-                                }
+                                schema[name] = {name: column.get("type") for name, column in columns.items()}
                             return schema
 
                         base_sql = self.generate_sql(
-                            base_node.get('raw_code'),
+                            base_node.get("raw_code"),
                             context=jinja_context,
-                            provided_manifest=base_manifest
+                            provided_manifest=base_manifest,
                         )
                         curr_sql = self.generate_sql(
-                            curr_node.get('raw_code'),
+                            curr_node.get("raw_code"),
                             context=jinja_context,
-                            provided_manifest=curr_manifest
+                            provided_manifest=curr_manifest,
                         )
                         base_schema = _get_schema(base)
                         curr_schema = _get_schema(current)
@@ -834,14 +870,13 @@ class DbtAdapter(BaseAdapter):
 
                         # Make sure that the case of the column names are the same
                         changed_columns = {
-                            column.lower(): change_status
-                            for column, change_status in (change.columns or {}).items()
+                            column.lower(): change_status for column, change_status in (change.columns or {}).items()
                         }
                         changed_columns_names = set(changed_columns)
                         changed_columns_final = {}
 
-                        base_columns = base_node.get('columns') or {}
-                        curr_columns = curr_node.get('columns') or {}
+                        base_columns = base_node.get("columns") or {}
+                        curr_columns = curr_node.get("columns") or {}
                         columns_names = set(base_columns) | set(curr_columns)
 
                         for column_name in columns_names:
@@ -850,16 +885,16 @@ class DbtAdapter(BaseAdapter):
 
                         change.columns = changed_columns_final
                     except Exception:
-                        change = NodeChange(category='unknown')
+                        change = NodeChange(category="unknown")
 
-                diff[key] = NodeDiff(change_status='modified', change=change)
+                diff[key] = NodeDiff(change_status="modified", change=change)
             elif base_node:
-                diff[key] = NodeDiff(change_status='removed')
+                diff[key] = NodeDiff(change_status="removed")
             elif curr_node:
-                diff[key] = NodeDiff(change_status='added')
+                diff[key] = NodeDiff(change_status="added")
 
         perf_tracking.end_lineage_diff()
-        log_performance('model lineage diff', perf_tracking.to_dict())
+        log_performance("model lineage diff", perf_tracking.to_dict())
 
         return LineageDiff(
             base=base,
@@ -874,8 +909,8 @@ class DbtAdapter(BaseAdapter):
         manifest = self.curr_manifest if base is False else self.base_manifest
         manifest_dict = manifest.to_dict()
 
-        parent_ids = find_upstream(node_id, manifest_dict.get('parent_map'))
-        child_ids = find_downstream(node_id, manifest_dict.get('child_map'))
+        parent_ids = find_upstream(node_id, manifest_dict.get("parent_map"))
+        child_ids = find_downstream(node_id, manifest_dict.get("child_map"))
         cll_node_ids = parent_ids.union(child_ids)
         cll_node_ids.add(node_id)
 
@@ -888,7 +923,7 @@ class DbtAdapter(BaseAdapter):
 
         cll_tracker.end_column_lineage()
         cll_tracker.set_total_nodes(len(nodes))
-        log_performance('column level lineage', cll_tracker.to_dict())
+        log_performance("column level lineage", cll_tracker.to_dict())
         cll_tracker.reset()
 
         return dict(nodes=nodes)
@@ -900,8 +935,8 @@ class DbtAdapter(BaseAdapter):
         manifest = self.curr_manifest if base is False else self.base_manifest
         manifest_dict = manifest.to_dict()
         parent_list = []
-        if node_id in manifest_dict['parent_map']:
-            parent_list = manifest_dict['parent_map'][node_id]
+        if node_id in manifest_dict["parent_map"]:
+            parent_list = manifest_dict["parent_map"][node_id]
 
         node = deepcopy(nodes[node_id])
         self.append_column_lineage(node, parent_list, base)
@@ -909,49 +944,49 @@ class DbtAdapter(BaseAdapter):
 
     def append_column_lineage(self, node: Dict, parent_list: List, base: Optional[bool] = False):
         def _apply_all_columns(node, trans_type, depends_on):
-            for col in node.get('columns', {}).values():
-                col['transformation_type'] = trans_type
-                col['depends_on'] = depends_on
+            for col in node.get("columns", {}).values():
+                col["transformation_type"] = trans_type
+                col["depends_on"] = depends_on
 
         def _depend_node_to_id(column_lineage, nodes):
             for cl in column_lineage.values():
                 for depend_on in cl.depends_on:
-                    if depend_on.node.startswith('__'):
+                    if depend_on.node.startswith("__"):
                         for n in nodes.values():
-                            if n.get('resource_type') != 'source':
+                            if n.get("resource_type") != "source":
                                 continue
                             # __source__table -> source.table
                             source_table = depend_on.node.lstrip("_").replace("__", ".", 1).lower()
-                            if source_table in n.get('id'):
-                                depend_on.node = n.get('id')
+                            if source_table in n.get("id"):
+                                depend_on.node = n.get("id")
                                 break
                     else:
                         for n in nodes.values():
-                            if n.get('name') == depend_on.node.lower():
-                                depend_on.node = n.get('id')
+                            if n.get("name") == depend_on.node.lower():
+                                depend_on.node = n.get("id")
                                 break
 
         cll_tracker = CLLPerformanceTracking()
         nodes = self.get_lineage_nodes_metadata(base=base)
         manifest = as_manifest(self.get_manifest(base))
-        resource_type = node.get('resource_type')
-        if resource_type not in {'model', 'seed', 'source', 'snapshot'}:
+        resource_type = node.get("resource_type")
+        if resource_type not in {"model", "seed", "source", "snapshot"}:
             return
 
-        if resource_type == 'source' or resource_type == 'seed':
-            _apply_all_columns(node, 'source', [])
+        if resource_type == "source" or resource_type == "seed":
+            _apply_all_columns(node, "source", [])
             return
 
-        if node.get('raw_code') is None or self.is_python_model(node.get('id'), base=base):
-            _apply_all_columns(node, 'unknown', [])
+        if node.get("raw_code") is None or self.is_python_model(node.get("id"), base=base):
+            _apply_all_columns(node, "unknown", [])
             return
 
         # dbt <= 1.8, MetricFlow expects the time spine table to be named metricflow_time_spine
-        if node.get('name') == 'metricflow_time_spine':
-            _apply_all_columns(node, 'source', [])
+        if node.get("name") == "metricflow_time_spine":
+            _apply_all_columns(node, "source", [])
             return
 
-        if not node.get('columns', {}):
+        if not node.get("columns", {}):
             # no catalog
             return
 
@@ -967,7 +1002,7 @@ class DbtAdapter(BaseAdapter):
         def source_func(source_name, table_name):
             return f"__{source_name}__{table_name}"
 
-        raw_code = node.get('raw_code')
+        raw_code = node.get("raw_code")
         jinja_context = dict(
             ref=ref_func,
             source=source_func,
@@ -978,16 +1013,14 @@ class DbtAdapter(BaseAdapter):
             parent_node = nodes.get(parent_id)
             if parent_node is None:
                 continue
-            columns = parent_node.get('columns') or {}
-            name = parent_node.get('name')
-            if parent_node.get('resource_type') == 'source':
-                parts = parent_id.split('.')
+            columns = parent_node.get("columns") or {}
+            name = parent_node.get("name")
+            if parent_node.get("resource_type") == "source":
+                parts = parent_id.split(".")
                 source = parts[2]
                 table = parts[3]
                 name = f"__{source}__{table}"
-            schema[name] = {
-                name: column.get('type') for name, column in columns.items()
-            }
+            schema[name] = {name: column.get("type") for name, column in columns.items()}
 
         try:
             # provide a manifest to speedup and not pollute the manifest
@@ -999,20 +1032,20 @@ class DbtAdapter(BaseAdapter):
             column_lineage = cll(compiled_sql, schema=schema, dialect=dialect)
         except RecceException:
             # TODO: provide parsing error message if needed
-            _apply_all_columns(node, 'unknown', [])
+            _apply_all_columns(node, "unknown", [])
             cll_tracker.increment_sqlglot_error_nodes()
             return
         except Exception:
-            _apply_all_columns(node, 'unknown', [])
+            _apply_all_columns(node, "unknown", [])
             cll_tracker.increment_other_error_nodes()
             return
 
         _depend_node_to_id(column_lineage, nodes)
 
-        for name, column in node.get('columns', {}).items():
+        for name, column in node.get("columns", {}).items():
             if name in column_lineage:
-                column['depends_on'] = column_lineage[name].depends_on
-                column['transformation_type'] = column_lineage[name].type
+                column["depends_on"] = column_lineage[name].depends_on
+                column["transformation_type"] = column_lineage[name].type
 
     @lru_cache(maxsize=2)
     def get_lineage_nodes_metadata(self, base: Optional[bool] = False):
@@ -1021,18 +1054,18 @@ class DbtAdapter(BaseAdapter):
         manifest_dict = manifest.to_dict()
 
         nodes = {}
-        for node in manifest_dict['nodes'].values():
-            unique_id = node['unique_id']
-            resource_type = node['resource_type']
+        for node in manifest_dict["nodes"].values():
+            unique_id = node["unique_id"]
+            resource_type = node["resource_type"]
 
-            if resource_type not in ['model', 'seed', 'exposure', 'snapshot']:
+            if resource_type not in ["model", "seed", "exposure", "snapshot"]:
                 continue
 
             nodes[unique_id] = {
-                'id': node['unique_id'],
-                'name': node['name'],
-                'resource_type': node['resource_type'],
-                'raw_code': node['raw_code'],
+                "id": node["unique_id"],
+                "name": node["name"],
+                "resource_type": node["resource_type"],
+                "raw_code": node["raw_code"],
             }
 
             if catalog is not None and unique_id in catalog.nodes:
@@ -1040,23 +1073,20 @@ class DbtAdapter(BaseAdapter):
                 for col_name, col_metadata in catalog.nodes[unique_id].columns.items():
                     col = dict(name=col_name, type=col_metadata.type)
                     columns[col_name] = col
-                nodes[unique_id]['columns'] = columns
+                nodes[unique_id]["columns"] = columns
 
-        for source in manifest_dict['sources'].values():
-            unique_id = source['unique_id']
+        for source in manifest_dict["sources"].values():
+            unique_id = source["unique_id"]
 
             nodes[unique_id] = {
-                'id': source['unique_id'],
-                'name': source['name'],
-                'resource_type': source['resource_type'],
+                "id": source["unique_id"],
+                "name": source["name"],
+                "resource_type": source["resource_type"],
             }
 
             if catalog is not None and unique_id in catalog.sources:
-                nodes[unique_id]['columns'] = {
-                    col_name: {
-                        'name': col_name,
-                        'type': col_metadata.type
-                    }
+                nodes[unique_id]["columns"] = {
+                    col_name: {"name": col_name, "type": col_metadata.type}
                     for col_name, col_metadata in catalog.sources[unique_id].columns.items()
                 }
 
@@ -1067,8 +1097,8 @@ class DbtAdapter(BaseAdapter):
         base_manifest = self.get_manifest(base=True)
         if unique_id in curr_manifest.nodes.keys() or unique_id in base_manifest.nodes.keys():
             return {
-                'current': curr_manifest.nodes.get(unique_id),
-                'base': base_manifest.nodes.get(unique_id)
+                "current": curr_manifest.nodes.get(unique_id),
+                "base": base_manifest.nodes.get(unique_id),
             }
         return None
 
@@ -1091,39 +1121,40 @@ class DbtAdapter(BaseAdapter):
             if self.base_path:
                 self.artifacts_observer.schedule(event_handler, self.base_path, recursive=False)
             self.artifacts_observer.start()
-            logger.info('Start monitoring dbt artifacts')
+            logger.info("Start monitoring dbt artifacts")
 
     def stop_monitor_artifacts(self):
         if self.artifacts_files:
             self.artifacts_observer.stop()
             self.artifacts_observer.join()
-            logger.info('Stop monitoring artifacts')
+            logger.info("Stop monitoring artifacts")
 
     def start_monitor_base_env(self, callback: Callable = None):
-        target_base_dir = os.path.join(self.runtime_config.project_root, 'target-base')
+        target_base_dir = os.path.join(self.runtime_config.project_root, "target-base")
         base_env_files = {
-            os.path.join(target_base_dir, 'manifest.json'),
-            os.path.join(target_base_dir, 'catalog.json'),
+            os.path.join(target_base_dir, "manifest.json"),
+            os.path.join(target_base_dir, "catalog.json"),
         }
         event_handler = EnvironmentEventHandler(self.base_env_observer, base_env_files, callback=callback)
         self.base_env_observer.schedule(event_handler, self.runtime_config.project_root, recursive=True)
         self.base_env_observer.start()
-        logger.info('Start monitoring base environment')
+        logger.info("Start monitoring base environment")
 
     def stop_monitor_base_env(self):
         if self.base_env_observer.is_alive():
             self.base_env_observer.stop()
         self.base_env_observer.join()
-        logger.info('Stop monitoring base environment')
-
-    def set_artifacts(self,
-                      base_manifest: WritableManifest,
-                      curr_manifest: WritableManifest,
-                      manifest: Manifest,
-                      previous_manifest: Manifest,
-                      base_catalog: CatalogArtifact,
-                      curr_catalog: CatalogArtifact,
-                      ):
+        logger.info("Stop monitoring base environment")
+
+    def set_artifacts(
+        self,
+        base_manifest: WritableManifest,
+        curr_manifest: WritableManifest,
+        manifest: Manifest,
+        previous_manifest: Manifest,
+        base_catalog: CatalogArtifact,
+        curr_catalog: CatalogArtifact,
+    ):
         self.curr_manifest = curr_manifest
         self.base_manifest = base_manifest
         self.manifest = manifest
@@ -1132,7 +1163,7 @@ class DbtAdapter(BaseAdapter):
         self.previous_state = previous_state(
             Path(self.base_path),
             Path(self.runtime_config.target_path),
-            Path(self.runtime_config.project_root)
+            Path(self.runtime_config.project_root),
         )
         self.previous_state.manifest = previous_manifest
 
@@ -1154,18 +1185,18 @@ class DbtAdapter(BaseAdapter):
         # we capture the original manifest as base and only update the current
         target_type = os.path.basename(os.path.dirname(refresh_file_path))
         if self.target_path and target_type == os.path.basename(self.target_path):
-            if refresh_file_path.endswith('manifest.json'):
+            if refresh_file_path.endswith("manifest.json"):
                 self.curr_manifest = load_manifest(path=refresh_file_path)
                 self.manifest = as_manifest(self.curr_manifest)
                 self.get_cll_cached.cache_clear()
                 self.get_lineage_nodes_metadata.cache_clear()
-            elif refresh_file_path.endswith('catalog.json'):
+            elif refresh_file_path.endswith("catalog.json"):
                 self.curr_catalog = load_catalog(path=refresh_file_path)
                 self.get_lineage_nodes_metadata.cache_clear()
         elif self.base_path and target_type == os.path.basename(self.base_path):
-            if refresh_file_path.endswith('manifest.json'):
+            if refresh_file_path.endswith("manifest.json"):
                 self.base_manifest = load_manifest(path=refresh_file_path)
-            elif refresh_file_path.endswith('catalog.json'):
+            elif refresh_file_path.endswith("catalog.json"):
                 self.base_catalog = load_catalog(path=refresh_file_path)
 
     def create_relation(self, model, base=False):
@@ -1180,18 +1211,22 @@ class DbtAdapter(BaseAdapter):
         select: Optional[str] = None,
         exclude: Optional[str] = None,
         packages: Optional[list[str]] = None,
-        view_mode: Optional[Literal['all', 'changed_models']] = None,
+        view_mode: Optional[Literal["all", "changed_models"]] = None,
     ) -> Set[str]:
-        from dbt.graph import NodeSelector
-        from dbt.compilation import Compiler
-        from dbt.graph import parse_difference, SelectionIntersection, SelectionUnion
         import dbt.compilation
+        from dbt.compilation import Compiler
+        from dbt.graph import (
+            NodeSelector,
+            SelectionIntersection,
+            SelectionUnion,
+            parse_difference,
+        )
 
         select_list = [select] if select else None
         exclude_list = [exclude] if exclude else None
 
         def _parse_difference(include, exclude):
-            if dbt_version < 'v1.8':
+            if dbt_version < "v1.8":
                 return parse_difference(include, exclude, "eager")
             else:
                 return parse_difference(include, exclude)
@@ -1199,10 +1234,10 @@ class DbtAdapter(BaseAdapter):
         specs = [_parse_difference(select_list, exclude_list)]
 
         if packages is not None:
-            package_spec = SelectionUnion([_parse_difference([f'package:{p}'], None) for p in packages])
+            package_spec = SelectionUnion([_parse_difference([f"package:{p}"], None) for p in packages])
             specs.append(package_spec)
-        if view_mode and view_mode == 'changed_models':
-            specs.append(_parse_difference(['1+state:modified+'], None))
+        if view_mode and view_mode == "changed_models":
+            specs.append(_parse_difference(["1+state:modified+"], None))
         spec = SelectionIntersection(specs)
 
         manifest = Manifest()
@@ -1215,8 +1250,8 @@ class DbtAdapter(BaseAdapter):
         for node_id, node in manifest_prev.nodes.items():
             if node_id not in manifest.nodes:
                 node_dict = node.to_dict()
-                if 'raw_code' in node_dict:
-                    node_dict['raw_code'] = "__removed__"
+                if "raw_code" in node_dict:
+                    node_dict["raw_code"] = "__removed__"
                 node_class = type(node)
                 removed_node = node_class.from_dict(node_dict)
                 manifest.nodes[node_id] = removed_node
@@ -1225,8 +1260,11 @@ class DbtAdapter(BaseAdapter):
         manifest.sources = {**manifest_prev.sources, **manifest_curr.sources}
         manifest.exposures = {**manifest_prev.exposures, **manifest_curr.exposures}
         manifest.metrics = {**manifest_prev.metrics, **manifest_curr.metrics}
-        if hasattr(manifest_prev, 'semantic_models'):
-            manifest.semantic_models = {**manifest_prev.semantic_models, **manifest_curr.semantic_models}
+        if hasattr(manifest_prev, "semantic_models"):
+            manifest.semantic_models = {
+                **manifest_prev.semantic_models,
+                **manifest_curr.semantic_models,
+            }
 
         compiler = Compiler(self.runtime_config)
         # disable to print compile states
@@ -1241,28 +1279,28 @@ class DbtAdapter(BaseAdapter):
             return selector.get_selected(spec)
 
     def export_artifacts(self) -> ArtifactsRoot:
-        '''
+        """
         Export the artifacts from the current state
-        '''
+        """
         artifacts = ArtifactsRoot()
 
         def _load_artifact(artifact):
             return artifact.to_dict() if artifact else None
 
         artifacts.base = {
-            'manifest': _load_artifact(self.base_manifest),
-            'catalog': _load_artifact(self.base_catalog),
+            "manifest": _load_artifact(self.base_manifest),
+            "catalog": _load_artifact(self.base_catalog),
         }
         artifacts.current = {
-            'manifest': _load_artifact(self.curr_manifest),
-            'catalog': _load_artifact(self.curr_catalog),
+            "manifest": _load_artifact(self.curr_manifest),
+            "catalog": _load_artifact(self.curr_catalog),
         }
         return artifacts
 
     def export_artifacts_from_file(self) -> ArtifactsRoot:
-        '''
+        """
         Export the artifacts from the state file. This is the old implementation
-        '''
+        """
         artifacts = ArtifactsRoot()
         target_path = self.runtime_config.target_path
         target_base_path = self.base_path
@@ -1271,18 +1309,18 @@ class DbtAdapter(BaseAdapter):
             if not os.path.isfile(path):
                 return None
 
-            with open(path, 'r') as f:
+            with open(path, "r") as f:
                 json_content = f.read()
                 return json.loads(json_content)
 
         project_root = self.runtime_config.project_root
         artifacts.base = {
-            'manifest': _load_artifact(os.path.join(project_root, target_base_path, 'manifest.json')),
-            'catalog': _load_artifact(os.path.join(project_root, target_base_path, 'catalog.json')),
+            "manifest": _load_artifact(os.path.join(project_root, target_base_path, "manifest.json")),
+            "catalog": _load_artifact(os.path.join(project_root, target_base_path, "catalog.json")),
         }
         artifacts.current = {
-            'manifest': _load_artifact(os.path.join(project_root, target_path, 'manifest.json')),
-            'catalog': _load_artifact(os.path.join(project_root, target_path, 'catalog.json')),
+            "manifest": _load_artifact(os.path.join(project_root, target_path, "manifest.json")),
+            "catalog": _load_artifact(os.path.join(project_root, target_path, "catalog.json")),
         }
         return artifacts
 
@@ -1290,7 +1328,7 @@ class DbtAdapter(BaseAdapter):
         # Merge the artifacts from the state file or cloud
         def _select_artifact(
             original: Union[WritableManifest, CatalogArtifact],
-            new: Union[WritableManifest, CatalogArtifact]
+            new: Union[WritableManifest, CatalogArtifact],
         ):
             if merge:
                 if not original:
@@ -1301,16 +1339,16 @@ class DbtAdapter(BaseAdapter):
             else:
                 return new
 
-        self.base_manifest = _select_artifact(self.base_manifest, load_manifest(data=artifacts.base.get('manifest')))
-        self.curr_manifest = _select_artifact(self.curr_manifest, load_manifest(data=artifacts.current.get('manifest')))
-        self.base_catalog = _select_artifact(self.base_catalog, load_catalog(data=artifacts.base.get('catalog')))
-        self.curr_catalog = _select_artifact(self.curr_catalog, load_catalog(data=artifacts.current.get('catalog')))
+        self.base_manifest = _select_artifact(self.base_manifest, load_manifest(data=artifacts.base.get("manifest")))
+        self.curr_manifest = _select_artifact(self.curr_manifest, load_manifest(data=artifacts.current.get("manifest")))
+        self.base_catalog = _select_artifact(self.base_catalog, load_catalog(data=artifacts.base.get("catalog")))
+        self.curr_catalog = _select_artifact(self.curr_catalog, load_catalog(data=artifacts.current.get("catalog")))
 
         self.manifest = as_manifest(self.curr_manifest)
         self.previous_state = previous_state(
             Path(self.base_path),
             Path(self.runtime_config.target_path),
-            Path(self.runtime_config.project_root)
+            Path(self.runtime_config.project_root),
         )
         self.previous_state.manifest = as_manifest(self.base_manifest)
 
@@ -1326,7 +1364,8 @@ class DbtAdapter(BaseAdapter):
 
         if not self.curr_manifest or not self.base_manifest:
             raise Exception(
-                'No enough dbt artifacts in the state file. Please use the latest recce to generate the recce state')
+                "No enough dbt artifacts in the state file. Please use the latest recce to generate the recce state"
+            )
 
     @contextmanager
     def connection_named(self, name: str) -> Iterator[None]: