apache-airflow-providers-databricks 7.2.2rc1__py3-none-any.whl → 7.3.0__py3-none-any.whl

airflow/providers/databricks/__init__.py

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

airflow/providers/databricks/get_provider_info.py

@@ -27,8 +27,9 @@ def get_provider_info():
         "name": "Databricks",
         "description": "`Databricks <https://databricks.com/>`__\n",
         "state": "ready",
-        "source-date-epoch": 1742979996,
+        "source-date-epoch": 1743835987,
         "versions": [
+            "7.3.0",
             "7.2.2",
             "7.2.1",
             "7.2.0",
@@ -181,7 +182,7 @@ def get_provider_info():
         "dependencies": [
             "apache-airflow>=2.9.0",
             "apache-airflow-providers-common-sql>=1.20.0",
-            "requests>=2.27.0,<3",
+            "requests>=2.31.0,<3",
             "databricks-sql-connector>=3.0.0",
             "aiohttp>=3.9.2, <4",
             "mergedeep>=1.3.4",

airflow/providers/databricks/hooks/databricks.py

@@ -63,6 +63,7 @@ LIST_PIPELINES_ENDPOINT = ("GET", "api/2.0/pipelines")
 WORKSPACE_GET_STATUS_ENDPOINT = ("GET", "api/2.0/workspace/get-status")
 
 SPARK_VERSIONS_ENDPOINT = ("GET", "api/2.0/clusters/spark-versions")
+SQL_STATEMENTS_ENDPOINT = "api/2.0/sql/statements"
 
 
 class RunLifeCycleState(Enum):
@@ -189,6 +190,67 @@ class ClusterState:
         return ClusterState(**json.loads(data))
 
 
+class SQLStatementState:
+    """Utility class for the SQL statement state concept of Databricks statements."""
+
+    SQL_STATEMENT_LIFE_CYCLE_STATES = [
+        "PENDING",
+        "RUNNING",
+        "SUCCEEDED",
+        "FAILED",
+        "CANCELED",
+        "CLOSED",
+    ]
+
+    def __init__(
+        self, state: str = "", error_code: str = "", error_message: str = "", *args, **kwargs
+    ) -> None:
+        if state not in self.SQL_STATEMENT_LIFE_CYCLE_STATES:
+            raise AirflowException(
+                f"Unexpected SQL statement life cycle state: {state}: If the state has "
+                "been introduced recently, please check the Databricks user "
+                "guide for troubleshooting information"
+            )
+
+        self.state = state
+        self.error_code = error_code
+        self.error_message = error_message
+
+    @property
+    def is_terminal(self) -> bool:
+        """True if the current state is a terminal state."""
+        return self.state in ("SUCCEEDED", "FAILED", "CANCELED", "CLOSED")
+
+    @property
+    def is_running(self) -> bool:
+        """True if the current state is running."""
+        return self.state in ("PENDING", "RUNNING")
+
+    @property
+    def is_successful(self) -> bool:
+        """True if the state is SUCCEEDED."""
+        return self.state == "SUCCEEDED"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SQLStatementState):
+            return NotImplemented
+        return (
+            self.state == other.state
+            and self.error_code == other.error_code
+            and self.error_message == other.error_message
+        )
+
+    def __repr__(self) -> str:
+        return str(self.__dict__)
+
+    def to_json(self) -> str:
+        return json.dumps(self.__dict__)
+
+    @classmethod
+    def from_json(cls, data: str) -> SQLStatementState:
+        return SQLStatementState(**json.loads(data))
+
+
 class DatabricksHook(BaseDatabricksHook):
     """
     Interact with Databricks.
@@ -709,6 +771,54 @@ class DatabricksHook(BaseDatabricksHook):
         """
         return self._do_api_call(("PATCH", f"api/2.0/permissions/jobs/{job_id}"), json)
 
+    def post_sql_statement(self, json: dict[str, Any]) -> str:
+        """
+        Submit a SQL statement to the Databricks SQL Statements endpoint.
+
+        :param json: The data used in the body of the request to the SQL Statements endpoint.
+        :return: The statement_id as a string.
+        """
+        response = self._do_api_call(("POST", f"{SQL_STATEMENTS_ENDPOINT}"), json)
+        return response["statement_id"]
+
+    def get_sql_statement_state(self, statement_id: str) -> SQLStatementState:
+        """
+        Retrieve run state of the SQL statement.
+
+        :param statement_id: ID of the SQL statement.
+        :return: state of the SQL statement.
+        """
+        get_statement_endpoint = ("GET", f"{SQL_STATEMENTS_ENDPOINT}/{statement_id}")
+        response = self._do_api_call(get_statement_endpoint)
+        state = response["status"]["state"]
+        error_code = response["status"].get("error", {}).get("error_code", "")
+        error_message = response["status"].get("error", {}).get("message", "")
+        return SQLStatementState(state, error_code, error_message)
+
+    async def a_get_sql_statement_state(self, statement_id: str) -> SQLStatementState:
+        """
+        Async version of `get_sql_statement_state`.
+
+        :param statement_id: ID of the SQL statement
+        :return: state of the SQL statement
+        """
+        get_sql_statement_endpoint = ("GET", f"{SQL_STATEMENTS_ENDPOINT}/{statement_id}")
+        response = await self._a_do_api_call(get_sql_statement_endpoint)
+        state = response["status"]["state"]
+        error_code = response["status"].get("error", {}).get("error_code", "")
+        error_message = response["status"].get("error", {}).get("message", "")
+        return SQLStatementState(state, error_code, error_message)
+
+    def cancel_sql_statement(self, statement_id: str) -> None:
+        """
+        Cancel the SQL statement.
+
+        :param statement_id: ID of the SQL statement
+        """
+        self.log.info("Canceling SQL statement with ID: %s", statement_id)
+        cancel_sql_statement_endpoint = ("POST", f"{SQL_STATEMENTS_ENDPOINT}/{statement_id}/cancel")
+        self._do_api_call(cancel_sql_statement_endpoint)
+
     def test_connection(self) -> tuple[bool, str]:
         """Test the Databricks connectivity from UI."""
         hook = DatabricksHook(databricks_conn_id=self.databricks_conn_id)

airflow/providers/databricks/hooks/databricks_sql.py

@@ -35,7 +35,6 @@ from databricks import sql  # type: ignore[attr-defined]
 from databricks.sql.types import Row
 
 from airflow.exceptions import AirflowException
-from airflow.models.connection import Connection as AirflowConnection
 from airflow.providers.common.sql.hooks.sql import DbApiHook, return_single_query_results
 from airflow.providers.databricks.exceptions import DatabricksSqlExecutionError, DatabricksSqlExecutionTimeout
 from airflow.providers.databricks.hooks.databricks_base import BaseDatabricksHook
@@ -43,6 +42,8 @@ from airflow.providers.databricks.hooks.databricks_base import BaseDatabricksHoo
 if TYPE_CHECKING:
     from databricks.sql.client import Connection
 
+    from airflow.models.connection import Connection as AirflowConnection
+
 
 LIST_SQL_ENDPOINTS_ENDPOINT = ("GET", "api/2.0/sql/endpoints")
 
@@ -167,7 +168,7 @@ class DatabricksSqlHook(BaseDatabricksHook, DbApiHook):
 
         if self._sql_conn is None:
             raise AirflowException("SQL connection is not initialized")
-        return cast(AirflowConnection, self._sql_conn)
+        return cast("AirflowConnection", self._sql_conn)
 
     @overload  # type: ignore[override]
     def run(
@@ -295,11 +296,11 @@ class DatabricksSqlHook(BaseDatabricksHook, DbApiHook):
                 return []
             rows_fields = tuple(rows[0].__fields__)
             rows_object = namedtuple("Row", rows_fields, rename=True)  # type: ignore
-            return cast(list[tuple[Any, ...]], [rows_object(*row) for row in rows])
+            return cast("list[tuple[Any, ...]]", [rows_object(*row) for row in rows])
         elif isinstance(result, Row):
             row_fields = tuple(result.__fields__)
             row_object = namedtuple("Row", row_fields, rename=True)  # type: ignore
-            return cast(tuple[Any, ...], row_object(*result))
+            return cast("tuple[Any, ...]", row_object(*result))
         else:
             raise TypeError(f"Expected Sequence[Row] or Row, but got {type(result)}")
 

airflow/providers/databricks/operators/databricks.py

@@ -30,7 +30,12 @@ from typing import TYPE_CHECKING, Any
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException
 from airflow.models import BaseOperator
-from airflow.providers.databricks.hooks.databricks import DatabricksHook, RunLifeCycleState, RunState
+from airflow.providers.databricks.hooks.databricks import (
+    DatabricksHook,
+    RunLifeCycleState,
+    RunState,
+    SQLStatementState,
+)
 from airflow.providers.databricks.operators.databricks_workflow import (
     DatabricksWorkflowTaskGroup,
     WorkflowRunMetadata,
@@ -39,7 +44,10 @@ from airflow.providers.databricks.plugins.databricks_workflow import (
     WorkflowJobRepairSingleTaskLink,
     WorkflowJobRunLink,
 )
-from airflow.providers.databricks.triggers.databricks import DatabricksExecutionTrigger
+from airflow.providers.databricks.triggers.databricks import (
+    DatabricksExecutionTrigger,
+    DatabricksSQLStatementExecutionTrigger,
+)
 from airflow.providers.databricks.utils.databricks import normalise_json_content, validate_trigger_event
 from airflow.providers.databricks.version_compat import AIRFLOW_V_3_0_PLUS
 
@@ -59,6 +67,7 @@ DEFER_METHOD_NAME = "execute_complete"
 XCOM_RUN_ID_KEY = "run_id"
 XCOM_JOB_ID_KEY = "job_id"
 XCOM_RUN_PAGE_URL_KEY = "run_page_url"
+XCOM_STATEMENT_ID_KEY = "statement_id"
 
 
 def _handle_databricks_operator_execution(operator, hook, log, context) -> None:
@@ -969,6 +978,204 @@ class DatabricksRunNowOperator(BaseOperator):
             self.log.error("Error: Task: %s with invalid run_id was requested to be cancelled.", self.task_id)
 
 
+class DatabricksSQLStatementsOperator(BaseOperator):
+    """
+    Submits a Databricks SQL Statement to Databricks using the api/2.0/sql/statements/ API endpoint.
+
+    See: https://docs.databricks.com/api/workspace/statementexecution
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DatabricksSQLStatementsOperator`
+
+    :param statement: The SQL statement to execute. The statement can optionally be parameterized, see parameters.
+    :param warehouse_id: Warehouse upon which to execute a statement.
+    :param catalog: Sets default catalog for statement execution, similar to USE CATALOG in SQL.
+    :param schema: Sets default schema for statement execution, similar to USE SCHEMA in SQL.
+    :param parameters: A list of parameters to pass into a SQL statement containing parameter markers.
+
+        .. seealso::
+            https://docs.databricks.com/api/workspace/statementexecution/executestatement#parameters
+    :param wait_for_termination: if we should wait for termination of the statement execution. ``True`` by default.
+    :param databricks_conn_id: Reference to the :ref:`Databricks connection <howto/connection:databricks>`.
+        By default and in the common case this will be ``databricks_default``. To use
+        token based authentication, provide the key ``token`` in the extra field for the
+        connection and create the key ``host`` and leave the ``host`` field empty. (templated)
+    :param polling_period_seconds: Controls the rate which we poll for the result of
+        this statement. By default the operator will poll every 30 seconds.
+    :param databricks_retry_limit: Amount of times retry if the Databricks backend is
+        unreachable. Its value must be greater than or equal to 1.
+    :param databricks_retry_delay: Number of seconds to wait between retries (it
+            might be a floating point number).
+    :param databricks_retry_args: An optional dictionary with arguments passed to ``tenacity.Retrying`` class.
+    :param do_xcom_push: Whether we should push statement_id to xcom.:
+    :param timeout: The timeout for the Airflow task executing the SQL statement. By default a value of 3600 seconds is used.
+    :param deferrable: Run operator in the deferrable mode.
+    """
+
+    # Used in airflow.models.BaseOperator
+    template_fields: Sequence[str] = ("databricks_conn_id",)
+    template_ext: Sequence[str] = (".json-tpl",)
+    # Databricks brand color (blue) under white text
+    ui_color = "#1CB1C2"
+    ui_fgcolor = "#fff"
+
+    def __init__(
+        self,
+        statement: str,
+        warehouse_id: str,
+        *,
+        catalog: str | None = None,
+        schema: str | None = None,
+        parameters: list[dict[str, Any]] | None = None,
+        databricks_conn_id: str = "databricks_default",
+        polling_period_seconds: int = 30,
+        databricks_retry_limit: int = 3,
+        databricks_retry_delay: int = 1,
+        databricks_retry_args: dict[Any, Any] | None = None,
+        do_xcom_push: bool = True,
+        wait_for_termination: bool = True,
+        timeout: float = 3600,
+        deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
+        **kwargs,
+    ) -> None:
+        """Create a new ``DatabricksSubmitRunOperator``."""
+        super().__init__(**kwargs)
+        self.statement = statement
+        self.warehouse_id = warehouse_id
+        self.catalog = catalog
+        self.schema = schema
+        self.parameters = parameters
+        self.databricks_conn_id = databricks_conn_id
+        self.polling_period_seconds = polling_period_seconds
+        self.databricks_retry_limit = databricks_retry_limit
+        self.databricks_retry_delay = databricks_retry_delay
+        self.databricks_retry_args = databricks_retry_args
+        self.wait_for_termination = wait_for_termination
+        self.deferrable = deferrable
+
+        # This variable will be used in case our task gets killed.
+        self.statement_id: str | None = None
+
+        self.timeout = timeout
+        self.do_xcom_push = do_xcom_push
+
+    @cached_property
+    def _hook(self):
+        return self._get_hook(caller="DatabricksSQLStatementsOperator")
+
+    def _get_hook(self, caller: str) -> DatabricksHook:
+        return DatabricksHook(
+            self.databricks_conn_id,
+            retry_limit=self.databricks_retry_limit,
+            retry_delay=self.databricks_retry_delay,
+            retry_args=self.databricks_retry_args,
+            caller=caller,
+        )
+
+    def _handle_operator_execution(self) -> None:
+        end_time = time.time() + self.timeout
+        while end_time > time.time():
+            statement_state = self._hook.get_sql_statement_state(self.statement_id)
+            if statement_state.is_terminal:
+                if statement_state.is_successful:
+                    self.log.info("%s completed successfully.", self.task_id)
+                    return
+                error_message = (
+                    f"{self.task_id} failed with terminal state: {statement_state.state} "
+                    f"and with the error code {statement_state.error_code} "
+                    f"and error message {statement_state.error_message}"
+                )
+                raise AirflowException(error_message)
+
+            self.log.info("%s in run state: %s", self.task_id, statement_state.state)
+            self.log.info("Sleeping for %s seconds.", self.polling_period_seconds)
+            time.sleep(self.polling_period_seconds)
+
+        self._hook.cancel_sql_statement(self.statement_id)
+        raise AirflowException(
+            f"{self.task_id} timed out after {self.timeout} seconds with state: {statement_state.state}",
+        )
+
+    def _handle_deferrable_operator_execution(self) -> None:
+        statement_state = self._hook.get_sql_statement_state(self.statement_id)
+        end_time = time.time() + self.timeout
+        if not statement_state.is_terminal:
+            if not self.statement_id:
+                raise AirflowException("Failed to retrieve statement_id after submitting SQL statement.")
+            self.defer(
+                trigger=DatabricksSQLStatementExecutionTrigger(
+                    statement_id=self.statement_id,
+                    databricks_conn_id=self.databricks_conn_id,
+                    end_time=end_time,
+                    polling_period_seconds=self.polling_period_seconds,
+                    retry_limit=self.databricks_retry_limit,
+                    retry_delay=self.databricks_retry_delay,
+                    retry_args=self.databricks_retry_args,
+                ),
+                method_name=DEFER_METHOD_NAME,
+            )
+        else:
+            if statement_state.is_successful:
+                self.log.info("%s completed successfully.", self.task_id)
+            else:
+                error_message = (
+                    f"{self.task_id} failed with terminal state: {statement_state.state} "
+                    f"and with the error code {statement_state.error_code} "
+                    f"and error message {statement_state.error_message}"
+                )
+                raise AirflowException(error_message)
+
+    def execute(self, context: Context):
+        json = {
+            "statement": self.statement,
+            "warehouse_id": self.warehouse_id,
+            "catalog": self.catalog,
+            "schema": self.schema,
+            "parameters": self.parameters,
+            # We set the wait timeout to 0s as that seems the appropriate way for our deferrable version
+            # support of the operator. For synchronous version, we still poll on the statement
+            # execution state.
+            "wait_timeout": "0s",
+        }
+        self.statement_id = self._hook.post_sql_statement(json)
+        if self.do_xcom_push and context is not None:
+            context["ti"].xcom_push(key=XCOM_STATEMENT_ID_KEY, value=self.statement_id)
+
+        self.log.info("SQL Statement submitted with statement_id: %s", self.statement_id)
+        if not self.wait_for_termination:
+            return
+        if self.deferrable:
+            self._handle_deferrable_operator_execution()
+        else:
+            self._handle_operator_execution()
+
+    def on_kill(self):
+        if self.statement_id:
+            self._hook.cancel_sql_statement(self.statement_id)
+            self.log.info(
+                "Task: %s with statement ID: %s was requested to be cancelled.",
+                self.task_id,
+                self.statement_id,
+            )
+        else:
+            self.log.error(
+                "Error: Task: %s with invalid statement_id was requested to be cancelled.", self.task_id
+            )
+
+    def execute_complete(self, context: dict | None, event: dict):
+        statement_state = SQLStatementState.from_json(event["state"])
+        error = event["error"]
+        statement_id = event["statement_id"]
+
+        if statement_state.is_successful:
+            self.log.info("SQL Statement with ID %s completed successfully.", statement_id)
+            return
+
+        error_message = f"SQL Statement execution failed with terminal state: {statement_state} and with the error {error}"
+        raise AirflowException(error_message)
+
+
 class DatabricksTaskBaseOperator(BaseOperator, ABC):
     """
     Base class for operators that are run as Databricks job tasks or tasks within a Databricks workflow.

airflow/providers/databricks/triggers/databricks.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from typing import Any
 
 from airflow.providers.databricks.hooks.databricks import DatabricksHook
@@ -119,3 +120,102 @@ class DatabricksExecutionTrigger(BaseTrigger):
                     }
                 )
                 return
+
+
+class DatabricksSQLStatementExecutionTrigger(BaseTrigger):
+    """
+    The trigger handles the logic of async communication with DataBricks SQL Statements API.
+
+    :param statement_id: ID of the SQL statement.
+    :param databricks_conn_id: Reference to the :ref:`Databricks connection <howto/connection:databricks>`.
+    :param end_time: The end time (set based on timeout supplied for the operator) for the SQL statement execution.
+    :param polling_period_seconds: Controls the rate of the poll for the result of this run.
+        By default, the trigger will poll every 30 seconds.
+    :param retry_limit: The number of times to retry the connection in case of service outages.
+    :param retry_delay: The number of seconds to wait between retries.
+    :param retry_args: An optional dictionary with arguments passed to ``tenacity.Retrying`` class.
+    """
+
+    def __init__(
+        self,
+        statement_id: str,
+        databricks_conn_id: str,
+        end_time: float,
+        polling_period_seconds: int = 30,
+        retry_limit: int = 3,
+        retry_delay: int = 10,
+        retry_args: dict[Any, Any] | None = None,
+        caller: str = "DatabricksSQLStatementExecutionTrigger",
+    ) -> None:
+        super().__init__()
+        self.statement_id = statement_id
+        self.databricks_conn_id = databricks_conn_id
+        self.end_time = end_time
+        self.polling_period_seconds = polling_period_seconds
+        self.retry_limit = retry_limit
+        self.retry_delay = retry_delay
+        self.retry_args = retry_args
+        self.hook = DatabricksHook(
+            databricks_conn_id,
+            retry_limit=self.retry_limit,
+            retry_delay=self.retry_delay,
+            retry_args=retry_args,
+            caller=caller,
+        )
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        return (
+            "airflow.providers.databricks.triggers.databricks.DatabricksSQLStatementExecutionTrigger",
+            {
+                "statement_id": self.statement_id,
+                "databricks_conn_id": self.databricks_conn_id,
+                "polling_period_seconds": self.polling_period_seconds,
+                "end_time": self.end_time,
+                "retry_limit": self.retry_limit,
+                "retry_delay": self.retry_delay,
+                "retry_args": self.retry_args,
+            },
+        )
+
+    async def run(self):
+        async with self.hook:
+            while self.end_time > time.time():
+                statement_state = await self.hook.a_get_sql_statement_state(self.statement_id)
+                if not statement_state.is_terminal:
+                    self.log.info(
+                        "Statement ID %s is in state %s. sleeping for %s seconds",
+                        self.statement_id,
+                        statement_state,
+                        self.polling_period_seconds,
+                    )
+                    await asyncio.sleep(self.polling_period_seconds)
+                    continue
+
+                error = {}
+                if statement_state.error_code:
+                    error = {
+                        "error_code": statement_state.error_code,
+                        "error_message": statement_state.error_message,
+                    }
+                yield TriggerEvent(
+                    {
+                        "statement_id": self.statement_id,
+                        "state": statement_state.to_json(),
+                        "error": error,
+                    }
+                )
+                return
+
+            # If we reach here, it means the statement should be timed out as per the end_time.
+            self.hook.cancel_sql_statement(self.statement_id)
+            yield TriggerEvent(
+                {
+                    "statement_id": self.statement_id,
+                    "state": statement_state.to_json(),
+                    "error": {
+                        "error_code": "TIMEOUT",
+                        "error_message": f"Statement ID {self.statement_id} timed out after set end time {self.end_time}",
+                    },
+                }
+            )
+            return

airflow/providers/databricks/utils/databricks.py

@@ -63,4 +63,4 @@ def validate_trigger_event(event: dict):
     try:
         RunState.from_json(event["run_state"])
     except Exception:
-        raise AirflowException(f'Run state returned by the Trigger is incorrect: {event["run_state"]}')
+        raise AirflowException(f"Run state returned by the Trigger is incorrect: {event['run_state']}")

{apache_airflow_providers_databricks-7.2.2rc1.dist-info → apache_airflow_providers_databricks-7.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-databricks
-Version: 7.2.2rc1
+Version: 7.3.0
 Summary: Provider package apache-airflow-providers-databricks for Apache Airflow
 Keywords: airflow-provider,databricks,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -20,9 +20,9 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
-Requires-Dist: apache-airflow>=2.9.0rc0
-Requires-Dist: apache-airflow-providers-common-sql>=1.20.0rc0
-Requires-Dist: requests>=2.27.0,<3
+Requires-Dist: apache-airflow>=2.9.0
+Requires-Dist: apache-airflow-providers-common-sql>=1.20.0
+Requires-Dist: requests>=2.31.0,<3
 Requires-Dist: databricks-sql-connector>=3.0.0
 Requires-Dist: aiohttp>=3.9.2, <4
 Requires-Dist: mergedeep>=1.3.4
@@ -33,8 +33,8 @@ Requires-Dist: apache-airflow-providers-fab ; extra == "fab"
 Requires-Dist: databricks-sdk==0.10.0 ; extra == "sdk"
 Requires-Dist: apache-airflow-providers-standard ; extra == "standard"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.2.2/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.2.2
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.3.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.3.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
@@ -69,7 +69,7 @@ Provides-Extra: standard
 
 Package ``apache-airflow-providers-databricks``
 
-Release: ``7.2.2``
+Release: ``7.3.0``
 
 
 `Databricks <https://databricks.com/>`__
@@ -82,7 +82,7 @@ This is a provider package for ``databricks`` provider. All classes for this pro
 are in ``airflow.providers.databricks`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.2.2/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.3.0/>`_.
 
 Installation
 ------------
@@ -101,7 +101,7 @@ PIP package                              Version required
 =======================================  ==================
 ``apache-airflow``                       ``>=2.9.0``
 ``apache-airflow-providers-common-sql``  ``>=1.20.0``
-``requests``                             ``>=2.27.0,<3``
+``requests``                             ``>=2.31.0,<3``
 ``databricks-sql-connector``             ``>=3.0.0``
 ``aiohttp``                              ``>=3.9.2,<4``
 ``mergedeep``                            ``>=1.3.4``
@@ -130,5 +130,5 @@ Dependent package
 ============================================================================================================  ==============
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.2.2/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-databricks/7.3.0/changelog.html>`_.
 

{apache_airflow_providers_databricks-7.2.2rc1.dist-info → apache_airflow_providers_databricks-7.3.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 airflow/providers/databricks/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/databricks/__init__.py,sha256=-094H4znLyAeiEWK6WoEtwB7J3mRF_mh1HRqSC6_X2E,1497
+airflow/providers/databricks/__init__.py,sha256=WqZExeHAUK-Gw7a9kjzNnUEcsc7-ku5xymJ7QUIZe1g,1497
 airflow/providers/databricks/exceptions.py,sha256=85RklmLOI_PnTzfXNIUd5fAu2aMMUhelwumQAX0wANE,1261
-airflow/providers/databricks/get_provider_info.py,sha256=zfvrXwvvfkp7sneZrK7Mhslxv9oZRG7efWLUnndGLNE,7371
+airflow/providers/databricks/get_provider_info.py,sha256=GVM7LE1BQ4VW1mRxsXMzlqb_qi7ydOmC4yVtGviCnvI,7392
 airflow/providers/databricks/version_compat.py,sha256=aHg90_DtgoSnQvILFICexMyNlHlALBdaeWqkX3dFDug,1605
 airflow/providers/databricks/hooks/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/databricks/hooks/databricks.py,sha256=-rgK_sMc2_BjTvSvMh1Md3XanVayOmcxijQfs1vRCPw,24774
+airflow/providers/databricks/hooks/databricks.py,sha256=MSVcURTF7g_B_a3Oi9katAim5ILqlm7MHANGvfRC5yY,28921
 airflow/providers/databricks/hooks/databricks_base.py,sha256=8KVRF-ty20UQpJP3kgE6RDLAYqXk7ZjI07ZpwFIcGB8,34917
-airflow/providers/databricks/hooks/databricks_sql.py,sha256=Giy0XBz0t6PHepREIXzxlFZhaNYgnS4bzBT_I04v5rM,13119
+airflow/providers/databricks/hooks/databricks_sql.py,sha256=x-8Ua6LdKXjP_ZJDvA4dr6Lda1Iv0abgVwkvMrtGuzw,13130
 airflow/providers/databricks/operators/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/databricks/operators/databricks.py,sha256=YCZKJE4-r1Q18tHYhT7Fp6Nv18l_KyqyYte8ev0B9P4,70035
+airflow/providers/databricks/operators/databricks.py,sha256=bBVHXmS5SIYYQN_KI3hLBt6GnY7O_bdDAOjYysmFwTk,79403
 airflow/providers/databricks/operators/databricks_repos.py,sha256=m_72OnnU9df7UB-8SK2Tp5VjfNyjYeAnil3dCKs9SbA,13282
 airflow/providers/databricks/operators/databricks_sql.py,sha256=thBHpt9_LMLJZ0PN-eLCI3AaT8IFq3NAHLDWDFP-Jiw,17031
 airflow/providers/databricks/operators/databricks_workflow.py,sha256=0vFu4w6O4tlStZ_Jhk1iswKFcTk-g_dthGFeDpXGZlw,14146
@@ -18,10 +18,10 @@ airflow/providers/databricks/sensors/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOF
 airflow/providers/databricks/sensors/databricks_partition.py,sha256=hS6Q2fb84_vASb7Ai50-pmjVukX6G8xIwdaZVIE17oM,10045
 airflow/providers/databricks/sensors/databricks_sql.py,sha256=jIA9oGBUCAlXzyrqigxlg7JQDsBFuNIF8ZUEJM8gPxg,5766
 airflow/providers/databricks/triggers/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/databricks/triggers/databricks.py,sha256=xk9aEfdZnG33a4WSFfg6SZF4FfROV8B4HOyBYBvZR_Q,5104
+airflow/providers/databricks/triggers/databricks.py,sha256=dSogx6GlcJfZ4CFhtlMeWs9sYFEYthP82S_U8-tM2Tk,9240
 airflow/providers/databricks/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/databricks/utils/databricks.py,sha256=EICTPZTD0R0dy9UGKgv8srkrBTgzCQrcYNL9oBWuhzk,2890
-apache_airflow_providers_databricks-7.2.2rc1.dist-info/entry_points.txt,sha256=hjmZm3ab2cteTR4t9eE28oKixHwNIKtLCThd6sx3XRQ,227
-apache_airflow_providers_databricks-7.2.2rc1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-apache_airflow_providers_databricks-7.2.2rc1.dist-info/METADATA,sha256=pXVe24YFANIMT6d57YVSzcMOQEyfxm0qanQ4nj2CH7U,6088
-apache_airflow_providers_databricks-7.2.2rc1.dist-info/RECORD,,
+airflow/providers/databricks/utils/databricks.py,sha256=9LLgqYAS68s_PTnIez1HfN8xCKPK9D_Dt5SDF4wlbzQ,2890
+apache_airflow_providers_databricks-7.3.0.dist-info/entry_points.txt,sha256=hjmZm3ab2cteTR4t9eE28oKixHwNIKtLCThd6sx3XRQ,227
+apache_airflow_providers_databricks-7.3.0.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+apache_airflow_providers_databricks-7.3.0.dist-info/METADATA,sha256=fpbgZg7zFQVM7PiNNEGeOfGsxrWfDCyLkFZ7e2mnVhM,6079
+apache_airflow_providers_databricks-7.3.0.dist-info/RECORD,,