apache-airflow-providers-google 17.2.0__py3-none-any.whl → 18.0.0rc1__py3-none-any.whl

airflow/providers/google/__init__.py

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

airflow/providers/google/cloud/hooks/bigquery.py

@@ -1702,6 +1702,7 @@ class BigQueryCursor(BigQueryBaseCursor):
         schema_update_options: Iterable | None = None,
         priority: str | None = None,
         time_partitioning: dict | None = None,
+        range_partitioning: dict | None = None,
         api_resource_configs: dict | None = None,
         cluster_fields: list[str] | None = None,
         encryption_configuration: dict | None = None,
@@ -1714,6 +1715,10 @@ class BigQueryCursor(BigQueryBaseCursor):
 
         if time_partitioning is None:
             time_partitioning = {}
+        if range_partitioning is None:
+            range_partitioning = {}
+        if time_partitioning and range_partitioning:
+            raise ValueError("Only one of time_partitioning or range_partitioning can be set.")
 
         if not api_resource_configs:
             api_resource_configs = self.hook.api_resource_configs
@@ -1766,6 +1771,7 @@ class BigQueryCursor(BigQueryBaseCursor):
             (maximum_billing_tier, "maximumBillingTier", None, int),
             (maximum_bytes_billed, "maximumBytesBilled", None, float),
             (time_partitioning, "timePartitioning", {}, dict),
+            (range_partitioning, "rangePartitioning", {}, dict),
             (schema_update_options, "schemaUpdateOptions", None, list),
             (destination_dataset_table, "destinationTable", None, dict),
             (cluster_fields, "clustering", None, dict),

airflow/providers/google/cloud/hooks/cloud_composer.py

@@ -18,12 +18,15 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import time
 from collections.abc import MutableSequence, Sequence
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urljoin
 
 from google.api_core.client_options import ClientOptions
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.auth.transport.requests import AuthorizedSession
 from google.cloud.orchestration.airflow.service_v1 import (
     EnvironmentsAsyncClient,
     EnvironmentsClient,
@@ -33,7 +36,7 @@ from google.cloud.orchestration.airflow.service_v1 import (
 
 from airflow.exceptions import AirflowException
 from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
+from airflow.providers.google.common.hooks.base_google import GoogleBaseAsyncHook, GoogleBaseHook
 
 if TYPE_CHECKING:
     from google.api_core.operation import Operation
@@ -76,6 +79,34 @@ class CloudComposerHook(GoogleBaseHook, OperationHelper):
             client_options=self.client_options,
         )
 
+    def make_composer_airflow_api_request(
+        self,
+        method: str,
+        airflow_uri: str,
+        path: str,
+        data: Any | None = None,
+        timeout: float | None = None,
+    ):
+        """
+        Make a request to Cloud Composer environment's web server.
+
+        :param method: The request method to use ('GET', 'OPTIONS', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE').
+        :param airflow_uri: The URI of the Apache Airflow Web UI hosted within this environment.
+        :param path: The path to send the request.
+        :param data: Dictionary, list of tuples, bytes, or file-like object to send in the body of the request.
+        :param timeout: The timeout for this request.
+        """
+        authed_session = AuthorizedSession(self.get_credentials())
+
+        resp = authed_session.request(
+            method=method,
+            url=urljoin(airflow_uri, path),
+            data=data,
+            headers={"Content-Type": "application/json"},
+            timeout=timeout,
+        )
+        return resp
+
     def get_operation(self, operation_name):
         return self.get_environment_client().transport.operations_client.get_operation(name=operation_name)
 
@@ -408,16 +439,52 @@ class CloudComposerHook(GoogleBaseHook, OperationHelper):
             self.log.info("Waiting for result...")
             time.sleep(poll_interval)
 
+    def trigger_dag_run(
+        self,
+        composer_airflow_uri: str,
+        composer_dag_id: str,
+        composer_dag_conf: dict | None = None,
+        timeout: float | None = None,
+    ) -> dict:
+        """
+        Trigger DAG run for provided Apache Airflow Web UI hosted within Composer environment.
+
+        :param composer_airflow_uri: The URI of the Apache Airflow Web UI hosted within Composer environment.
+        :param composer_dag_id: The ID of DAG which will be triggered.
+        :param composer_dag_conf: Configuration parameters for the DAG run.
+        :param timeout: The timeout for this request.
+        """
+        response = self.make_composer_airflow_api_request(
+            method="POST",
+            airflow_uri=composer_airflow_uri,
+            path=f"/api/v1/dags/{composer_dag_id}/dagRuns",
+            data=json.dumps(
+                {
+                    "conf": composer_dag_conf or {},
+                }
+            ),
+            timeout=timeout,
+        )
 
-class CloudComposerAsyncHook(GoogleBaseHook):
+        if response.status_code != 200:
+            self.log.error(response.text)
+            response.raise_for_status()
+
+        return response.json()
+
+
+class CloudComposerAsyncHook(GoogleBaseAsyncHook):
     """Hook for Google Cloud Composer async APIs."""
 
+    sync_hook_class = CloudComposerHook
+
     client_options = ClientOptions(api_endpoint="composer.googleapis.com:443")
 
-    def get_environment_client(self) -> EnvironmentsAsyncClient:
+    async def get_environment_client(self) -> EnvironmentsAsyncClient:
         """Retrieve client library object that allow access Environments service."""
+        sync_hook = await self.get_sync_hook()
         return EnvironmentsAsyncClient(
-            credentials=self.get_credentials(),
+            credentials=sync_hook.get_credentials(),
             client_info=CLIENT_INFO,
             client_options=self.client_options,
         )
@@ -429,9 +496,8 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         return f"projects/{project_id}/locations/{region}"
 
     async def get_operation(self, operation_name):
-        return await self.get_environment_client().transport.operations_client.get_operation(
-            name=operation_name
-        )
+        client = await self.get_environment_client()
+        return await client.transport.operations_client.get_operation(name=operation_name)
 
     @GoogleBaseHook.fallback_to_default_project_id
     async def create_environment(
@@ -454,7 +520,7 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         :param timeout: The timeout for this request.
         :param metadata: Strings which should be sent along with the request as metadata.
         """
-        client = self.get_environment_client()
+        client = await self.get_environment_client()
         return await client.create_environment(
             request={"parent": self.get_parent(project_id, region), "environment": environment},
             retry=retry,
@@ -482,7 +548,7 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         :param timeout: The timeout for this request.
         :param metadata: Strings which should be sent along with the request as metadata.
         """
-        client = self.get_environment_client()
+        client = await self.get_environment_client()
         name = self.get_environment_name(project_id, region, environment_id)
         return await client.delete_environment(
             request={"name": name}, retry=retry, timeout=timeout, metadata=metadata
@@ -518,7 +584,7 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         :param timeout: The timeout for this request.
         :param metadata: Strings which should be sent along with the request as metadata.
         """
-        client = self.get_environment_client()
+        client = await self.get_environment_client()
         name = self.get_environment_name(project_id, region, environment_id)
 
         return await client.update_environment(
@@ -556,7 +622,7 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         :param timeout: The timeout for this request.
         :param metadata: Strings which should be sent along with the request as metadata.
         """
-        client = self.get_environment_client()
+        client = await self.get_environment_client()
 
         return await client.execute_airflow_command(
             request={
@@ -598,7 +664,7 @@ class CloudComposerAsyncHook(GoogleBaseHook):
         :param timeout: The timeout for this request.
         :param metadata: Strings which should be sent along with the request as metadata.
         """
-        client = self.get_environment_client()
+        client = await self.get_environment_client()
 
         return await client.poll_airflow_command(
             request={

airflow/providers/google/cloud/hooks/cloud_run.py

@@ -42,7 +42,11 @@ from google.longrunning import operations_pb2
 
 from airflow.exceptions import AirflowException
 from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID, GoogleBaseHook
+from airflow.providers.google.common.hooks.base_google import (
+    PROVIDE_PROJECT_ID,
+    GoogleBaseAsyncHook,
+    GoogleBaseHook,
+)
 
 if TYPE_CHECKING:
     from google.api_core import operation
@@ -159,7 +163,7 @@ class CloudRunHook(GoogleBaseHook):
         return list(itertools.islice(jobs, limit))
 
 
-class CloudRunAsyncHook(GoogleBaseHook):
+class CloudRunAsyncHook(GoogleBaseAsyncHook):
     """
     Async hook for the Google Cloud Run service.
 
@@ -174,6 +178,8 @@ class CloudRunAsyncHook(GoogleBaseHook):
         account from the list granting this role to the originating account.
     """
 
+    sync_hook_class = CloudRunHook
+
     def __init__(
         self,
         gcp_conn_id: str = "google_cloud_default",
@@ -183,16 +189,16 @@ class CloudRunAsyncHook(GoogleBaseHook):
         self._client: JobsAsyncClient | None = None
         super().__init__(gcp_conn_id=gcp_conn_id, impersonation_chain=impersonation_chain, **kwargs)
 
-    def get_conn(self):
+    async def get_conn(self):
         if self._client is None:
-            self._client = JobsAsyncClient(credentials=self.get_credentials(), client_info=CLIENT_INFO)
+            sync_hook = await self.get_sync_hook()
+            self._client = JobsAsyncClient(credentials=sync_hook.get_credentials(), client_info=CLIENT_INFO)
 
         return self._client
 
     async def get_operation(self, operation_name: str) -> operations_pb2.Operation:
-        return await self.get_conn().get_operation(
-            operations_pb2.GetOperationRequest(name=operation_name), timeout=120
-        )
+        conn = await self.get_conn()
+        return await conn.get_operation(operations_pb2.GetOperationRequest(name=operation_name), timeout=120)
 
 
 class CloudRunServiceHook(GoogleBaseHook):
@@ -258,7 +264,7 @@ class CloudRunServiceHook(GoogleBaseHook):
         return operation.result()
 
 
-class CloudRunServiceAsyncHook(GoogleBaseHook):
+class CloudRunServiceAsyncHook(GoogleBaseAsyncHook):
     """
     Async hook for the Google Cloud Run services.
 
@@ -273,6 +279,8 @@ class CloudRunServiceAsyncHook(GoogleBaseHook):
         account from the list granting this role to the originating account.
     """
 
+    sync_hook_class = CloudRunServiceHook
+
     def __init__(
         self,
         gcp_conn_id: str = "google_cloud_default",

airflow/providers/google/cloud/hooks/vertex_ai/auto_ml.py

@@ -38,7 +38,6 @@ from google.cloud.aiplatform_v1 import JobServiceClient, PipelineServiceClient
 
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
 from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.deprecated import deprecated
 from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
 from airflow.providers.google.common.hooks.operation_helpers import OperationHelper
 
@@ -951,178 +950,6 @@ class AutoMLHook(GoogleBaseHook, OperationHelper):
             )
         return model, training_id
 
-    @GoogleBaseHook.fallback_to_default_project_id
-    @deprecated(
-        planned_removal_date="September 15, 2025",
-        category=AirflowProviderDeprecationWarning,
-        reason="Deprecation of AutoMLText API",
-    )
-    def create_auto_ml_text_training_job(
-        self,
-        project_id: str,
-        region: str,
-        display_name: str,
-        dataset: datasets.TextDataset,
-        prediction_type: str,
-        multi_label: bool = False,
-        sentiment_max: int = 10,
-        labels: dict[str, str] | None = None,
-        training_encryption_spec_key_name: str | None = None,
-        model_encryption_spec_key_name: str | None = None,
-        training_fraction_split: float | None = None,
-        validation_fraction_split: float | None = None,
-        test_fraction_split: float | None = None,
-        training_filter_split: str | None = None,
-        validation_filter_split: str | None = None,
-        test_filter_split: str | None = None,
-        model_display_name: str | None = None,
-        model_labels: dict[str, str] | None = None,
-        sync: bool = True,
-        parent_model: str | None = None,
-        is_default_version: bool | None = None,
-        model_version_aliases: list[str] | None = None,
-        model_version_description: str | None = None,
-    ) -> tuple[models.Model | None, str]:
-        """
-        Create an AutoML Text Training Job.
-
-        WARNING: Text creation API is deprecated since September 15, 2024
-        (https://cloud.google.com/vertex-ai/docs/tutorials/text-classification-automl/overview).
-
-        :param project_id: Required. Project to run training in.
-        :param region: Required. Location to run training in.
-        :param display_name: Required. The user-defined name of this TrainingPipeline.
-        :param dataset: Required. The dataset within the same Project from which data will be used to train
-            the Model. The Dataset must use schema compatible with Model being trained, and what is
-            compatible should be described in the used TrainingPipeline's [training_task_definition]
-            [google.cloud.aiplatform.v1beta1.TrainingPipeline.training_task_definition].
-        :param prediction_type: The type of prediction the Model is to produce, one of:
-            "classification" - A classification model analyzes text data and returns a list of categories
-            that apply to the text found in the data. Vertex AI offers both single-label and multi-label text
-            classification models.
-            "extraction" - An entity extraction model inspects text data for known entities referenced in the
-            data and labels those entities in the text.
-            "sentiment" - A sentiment analysis model inspects text data and identifies the prevailing
-            emotional opinion within it, especially to determine a writer's attitude as positive, negative,
-            or neutral.
-        :param parent_model: Optional. The resource name or model ID of an existing model.
-            The new model uploaded by this job will be a version of `parent_model`.
-            Only set this field when training a new version of an existing model.
-        :param is_default_version: Optional. When set to True, the newly uploaded model version will
-            automatically have alias "default" included. Subsequent uses of
-            the model produced by this job without a version specified will
-            use this "default" version.
-            When set to False, the "default" alias will not be moved.
-            Actions targeting the model version produced by this job will need
-            to specifically reference this version by ID or alias.
-            New model uploads, i.e. version 1, will always be "default" aliased.
-        :param model_version_aliases: Optional. User provided version aliases so that the model version
-            uploaded by this job can be referenced via alias instead of
-            auto-generated version ID. A default version alias will be created
-            for the first version of the model.
-            The format is [a-z][a-zA-Z0-9-]{0,126}[a-z0-9]
-        :param model_version_description: Optional. The description of the model version
-            being uploaded by this job.
-        :param multi_label: Required and only applicable for text classification task. If false, a
-            single-label (multi-class) Model will be trained (i.e. assuming that for each text snippet just
-            up to one annotation may be applicable). If true, a multi-label Model will be trained (i.e.
-            assuming that for each text snippet multiple annotations may be applicable).
-        :param sentiment_max: Required and only applicable for sentiment task. A sentiment is expressed as an
-            integer ordinal, where higher value means a more positive sentiment. The range of sentiments that
-            will be used is between 0 and sentimentMax (inclusive on both ends), and all the values in the
-            range must be represented in the dataset before a model can be created. Only the Annotations with
-            this sentimentMax will be used for training. sentimentMax value must be between 1 and 10
-            (inclusive).
-        :param labels: Optional. The labels with user-defined metadata to organize TrainingPipelines. Label
-            keys and values can be no longer than 64 characters (Unicode codepoints), can only contain
-            lowercase letters, numeric characters, underscores and dashes. International characters are
-            allowed. See https://goo.gl/xmQnxf for more information and examples of labels.
-        :param training_encryption_spec_key_name: Optional. The Cloud KMS resource identifier of the customer
-            managed encryption key used to protect the training pipeline. Has the form:
-            ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``.
-            The key needs to be in the same region as where the compute resource is created.
-            If set, this TrainingPipeline will be secured by this key.
-            Note: Model trained by this TrainingPipeline is also secured by this key if ``model_to_upload``
-            is not set separately.
-        :param model_encryption_spec_key_name: Optional. The Cloud KMS resource identifier of the customer
-            managed encryption key used to protect the model. Has the form:
-            ``projects/my-project/locations/my-region/keyRings/my-kr/cryptoKeys/my-key``.
-            The key needs to be in the same region as where the compute resource is created.
-            If set, the trained Model will be secured by this key.
-        :param training_fraction_split: Optional. The fraction of the input data that is to be used to train
-            the Model. This is ignored if Dataset is not provided.
-        :param validation_fraction_split: Optional. The fraction of the input data that is to be used to
-            validate the Model. This is ignored if Dataset is not provided.
-        :param test_fraction_split: Optional. The fraction of the input data that is to be used to evaluate
-            the Model. This is ignored if Dataset is not provided.
-        :param training_filter_split: Optional. A filter on DataItems of the Dataset. DataItems that match
-            this filter are used to train the Model. A filter with same syntax as the one used in
-            DatasetService.ListDataItems may be used. If a single DataItem is matched by more than one of the
-            FilterSplit filters, then it is assigned to the first set that applies to it in the training,
-            validation, test order. This is ignored if Dataset is not provided.
-        :param validation_filter_split: Optional. A filter on DataItems of the Dataset. DataItems that match
-            this filter are used to validate the Model. A filter with same syntax as the one used in
-            DatasetService.ListDataItems may be used. If a single DataItem is matched by more than one of the
-            FilterSplit filters, then it is assigned to the first set that applies to it in the training,
-            validation, test order. This is ignored if Dataset is not provided.
-        :param test_filter_split: Optional. A filter on DataItems of the Dataset. DataItems that match this
-            filter are used to test the Model. A filter with same syntax as the one used in
-            DatasetService.ListDataItems may be used. If a single DataItem is matched by more than one of the
-            FilterSplit filters, then it is assigned to the first set that applies to it in the training,
-            validation, test order. This is ignored if Dataset is not provided.
-        :param model_display_name: Optional. The display name of the managed Vertex AI Model. The name can be
-            up to 128 characters long and can consist of any UTF-8 characters.
-            If not provided upon creation, the job's display_name is used.
-        :param model_labels: Optional. The labels with user-defined metadata to organize your Models. Label
-            keys and values can be no longer than 64 characters (Unicode codepoints), can only contain
-            lowercase letters, numeric characters, underscores and dashes. International characters are
-            allowed. See https://goo.gl/xmQnxf for more information and examples of labels.
-        :param sync: Whether to execute this method synchronously. If False, this method will be executed in
-            concurrent Future and any downstream object will be immediately returned and synced when the
-            Future has completed.
-        """
-        self._job = AutoMLTextTrainingJob(
-            display_name=display_name,
-            prediction_type=prediction_type,
-            multi_label=multi_label,
-            sentiment_max=sentiment_max,
-            project=project_id,
-            location=region,
-            credentials=self.get_credentials(),
-            labels=labels,
-            training_encryption_spec_key_name=training_encryption_spec_key_name,
-            model_encryption_spec_key_name=model_encryption_spec_key_name,
-        )
-
-        if not self._job:
-            raise AirflowException("AutoMLTextTrainingJob was not created")
-
-        model = self._job.run(
-            dataset=dataset,
-            training_fraction_split=training_fraction_split,
-            validation_fraction_split=validation_fraction_split,
-            test_fraction_split=test_fraction_split,
-            training_filter_split=training_filter_split,
-            validation_filter_split=validation_filter_split,
-            test_filter_split=test_filter_split,
-            model_display_name=model_display_name,
-            model_labels=model_labels,
-            sync=sync,
-            parent_model=parent_model,
-            is_default_version=is_default_version,
-            model_version_aliases=model_version_aliases,
-            model_version_description=model_version_description,
-        )
-        training_id = self.extract_training_id(self._job.resource_name)
-        if model:
-            model.wait()
-        else:
-            self.log.warning(
-                "Training did not produce a Managed Model returning None. AutoML Text Training "
-                "Pipeline is not configured to upload a Model."
-            )
-        return model, training_id
-
     @GoogleBaseHook.fallback_to_default_project_id
     def create_auto_ml_video_training_job(
         self,

airflow/providers/google/cloud/log/gcs_task_handler.py

@@ -213,9 +213,15 @@ class GCSTaskHandler(FileTaskHandler, LoggingMixin):
         gcp_keyfile_dict: dict | None = None,
         gcp_scopes: Collection[str] | None = _DEFAULT_SCOPESS,
         project_id: str = PROVIDE_PROJECT_ID,
+        max_bytes: int = 0,
+        backup_count: int = 0,
+        delay: bool = False,
         **kwargs,
-    ):
-        super().__init__(base_log_folder)
+    ) -> None:
+        # support log file size handling of FileTaskHandler
+        super().__init__(
+            base_log_folder=base_log_folder, max_bytes=max_bytes, backup_count=backup_count, delay=delay
+        )
         self.handler: logging.FileHandler | None = None
         self.log_relative_path = ""
         self.closed = False

airflow/providers/google/cloud/operators/cloud_composer.py

@@ -21,7 +21,7 @@ import shlex
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any
 
-from google.api_core.exceptions import AlreadyExists
+from google.api_core.exceptions import AlreadyExists, NotFound
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.cloud.orchestration.airflow.service_v1 import ImageVersion
 from google.cloud.orchestration.airflow.service_v1.types import Environment, ExecuteAirflowCommandResponse
@@ -798,3 +798,86 @@ class CloudComposerRunAirflowCLICommandOperator(GoogleCloudBaseOperator):
         """Merge output to one string."""
         result_str = "\n".join(line_dict["content"] for line_dict in result["output"])
         return result_str
+
+
+class CloudComposerTriggerDAGRunOperator(GoogleCloudBaseOperator):
+    """
+    Trigger DAG run for provided Composer environment.
+
+    :param project_id: The ID of the Google Cloud project that the service belongs to.
+    :param region: The ID of the Google Cloud region that the service belongs to.
+    :param environment_id: The ID of the Google Cloud environment that the service belongs to.
+    :param composer_dag_id: The ID of DAG which will be triggered.
+    :param composer_dag_conf: Configuration parameters for the DAG run.
+    :param timeout: The timeout for this request.
+    :param gcp_conn_id: The connection ID used to connect to Google Cloud Platform.
+    :param impersonation_chain: Optional service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields = (
+        "project_id",
+        "region",
+        "environment_id",
+        "composer_dag_id",
+        "impersonation_chain",
+    )
+
+    def __init__(
+        self,
+        *,
+        project_id: str,
+        region: str,
+        environment_id: str,
+        composer_dag_id: str,
+        composer_dag_conf: dict | None = None,
+        timeout: float | None = None,
+        gcp_conn_id: str = "google_cloud_default",
+        impersonation_chain: str | Sequence[str] | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.project_id = project_id
+        self.region = region
+        self.environment_id = environment_id
+        self.composer_dag_id = composer_dag_id
+        self.composer_dag_conf = composer_dag_conf or {}
+        self.timeout = timeout
+        self.gcp_conn_id = gcp_conn_id
+        self.impersonation_chain = impersonation_chain
+
+    def execute(self, context: Context):
+        hook = CloudComposerHook(
+            gcp_conn_id=self.gcp_conn_id,
+            impersonation_chain=self.impersonation_chain,
+        )
+        try:
+            environment = hook.get_environment(
+                project_id=self.project_id,
+                region=self.region,
+                environment_id=self.environment_id,
+                timeout=self.timeout,
+            )
+        except NotFound as not_found_err:
+            self.log.info("The Composer environment %s does not exist.", self.environment_id)
+            raise AirflowException(not_found_err)
+        composer_airflow_uri = environment.config.airflow_uri
+
+        self.log.info(
+            "Triggering the DAG %s on the %s environment...", self.composer_dag_id, self.environment_id
+        )
+        dag_run = hook.trigger_dag_run(
+            composer_airflow_uri=composer_airflow_uri,
+            composer_dag_id=self.composer_dag_id,
+            composer_dag_conf=self.composer_dag_conf,
+            timeout=self.timeout,
+        )
+        self.log.info("The DAG %s was triggered with Run ID: %s", self.composer_dag_id, dag_run["dag_run_id"])
+
+        return dag_run

airflow/providers/google/cloud/sensors/cloud_composer.py

@@ -222,7 +222,7 @@ class CloudComposerDAGRunSensor(BaseSensorOperator):
         if self.deferrable:
             start_date, end_date = self._get_logical_dates(context)
             self.defer(
-                timeout=self.timeout,
+                timeout=timedelta(seconds=self.timeout) if self.timeout else None,
                 trigger=CloudComposerDAGRunTrigger(
                     project_id=self.project_id,
                     region=self.region,

airflow/providers/google/cloud/transfers/bigquery_to_mssql.py

@@ -25,13 +25,11 @@ from functools import cached_property
 from typing import TYPE_CHECKING
 
 from airflow.exceptions import AirflowProviderDeprecationWarning
-from airflow.providers.google.cloud.hooks.bigquery import BigQueryHook
 from airflow.providers.google.cloud.links.bigquery import BigQueryTableLink
 from airflow.providers.google.cloud.transfers.bigquery_to_sql import BigQueryToSqlBaseOperator
 from airflow.providers.microsoft.mssql.hooks.mssql import MsSqlHook
 
 if TYPE_CHECKING:
-    from airflow.providers.openlineage.extractors import OperatorLineage
     from airflow.utils.context import Context
 
 
@@ -112,67 +110,3 @@ class BigQueryToMsSqlOperator(BigQueryToSqlBaseOperator):
             project_id=project_id,
             table_id=table_id,
         )
-
-    def get_openlineage_facets_on_complete(self, task_instance) -> OperatorLineage | None:
-        from airflow.providers.common.compat.openlineage.facet import Dataset
-        from airflow.providers.google.cloud.openlineage.utils import (
-            BIGQUERY_NAMESPACE,
-            get_facets_from_bq_table_for_given_fields,
-            get_identity_column_lineage_facet,
-        )
-        from airflow.providers.openlineage.extractors import OperatorLineage
-
-        if not self.bigquery_hook:
-            self.bigquery_hook = BigQueryHook(
-                gcp_conn_id=self.gcp_conn_id,
-                location=self.location,
-                impersonation_chain=self.impersonation_chain,
-            )
-
-        try:
-            table_obj = self.bigquery_hook.get_client().get_table(self.source_project_dataset_table)
-        except Exception:
-            self.log.debug(
-                "OpenLineage: could not fetch BigQuery table %s",
-                self.source_project_dataset_table,
-                exc_info=True,
-            )
-            return OperatorLineage()
-
-        if self.selected_fields:
-            if isinstance(self.selected_fields, str):
-                bigquery_field_names = list(self.selected_fields)
-            else:
-                bigquery_field_names = self.selected_fields
-        else:
-            bigquery_field_names = [f.name for f in getattr(table_obj, "schema", [])]
-
-        input_dataset = Dataset(
-            namespace=BIGQUERY_NAMESPACE,
-            name=self.source_project_dataset_table,
-            facets=get_facets_from_bq_table_for_given_fields(table_obj, bigquery_field_names),
-        )
-
-        db_info = self.mssql_hook.get_openlineage_database_info(self.mssql_hook.get_conn())
-        default_schema = self.mssql_hook.get_openlineage_default_schema()
-        namespace = f"{db_info.scheme}://{db_info.authority}"
-
-        if self.target_table_name and "." in self.target_table_name:
-            schema_name, table_name = self.target_table_name.split(".", 1)
-        else:
-            schema_name = default_schema or ""
-            table_name = self.target_table_name or ""
-
-        if self.database:
-            output_name = f"{self.database}.{schema_name}.{table_name}"
-        else:
-            output_name = f"{schema_name}.{table_name}"
-
-        column_lineage_facet = get_identity_column_lineage_facet(
-            bigquery_field_names, input_datasets=[input_dataset]
-        )
-
-        output_facets = column_lineage_facet or {}
-        output_dataset = Dataset(namespace=namespace, name=output_name, facets=output_facets)
-
-        return OperatorLineage(inputs=[input_dataset], outputs=[output_dataset])