airflow-dbt-python 2.2.0__tar.gz → 3.0.0__tar.gz

{airflow_dbt_python-2.2.0 → airflow_dbt_python-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: airflow-dbt-python
-Version: 2.2.0
+Version: 3.0.0
 Summary: A collection of Airflow operators, hooks, and utilities to execute dbt commands
 License: MIT
 Author: Tomás Farías Santana
@@ -9,7 +9,6 @@ Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -17,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: adapters
 Provides-Extra: airflow-providers
 Provides-Extra: bigquery
-Provides-Extra: docs
+Provides-Extra: gcs
 Provides-Extra: git
 Provides-Extra: postgres
 Provides-Extra: redshift
@@ -25,18 +24,25 @@ Provides-Extra: s3
 Provides-Extra: snowflake
 Provides-Extra: spark
 Requires-Dist: apache-airflow (>=2.8)
-Requires-Dist: apache-airflow-providers-amazon (>=3.0.0) ; extra == "airflow-providers" or extra == "s3"
-Requires-Dist: apache-airflow-providers-ssh (>=3.0.0) ; extra == "airflow-providers" or extra == "git"
-Requires-Dist: connexion (<3.0)
+Requires-Dist: apache-airflow-providers-amazon (>=3.0.0) ; extra == "airflow-providers"
+Requires-Dist: apache-airflow-providers-amazon (>=3.0.0) ; extra == "s3"
+Requires-Dist: apache-airflow-providers-google (>=11.0.0) ; extra == "airflow-providers"
+Requires-Dist: apache-airflow-providers-google (>=11.0.0) ; extra == "gcs"
+Requires-Dist: apache-airflow-providers-ssh (>=3.0.0) ; extra == "airflow-providers"
+Requires-Dist: apache-airflow-providers-ssh (>=3.0.0) ; extra == "git"
 Requires-Dist: contextlib-chdir (==1.0.2) ; python_version < "3.11"
-Requires-Dist: dbt-bigquery (>=1.8.0,<2.0.0) ; extra == "adapters" or extra == "bigquery"
+Requires-Dist: dbt-bigquery (>=1.8.0,<2.0.0) ; extra == "adapters"
+Requires-Dist: dbt-bigquery (>=1.8.0,<2.0.0) ; extra == "bigquery"
 Requires-Dist: dbt-core (>=1.8.0,<2.0.0)
-Requires-Dist: dbt-postgres (>=1.8.0,<2.0.0) ; extra == "adapters" or extra == "postgres"
-Requires-Dist: dbt-redshift (>=1.8.0,<2.0.0) ; extra == "adapters" or extra == "redshift"
-Requires-Dist: dbt-snowflake (>=1.8.0,<2.0.0) ; extra == "adapters" or extra == "snowflake"
-Requires-Dist: dbt-spark (>=1.8.0,<2.0.0) ; extra == "adapters" or extra == "spark"
+Requires-Dist: dbt-postgres (>=1.8.0,<2.0.0) ; extra == "adapters"
+Requires-Dist: dbt-postgres (>=1.8.0,<2.0.0) ; extra == "postgres"
+Requires-Dist: dbt-redshift (>=1.8.0,<2.0.0) ; extra == "adapters"
+Requires-Dist: dbt-redshift (>=1.8.0,<2.0.0) ; extra == "redshift"
+Requires-Dist: dbt-snowflake (>=1.8.0,<2.0.0) ; extra == "adapters"
+Requires-Dist: dbt-snowflake (>=1.8.0,<2.0.0) ; extra == "snowflake"
+Requires-Dist: dbt-spark (>=1.8.0,<2.0.0) ; extra == "spark"
+Requires-Dist: dbt-spark[all] (>=1.8.0,<2.0.0) ; extra == "adapters"
 Requires-Dist: dulwich (>=0.21) ; extra == "git"
-Project-URL: Repository, https://github.com/tomasfarias/airflow-dbt-python
 Description-Content-Type: text/markdown
 
 # airflow-dbt-python
@@ -62,7 +68,7 @@ Before using *airflow-dbt-python*, ensure you meet the following requirements:
   * If using any managed service, like AWS MWAA or GCP Cloud Composer 2/3, ensure your environment is created with a supported version of Airflow.
   * If self-hosting, Airflow installation instructions can be found in their [official documentation](https://airflow.apache.org/docs/apache-airflow/stable/installation/index.html).
 
-* Running Python 3.8 or later in your Airflow environment.
+* Running Python 3.9 or later in your Airflow environment.
 
 > **Warning**
 >

{airflow_dbt_python-2.2.0 → airflow_dbt_python-3.0.0}/README.md

@@ -21,7 +21,7 @@ Before using *airflow-dbt-python*, ensure you meet the following requirements:
   * If using any managed service, like AWS MWAA or GCP Cloud Composer 2/3, ensure your environment is created with a supported version of Airflow.
   * If self-hosting, Airflow installation instructions can be found in their [official documentation](https://airflow.apache.org/docs/apache-airflow/stable/installation/index.html).
 
-* Running Python 3.8 or later in your Airflow environment.
+* Running Python 3.9 or later in your Airflow environment.
 
 > **Warning**
 >

{airflow_dbt_python-2.2.0 → airflow_dbt_python-3.0.0}/airflow_dbt_python/__version__.py

@@ -3,4 +3,4 @@
 __author__ = "Tomás Farías Santana"
 __copyright__ = "Copyright 2021 Tomás Farías Santana"
 __title__ = "airflow-dbt-python"
-__version__ = "2.2.0"
+__version__ = "3.0.0"

airflow_dbt_python-3.0.0/airflow_dbt_python/hooks/__init__.py

@@ -0,0 +1 @@
+"""Hooks module provides DbtHooks and DbtFSHooks."""

{airflow_dbt_python-2.2.0 → airflow_dbt_python-3.0.0}/airflow_dbt_python/hooks/dbt.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import logging
 import sys
+from abc import ABC
 from contextlib import contextmanager
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -17,13 +18,11 @@ from typing import (
     NamedTuple,
     Optional,
     Tuple,
-    Union,
 )
 from urllib.parse import urlparse
 
 from airflow.exceptions import AirflowException
-from airflow.hooks.base import BaseHook
-from airflow.models.connection import Connection
+from airflow.utils.log.logging_mixin import LoggingMixin
 
 if sys.version_info >= (3, 11):
     from contextlib import chdir as chdir_ctx
@@ -32,13 +31,13 @@ else:
 
 if TYPE_CHECKING:
     from dbt.contracts.results import RunResult
-    from dbt.task.base import BaseTask
 
-    from airflow_dbt_python.hooks.remote import DbtRemoteHook
+    from airflow_dbt_python.hooks.fs import DbtFSHook
+    from airflow_dbt_python.hooks.target import DbtConnectionHook
     from airflow_dbt_python.utils.configs import BaseConfig
     from airflow_dbt_python.utils.url import URLLike
 
-    DbtRemoteHooksDict = Dict[Tuple[str, Optional[str]], DbtRemoteHook]
+    DbtFSHooksDict = Dict[Tuple[str, Optional[str]], DbtFSHook]
 
 
 class DbtTaskResult(NamedTuple):
@@ -55,35 +54,6 @@ class DbtTaskResult(NamedTuple):
     artifacts: dict[str, Any]
 
 
-class DbtConnectionParam(NamedTuple):
-    """A tuple indicating connection parameters relevant to dbt.
-
-    Attributes:
-        name: The name of the connection parameter. This name will be used to get the
-            parameter from an Airflow Connection or its extras.
-        store_override_name: A new name for the connection parameter. If not None, this
-            is the name used in a dbt profiles.
-        default: A default value if the parameter is not found.
-    """
-
-    name: str
-    store_override_name: Optional[str] = None
-    default: Optional[Any] = None
-
-    @property
-    def override_name(self):
-        """Returns the override_name if defined, otherwise defaults to name.
-
-        >>> DbtConnectionParam("login", "user").override_name
-        'user'
-        >>> DbtConnectionParam("port").override_name
-        'port'
-        """
-        if self.store_override_name is None:
-            return self.name
-        return self.store_override_name
-
-
 class DbtTemporaryDirectory(TemporaryDirectory):
     """A wrapper on TemporaryDirectory for older versions of Python.
 
@@ -105,57 +75,43 @@ class DbtTemporaryDirectory(TemporaryDirectory):
             )
 
 
-class DbtHook(BaseHook):
+class DbtHook(ABC, LoggingMixin):
     """A hook to interact with dbt.
 
     Allows for running dbt tasks and provides required configurations for each task.
     """
 
-    conn_name_attr = "dbt_conn_id"
-    default_conn_name = "dbt_default"
-    conn_type = "dbt"
-    hook_name = "dbt Hook"
-
-    conn_params: list[Union[DbtConnectionParam, str]] = [
-        DbtConnectionParam("conn_type", "type"),
-        "host",
-        DbtConnectionParam("conn_id", "dbname"),
-        "schema",
-        DbtConnectionParam("login", "user"),
-        "password",
-        "port",
-    ]
-    conn_extra_params: list[Union[DbtConnectionParam, str]] = []
-
     def __init__(
         self,
         *args,
-        dbt_conn_id: Optional[str] = default_conn_name,
+        dbt_conn_id: Optional[str] = None,
         project_conn_id: Optional[str] = None,
         profiles_conn_id: Optional[str] = None,
         **kwargs,
     ):
-        self.remotes: DbtRemoteHooksDict = {}
         self.dbt_conn_id = dbt_conn_id
         self.project_conn_id = project_conn_id
         self.profiles_conn_id = profiles_conn_id
         super().__init__(*args, **kwargs)
 
-    def get_remote(self, scheme: str, conn_id: Optional[str]) -> DbtRemoteHook:
-        """Get a remote to interact with dbt files.
+    @staticmethod
+    def get_dbt_target_hook(conn_id: str) -> DbtConnectionHook:
+        """Get a hook to get a dbt profile based on the Airflow connection."""
+        from .target import DbtConnectionHook
 
-        RemoteHooks are defined by the scheme we are looking for and an optional
+        return DbtConnectionHook.get_db_conn_hook(conn_id)
+
+    @staticmethod
+    def get_fs_hook(scheme: str, conn_id: Optional[str]) -> DbtFSHook:
+        """Get a fs_hook to interact with dbt files.
+
+        FSHooks are defined by the scheme we are looking for and an optional
         connection id if we are looking to interface with any Airflow hook that
         uses a connection.
         """
-        from .remote import get_remote
+        from .fs import get_fs_hook
 
-        try:
-            return self.remotes[(scheme, conn_id)]
-        except KeyError:
-            remote = get_remote(scheme, conn_id)
-        self.remotes[(scheme, conn_id)] = remote
-        return remote
+        return get_fs_hook(scheme, conn_id)
 
     def download_dbt_profiles(
         self,
@@ -164,13 +120,13 @@ class DbtHook(BaseHook):
     ) -> Path:
         """Pull a dbt profiles.yml file from a given profiles_dir.
 
-        This operation is delegated to a DbtRemoteHook. An optional connection id is
+        This operation is delegated to a DbtFSHook. An optional connection id is
         supported for remotes that require it.
         """
         scheme = urlparse(str(profiles_dir)).scheme
-        remote = self.get_remote(scheme, self.project_conn_id)
+        fs_hook = self.get_fs_hook(scheme, self.profiles_conn_id)
 
-        return remote.download_dbt_profiles(profiles_dir, destination)
+        return fs_hook.download_dbt_profiles(profiles_dir, destination)
 
     def download_dbt_project(
         self,
@@ -179,13 +135,13 @@ class DbtHook(BaseHook):
     ) -> Path:
         """Pull a dbt project from a given project_dir.
 
-        This operation is delegated to a DbtRemoteHook. An optional connection id is
+        This operation is delegated to a DbtFSHook. An optional connection id is
         supported for remotes that require it.
         """
         scheme = urlparse(str(project_dir)).scheme
-        remote = self.get_remote(scheme, self.project_conn_id)
+        fs_hook = self.get_fs_hook(scheme, self.project_conn_id)
 
-        return remote.download_dbt_project(project_dir, destination)
+        return fs_hook.download_dbt_project(project_dir, destination)
 
     def upload_dbt_project(
         self,
@@ -196,13 +152,13 @@ class DbtHook(BaseHook):
     ) -> None:
         """Push a dbt project from a given project_dir.
 
-        This operation is delegated to a DbtRemoteHook. An optional connection id is
+        This operation is delegated to a DbtFSHook. An optional connection id is
         supported for remotes that require it.
         """
         scheme = urlparse(str(destination)).scheme
-        remote = self.get_remote(scheme, self.project_conn_id)
+        fs_hook = self.get_fs_hook(scheme, self.project_conn_id)
 
-        return remote.upload_dbt_project(
+        return fs_hook.upload_dbt_project(
             project_dir, destination, replace=replace, delete_before=delete_before
         )
 
@@ -231,8 +187,14 @@ class DbtHook(BaseHook):
         from dbt.task.deps import DepsTask
         from dbt.tracking import track_run
 
+        if self.dbt_conn_id:
+            kwargs["target"] = self.dbt_conn_id
+            target_hook = self.get_dbt_target_hook(self.dbt_conn_id)
+            extra_target = target_hook.get_dbt_target_from_connection()
+        else:
+            extra_target = None
+
         config = self.get_dbt_task_config(command, **kwargs)
-        extra_target = self.get_dbt_target_from_connection(config.target)
 
         with self.dbt_directory(
             config,
@@ -246,15 +208,13 @@ class DbtHook(BaseHook):
             nearest_project_dir = get_nearest_project_dir(config.project_dir)
 
             with chdir_ctx(nearest_project_dir):
-                self.ensure_profiles(config)
-
                 with adapter_management():
                     task, runtime_config = config.create_dbt_task(
                         extra_target, write_perf_info
                     )
                     requires_profile = isinstance(task, (CleanTask, DepsTask))
 
-                    self.setup_dbt_logging(task, config.debug)
+                    self.setup_dbt_logging(config.debug)
 
                     if runtime_config is not None and not requires_profile:
                         # The deps command installs the dependencies, which means they
@@ -373,25 +333,24 @@ class DbtHook(BaseHook):
             project_dir,
             tmp_dir,
         )
-        new_project_dir = str(project_dir_path) + "/"
-
-        if (project_dir_path / "profiles.yml").exists():
-            # We may have downloaded the profiles.yml file together
-            # with the project.
-            return new_project_dir, new_project_dir
 
         if profiles_dir is not None:
             profiles_file_path = self.download_dbt_profiles(
                 profiles_dir,
                 tmp_dir,
             )
-            new_profiles_dir = str(profiles_file_path.parent) + "/"
+            profiles_dir_path = profiles_file_path.parent
+        elif (project_dir_path / "profiles.yml").exists():
+            profiles_dir_path = project_dir_path
         else:
-            new_profiles_dir = None
+            profiles_dir_path = None
 
-        return new_project_dir, new_profiles_dir
+        return (
+            str(project_dir_path),
+            str(profiles_dir_path) if profiles_dir_path is not None else None,
+        )
 
-    def setup_dbt_logging(self, task: BaseTask, debug: Optional[bool]):
+    def setup_dbt_logging(self, debug: Optional[bool]):
         """Setup dbt logging.
 
         Starting with dbt v1, dbt initializes two loggers: default_file and
@@ -407,6 +366,7 @@ class DbtHook(BaseHook):
         configured_file = logging.getLogger("configured_file")
         file_log = logging.getLogger("file_log")
         stdout_log = logging.getLogger("stdout_log")
+        stdout_log.handlers.clear()
         stdout_log.propagate = True
 
         if not debug:
@@ -417,166 +377,3 @@ class DbtHook(BaseHook):
             file_log.propagate = False
             configured_file.setLevel("INFO")
             configured_file.propagate = False
-
-    def ensure_profiles(self, config: BaseConfig):
-        """Ensure a profiles file exists."""
-        if config.profiles_dir is not None:
-            # We expect one to exist given that we have passed a profiles_dir.
-            return
-
-        profiles_path = Path.home() / ".dbt/profiles.yml"
-        config.profiles_dir = str(profiles_path.parent)
-        if not profiles_path.exists():
-            profiles_path.parent.mkdir(exist_ok=True)
-            with profiles_path.open("w", encoding="utf-8") as f:
-                f.write("flags:\n  send_anonymous_usage_stats: false\n")
-
-    def get_dbt_target_from_connection(
-        self, target: Optional[str]
-    ) -> Optional[dict[str, Any]]:
-        """Return a dictionary of connection details to use as a dbt target.
-
-        The connection details are fetched from an Airflow connection identified by
-        target or self.dbt_conn_id.
-
-        Args:
-            target: The target name to use as an Airflow connection ID. If ommitted, we
-                will use self.dbt_conn_id.
-
-        Returns:
-            A dictionary with a configuration for a dbt target, or None if a matching
-                Airflow connection is not found for given dbt target.
-        """
-        conn_id = target or self.dbt_conn_id
-
-        if conn_id is None:
-            return None
-
-        try:
-            conn = self.get_connection(conn_id)
-        except AirflowException:
-            self.log.debug(
-                "No Airflow connection matching dbt target %s was found.", target
-            )
-            return None
-
-        details = self.get_dbt_details_from_connection(conn)
-
-        return {conn_id: details}
-
-    def get_dbt_details_from_connection(self, conn: Connection) -> dict[str, Any]:
-        """Extract dbt connection details from Airflow Connection.
-
-        dbt connection details may be present as Airflow Connection attributes or in the
-        Connection's extras. This class' conn_params and conn_extra_params will be used
-        to fetch required attributes from attributes and extras respectively. If
-        conn_extra_params is empty, we merge parameters with all extras.
-
-        Subclasses may override this class attributes to narrow down the connection
-        details for a specific dbt target (like Postgres, or Redshift).
-
-        Args:
-            conn: The Airflow Connection to extract dbt connection details from.
-
-        Returns:
-            A dictionary of dbt connection details.
-        """
-        dbt_details = {}
-        for param in self.conn_params:
-            if isinstance(param, DbtConnectionParam):
-                key = param.override_name
-                value = getattr(conn, param.name, param.default)
-            else:
-                key = param
-                value = getattr(conn, key, None)
-
-            if value is None:
-                continue
-
-            dbt_details[key] = value
-
-        extra = conn.extra_dejson
-
-        if not self.conn_extra_params:
-            return {**dbt_details, **extra}
-
-        for param in self.conn_extra_params:
-            if isinstance(param, DbtConnectionParam):
-                key = param.override_name
-                value = extra.get(param.name, param.default)
-            else:
-                key = param
-                value = extra.get(key, None)
-
-            if value is None:
-                continue
-
-            dbt_details[key] = value
-
-        return dbt_details
-
-
-class DbtPostgresHook(DbtHook):
-    """A hook to interact with dbt using a Postgres connection."""
-
-    conn_type = "postgres"
-    hook_name = "dbt Postgres Hook"
-    conn_params = [
-        DbtConnectionParam("conn_type", "type", "postgres"),
-        "host",
-        "schema",
-        DbtConnectionParam("login", "user"),
-        "password",
-        "port",
-    ]
-    conn_extra_params = [
-        "dbname",
-        "threads",
-        "keepalives_idle",
-        "connect_timeout",
-        "retries",
-        "search_path",
-        "role",
-        "sslmode",
-    ]
-
-
-class DbtRedshiftHook(DbtPostgresHook):
-    """A hook to interact with dbt using a Redshift connection."""
-
-    conn_type = "redshift"
-    hook_name = "dbt Redshift Hook"
-    conn_extra_params = DbtPostgresHook.conn_extra_params + [
-        "ra3_node",
-        "iam_profile",
-        "iam_duration_secons",
-        "autocreate",
-        "db_groups",
-    ]
-
-
-class DbtSnowflakeHook(DbtHook):
-    """A hook to interact with dbt using a Snowflake connection."""
-
-    conn_type = "snowflake"
-    hook_name = "dbt Snowflake Hook"
-    conn_params = [
-        DbtConnectionParam("conn_type", "type", "postgres"),
-        "host",
-        "schema",
-        DbtConnectionParam("login", "user"),
-        "password",
-    ]
-    conn_extra_params = [
-        "account",
-        "role",
-        "database",
-        "warehouse",
-        "threads",
-        "client_session_keep_alive",
-        "query_tag",
-        "connect_retries",
-        "connect_timeout",
-        "retry_on_database_errors",
-        "retry_all",
-    ]

airflow_dbt_python-2.2.0/airflow_dbt_python/hooks/remote.py → airflow_dbt_python-3.0.0/airflow_dbt_python/hooks/fs/__init__.py

@@ -1,11 +1,12 @@
-"""The DbtRemoteHook interface includes methods for downloading and uploading files.
+"""The DbtFSHook interface includes methods for downloading and uploading files.
 
-Internally, DbtRemoteHooks can use Airflow hooks to execute the actual operations.
+Internally, DbtFSHooks can use Airflow hooks to execute the actual operations.
 
 Currently, only AWS S3 and the local filesystem are supported as remotes.
 """
 
 from abc import ABC, abstractmethod
+from functools import cache
 from pathlib import Path
 from typing import Optional, Type
 
@@ -16,7 +17,7 @@ from airflow_dbt_python.utils.url import URL, URLLike
 StrPath = str
 
 
-class DbtRemoteHook(ABC, LoggingMixin):
+class DbtFSHook(ABC, LoggingMixin):
     """Represents a dbt project storing any dbt files.
 
     A concrete backend class should implement the push and pull methods to fetch one
@@ -32,7 +33,7 @@ class DbtRemoteHook(ABC, LoggingMixin):
     """
 
     @abstractmethod
-    def download(
+    def _download(
         self,
         source: URL,
         destination: URL,
@@ -43,7 +44,7 @@ class DbtRemoteHook(ABC, LoggingMixin):
         return NotImplemented
 
     @abstractmethod
-    def upload(
+    def _upload(
         self,
         source: URL,
         destination: URL,
@@ -71,7 +72,7 @@ class DbtRemoteHook(ABC, LoggingMixin):
         if source_url.is_archive():
             destination_url = destination_url / source_url.name
 
-        self.download(source_url, destination_url)
+        self._download(source_url, destination_url)
 
         if destination_url.exists() and destination_url.is_archive():
             destination_url.extract()
@@ -103,7 +104,7 @@ class DbtRemoteHook(ABC, LoggingMixin):
         if destination_url.is_dir() or destination_url.name != "profiles.yml":
             destination_url = destination_url / "profiles.yml"
 
-        self.download(source_url, destination_url)
+        self._download(source_url, destination_url)
 
         return destination_url.path
 
@@ -133,35 +134,40 @@ class DbtRemoteHook(ABC, LoggingMixin):
             source_url.archive(zip_url)
             source_url = zip_url
 
-        self.upload(source_url, destination_url, replace, delete_before)
+        self._upload(source_url, destination_url, replace, delete_before)
 
         if destination_url.is_archive():
             source_url.unlink()
 
 
-def get_remote(scheme: str, conn_id: Optional[str] = None) -> DbtRemoteHook:
-    """Get a DbtRemoteHook as long as the scheme is supported.
+@cache
+def get_fs_hook(scheme: str, conn_id: Optional[str] = None) -> DbtFSHook:
+    """Get a DbtFSHook as long as the scheme is supported.
 
     In the future we should make our hooks discoverable and package ourselves as a
     proper Airflow providers package.
     """
     if scheme == "s3":
-        from .s3 import DbtS3RemoteHook
+        from .s3 import DbtS3FSHook
 
-        remote_cls: Type[DbtRemoteHook] = DbtS3RemoteHook
+        fs_hook_cls: Type[DbtFSHook] = DbtS3FSHook
+    elif scheme == "gs":
+        from .gcs import DbtGCSFSHook
+
+        fs_hook_cls = DbtGCSFSHook
     elif scheme in ("https", "git", "git+ssh", "ssh", "http"):
-        from .git import DbtGitRemoteHook
+        from .git import DbtGitFSHook
 
-        remote_cls = DbtGitRemoteHook
+        fs_hook_cls = DbtGitFSHook
     elif scheme == "":
-        from .localfs import DbtLocalFsRemoteHook
+        from .local import DbtLocalFsHook
 
-        remote_cls = DbtLocalFsRemoteHook
+        fs_hook_cls = DbtLocalFsHook
     else:
         raise NotImplementedError(f"Backend {scheme} is not supported")
 
     if conn_id is not None:
-        remote = remote_cls(conn_id)
+        fs_hook = fs_hook_cls(conn_id)
     else:
-        remote = remote_cls()
-    return remote
+        fs_hook = fs_hook_cls()
+    return fs_hook