apache-airflow-providers-teradata 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

airflow/providers/teradata/__init__.py

@@ -29,7 +29,7 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
     "2.10.0"

airflow/providers/teradata/get_provider_info.py

@@ -45,10 +45,13 @@ def get_provider_info():
                     "airflow.providers.teradata.operators.teradata",
                     "airflow.providers.teradata.operators.teradata_compute_cluster",
                 ],
-            }
+            },
+            {"integration-name": "Bteq", "python-modules": ["airflow.providers.teradata.operators.bteq"]},
         ],
         "hooks": [
-            {"integration-name": "Teradata", "python-modules": ["airflow.providers.teradata.hooks.teradata"]}
+            {"integration-name": "Teradata", "python-modules": ["airflow.providers.teradata.hooks.teradata"]},
+            {"integration-name": "Ttu", "python-modules": ["airflow.providers.teradata.hooks.ttu"]},
+            {"integration-name": "Bteq", "python-modules": ["airflow.providers.teradata.hooks.bteq"]},
         ],
         "transfers": [
             {

airflow/providers/teradata/hooks/bteq.py

@@ -0,0 +1,339 @@
+# 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 socket
+import subprocess
+import tempfile
+from contextlib import contextmanager
+
+from paramiko import SSHException
+
+from airflow.exceptions import AirflowException
+from airflow.providers.ssh.hooks.ssh import SSHHook
+from airflow.providers.teradata.hooks.ttu import TtuHook
+from airflow.providers.teradata.utils.bteq_util import (
+    get_remote_tmp_dir,
+    identify_os,
+    prepare_bteq_command_for_local_execution,
+    prepare_bteq_command_for_remote_execution,
+    transfer_file_sftp,
+    verify_bteq_installed,
+    verify_bteq_installed_remote,
+)
+from airflow.providers.teradata.utils.encryption_utils import (
+    decrypt_remote_file_to_string,
+    generate_encrypted_file_with_openssl,
+    generate_random_password,
+)
+
+
+class BteqHook(TtuHook):
+    """
+    Hook for executing BTEQ (Basic Teradata Query) scripts.
+
+    This hook provides functionality to execute BTEQ scripts either locally or remotely via SSH.
+    It extends the `TtuHook` and integrates with Airflow's SSHHook for remote execution.
+
+    The BTEQ scripts are used to interact with Teradata databases, allowing users to perform
+    operations such as querying, data manipulation, and administrative tasks.
+
+    Features:
+    - Supports both local and remote execution of BTEQ scripts.
+    - Handles connection details, script preparation, and execution.
+    - Provides robust error handling and logging for debugging.
+    - Allows configuration of session parameters like output width and encoding.
+
+    .. seealso::
+        - :ref:`hook API connection <howto/connection:teradata>`
+
+    :param bteq_script: The BTEQ script to be executed. This can be a string containing the BTEQ commands.
+    :param remote_working_dir: Temporary directory location on the remote host (via SSH) where the BTEQ script will be transferred and executed. Defaults to `/tmp` if not specified. This is only applicable when `ssh_conn_id` is provided.
+    :param bteq_script_encoding: Character encoding for the BTEQ script file. Defaults to ASCII if not specified.
+    :param timeout: Timeout (in seconds) for executing the BTEQ command. Default is 600 seconds (10 minutes).
+    :param timeout_rc: Return code to use if the BTEQ execution fails due to a timeout. To allow DAG execution to continue after a timeout, include this value in `bteq_quit_rc`. If not specified, a timeout will raise an exception and stop the DAG.
+    :param bteq_session_encoding: Character encoding for the BTEQ session. Defaults to UTF-8 if not specified.
+    :param bteq_quit_rc: Accepts a single integer, list, or tuple of return codes. Specifies which BTEQ return codes should be treated as successful, allowing subsequent tasks to continue execution.
+    """
+
+    def __init__(self, teradata_conn_id: str, ssh_conn_id: str | None = None, *args, **kwargs):
+        super().__init__(teradata_conn_id, *args, **kwargs)
+        self.ssh_conn_id = ssh_conn_id
+        self.ssh_hook = SSHHook(ssh_conn_id=ssh_conn_id) if ssh_conn_id else None
+
+    def execute_bteq_script(
+        self,
+        bteq_script: str,
+        remote_working_dir: str | None,
+        bteq_script_encoding: str | None,
+        timeout: int,
+        timeout_rc: int | None,
+        bteq_session_encoding: str | None,
+        bteq_quit_rc: int | list[int] | tuple[int, ...] | None,
+        temp_file_read_encoding: str | None,
+    ) -> int | None:
+        """Execute the BTEQ script either in local machine or on remote host based on ssh_conn_id."""
+        # Remote execution
+        if self.ssh_hook:
+            # Write script to local temp file
+            # Encrypt the file locally
+            return self.execute_bteq_script_at_remote(
+                bteq_script,
+                remote_working_dir,
+                bteq_script_encoding,
+                timeout,
+                timeout_rc,
+                bteq_session_encoding,
+                bteq_quit_rc,
+                temp_file_read_encoding,
+            )
+        return self.execute_bteq_script_at_local(
+            bteq_script,
+            bteq_script_encoding,
+            timeout,
+            timeout_rc,
+            bteq_quit_rc,
+            bteq_session_encoding,
+            temp_file_read_encoding,
+        )
+
+    def execute_bteq_script_at_remote(
+        self,
+        bteq_script: str,
+        remote_working_dir: str | None,
+        bteq_script_encoding: str | None,
+        timeout: int,
+        timeout_rc: int | None,
+        bteq_session_encoding: str | None,
+        bteq_quit_rc: int | list[int] | tuple[int, ...] | None,
+        temp_file_read_encoding: str | None,
+    ) -> int | None:
+        with (
+            self.preferred_temp_directory() as tmp_dir,
+        ):
+            file_path = os.path.join(tmp_dir, "bteq_script.txt")
+            with open(file_path, "w", encoding=str(temp_file_read_encoding or "UTF-8")) as f:
+                f.write(bteq_script)
+            return self._transfer_to_and_execute_bteq_on_remote(
+                file_path,
+                remote_working_dir,
+                bteq_script_encoding,
+                timeout,
+                timeout_rc,
+                bteq_quit_rc,
+                bteq_session_encoding,
+                tmp_dir,
+            )
+
+    def _transfer_to_and_execute_bteq_on_remote(
+        self,
+        file_path: str,
+        remote_working_dir: str | None,
+        bteq_script_encoding: str | None,
+        timeout: int,
+        timeout_rc: int | None,
+        bteq_quit_rc: int | list[int] | tuple[int, ...] | None,
+        bteq_session_encoding: str | None,
+        tmp_dir: str,
+    ) -> int | None:
+        encrypted_file_path = None
+        remote_encrypted_path = None
+        try:
+            if self.ssh_hook and self.ssh_hook.get_conn():
+                with self.ssh_hook.get_conn() as ssh_client:
+                    if ssh_client is None:
+                        raise AirflowException("Failed to establish SSH connection. `ssh_client` is None.")
+                    verify_bteq_installed_remote(ssh_client)
+                    password = generate_random_password()  # Encryption/Decryption password
+                    encrypted_file_path = os.path.join(tmp_dir, "bteq_script.enc")
+                    generate_encrypted_file_with_openssl(file_path, password, encrypted_file_path)
+                    if not remote_working_dir:
+                        remote_working_dir = get_remote_tmp_dir(ssh_client)
+                        self.log.debug(
+                            "Transferring encrypted BTEQ script to remote host: %s", remote_working_dir
+                        )
+                    remote_encrypted_path = os.path.join(remote_working_dir or "", "bteq_script.enc")
+                    remote_encrypted_path = remote_encrypted_path.replace("/", "\\")
+
+                    transfer_file_sftp(ssh_client, encrypted_file_path, remote_encrypted_path)
+
+                    bteq_command_str = prepare_bteq_command_for_remote_execution(
+                        timeout=timeout,
+                        bteq_script_encoding=bteq_script_encoding or "",
+                        bteq_session_encoding=bteq_session_encoding or "",
+                        timeout_rc=timeout_rc or -1,
+                    )
+
+                    exit_status, stdout, stderr = decrypt_remote_file_to_string(
+                        ssh_client,
+                        remote_encrypted_path,
+                        password,
+                        bteq_command_str,
+                    )
+
+                    failure_message = None
+                    password = None  # Clear sensitive data
+
+                    if "Failure" in stderr or "Error" in stderr:
+                        failure_message = stderr
+                    # Raising an exception if there is any failure in bteq and also user wants to fail the
+                    # task otherwise just log the error message as warning to not fail the task.
+                    if (
+                        failure_message
+                        and exit_status != 0
+                        and exit_status
+                        not in (
+                            bteq_quit_rc
+                            if isinstance(bteq_quit_rc, (list, tuple))
+                            else [bteq_quit_rc if bteq_quit_rc is not None else 0]
+                        )
+                    ):
+                        raise AirflowException(f"BTEQ task failed with error: {failure_message}")
+                    if failure_message:
+                        self.log.warning(failure_message)
+                    return exit_status
+            else:
+                raise AirflowException("SSH connection is not established. `ssh_hook` is None or invalid.")
+        except (OSError, socket.gaierror):
+            raise AirflowException(
+                "SSH connection timed out. Please check the network or server availability."
+            )
+        except SSHException as e:
+            raise AirflowException(f"An unexpected error occurred during SSH connection: {str(e)}")
+        except AirflowException as e:
+            raise e
+        except Exception as e:
+            raise AirflowException(
+                f"An unexpected error occurred while executing BTEQ script on remote machine: {str(e)}"
+            )
+        finally:
+            # Remove the local script file
+            if encrypted_file_path and os.path.exists(encrypted_file_path):
+                os.remove(encrypted_file_path)
+            # Cleanup: Delete the remote temporary file
+            if remote_encrypted_path:
+                if self.ssh_hook and self.ssh_hook.get_conn():
+                    with self.ssh_hook.get_conn() as ssh_client:
+                        if ssh_client is None:
+                            raise AirflowException(
+                                "Failed to establish SSH connection. `ssh_client` is None."
+                            )
+                        # Detect OS
+                        os_info = identify_os(ssh_client)
+                        if "windows" in os_info:
+                            cleanup_en_command = f'del /f /q "{remote_encrypted_path}"'
+                        else:
+                            cleanup_en_command = f"rm -f '{remote_encrypted_path}'"
+                        self.log.debug("cleaning up remote file: %s", cleanup_en_command)
+                        ssh_client.exec_command(cleanup_en_command)
+
+    def execute_bteq_script_at_local(
+        self,
+        bteq_script: str,
+        bteq_script_encoding: str | None,
+        timeout: int,
+        timeout_rc: int | None,
+        bteq_quit_rc: int | list[int] | tuple[int, ...] | None,
+        bteq_session_encoding: str | None,
+        temp_file_read_encoding: str | None,
+    ) -> int | None:
+        verify_bteq_installed()
+        bteq_command_str = prepare_bteq_command_for_local_execution(
+            self.get_conn(),
+            timeout=timeout,
+            bteq_script_encoding=bteq_script_encoding or "",
+            bteq_session_encoding=bteq_session_encoding or "",
+            timeout_rc=timeout_rc or -1,
+        )
+        process = subprocess.Popen(
+            bteq_command_str,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            shell=True,
+            preexec_fn=os.setsid,
+        )
+        encode_bteq_script = bteq_script.encode(str(temp_file_read_encoding or "UTF-8"))
+        stdout_data, _ = process.communicate(input=encode_bteq_script)
+        try:
+            # https://docs.python.org/3.10/library/subprocess.html#subprocess.Popen.wait  timeout is in seconds
+            process.wait(timeout=timeout + 60)  # Adding 1 minute extra for BTEQ script timeout
+        except subprocess.TimeoutExpired:
+            self.on_kill()
+            raise AirflowException(f"BTEQ command timed out after {timeout} seconds.")
+        conn = self.get_conn()
+        conn["sp"] = process  # For `on_kill` support
+        failure_message = None
+        if stdout_data is None:
+            raise AirflowException("Process stdout is None. Unable to read BTEQ output.")
+        decoded_line = ""
+        for line in stdout_data.splitlines():
+            try:
+                decoded_line = line.decode("UTF-8").strip()
+            except UnicodeDecodeError:
+                self.log.warning("Failed to decode line: %s", line)
+            if "Failure" in decoded_line or "Error" in decoded_line:
+                failure_message = decoded_line
+        # Raising an exception if there is any failure in bteq and also user wants to fail the
+        # task otherwise just log the error message as warning to not fail the task.
+        if (
+            failure_message
+            and process.returncode != 0
+            and process.returncode
+            not in (
+                bteq_quit_rc
+                if isinstance(bteq_quit_rc, (list, tuple))
+                else [bteq_quit_rc if bteq_quit_rc is not None else 0]
+            )
+        ):
+            raise AirflowException(f"BTEQ task failed with error: {failure_message}")
+        if failure_message:
+            self.log.warning(failure_message)
+
+        return process.returncode
+
+    def on_kill(self):
+        """Terminate the subprocess if running."""
+        conn = self.get_conn()
+        process = conn.get("sp")
+        if process:
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.log.warning("Subprocess did not terminate in time. Forcing kill...")
+                process.kill()
+            except Exception as e:
+                self.log.error("Failed to terminate subprocess: %s", str(e))
+
+    def get_airflow_home_dir(self) -> str:
+        """Get the AIRFLOW_HOME directory."""
+        return os.environ.get("AIRFLOW_HOME", "~/airflow")
+
+    @contextmanager
+    def preferred_temp_directory(self, prefix="bteq_"):
+        try:
+            temp_dir = tempfile.gettempdir()
+            if not os.path.isdir(temp_dir) or not os.access(temp_dir, os.W_OK):
+                raise OSError("OS temp dir not usable")
+        except Exception:
+            temp_dir = self.get_airflow_home_dir()
+
+        with tempfile.TemporaryDirectory(dir=temp_dir, prefix=prefix) as tmp:
+            yield tmp

airflow/providers/teradata/hooks/teradata.py

@@ -29,7 +29,10 @@ from teradatasql import TeradataConnection
 from airflow.providers.common.sql.hooks.sql import DbApiHook
 
 if TYPE_CHECKING:
-    from airflow.models.connection import Connection
+    try:
+        from airflow.sdk import Connection
+    except ImportError:
+        from airflow.models.connection import Connection  # type: ignore[assignment]
 
 PARAM_TYPES = {bool, float, int, str}
 
@@ -176,7 +179,7 @@ class TeradataHook(DbApiHook):
 
         if conn.extra_dejson.get("sslmode", False):
             conn_config["sslmode"] = conn.extra_dejson["sslmode"]
-            if "verify" in conn_config["sslmode"]:
+            if "verify" in str(conn_config["sslmode"]):
                 if conn.extra_dejson.get("sslca", False):
                     conn_config["sslca"] = conn.extra_dejson["sslca"]
                 if conn.extra_dejson.get("sslcapath", False):

airflow/providers/teradata/hooks/ttu.py

@@ -0,0 +1,97 @@
+#
+# 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 subprocess
+from abc import ABC
+from typing import Any
+
+from airflow.exceptions import AirflowException
+
+try:
+    from airflow.sdk import BaseHook
+except ImportError:
+    from airflow.hooks.base import BaseHook  # type: ignore[attr-defined,no-redef]
+
+
+class TtuHook(BaseHook, ABC):
+    """
+    Abstract base hook for integrating Teradata Tools and Utilities (TTU) in Airflow.
+
+    This hook provides common connection handling, resource management, and lifecycle
+    support for TTU based operations such as BTEQ, TLOAD, and TPT.
+
+    It should not be used directly. Instead, it must be subclassed by concrete hooks
+    like `BteqHook`, `TloadHook`, or `TddlHook` that implement the actual TTU command logic.
+
+    Core Features:
+    - Establishes a reusable Teradata connection configuration.
+    - Provides context management for safe resource cleanup.
+    - Manages subprocess termination (e.g., for long-running TTU jobs).
+
+    Requirements:
+    - TTU command-line tools must be installed and accessible via PATH.
+    - A valid Airflow connection with Teradata credentials must be configured.
+    """
+
+    def __init__(self, teradata_conn_id: str = "teradata_default", *args, **kwargs) -> None:
+        super().__init__()
+        self.teradata_conn_id = teradata_conn_id
+        self.conn: dict[str, Any] | None = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        if self.conn is not None:
+            self.close_conn()
+
+    def get_conn(self) -> dict[str, Any]:
+        """
+        Set up and return a Teradata connection dictionary.
+
+        This dictionary includes connection credentials and a subprocess placeholder.
+        Ensures connection is created only once per hook instance.
+
+        :return: Dictionary with connection details.
+        """
+        if not self.conn:
+            connection = self.get_connection(self.teradata_conn_id)
+            if not connection.login or not connection.password or not connection.host:
+                raise AirflowException("Missing required connection parameters: login, password, or host.")
+
+            self.conn = dict(
+                login=connection.login,
+                password=connection.password,
+                host=connection.host,
+                database=connection.schema,
+                sp=None,  # Subprocess placeholder
+            )
+        return self.conn
+
+    def close_conn(self):
+        """Terminate any active TTU subprocess and clear the connection."""
+        if self.conn:
+            if self.conn.get("sp") and self.conn["sp"].poll() is None:
+                self.conn["sp"].terminate()
+                try:
+                    self.conn["sp"].wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.log.warning("Subprocess did not terminate in time. Forcing kill...")
+                    self.conn["sp"].kill()
+            self.conn = None

airflow/providers/teradata/operators/bteq.py

@@ -0,0 +1,282 @@
+#
+# 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 typing import TYPE_CHECKING, Literal
+
+from airflow.providers.teradata.utils.bteq_util import (
+    is_valid_encoding,
+    is_valid_file,
+    is_valid_remote_bteq_script_file,
+    prepare_bteq_script_for_local_execution,
+    prepare_bteq_script_for_remote_execution,
+    read_file,
+)
+
+if TYPE_CHECKING:
+    from paramiko import SSHClient
+
+    try:
+        from airflow.sdk.definitions.context import Context
+    except ImportError:
+        from airflow.utils.context import Context
+
+from airflow.providers.ssh.hooks.ssh import SSHHook
+from airflow.providers.teradata.hooks.bteq import BteqHook
+from airflow.providers.teradata.hooks.teradata import TeradataHook
+from airflow.providers.teradata.version_compat import BaseOperator
+
+
+def contains_template(parameter_value):
+    # Check if the parameter contains Jinja templating syntax
+    return "{{" in parameter_value and "}}" in parameter_value
+
+
+class BteqOperator(BaseOperator):
+    """
+    Teradata Operator to execute SQL Statements or BTEQ (Basic Teradata Query) scripts using Teradata BTEQ utility.
+
+    This supports execution of BTEQ scripts either locally or remotely via SSH.
+
+    The BTEQ scripts are used to interact with Teradata databases, allowing users to perform
+    operations such as querying, data manipulation, and administrative tasks.
+
+    Features:
+    - Supports both local and remote execution of BTEQ scripts.
+    - Handles connection details, script preparation, and execution.
+    - Provides robust error handling and logging for debugging.
+    - Allows configuration of session parameters like session and BTEQ I/O encoding.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:BteqOperator`
+
+    :param sql: SQL statement(s) to be executed using BTEQ. (templated)
+    :param file_path: Optional path to an existing SQL or BTEQ script file. If provided, this file will be used instead of the `sql` content. This path represents remote file path when executing remotely via SSH, or local file path when executing locally.
+    :param teradata_conn_id: Reference to a specific Teradata connection.
+    :param ssh_conn_id: Optional SSH connection ID for remote execution. Used only when executing scripts remotely.
+    :param remote_working_dir: Temporary directory location on the remote host (via SSH) where the BTEQ script will be transferred and executed. Defaults to `/tmp` if not specified. This is only applicable when `ssh_conn_id` is provided.
+    :param bteq_session_encoding: Character set encoding for the BTEQ session. Defaults to ASCII if not specified.
+    :param bteq_script_encoding: Character encoding for the BTEQ script file. Defaults to ASCII if not specified.
+    :param bteq_quit_rc: Accepts a single integer, list, or tuple of return codes. Specifies which BTEQ return codes should be treated as successful, allowing subsequent tasks to continue execution.
+    :param timeout: Timeout (in seconds) for executing the BTEQ command. Default is 600 seconds (10 minutes).
+    :param timeout_rc: Return code to use if the BTEQ execution fails due to a timeout. To allow DAG execution to continue after a timeout, include this value in `bteq_quit_rc`. If not specified, a timeout will raise an exception and stop the DAG.
+    """
+
+    template_fields = "sql"
+    ui_color = "#ff976d"
+
+    def __init__(
+        self,
+        *,
+        sql: str | None = None,
+        file_path: str | None = None,
+        teradata_conn_id: str = TeradataHook.default_conn_name,
+        ssh_conn_id: str | None = None,
+        remote_working_dir: str | None = None,
+        bteq_session_encoding: str | None = None,
+        bteq_script_encoding: str | None = None,
+        bteq_quit_rc: int | list[int] | tuple[int, ...] | None = None,
+        timeout: int | Literal[600] = 600,  # Default to 10 minutes
+        timeout_rc: int | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.sql = sql
+        self.file_path = file_path
+        self.teradata_conn_id = teradata_conn_id
+        self.ssh_conn_id = ssh_conn_id
+        self.remote_working_dir = remote_working_dir
+        self.timeout = timeout
+        self.timeout_rc = timeout_rc
+        self.bteq_session_encoding = bteq_session_encoding
+        self.bteq_script_encoding = bteq_script_encoding
+        self.bteq_quit_rc = bteq_quit_rc
+        self._hook: BteqHook | None = None
+        self._ssh_hook: SSHHook | None = None
+        self.temp_file_read_encoding = "UTF-8"
+
+    def execute(self, context: Context) -> int | None:
+        """Execute BTEQ code using the BteqHook."""
+        if not self.sql and not self.file_path:
+            raise ValueError(
+                "BteqOperator requires either the 'sql' or 'file_path' parameter. Both are missing."
+            )
+        self._hook = BteqHook(teradata_conn_id=self.teradata_conn_id, ssh_conn_id=self.ssh_conn_id)
+        self._ssh_hook = SSHHook(ssh_conn_id=self.ssh_conn_id) if self.ssh_conn_id else None
+
+        # Validate and set BTEQ session and script encoding
+        if not self.bteq_session_encoding or self.bteq_session_encoding == "ASCII":
+            self.bteq_session_encoding = ""
+            if self.bteq_script_encoding == "UTF8":
+                self.temp_file_read_encoding = "UTF-8"
+            elif self.bteq_script_encoding == "UTF16":
+                self.temp_file_read_encoding = "UTF-16"
+            self.bteq_script_encoding = ""
+        elif self.bteq_session_encoding == "UTF8" and (
+            not self.bteq_script_encoding or self.bteq_script_encoding == "ASCII"
+        ):
+            self.bteq_script_encoding = "UTF8"
+        elif self.bteq_session_encoding == "UTF16":
+            if not self.bteq_script_encoding or self.bteq_script_encoding == "ASCII":
+                self.bteq_script_encoding = "UTF8"
+        # for file reading in python. Mapping BTEQ encoding to Python encoding
+        if self.bteq_script_encoding == "UTF8":
+            self.temp_file_read_encoding = "UTF-8"
+        elif self.bteq_script_encoding == "UTF16":
+            self.temp_file_read_encoding = "UTF-16"
+
+        # Handling execution on local:
+        if not self._ssh_hook:
+            if self.sql:
+                bteq_script = prepare_bteq_script_for_local_execution(
+                    sql=self.sql,
+                )
+                return self._hook.execute_bteq_script(
+                    bteq_script,
+                    self.remote_working_dir,
+                    self.bteq_script_encoding,
+                    self.timeout,
+                    self.timeout_rc,
+                    self.bteq_session_encoding,
+                    self.bteq_quit_rc,
+                    self.temp_file_read_encoding,
+                )
+            if self.file_path:
+                if not is_valid_file(self.file_path):
+                    raise ValueError(
+                        f"The provided file path '{self.file_path}' is invalid or does not exist."
+                    )
+                try:
+                    is_valid_encoding(self.file_path, self.temp_file_read_encoding or "UTF-8")
+                except UnicodeDecodeError as e:
+                    errmsg = f"The provided file '{self.file_path}' encoding is different from BTEQ I/O encoding i.e.'UTF-8'."
+                    if self.bteq_script_encoding:
+                        errmsg = f"The provided file '{self.file_path}' encoding is different from the specified BTEQ I/O encoding '{self.bteq_script_encoding}'."
+                    raise ValueError(errmsg) from e
+                return self._handle_local_bteq_file(
+                    file_path=self.file_path,
+                    context=context,
+                )
+        # Execution on Remote machine
+        elif self._ssh_hook:
+            # When sql statement is provided as input through sql parameter, Preparing the bteq script
+            if self.sql:
+                bteq_script = prepare_bteq_script_for_remote_execution(
+                    conn=self._hook.get_conn(),
+                    sql=self.sql,
+                )
+                return self._hook.execute_bteq_script(
+                    bteq_script,
+                    self.remote_working_dir,
+                    self.bteq_script_encoding,
+                    self.timeout,
+                    self.timeout_rc,
+                    self.bteq_session_encoding,
+                    self.bteq_quit_rc,
+                    self.temp_file_read_encoding,
+                )
+            if self.file_path:
+                with self._ssh_hook.get_conn() as ssh_client:
+                    # When .sql or .bteq remote file path is provided as input through file_path parameter, executing on remote machine
+                    if self.file_path and is_valid_remote_bteq_script_file(ssh_client, self.file_path):
+                        return self._handle_remote_bteq_file(
+                            ssh_client=self._ssh_hook.get_conn(),
+                            file_path=self.file_path,
+                            context=context,
+                        )
+                    raise ValueError(
+                        f"The provided remote file path '{self.file_path}' is invalid or file does not exist on remote machine at given path."
+                    )
+            else:
+                raise ValueError(
+                    "BteqOperator requires either the 'sql' or 'file_path' parameter. Both are missing."
+                )
+        return None
+
+    def _handle_remote_bteq_file(
+        self,
+        ssh_client: SSHClient,
+        file_path: str | None,
+        context: Context,
+    ) -> int | None:
+        if file_path:
+            with ssh_client:
+                sftp = ssh_client.open_sftp()
+                try:
+                    with sftp.open(file_path, "r") as remote_file:
+                        original_content = remote_file.read().decode(self.temp_file_read_encoding or "UTF-8")
+                finally:
+                    sftp.close()
+                rendered_content = original_content
+                if contains_template(original_content):
+                    rendered_content = self.render_template(original_content, context)
+                if self._hook:
+                    bteq_script = prepare_bteq_script_for_remote_execution(
+                        conn=self._hook.get_conn(),
+                        sql=rendered_content,
+                    )
+                    return self._hook.execute_bteq_script_at_remote(
+                        bteq_script,
+                        self.remote_working_dir,
+                        self.bteq_script_encoding,
+                        self.timeout,
+                        self.timeout_rc,
+                        self.bteq_session_encoding,
+                        self.bteq_quit_rc,
+                        self.temp_file_read_encoding,
+                    )
+            return None
+        raise ValueError(
+            "Please provide a valid file path for the BTEQ script to be executed on the remote machine."
+        )
+
+    def _handle_local_bteq_file(
+        self,
+        file_path: str,
+        context: Context,
+    ) -> int | None:
+        if file_path and is_valid_file(file_path):
+            file_content = read_file(file_path, encoding=str(self.temp_file_read_encoding or "UTF-8"))
+            # Manually render using operator's context
+            rendered_content = file_content
+            if contains_template(file_content):
+                rendered_content = self.render_template(file_content, context)
+            bteq_script = prepare_bteq_script_for_local_execution(
+                sql=rendered_content,
+            )
+            if self._hook:
+                result = self._hook.execute_bteq_script(
+                    bteq_script,
+                    self.remote_working_dir,
+                    self.bteq_script_encoding,
+                    self.timeout,
+                    self.timeout_rc,
+                    self.bteq_session_encoding,
+                    self.bteq_quit_rc,
+                    self.temp_file_read_encoding,
+                )
+                return result
+        return None
+
+    def on_kill(self) -> None:
+        """Handle task termination by invoking the on_kill method of BteqHook."""
+        if self._hook:
+            self._hook.on_kill()
+        else:
+            self.log.warning("BteqHook was not initialized. Nothing to terminate.")

airflow/providers/teradata/operators/teradata.py

@@ -20,9 +20,9 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, ClassVar
 
-from airflow.models import BaseOperator
 from airflow.providers.common.sql.operators.sql import SQLExecuteQueryOperator
 from airflow.providers.teradata.hooks.teradata import TeradataHook
+from airflow.providers.teradata.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     try:

airflow/providers/teradata/operators/teradata_compute_cluster.py

@@ -23,9 +23,9 @@ from enum import Enum
 from functools import cached_property
 from typing import TYPE_CHECKING
 
-from airflow.models import BaseOperator
 from airflow.providers.teradata.hooks.teradata import TeradataHook
 from airflow.providers.teradata.utils.constants import Constants
+from airflow.providers.teradata.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     try:

airflow/providers/teradata/transfers/azure_blob_to_teradata.py

@@ -21,8 +21,6 @@ from collections.abc import Sequence
 from textwrap import dedent
 from typing import TYPE_CHECKING
 
-from airflow.models import BaseOperator
-
 try:
     from airflow.providers.microsoft.azure.hooks.wasb import WasbHook
 except ModuleNotFoundError as e:
@@ -31,6 +29,7 @@ except ModuleNotFoundError as e:
     raise AirflowOptionalProviderFeatureException(e)
 
 from airflow.providers.teradata.hooks.teradata import TeradataHook
+from airflow.providers.teradata.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context

airflow/providers/teradata/transfers/s3_to_teradata.py

@@ -21,8 +21,6 @@ from collections.abc import Sequence
 from textwrap import dedent
 from typing import TYPE_CHECKING
 
-from airflow.models import BaseOperator
-
 try:
     from airflow.providers.amazon.aws.hooks.s3 import S3Hook
 except ModuleNotFoundError as e:
@@ -30,6 +28,7 @@ except ModuleNotFoundError as e:
 
     raise AirflowOptionalProviderFeatureException(e)
 from airflow.providers.teradata.hooks.teradata import TeradataHook
+from airflow.providers.teradata.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     try:

airflow/providers/teradata/transfers/teradata_to_teradata.py

@@ -21,8 +21,8 @@ from collections.abc import Sequence
 from functools import cached_property
 from typing import TYPE_CHECKING
 
-from airflow.models import BaseOperator
 from airflow.providers.teradata.hooks.teradata import TeradataHook
+from airflow.providers.teradata.version_compat import BaseOperator
 
 if TYPE_CHECKING:
     try:

airflow/providers/teradata/utils/bteq_util.py

@@ -0,0 +1,217 @@
+#
+# 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 stat
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from paramiko import SSHClient
+
+from airflow.exceptions import AirflowException
+
+
+def identify_os(ssh_client: SSHClient) -> str:
+    stdin, stdout, stderr = ssh_client.exec_command("uname || ver")
+    return stdout.read().decode().lower()
+
+
+def verify_bteq_installed():
+    """Verify if BTEQ is installed and available in the system's PATH."""
+    if shutil.which("bteq") is None:
+        raise AirflowException("BTEQ is not installed or not available in the system's PATH.")
+
+
+def verify_bteq_installed_remote(ssh_client: SSHClient):
+    """Verify if BTEQ is installed on the remote machine."""
+    # Detect OS
+    os_info = identify_os(ssh_client)
+
+    if "windows" in os_info:
+        check_cmd = "where bteq"
+    elif "darwin" in os_info:
+        # Check if zsh exists first
+        stdin, stdout, stderr = ssh_client.exec_command("command -v zsh")
+        zsh_path = stdout.read().strip()
+        if zsh_path:
+            check_cmd = 'zsh -l -c "which bteq"'
+        else:
+            check_cmd = "which bteq"
+    else:
+        check_cmd = "which bteq"
+
+    stdin, stdout, stderr = ssh_client.exec_command(check_cmd)
+    exit_status = stdout.channel.recv_exit_status()
+    output = stdout.read().strip()
+    error = stderr.read().strip()
+
+    if exit_status != 0 or not output:
+        raise AirflowException(
+            f"BTEQ is not installed or not available in PATH. stderr: {error.decode() if error else 'N/A'}"
+        )
+
+
+def transfer_file_sftp(ssh_client, local_path, remote_path):
+    sftp = ssh_client.open_sftp()
+    sftp.put(local_path, remote_path)
+    sftp.close()
+
+
+def get_remote_tmp_dir(ssh_client):
+    os_info = identify_os(ssh_client)
+
+    if "windows" in os_info:
+        # Try getting Windows temp dir
+        stdin, stdout, stderr = ssh_client.exec_command("echo %TEMP%")
+        tmp_dir = stdout.read().decode().strip()
+        if not tmp_dir:
+            tmp_dir = "C:\\Temp"
+    else:
+        tmp_dir = "/tmp"
+    return tmp_dir
+
+
+# We can not pass host details with bteq command when executing on remote machine. Instead, we will prepare .logon in bteq script itself to avoid risk of
+# exposing sensitive information
+def prepare_bteq_script_for_remote_execution(conn: dict[str, Any], sql: str) -> str:
+    """Build a BTEQ script with necessary connection and session commands."""
+    script_lines = []
+    host = conn["host"]
+    login = conn["login"]
+    password = conn["password"]
+    script_lines.append(f" .LOGON {host}/{login},{password}")
+    return _prepare_bteq_script(script_lines, sql)
+
+
+def prepare_bteq_script_for_local_execution(
+    sql: str,
+) -> str:
+    """Build a BTEQ script with necessary connection and session commands."""
+    script_lines: list[str] = []
+    return _prepare_bteq_script(script_lines, sql)
+
+
+def _prepare_bteq_script(script_lines: list[str], sql: str) -> str:
+    script_lines.append(sql.strip())
+    script_lines.append(".EXIT")
+    return "\n".join(script_lines)
+
+
+def _prepare_bteq_command(
+    timeout: int,
+    bteq_script_encoding: str,
+    bteq_session_encoding: str,
+    timeout_rc: int,
+) -> list[str]:
+    bteq_core_cmd = ["bteq"]
+    if bteq_session_encoding:
+        bteq_core_cmd.append(f" -e {bteq_script_encoding}")
+        bteq_core_cmd.append(f" -c {bteq_session_encoding}")
+    bteq_core_cmd.append('"')
+    bteq_core_cmd.append(f".SET EXITONDELAY ON MAXREQTIME {timeout}")
+    if timeout_rc is not None and timeout_rc >= 0:
+        bteq_core_cmd.append(f" RC {timeout_rc}")
+    bteq_core_cmd.append(";")
+    # Airflow doesn't display the script of BTEQ in UI but only in log so WIDTH is 500 enough
+    bteq_core_cmd.append(" .SET WIDTH 500;")
+    return bteq_core_cmd
+
+
+def prepare_bteq_command_for_remote_execution(
+    timeout: int,
+    bteq_script_encoding: str,
+    bteq_session_encoding: str,
+    timeout_rc: int,
+) -> str:
+    """Prepare the BTEQ command with necessary parameters."""
+    bteq_core_cmd = _prepare_bteq_command(timeout, bteq_script_encoding, bteq_session_encoding, timeout_rc)
+    bteq_core_cmd.append('"')
+    return " ".join(bteq_core_cmd)
+
+
+def prepare_bteq_command_for_local_execution(
+    conn: dict[str, Any],
+    timeout: int,
+    bteq_script_encoding: str,
+    bteq_session_encoding: str,
+    timeout_rc: int,
+) -> str:
+    """Prepare the BTEQ command with necessary parameters."""
+    bteq_core_cmd = _prepare_bteq_command(timeout, bteq_script_encoding, bteq_session_encoding, timeout_rc)
+    host = conn["host"]
+    login = conn["login"]
+    password = conn["password"]
+    bteq_core_cmd.append(f" .LOGON {host}/{login},{password}")
+    bteq_core_cmd.append('"')
+    bteq_command_str = " ".join(bteq_core_cmd)
+    return bteq_command_str
+
+
+def is_valid_file(file_path: str) -> bool:
+    return os.path.isfile(file_path)
+
+
+def is_valid_encoding(file_path: str, encoding: str = "UTF-8") -> bool:
+    """
+    Check if the file can be read with the specified encoding.
+
+    :param file_path: Path to the file to be checked.
+    :param encoding: Encoding to use for reading the file.
+    :return: True if the file can be read with the specified encoding, False otherwise.
+    """
+    with open(file_path, encoding=encoding) as f:
+        f.read()
+        return True
+
+
+def read_file(file_path: str, encoding: str = "UTF-8") -> str:
+    """
+    Read the content of a file with the specified encoding.
+
+    :param file_path: Path to the file to be read.
+    :param encoding: Encoding to use for reading the file.
+    :return: Content of the file as a string.
+    """
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"The file {file_path} does not exist.")
+
+    with open(file_path, encoding=encoding) as f:
+        return f.read()
+
+
+def is_valid_remote_bteq_script_file(ssh_client: SSHClient, remote_file_path: str, logger=None) -> bool:
+    """Check if the given remote file path is a valid BTEQ script file."""
+    if remote_file_path:
+        sftp_client = ssh_client.open_sftp()
+        try:
+            # Get file metadata
+            file_stat = sftp_client.stat(remote_file_path)
+            if file_stat.st_mode:
+                is_regular_file = stat.S_ISREG(file_stat.st_mode)
+                return is_regular_file
+            return False
+        except FileNotFoundError:
+            if logger:
+                logger.error("File does not exist on remote at : %s", remote_file_path)
+            return False
+        finally:
+            sftp_client.close()
+    else:
+        return False

airflow/providers/teradata/utils/encryption_utils.py

@@ -0,0 +1,75 @@
+#
+# 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 secrets
+import string
+import subprocess
+
+
+def generate_random_password(length=12):
+    # Define the character set: letters, digits, and special characters
+    characters = string.ascii_letters + string.digits + string.punctuation
+    # Generate a random password
+    password = "".join(secrets.choice(characters) for _ in range(length))
+    return password
+
+
+def generate_encrypted_file_with_openssl(file_path: str, password: str, out_file: str):
+    # Write plaintext temporarily to file
+
+    # Run openssl enc with AES-256-CBC, pbkdf2, salt
+    cmd = [
+        "openssl",
+        "enc",
+        "-aes-256-cbc",
+        "-salt",
+        "-pbkdf2",
+        "-pass",
+        f"pass:{password}",
+        "-in",
+        file_path,
+        "-out",
+        out_file,
+    ]
+    subprocess.run(cmd, check=True)
+
+
+def decrypt_remote_file_to_string(ssh_client, remote_enc_file, password, bteq_command_str):
+    # Run openssl decrypt command on remote machine
+    quoted_password = shell_quote_single(password)
+
+    decrypt_cmd = (
+        f"openssl enc -d -aes-256-cbc -salt -pbkdf2 -pass pass:{quoted_password} -in {remote_enc_file} | "
+        + bteq_command_str
+    )
+    # Clear password to prevent lingering sensitive data
+    password = None
+    quoted_password = None
+    stdin, stdout, stderr = ssh_client.exec_command(decrypt_cmd)
+    # Wait for command to finish
+    exit_status = stdout.channel.recv_exit_status()
+    output = stdout.read().decode()
+    err = stderr.read().decode()
+    return exit_status, output, err
+
+
+def shell_quote_single(s):
+    # Escape single quotes in s, then wrap in single quotes
+    # In shell, to include a single quote inside single quotes, close, add '\'' and reopen
+    return "'" + s.replace("'", "'\\''") + "'"

airflow/providers/teradata/version_compat.py

@@ -0,0 +1,42 @@
+# 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.
+#
+# NOTE! THIS FILE IS COPIED MANUALLY IN OTHER PROVIDERS DELIBERATELY TO AVOID ADDING UNNECESSARY
+# DEPENDENCIES BETWEEN PROVIDERS. IF YOU WANT TO ADD CONDITIONAL CODE IN YOUR PROVIDER THAT DEPENDS
+# ON AIRFLOW VERSION, PLEASE COPY THIS FILE TO THE ROOT PACKAGE OF YOUR PROVIDER AND IMPORT
+# THOSE CONSTANTS FROM IT RATHER THAN IMPORTING THEM FROM ANOTHER PROVIDER OR TEST CODE
+#
+from __future__ import annotations
+
+
+def get_base_airflow_version_tuple() -> tuple[int, int, int]:
+    from packaging.version import Version
+
+    from airflow import __version__
+
+    airflow_version = Version(__version__)
+    return airflow_version.major, airflow_version.minor, airflow_version.micro
+
+
+AIRFLOW_V_3_0_PLUS = get_base_airflow_version_tuple() >= (3, 0, 0)
+
+if AIRFLOW_V_3_0_PLUS:
+    from airflow.sdk import BaseOperator
+else:
+    from airflow.models import BaseOperator  # type: ignore[no-redef]
+
+__all__ = ["AIRFLOW_V_3_0_PLUS", "BaseOperator"]

{apache_airflow_providers_teradata-3.1.0.dist-info → apache_airflow_providers_teradata-3.2.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-teradata
-Version: 3.1.0
+Version: 3.2.0
 Summary: Provider package apache-airflow-providers-teradata for Apache Airflow
 Keywords: airflow-provider,teradata,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
 Maintainer-email: Apache Software Foundation <dev@airflow.apache.org>
-Requires-Python: ~=3.9
+Requires-Python: ~=3.10
 Description-Content-Type: text/x-rst
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
@@ -15,7 +15,6 @@ Classifier: Intended Audience :: System Administrators
 Classifier: Framework :: Apache Airflow
 Classifier: Framework :: Apache Airflow :: Provider
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -26,15 +25,17 @@ Requires-Dist: teradatasqlalchemy>=17.20.0.0
 Requires-Dist: teradatasql>=17.20.0.28
 Requires-Dist: apache-airflow-providers-amazon ; extra == "amazon"
 Requires-Dist: apache-airflow-providers-microsoft-azure ; extra == "microsoft-azure"
+Requires-Dist: apache-airflow-providers-ssh ; extra == "ssh"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.1.0/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.1.0
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.2.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.2.0
 Project-URL: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
 Project-URL: YouTube, https://www.youtube.com/channel/UCSXwxpWZQ7XZ1WL3wqevChA/
 Provides-Extra: amazon
 Provides-Extra: microsoft-azure
+Provides-Extra: ssh
 
 
 .. Licensed to the Apache Software Foundation (ASF) under one
@@ -61,7 +62,7 @@ Provides-Extra: microsoft-azure
 
 Package ``apache-airflow-providers-teradata``
 
-Release: ``3.1.0``
+Release: ``3.2.0``
 
 
 `Teradata <https://www.teradata.com/>`__
@@ -74,7 +75,7 @@ This is a provider package for ``teradata`` provider. All classes for this provi
 are in ``airflow.providers.teradata`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.1.0/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.2.0/>`_.
 
 Installation
 ------------
@@ -83,7 +84,7 @@ You can install this package on top of an existing Airflow 2 installation (see `
 for the minimum Airflow version supported) via
 ``pip install apache-airflow-providers-teradata``
 
-The package supports the following python versions: 3.9,3.10,3.11,3.12
+The package supports the following python versions: 3.10,3.11,3.12
 
 Requirements
 ------------
@@ -116,8 +117,9 @@ Dependent package
 `apache-airflow-providers-amazon <https://airflow.apache.org/docs/apache-airflow-providers-amazon>`_                    ``amazon``
 `apache-airflow-providers-common-sql <https://airflow.apache.org/docs/apache-airflow-providers-common-sql>`_            ``common.sql``
 `apache-airflow-providers-microsoft-azure <https://airflow.apache.org/docs/apache-airflow-providers-microsoft-azure>`_  ``microsoft.azure``
+`apache-airflow-providers-ssh <https://airflow.apache.org/docs/apache-airflow-providers-ssh>`_                          ``ssh``
 ======================================================================================================================  ===================
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.1.0/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-teradata/3.2.0/changelog.html>`_.
 

apache_airflow_providers_teradata-3.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+airflow/providers/teradata/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
+airflow/providers/teradata/__init__.py,sha256=gsGQuyJbj0NqeMWHeK5du0fxg7L5EMOEvWtYIT8oW7w,1497
+airflow/providers/teradata/get_provider_info.py,sha256=SF-3YIl3CCi6mN6b9EEqLkJNyuMIM35CvY_H91QdELw,4031
+airflow/providers/teradata/version_compat.py,sha256=0VNFig0J24YH-32j11aTLlLRXdnHCmQHrNYkBXbOjx4,1727
+airflow/providers/teradata/hooks/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
+airflow/providers/teradata/hooks/bteq.py,sha256=9N9z2NbouKbwYiikCbMkVAobvgpRvHgN4uzChQ5c8GU,15067
+airflow/providers/teradata/hooks/teradata.py,sha256=fOt3ZriM-rB27d-7RWhoEBZJyZcNkHowrSh4hqiNNi8,10964
+airflow/providers/teradata/hooks/ttu.py,sha256=6editw7RKhLC8RBLmeZ4r4ILhrib1tOjytLJykPec5g,3778
+airflow/providers/teradata/operators/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
+airflow/providers/teradata/operators/bteq.py,sha256=w7CysOA1ioVvTLhPsj_g3paCM8YH0Yh-wUJLKRJsLZk,13223
+airflow/providers/teradata/operators/teradata.py,sha256=G8Vgu2g-lyX7lisdEZOafIFJEx-eeeM9bgNI4fDKnq0,3873
+airflow/providers/teradata/operators/teradata_compute_cluster.py,sha256=asnuih4an1AuKa2rBfyOuDDhfENx3sjvQe5LsfObvI0,21961
+airflow/providers/teradata/transfers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/teradata/transfers/azure_blob_to_teradata.py,sha256=XnMsQSLS-kQP7aBRer3bLro8qgNohcJ3H63c2YIjYMA,5678
+airflow/providers/teradata/transfers/s3_to_teradata.py,sha256=-YskshSjx-qVniuSIHIQc4qJmfpxvhqiiy2zvXDzewk,5700
+airflow/providers/teradata/transfers/teradata_to_teradata.py,sha256=J6ibOly6vjzS4Vwf0oLOL5pILCoyI8q9wDwpVP9efV4,4045
+airflow/providers/teradata/triggers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/teradata/triggers/teradata_compute_cluster.py,sha256=hjMTnOpqlbByTtmNdJ9usK7hilEAz4tFXpJoENgFhyo,6987
+airflow/providers/teradata/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/teradata/utils/bteq_util.py,sha256=GCIPc1PCIOC-YWwxgYHr-N1d7X8ZGPU5Lmax_JZY6rA,7360
+airflow/providers/teradata/utils/constants.py,sha256=ro1FVNsAakal8_uX27aN0DTVO0T9FG4fv9HzBIY2I-w,2253
+airflow/providers/teradata/utils/encryption_utils.py,sha256=ARGWmgBbvSq6_MQHfTevvfvHjaiBjQI62UXltDcJLJo,2578
+apache_airflow_providers_teradata-3.2.0.dist-info/entry_points.txt,sha256=JbigXoUoKVSNWG-_-029FCCuehMOmAvuSnNGZ9Bz1Kc,104
+apache_airflow_providers_teradata-3.2.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+apache_airflow_providers_teradata-3.2.0.dist-info/METADATA,sha256=_zS6wQIQciDGprt9Ncqc3BdcjbnFKCebs6Q0He6kDK0,5941
+apache_airflow_providers_teradata-3.2.0.dist-info/RECORD,,

apache_airflow_providers_teradata-3.1.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-airflow/providers/teradata/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/teradata/__init__.py,sha256=paySx53D2F3C5LDr55f32gk1eHLAD8p6o3d2pk6QbhE,1497
-airflow/providers/teradata/get_provider_info.py,sha256=lkm3HMP6Yq8hPF0BeAD9uIA2IgJovTMFDR9NPT8pHyU,3718
-airflow/providers/teradata/hooks/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/teradata/hooks/teradata.py,sha256=v7jCwOTBlAMtnR5cAakkNn0WSYGELcEACmV8I7yxTW0,10851
-airflow/providers/teradata/operators/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/teradata/operators/teradata.py,sha256=chuojW__qKu2RdWQpKSF3QN0rbTWB9TsAece8cKj0AU,3846
-airflow/providers/teradata/operators/teradata_compute_cluster.py,sha256=4c_EGQYcwuuXO62u_rwmyyXJ9Ph2rjYPCdjhV_lxJMk,21934
-airflow/providers/teradata/transfers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/teradata/transfers/azure_blob_to_teradata.py,sha256=Kcm97lJXAkNSdQf9u3yYY9iq9JtjB_Sr96nHqJBLNlQ,5652
-airflow/providers/teradata/transfers/s3_to_teradata.py,sha256=kWqTg9Z2Sl16BWdJWO3OXrnZveVBrj5byVuZtggfBbY,5674
-airflow/providers/teradata/transfers/teradata_to_teradata.py,sha256=z3sNPxZB012VZeUcLC16EwkpIUeENu3isw7bzwlb_r8,4018
-airflow/providers/teradata/triggers/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/teradata/triggers/teradata_compute_cluster.py,sha256=hjMTnOpqlbByTtmNdJ9usK7hilEAz4tFXpJoENgFhyo,6987
-airflow/providers/teradata/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/teradata/utils/constants.py,sha256=ro1FVNsAakal8_uX27aN0DTVO0T9FG4fv9HzBIY2I-w,2253
-apache_airflow_providers_teradata-3.1.0.dist-info/entry_points.txt,sha256=JbigXoUoKVSNWG-_-029FCCuehMOmAvuSnNGZ9Bz1Kc,104
-apache_airflow_providers_teradata-3.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-apache_airflow_providers_teradata-3.1.0.dist-info/METADATA,sha256=yD-eyr7NzWehwij37hkKtLXs7ODb45uqlpQ0D09BY2w,5785
-apache_airflow_providers_teradata-3.1.0.dist-info/RECORD,,