apache-airflow-providers-standard 0.0.3rc2__py3-none-any.whl → 1.0.0.dev0__py3-none-any.whl

airflow/providers/standard/hooks/package_index.py

@@ -1,95 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-"""Hook for additional Package Indexes (Python)."""
-
-from __future__ import annotations
-
-import subprocess
-from typing import Any
-from urllib.parse import quote, urlparse
-
-from airflow.hooks.base import BaseHook
-
-
-class PackageIndexHook(BaseHook):
-    """Specify package indexes/Python package sources using Airflow connections."""
-
-    conn_name_attr = "pi_conn_id"
-    default_conn_name = "package_index_default"
-    conn_type = "package_index"
-    hook_name = "Package Index (Python)"
-
-    def __init__(self, pi_conn_id: str = default_conn_name, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.pi_conn_id = pi_conn_id
-        self.conn = None
-
-    @staticmethod
-    def get_ui_field_behaviour() -> dict[str, Any]:
-        """Return custom field behaviour."""
-        return {
-            "hidden_fields": ["schema", "port", "extra"],
-            "relabeling": {"host": "Package Index URL"},
-            "placeholders": {
-                "host": "Example: https://my-package-mirror.net/pypi/repo-name/simple",
-                "login": "Username for package index",
-                "password": "Password for package index (will be masked)",
-            },
-        }
-
-    @staticmethod
-    def _get_basic_auth_conn_url(index_url: str, user: str | None, password: str | None) -> str:
-        """Return a connection URL with basic auth credentials based on connection config."""
-        url = urlparse(index_url)
-        host = url.netloc.split("@")[-1]
-        if user:
-            if password:
-                host = f"{quote(user)}:{quote(password)}@{host}"
-            else:
-                host = f"{quote(user)}@{host}"
-        return url._replace(netloc=host).geturl()
-
-    def get_conn(self) -> Any:
-        """Return connection for the hook."""
-        return self.get_connection_url()
-
-    def get_connection_url(self) -> Any:
-        """Return a connection URL with embedded credentials."""
-        conn = self.get_connection(self.pi_conn_id)
-        index_url = conn.host
-        if not index_url:
-            raise ValueError("Please provide an index URL.")
-        return self._get_basic_auth_conn_url(index_url, conn.login, conn.password)
-
-    def test_connection(self) -> tuple[bool, str]:
-        """Test connection to package index url."""
-        conn_url = self.get_connection_url()
-        proc = subprocess.run(
-            ["pip", "search", "not-existing-test-package", "--no-input", "--index", conn_url],
-            check=False,
-            capture_output=True,
-        )
-        conn = self.get_connection(self.pi_conn_id)
-        if proc.returncode not in [
-            0,  # executed successfully, found package
-            23,  # executed successfully, didn't find any packages
-            #      (but we do not expect it to find 'not-existing-test-package')
-        ]:
-            return False, f"Connection test to {conn.host} failed. Error: {str(proc.stderr)}"
-
-        return True, f"Connection to {conn.host} tested successfully!"

airflow/providers/standard/hooks/subprocess.py

@@ -1,119 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-from __future__ import annotations
-
-import contextlib
-import os
-import signal
-from collections import namedtuple
-from collections.abc import Iterator
-from subprocess import PIPE, STDOUT, Popen
-from tempfile import TemporaryDirectory, gettempdir
-
-from airflow.hooks.base import BaseHook
-
-SubprocessResult = namedtuple("SubprocessResult", ["exit_code", "output"])
-
-
-@contextlib.contextmanager
-def working_directory(cwd: str | None = None) -> Iterator[str]:
-    """
-    Context manager for handling (temporary) working directory.
-
-    Use the given cwd as working directory, if provided.
-    Otherwise, create a temporary directory.
-    """
-    with contextlib.ExitStack() as stack:
-        if cwd is None:
-            cwd = stack.enter_context(TemporaryDirectory(prefix="airflowtmp"))
-        yield cwd
-
-
-class SubprocessHook(BaseHook):
-    """Hook for running processes with the ``subprocess`` module."""
-
-    def __init__(self, **kwargs) -> None:
-        self.sub_process: Popen[bytes] | None = None
-        super().__init__(**kwargs)
-
-    def run_command(
-        self,
-        command: list[str],
-        env: dict[str, str] | None = None,
-        output_encoding: str = "utf-8",
-        cwd: str | None = None,
-    ) -> SubprocessResult:
-        """
-        Execute the command.
-
-        If ``cwd`` is None, execute the command in a temporary directory which will be cleaned afterwards.
-        If ``env`` is not supplied, ``os.environ`` is passed
-
-        :param command: the command to run
-        :param env: Optional dict containing environment variables to be made available to the shell
-            environment in which ``command`` will be executed.  If omitted, ``os.environ`` will be used.
-            Note, that in case you have Sentry configured, original variables from the environment
-            will also be passed to the subprocess with ``SUBPROCESS_`` prefix. See:
-            https://airflow.apache.org/docs/apache-airflow/stable/administration-and-deployment/logging-monitoring/errors.html for details.
-        :param output_encoding: encoding to use for decoding stdout
-        :param cwd: Working directory to run the command in.
-            If None (default), the command is run in a temporary directory.
-        :return: :class:`namedtuple` containing ``exit_code`` and ``output``, the last line from stderr
-            or stdout
-        """
-        self.log.info("Tmp dir root location: %s", gettempdir())
-        with working_directory(cwd=cwd) as cwd:
-
-            def pre_exec():
-                # Restore default signal disposition and invoke setsid
-                for sig in ("SIGPIPE", "SIGXFZ", "SIGXFSZ"):
-                    if hasattr(signal, sig):
-                        signal.signal(getattr(signal, sig), signal.SIG_DFL)
-                os.setsid()
-
-            self.log.info("Running command: %s", command)
-
-            self.sub_process = Popen(
-                command,
-                stdout=PIPE,
-                stderr=STDOUT,
-                cwd=cwd,
-                env=env if env or env == {} else os.environ,
-                preexec_fn=pre_exec,
-            )
-
-            self.log.info("Output:")
-            line = ""
-            if self.sub_process is None:
-                raise RuntimeError("The subprocess should be created here and is None!")
-            if self.sub_process.stdout is not None:
-                for raw_line in iter(self.sub_process.stdout.readline, b""):
-                    line = raw_line.decode(output_encoding, errors="backslashreplace").rstrip()
-                    self.log.info("%s", line)
-
-            self.sub_process.wait()
-
-            self.log.info("Command exited with return code %s", self.sub_process.returncode)
-            return_code: int = self.sub_process.returncode
-
-        return SubprocessResult(exit_code=return_code, output=line)
-
-    def send_sigterm(self):
-        """Send SIGTERM signal to ``self.sub_process`` if one exists."""
-        self.log.info("Sending SIGTERM signal to process group")
-        if self.sub_process and hasattr(self.sub_process, "pid"):
-            os.killpg(os.getpgid(self.sub_process.pid), signal.SIGTERM)

airflow/providers/standard/operators/bash.py

@@ -1,312 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-from collections.abc import Container, Sequence
-from functools import cached_property
-from typing import TYPE_CHECKING, Any, Callable, cast
-
-from airflow.exceptions import AirflowException, AirflowSkipException
-from airflow.models.baseoperator import BaseOperator
-from airflow.providers.standard.hooks.subprocess import SubprocessHook, SubprocessResult, working_directory
-from airflow.utils.operator_helpers import context_to_airflow_vars
-from airflow.utils.session import NEW_SESSION, provide_session
-from airflow.utils.types import ArgNotSet
-
-if TYPE_CHECKING:
-    from sqlalchemy.orm import Session as SASession
-
-    from airflow.models.taskinstance import TaskInstance
-    from airflow.utils.context import Context
-
-
-class BashOperator(BaseOperator):
-    r"""
-    Execute a Bash script, command or set of commands.
-
-    .. seealso::
-        For more information on how to use this operator, take a look at the guide:
-        :ref:`howto/operator:BashOperator`
-
-    If BaseOperator.do_xcom_push is True, the last line written to stdout
-    will also be pushed to an XCom when the bash command completes
-
-    :param bash_command: The command, set of commands or reference to a
-        Bash script (must be '.sh' or '.bash') to be executed. (templated)
-    :param env: If env is not None, it must be a dict that defines the
-        environment variables for the new process; these are used instead
-        of inheriting the current process environment, which is the default
-        behavior. (templated)
-    :param append_env: If False(default) uses the environment variables passed in env params
-        and does not inherit the current process environment. If True, inherits the environment variables
-        from current passes and then environment variable passed by the user will either update the existing
-        inherited environment variables or the new variables gets appended to it
-    :param output_encoding: Output encoding of Bash command
-    :param skip_on_exit_code: If task exits with this exit code, leave the task
-        in ``skipped`` state (default: 99). If set to ``None``, any non-zero
-        exit code will be treated as a failure.
-    :param cwd: Working directory to execute the command in (templated).
-        If None (default), the command is run in a temporary directory.
-        To use current DAG folder as the working directory,
-        you might set template ``{{ dag_run.dag.folder }}``.
-        When bash_command is a '.sh' or '.bash' file, Airflow must have write
-        access to the working directory. The script will be rendered (Jinja
-        template) into a new temporary file in this directory.
-    :param output_processor: Function to further process the output of the bash script
-        (default is lambda output: output).
-
-    Airflow will evaluate the exit code of the Bash command. In general, a non-zero exit code will result in
-    task failure and zero will result in task success.
-    Exit code ``99`` (or another set in ``skip_on_exit_code``)
-    will throw an :class:`airflow.exceptions.AirflowSkipException`, which will leave the task in ``skipped``
-    state. You can have all non-zero exit codes be treated as a failure by setting ``skip_on_exit_code=None``.
-
-    .. list-table::
-       :widths: 25 25
-       :header-rows: 1
-
-       * - Exit code
-         - Behavior
-       * - 0
-         - success
-       * - `skip_on_exit_code` (default: 99)
-         - raise :class:`airflow.exceptions.AirflowSkipException`
-       * - otherwise
-         - raise :class:`airflow.exceptions.AirflowException`
-
-    .. note::
-
-        Airflow will not recognize a non-zero exit code unless the whole shell exit with a non-zero exit
-        code.  This can be an issue if the non-zero exit arises from a sub-command.  The easiest way of
-        addressing this is to prefix the command with ``set -e;``
-
-        .. code-block:: python
-
-            bash_command = "set -e; python3 script.py '{{ data_interval_end }}'"
-
-    .. note::
-
-        To simply execute a ``.sh`` or ``.bash`` script (without any Jinja template), add a space after the
-        script name ``bash_command`` argument -- for example ``bash_command="my_script.sh "``. This
-        is because Airflow tries to load this file and process it as a Jinja template when
-        it ends with ``.sh`` or ``.bash``.
-
-        If you have Jinja template in your script, do not put any blank space. And add the script's directory
-        in the DAG's ``template_searchpath``. If you specify a ``cwd``, Airflow must have write access to
-        this directory. The script will be rendered (Jinja template) into a new temporary file in this directory.
-
-    .. warning::
-
-        Care should be taken with "user" input or when using Jinja templates in the
-        ``bash_command``, as this bash operator does not perform any escaping or
-        sanitization of the command.
-
-        This applies mostly to using "dag_run" conf, as that can be submitted via
-        users in the Web UI. Most of the default template variables are not at
-        risk.
-
-    For example, do **not** do this:
-
-    .. code-block:: python
-
-        bash_task = BashOperator(
-            task_id="bash_task",
-            bash_command='echo "Here is the message: \'{{ dag_run.conf["message"] if dag_run else "" }}\'"',
-        )
-
-    Instead, you should pass this via the ``env`` kwarg and use double-quotes
-    inside the bash_command, as below:
-
-    .. code-block:: python
-
-        bash_task = BashOperator(
-            task_id="bash_task",
-            bash_command="echo \"here is the message: '$message'\"",
-            env={"message": '{{ dag_run.conf["message"] if dag_run else "" }}'},
-        )
-
-    .. versionadded:: 2.10.0
-       The `output_processor` parameter.
-
-    """
-
-    template_fields: Sequence[str] = ("bash_command", "env", "cwd")
-    template_fields_renderers = {"bash_command": "bash", "env": "json"}
-    template_ext: Sequence[str] = (".sh", ".bash")
-    ui_color = "#f0ede4"
-
-    def __init__(
-        self,
-        *,
-        bash_command: str | ArgNotSet,
-        env: dict[str, str] | None = None,
-        append_env: bool = False,
-        output_encoding: str = "utf-8",
-        skip_on_exit_code: int | Container[int] | None = 99,
-        cwd: str | None = None,
-        output_processor: Callable[[str], Any] = lambda result: result,
-        **kwargs,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.bash_command = bash_command
-        self.env = env
-        self.output_encoding = output_encoding
-        self.skip_on_exit_code = (
-            skip_on_exit_code
-            if isinstance(skip_on_exit_code, Container)
-            else [skip_on_exit_code]
-            if skip_on_exit_code is not None
-            else []
-        )
-        self.cwd = cwd
-        self.append_env = append_env
-        self.output_processor = output_processor
-
-        # When using the @task.bash decorator, the Bash command is not known until the underlying Python
-        # callable is executed and therefore set to NOTSET initially. This flag is useful during execution to
-        # determine whether the bash_command value needs to re-rendered.
-        self._init_bash_command_not_set = isinstance(self.bash_command, ArgNotSet)
-
-        # Keep a copy of the original bash_command, without the Jinja template rendered.
-        # This is later used to determine if the bash_command is a script or an inline string command.
-        # We do this later, because the bash_command is not available in __init__ when using @task.bash.
-        self._unrendered_bash_command: str | ArgNotSet = bash_command
-
-    @cached_property
-    def subprocess_hook(self):
-        """Returns hook for running the bash command."""
-        return SubprocessHook()
-
-    # TODO: This should be replaced with Task SDK API call
-    @staticmethod
-    @provide_session
-    def refresh_bash_command(ti: TaskInstance, session: SASession = NEW_SESSION) -> None:
-        """
-        Rewrite the underlying rendered bash_command value for a task instance in the metadatabase.
-
-        TaskInstance.get_rendered_template_fields() cannot be used because this will retrieve the
-        RenderedTaskInstanceFields from the metadatabase which doesn't have the runtime-evaluated bash_command
-        value.
-
-        :meta private:
-        """
-        from airflow.models.renderedtifields import RenderedTaskInstanceFields
-
-        """Update rendered task instance fields for cases where runtime evaluated, not templated."""
-        # Note: Need lazy import to break the partly loaded class loop
-        from airflow.models.taskinstance import TaskInstance
-
-        # If called via remote API the DAG needs to be re-loaded
-        TaskInstance.ensure_dag(ti, session=session)
-
-        rtif = RenderedTaskInstanceFields(ti)
-        RenderedTaskInstanceFields.write(rtif, session=session)
-        RenderedTaskInstanceFields.delete_old_records(ti.task_id, ti.dag_id, session=session)
-
-    def get_env(self, context) -> dict:
-        """Build the set of environment variables to be exposed for the bash command."""
-        system_env = os.environ.copy()
-        env = self.env
-        if env is None:
-            env = system_env
-        else:
-            if self.append_env:
-                system_env.update(env)
-                env = system_env
-
-        airflow_context_vars = context_to_airflow_vars(context, in_env_var_format=True)
-        self.log.debug(
-            "Exporting env vars: %s",
-            " ".join(f"{k}={v!r}" for k, v in airflow_context_vars.items()),
-        )
-        env.update(airflow_context_vars)
-        return env
-
-    def execute(self, context: Context):
-        bash_path: str = shutil.which("bash") or "bash"
-        if self.cwd is not None:
-            if not os.path.exists(self.cwd):
-                raise AirflowException(f"Can not find the cwd: {self.cwd}")
-            if not os.path.isdir(self.cwd):
-                raise AirflowException(f"The cwd {self.cwd} must be a directory")
-        env = self.get_env(context)
-
-        # Because the bash_command value is evaluated at runtime using the @task.bash decorator, the
-        # RenderedTaskInstanceField data needs to be rewritten and the bash_command value re-rendered -- the
-        # latter because the returned command from the decorated callable could contain a Jinja expression.
-        # Both will ensure the correct Bash command is executed and that the Rendered Template view in the UI
-        # displays the executed command (otherwise it will display as an ArgNotSet type).
-        if self._init_bash_command_not_set:
-            is_inline_command = self._is_inline_command(bash_command=cast(str, self.bash_command))
-            ti = context["ti"]
-            self.refresh_bash_command(ti)
-        else:
-            is_inline_command = self._is_inline_command(bash_command=cast(str, self._unrendered_bash_command))
-
-        if is_inline_command:
-            result = self._run_inline_command(bash_path=bash_path, env=env)
-        else:
-            result = self._run_rendered_script_file(bash_path=bash_path, env=env)
-
-        if result.exit_code in self.skip_on_exit_code:
-            raise AirflowSkipException(f"Bash command returned exit code {result.exit_code}. Skipping.")
-        elif result.exit_code != 0:
-            raise AirflowException(
-                f"Bash command failed. The command returned a non-zero exit code {result.exit_code}."
-            )
-
-        return self.output_processor(result.output)
-
-    def _run_inline_command(self, bash_path: str, env: dict) -> SubprocessResult:
-        """Pass the bash command as string directly in the subprocess."""
-        return self.subprocess_hook.run_command(
-            command=[bash_path, "-c", self.bash_command],
-            env=env,
-            output_encoding=self.output_encoding,
-            cwd=self.cwd,
-        )
-
-    def _run_rendered_script_file(self, bash_path: str, env: dict) -> SubprocessResult:
-        """
-        Save the bash command into a file and execute this file.
-
-        This allows for longer commands, and prevents "Argument list too long error".
-        """
-        with working_directory(cwd=self.cwd) as cwd:
-            with tempfile.NamedTemporaryFile(mode="w", dir=cwd, suffix=".sh") as file:
-                file.write(cast(str, self.bash_command))
-                file.flush()
-
-                bash_script = os.path.basename(file.name)
-                return self.subprocess_hook.run_command(
-                    command=[bash_path, bash_script],
-                    env=env,
-                    output_encoding=self.output_encoding,
-                    cwd=cwd,
-                )
-
-    @classmethod
-    def _is_inline_command(cls, bash_command: str) -> bool:
-        """Return True if the bash command is an inline string. False if it's a bash script file."""
-        return not bash_command.endswith(tuple(cls.template_ext))
-
-    def on_kill(self) -> None:
-        self.subprocess_hook.send_sigterm()

airflow/providers/standard/operators/generic_transfer.py

@@ -1,134 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import TYPE_CHECKING
-
-from airflow.hooks.base import BaseHook
-from airflow.models import BaseOperator
-
-if TYPE_CHECKING:
-    from airflow.utils.context import Context
-
-
-class GenericTransfer(BaseOperator):
-    """
-    Moves data from a connection to another.
-
-    Assuming that they both provide the required methods in their respective hooks.
-    The source hook needs to expose a `get_records` method, and the destination a
-    `insert_rows` method.
-
-    This is meant to be used on small-ish datasets that fit in memory.
-
-    :param sql: SQL query to execute against the source database. (templated)
-    :param destination_table: target table. (templated)
-    :param source_conn_id: source connection. (templated)
-    :param destination_conn_id: destination connection. (templated)
-    :param preoperator: sql statement or list of statements to be
-        executed prior to loading the data. (templated)
-    :param insert_args: extra params for `insert_rows` method.
-    """
-
-    template_fields: Sequence[str] = (
-        "source_conn_id",
-        "destination_conn_id",
-        "sql",
-        "destination_table",
-        "preoperator",
-        "insert_args",
-    )
-    template_ext: Sequence[str] = (
-        ".sql",
-        ".hql",
-    )
-    template_fields_renderers = {"preoperator": "sql"}
-    ui_color = "#b0f07c"
-
-    def __init__(
-        self,
-        *,
-        sql: str,
-        destination_table: str,
-        source_conn_id: str,
-        source_hook_params: dict | None = None,
-        destination_conn_id: str,
-        destination_hook_params: dict | None = None,
-        preoperator: str | list[str] | None = None,
-        insert_args: dict | None = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.sql = sql
-        self.destination_table = destination_table
-        self.source_conn_id = source_conn_id
-        self.source_hook_params = source_hook_params
-        self.destination_conn_id = destination_conn_id
-        self.destination_hook_params = destination_hook_params
-        self.preoperator = preoperator
-        self.insert_args = insert_args or {}
-
-    @classmethod
-    def get_hook(cls, conn_id: str, hook_params: dict | None = None) -> BaseHook:
-        """
-        Return default hook for this connection id.
-
-        :param conn_id: connection id
-        :param hook_params: hook parameters
-        :return: default hook for this connection
-        """
-        connection = BaseHook.get_connection(conn_id)
-        return connection.get_hook(hook_params=hook_params)
-
-    def execute(self, context: Context):
-        source_hook = self.get_hook(conn_id=self.source_conn_id, hook_params=self.source_hook_params)
-        destination_hook = self.get_hook(
-            conn_id=self.destination_conn_id, hook_params=self.destination_hook_params
-        )
-
-        self.log.info("Extracting data from %s", self.source_conn_id)
-        self.log.info("Executing: \n %s", self.sql)
-        get_records = getattr(source_hook, "get_records", None)
-        if not callable(get_records):
-            raise RuntimeError(
-                f"Hook for connection {self.source_conn_id!r} "
-                f"({type(source_hook).__name__}) has no `get_records` method"
-            )
-        else:
-            results = get_records(self.sql)
-
-        if self.preoperator:
-            run = getattr(destination_hook, "run", None)
-            if not callable(run):
-                raise RuntimeError(
-                    f"Hook for connection {self.destination_conn_id!r} "
-                    f"({type(destination_hook).__name__}) has no `run` method"
-                )
-            self.log.info("Running preoperator")
-            self.log.info(self.preoperator)
-            run(self.preoperator)
-
-        insert_rows = getattr(destination_hook, "insert_rows", None)
-        if not callable(insert_rows):
-            raise RuntimeError(
-                f"Hook for connection {self.destination_conn_id!r} "
-                f"({type(destination_hook).__name__}) has no `insert_rows` method"
-            )
-        self.log.info("Inserting rows into %s", self.destination_conn_id)
-        insert_rows(table=self.destination_table, rows=results, **self.insert_args)