apache-airflow-providers-google 10.26.0__py3-none-any.whl → 11.0.0__py3-none-any.whl

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

@@ -19,25 +19,20 @@
 
 from __future__ import annotations
 
-import copy
-import re
 import uuid
-from contextlib import ExitStack
+from collections.abc import Sequence
 from enum import Enum
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Sequence
+from typing import TYPE_CHECKING, Any
 
 from googleapiclient.errors import HttpError
 
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
-from airflow.providers.apache.beam.hooks.beam import BeamHook, BeamRunnerType
 from airflow.providers.google.cloud.hooks.dataflow import (
     DEFAULT_DATAFLOW_LOCATION,
     DataflowHook,
-    process_line_and_extract_dataflow_job_id_callback,
 )
-from airflow.providers.google.cloud.hooks.gcs import GCSHook
 from airflow.providers.google.cloud.links.dataflow import DataflowJobLink, DataflowPipelineLink
 from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
 from airflow.providers.google.cloud.triggers.dataflow import (
@@ -47,7 +42,6 @@ from airflow.providers.google.cloud.triggers.dataflow import (
 from airflow.providers.google.common.consts import GOOGLE_DEFAULT_DEFERRABLE_METHOD_NAME
 from airflow.providers.google.common.deprecated import deprecated
 from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID
-from airflow.version import version
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -175,297 +169,6 @@ class DataflowConfiguration:
         self.service_account = service_account
 
 
-# TODO: Remove one day
-@deprecated(
-    planned_removal_date="November 01, 2024",
-    use_instead="providers.apache.beam.operators.beam.BeamRunJavaPipelineOperator",
-    category=AirflowProviderDeprecationWarning,
-)
-class DataflowCreateJavaJobOperator(GoogleCloudBaseOperator):
-    """
-    Start a Java Cloud Dataflow batch job; the parameters of the operation will be passed to the job.
-
-    This class is deprecated.
-
-    Please use :class:`providers.apache.beam.operators.beam.BeamRunJavaPipelineOperator`.
-
-    Example usage:
-
-    .. code-block:: python
-
-        default_args = {
-            "owner": "airflow",
-            "depends_on_past": False,
-            "start_date": (2016, 8, 1),
-            "email": ["alex@vanboxel.be"],
-            "email_on_failure": False,
-            "email_on_retry": False,
-            "retries": 1,
-            "retry_delay": timedelta(minutes=30),
-            "dataflow_default_options": {
-                "project": "my-gcp-project",
-                "zone": "us-central1-f",
-                "stagingLocation": "gs://bucket/tmp/dataflow/staging/",
-            },
-        }
-
-        dag = DAG("test-dag", default_args=default_args)
-
-        task = DataflowCreateJavaJobOperator(
-            gcp_conn_id="gcp_default",
-            task_id="normalize-cal",
-            jar="{{var.value.gcp_dataflow_base}}pipeline-ingress-cal-normalize-1.0.jar",
-            options={
-                "autoscalingAlgorithm": "BASIC",
-                "maxNumWorkers": "50",
-                "start": "{{ds}}",
-                "partitionType": "DAY",
-            },
-            dag=dag,
-        )
-
-
-    .. seealso::
-        For more detail on job submission have a look at the reference:
-        https://cloud.google.com/dataflow/pipelines/specifying-exec-params
-
-    .. seealso::
-        For more information on how to use this operator, take a look at the guide:
-        :ref:`howto/operator:DataflowCreateJavaJobOperator`
-
-    :param jar: The reference to a self executing Dataflow jar (templated).
-    :param job_name: The 'jobName' to use when executing the Dataflow job
-        (templated). This ends up being set in the pipeline options, so any entry
-        with key ``'jobName'`` in ``options`` will be overwritten.
-    :param dataflow_default_options: Map of default job options.
-    :param options: Map of job specific options.The key must be a dictionary.
-
-        The value can contain different types:
-
-        * If the value is None, the single option - ``--key`` (without value) will be added.
-        * If the value is False, this option will be skipped
-        * If the value is True, the single option - ``--key`` (without value) will be added.
-        * If the value is list, the many options will be added for each key.
-          If the value is ``['A', 'B']`` and the key is ``key`` then the ``--key=A --key=B`` options
-          will be left
-        * Other value types will be replaced with the Python textual representation.
-
-        When defining labels (``labels`` option), you can also provide a dictionary.
-
-    :param project_id: Optional, the Google Cloud project ID in which to start a job.
-        If set to None or missing, the default project_id from the Google Cloud connection is used.
-    :param location: Job location.
-    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
-    :param poll_sleep: The time in seconds to sleep between polling Google
-        Cloud Platform for the dataflow job status while the job is in the
-        JOB_STATE_RUNNING state.
-    :param job_class: The name of the dataflow job class to be executed, it
-        is often not the main class configured in the dataflow jar file.
-
-    :param multiple_jobs: If pipeline creates multiple jobs then monitor all jobs
-    :param check_if_running: before running job, validate that a previous run is not in process
-        if job is running finish with nothing, WaitForRun= wait until job finished and the run job)
-        ``jar``, ``options``, and ``job_name`` are templated so you can use variables in them.
-    :param cancel_timeout: How long (in seconds) operator should wait for the pipeline to be
-        successfully cancelled when task is being killed.
-    :param wait_until_finished: (Optional)
-        If True, wait for the end of pipeline execution before exiting.
-        If False, only submits job.
-        If None, default behavior.
-
-        The default behavior depends on the type of pipeline:
-
-        * for the streaming pipeline, wait for jobs to start,
-        * for the batch pipeline, wait for the jobs to complete.
-
-        .. warning::
-
-            You cannot call ``PipelineResult.wait_until_finish`` method in your pipeline code for the operator
-            to work properly. i. e. you must use asynchronous execution. Otherwise, your pipeline will
-            always wait until finished. For more information, look at:
-            `Asynchronous execution
-            <https://cloud.google.com/dataflow/docs/guides/specifying-exec-params#python_10>`__
-
-        The process of starting the Dataflow job in Airflow consists of two steps:
-
-        * running a subprocess and reading the stderr/stderr log for the job id.
-        * loop waiting for the end of the job ID from the previous step.
-          This loop checks the status of the job.
-
-        Step two is started just after step one has finished, so if you have wait_until_finished in your
-        pipeline code, step two will not start until the process stops. When this process stops,
-        steps two will run, but it will only execute one iteration as the job will be in a terminal state.
-
-        If you in your pipeline do not call the wait_for_pipeline method but pass wait_until_finish=True
-        to the operator, the second loop will wait for the job's terminal state.
-
-        If you in your pipeline do not call the wait_for_pipeline method, and pass wait_until_finish=False
-        to the operator, the second loop will check once is job not in terminal state and exit the loop.
-    :param expected_terminal_state: The expected terminal state of the operator on which the corresponding
-        Airflow task succeeds. When not specified, it will be determined by the hook.
-
-    Note that both
-    ``dataflow_default_options`` and ``options`` will be merged to specify pipeline
-    execution parameter, and ``dataflow_default_options`` is expected to save
-    high-level options, for instances, project and zone information, which
-    apply to all dataflow operators in the DAG.
-
-    It's a good practice to define dataflow_* parameters in the default_args of the dag
-    like the project, zone and staging location.
-
-    .. code-block:: python
-
-       default_args = {
-           "dataflow_default_options": {
-               "zone": "europe-west1-d",
-               "stagingLocation": "gs://my-staging-bucket/staging/",
-           }
-       }
-
-    You need to pass the path to your dataflow as a file reference with the ``jar``
-    parameter, the jar needs to be a self executing jar (see documentation here:
-    https://beam.apache.org/documentation/runners/dataflow/#self-executing-jar).
-    Use ``options`` to pass on options to your job.
-
-    .. code-block:: python
-
-       t1 = DataflowCreateJavaJobOperator(
-           task_id="dataflow_example",
-           jar="{{var.value.gcp_dataflow_base}}pipeline/build/libs/pipeline-example-1.0.jar",
-           options={
-               "autoscalingAlgorithm": "BASIC",
-               "maxNumWorkers": "50",
-               "start": "{{ds}}",
-               "partitionType": "DAY",
-               "labels": {"foo": "bar"},
-           },
-           gcp_conn_id="airflow-conn-id",
-           dag=my_dag,
-       )
-
-    """
-
-    template_fields: Sequence[str] = ("options", "jar", "job_name")
-    ui_color = "#0273d4"
-
-    def __init__(
-        self,
-        *,
-        jar: str,
-        job_name: str = "{{task.task_id}}",
-        dataflow_default_options: dict | None = None,
-        options: dict | None = None,
-        project_id: str = PROVIDE_PROJECT_ID,
-        location: str = DEFAULT_DATAFLOW_LOCATION,
-        gcp_conn_id: str = "google_cloud_default",
-        poll_sleep: int = 10,
-        job_class: str | None = None,
-        check_if_running: CheckJobRunning = CheckJobRunning.WaitForRun,
-        multiple_jobs: bool = False,
-        cancel_timeout: int | None = 10 * 60,
-        wait_until_finished: bool | None = None,
-        expected_terminal_state: str | None = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(**kwargs)
-
-        dataflow_default_options = dataflow_default_options or {}
-        options = options or {}
-        options.setdefault("labels", {}).update(
-            {"airflow-version": "v" + version.replace(".", "-").replace("+", "-")}
-        )
-        self.project_id = project_id
-        self.location = location
-        self.gcp_conn_id = gcp_conn_id
-        self.jar = jar
-        self.multiple_jobs = multiple_jobs
-        self.job_name = job_name
-        self.dataflow_default_options = dataflow_default_options
-        self.options = options
-        self.poll_sleep = poll_sleep
-        self.job_class = job_class
-        self.check_if_running = check_if_running
-        self.cancel_timeout = cancel_timeout
-        self.wait_until_finished = wait_until_finished
-        self.expected_terminal_state = expected_terminal_state
-        self.job_id = None
-        self.beam_hook: BeamHook | None = None
-        self.dataflow_hook: DataflowHook | None = None
-
-    def execute(self, context: Context):
-        """Execute the Apache Beam Pipeline."""
-        self.beam_hook = BeamHook(runner=BeamRunnerType.DataflowRunner)
-        self.dataflow_hook = DataflowHook(
-            gcp_conn_id=self.gcp_conn_id,
-            poll_sleep=self.poll_sleep,
-            cancel_timeout=self.cancel_timeout,
-            wait_until_finished=self.wait_until_finished,
-            expected_terminal_state=self.expected_terminal_state,
-        )
-        job_name = self.dataflow_hook.build_dataflow_job_name(job_name=self.job_name)
-        pipeline_options = copy.deepcopy(self.dataflow_default_options)
-
-        pipeline_options["jobName"] = self.job_name
-        pipeline_options["project"] = self.project_id or self.dataflow_hook.project_id
-        pipeline_options["region"] = self.location
-        pipeline_options.update(self.options)
-        pipeline_options.setdefault("labels", {}).update(
-            {"airflow-version": "v" + version.replace(".", "-").replace("+", "-")}
-        )
-        pipeline_options.update(self.options)
-
-        def set_current_job_id(job_id):
-            self.job_id = job_id
-
-        process_line_callback = process_line_and_extract_dataflow_job_id_callback(
-            on_new_job_id_callback=set_current_job_id
-        )
-
-        with ExitStack() as exit_stack:
-            if self.jar.lower().startswith("gs://"):
-                gcs_hook = GCSHook(self.gcp_conn_id)
-                tmp_gcs_file = exit_stack.enter_context(gcs_hook.provide_file(object_url=self.jar))
-                self.jar = tmp_gcs_file.name
-
-            is_running = False
-            if self.check_if_running != CheckJobRunning.IgnoreJob:
-                is_running = self.dataflow_hook.is_job_dataflow_running(
-                    name=self.job_name,
-                    variables=pipeline_options,
-                    location=self.location,
-                )
-                while is_running and self.check_if_running == CheckJobRunning.WaitForRun:
-                    is_running = self.dataflow_hook.is_job_dataflow_running(
-                        name=self.job_name,
-                        variables=pipeline_options,
-                        location=self.location,
-                    )
-            if not is_running:
-                pipeline_options["jobName"] = job_name
-                with self.dataflow_hook.provide_authorized_gcloud():
-                    self.beam_hook.start_java_pipeline(
-                        variables=pipeline_options,
-                        jar=self.jar,
-                        job_class=self.job_class,
-                        process_line_callback=process_line_callback,
-                    )
-                self.dataflow_hook.wait_for_done(
-                    job_name=job_name,
-                    location=self.location,
-                    job_id=self.job_id,
-                    multiple_jobs=self.multiple_jobs,
-                )
-
-        return {"job_id": self.job_id}
-
-    def on_kill(self) -> None:
-        self.log.info("On kill.")
-        if self.job_id:
-            self.dataflow_hook.cancel_job(
-                job_id=self.job_id, project_id=self.project_id or self.dataflow_hook.project_id
-            )
-
-
 class DataflowTemplatedJobStartOperator(GoogleCloudBaseOperator):
     """
     Start a Dataflow job with a classic template; the parameters of the operation will be passed to the job.
@@ -1233,224 +936,6 @@ class DataflowStartYamlJobOperator(GoogleCloudBaseOperator):
         )
 
 
-# TODO: Remove one day
-@deprecated(
-    planned_removal_date="November 01, 2024",
-    use_instead="providers.apache.beam.operators.beam.BeamRunPythonPipelineOperator",
-    category=AirflowProviderDeprecationWarning,
-)
-class DataflowCreatePythonJobOperator(GoogleCloudBaseOperator):
-    """
-    Launching Cloud Dataflow jobs written in python.
-
-    Note that both dataflow_default_options and options will be merged to specify pipeline
-    execution parameter, and dataflow_default_options is expected to save high-level options,
-    for instances, project and zone information, which apply to all dataflow operators in the DAG.
-
-    This class is deprecated.
-
-    Please use :class:`providers.apache.beam.operators.beam.BeamRunPythonPipelineOperator`.
-
-    .. seealso::
-        For more detail on job submission have a look at the reference:
-        https://cloud.google.com/dataflow/pipelines/specifying-exec-params
-
-    .. seealso::
-        For more information on how to use this operator, take a look at the guide:
-        :ref:`howto/operator:DataflowCreatePythonJobOperator`
-
-    :param py_file: Reference to the python dataflow pipeline file.py, e.g.,
-        /some/local/file/path/to/your/python/pipeline/file. (templated)
-    :param job_name: The 'job_name' to use when executing the Dataflow job
-        (templated). This ends up being set in the pipeline options, so any entry
-        with key ``'jobName'`` or ``'job_name'`` in ``options`` will be overwritten.
-    :param py_options: Additional python options, e.g., ["-m", "-v"].
-    :param dataflow_default_options: Map of default job options.
-    :param options: Map of job specific options.The key must be a dictionary.
-        The value can contain different types:
-
-        * If the value is None, the single option - ``--key`` (without value) will be added.
-        * If the value is False, this option will be skipped
-        * If the value is True, the single option - ``--key`` (without value) will be added.
-        * If the value is list, the many options will be added for each key.
-          If the value is ``['A', 'B']`` and the key is ``key`` then the ``--key=A --key=B`` options
-          will be left
-        * Other value types will be replaced with the Python textual representation.
-
-        When defining labels (``labels`` option), you can also provide a dictionary.
-    :param py_interpreter: Python version of the beam pipeline.
-        If None, this defaults to the python3.
-        To track python versions supported by beam and related
-        issues check: https://issues.apache.org/jira/browse/BEAM-1251
-    :param py_requirements: Additional python package(s) to install.
-        If a value is passed to this parameter, a new virtual environment has been created with
-        additional packages installed.
-
-        You could also install the apache_beam package if it is not installed on your system or you want
-        to use a different version.
-    :param py_system_site_packages: Whether to include system_site_packages in your virtualenv.
-        See virtualenv documentation for more information.
-
-        This option is only relevant if the ``py_requirements`` parameter is not None.
-    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
-    :param project_id: Optional, the Google Cloud project ID in which to start a job.
-        If set to None or missing, the default project_id from the Google Cloud connection is used.
-    :param location: Job location.
-    :param poll_sleep: The time in seconds to sleep between polling Google
-        Cloud Platform for the dataflow job status while the job is in the
-        JOB_STATE_RUNNING state.
-    :param drain_pipeline: Optional, set to True if want to stop streaming job by draining it
-        instead of canceling during killing task instance. See:
-        https://cloud.google.com/dataflow/docs/guides/stopping-a-pipeline
-    :param cancel_timeout: How long (in seconds) operator should wait for the pipeline to be
-        successfully cancelled when task is being killed.
-    :param wait_until_finished: (Optional)
-        If True, wait for the end of pipeline execution before exiting.
-        If False, only submits job.
-        If None, default behavior.
-
-        The default behavior depends on the type of pipeline:
-
-        * for the streaming pipeline, wait for jobs to start,
-        * for the batch pipeline, wait for the jobs to complete.
-
-        .. warning::
-
-            You cannot call ``PipelineResult.wait_until_finish`` method in your pipeline code for the operator
-            to work properly. i. e. you must use asynchronous execution. Otherwise, your pipeline will
-            always wait until finished. For more information, look at:
-            `Asynchronous execution
-            <https://cloud.google.com/dataflow/docs/guides/specifying-exec-params#python_10>`__
-
-        The process of starting the Dataflow job in Airflow consists of two steps:
-
-        * running a subprocess and reading the stderr/stderr log for the job id.
-        * loop waiting for the end of the job ID from the previous step.
-          This loop checks the status of the job.
-
-        Step two is started just after step one has finished, so if you have wait_until_finished in your
-        pipeline code, step two will not start until the process stops. When this process stops,
-        steps two will run, but it will only execute one iteration as the job will be in a terminal state.
-
-        If you in your pipeline do not call the wait_for_pipeline method but pass wait_until_finish=True
-        to the operator, the second loop will wait for the job's terminal state.
-
-        If you in your pipeline do not call the wait_for_pipeline method, and pass wait_until_finish=False
-        to the operator, the second loop will check once is job not in terminal state and exit the loop.
-    """
-
-    template_fields: Sequence[str] = ("options", "dataflow_default_options", "job_name", "py_file")
-
-    def __init__(
-        self,
-        *,
-        py_file: str,
-        job_name: str = "{{task.task_id}}",
-        dataflow_default_options: dict | None = None,
-        options: dict | None = None,
-        py_interpreter: str = "python3",
-        py_options: list[str] | None = None,
-        py_requirements: list[str] | None = None,
-        py_system_site_packages: bool = False,
-        project_id: str = PROVIDE_PROJECT_ID,
-        location: str = DEFAULT_DATAFLOW_LOCATION,
-        gcp_conn_id: str = "google_cloud_default",
-        poll_sleep: int = 10,
-        drain_pipeline: bool = False,
-        cancel_timeout: int | None = 10 * 60,
-        wait_until_finished: bool | None = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(**kwargs)
-
-        self.py_file = py_file
-        self.job_name = job_name
-        self.py_options = py_options or []
-        self.dataflow_default_options = dataflow_default_options or {}
-        self.options = options or {}
-        self.options.setdefault("labels", {}).update(
-            {"airflow-version": "v" + version.replace(".", "-").replace("+", "-")}
-        )
-        self.py_interpreter = py_interpreter
-        self.py_requirements = py_requirements
-        self.py_system_site_packages = py_system_site_packages
-        self.project_id = project_id
-        self.location = location
-        self.gcp_conn_id = gcp_conn_id
-        self.poll_sleep = poll_sleep
-        self.drain_pipeline = drain_pipeline
-        self.cancel_timeout = cancel_timeout
-        self.wait_until_finished = wait_until_finished
-        self.job_id = None
-        self.beam_hook: BeamHook | None = None
-        self.dataflow_hook: DataflowHook | None = None
-
-    def execute(self, context: Context):
-        """Execute the python dataflow job."""
-        self.beam_hook = BeamHook(runner=BeamRunnerType.DataflowRunner)
-        self.dataflow_hook = DataflowHook(
-            gcp_conn_id=self.gcp_conn_id,
-            poll_sleep=self.poll_sleep,
-            impersonation_chain=None,
-            drain_pipeline=self.drain_pipeline,
-            cancel_timeout=self.cancel_timeout,
-            wait_until_finished=self.wait_until_finished,
-        )
-
-        job_name = self.dataflow_hook.build_dataflow_job_name(job_name=self.job_name)
-        pipeline_options = self.dataflow_default_options.copy()
-        pipeline_options["job_name"] = job_name
-        pipeline_options["project"] = self.project_id or self.dataflow_hook.project_id
-        pipeline_options["region"] = self.location
-        pipeline_options.update(self.options)
-
-        # Convert argument names from lowerCamelCase to snake case.
-        def camel_to_snake(name):
-            return re.sub("[A-Z]", lambda x: "_" + x.group(0).lower(), name)
-
-        formatted_pipeline_options = {camel_to_snake(key): pipeline_options[key] for key in pipeline_options}
-
-        def set_current_job_id(job_id):
-            self.job_id = job_id
-
-        process_line_callback = process_line_and_extract_dataflow_job_id_callback(
-            on_new_job_id_callback=set_current_job_id
-        )
-
-        with ExitStack() as exit_stack:
-            if self.py_file.lower().startswith("gs://"):
-                gcs_hook = GCSHook(self.gcp_conn_id)
-                tmp_gcs_file = exit_stack.enter_context(gcs_hook.provide_file(object_url=self.py_file))
-                self.py_file = tmp_gcs_file.name
-
-            with self.dataflow_hook.provide_authorized_gcloud():
-                self.beam_hook.start_python_pipeline(
-                    variables=formatted_pipeline_options,
-                    py_file=self.py_file,
-                    py_options=self.py_options,
-                    py_interpreter=self.py_interpreter,
-                    py_requirements=self.py_requirements,
-                    py_system_site_packages=self.py_system_site_packages,
-                    process_line_callback=process_line_callback,
-                )
-
-            self.dataflow_hook.wait_for_done(
-                job_name=job_name,
-                location=self.location,
-                job_id=self.job_id,
-                multiple_jobs=False,
-            )
-
-        return {"job_id": self.job_id}
-
-    def on_kill(self) -> None:
-        self.log.info("On kill.")
-        if self.job_id:
-            self.dataflow_hook.cancel_job(
-                job_id=self.job_id, project_id=self.project_id or self.dataflow_hook.project_id
-            )
-
-
 class DataflowStopJobOperator(GoogleCloudBaseOperator):
     """
     Stops the job with the specified name prefix or Job ID.

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

@@ -16,7 +16,8 @@
 # under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from airflow.providers.google.cloud.links.dataform import (
     DataformRepositoryLink,

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

@@ -19,7 +19,8 @@
 from __future__ import annotations
 
 import time
-from typing import TYPE_CHECKING, Any, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
 
 from google.api_core.retry import exponential_sleep_generator
 from googleapiclient.errors import HttpError

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

@@ -19,7 +19,8 @@
 from __future__ import annotations
 
 import time
-from typing import TYPE_CHECKING, Any, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
 
 from airflow.exceptions import AirflowException
 from airflow.providers.google.cloud.triggers.dataplex import (
@@ -686,39 +687,44 @@ class DataplexCreateOrUpdateDataQualityScanOperator(GoogleCloudBaseOperator):
             impersonation_chain=self.impersonation_chain,
         )
 
-        self.log.info("Creating Dataplex Data Quality scan %s", self.data_scan_id)
-        try:
-            operation = hook.create_data_scan(
-                project_id=self.project_id,
-                region=self.region,
-                data_scan_id=self.data_scan_id,
-                body=self.body,
-                retry=self.retry,
-                timeout=self.timeout,
-                metadata=self.metadata,
-            )
-            hook.wait_for_operation(timeout=self.timeout, operation=operation)
-            self.log.info("Dataplex Data Quality scan %s created successfully!", self.data_scan_id)
-        except AlreadyExists:
-            self.log.info("Dataplex Data Quality scan already exists: %s", {self.data_scan_id})
-
-            operation = hook.update_data_scan(
-                project_id=self.project_id,
-                region=self.region,
-                data_scan_id=self.data_scan_id,
-                body=self.body,
-                update_mask=self.update_mask,
-                retry=self.retry,
-                timeout=self.timeout,
-                metadata=self.metadata,
-            )
-            hook.wait_for_operation(timeout=self.timeout, operation=operation)
-            self.log.info("Dataplex Data Quality scan %s updated successfully!", self.data_scan_id)
-        except GoogleAPICallError as e:
-            raise AirflowException(f"Error creating Data Quality scan {self.data_scan_id}", e)
+        if self.update_mask is not None:
+            self._update_data_scan(hook)
+        else:
+            self.log.info("Creating Dataplex Data Quality scan %s", self.data_scan_id)
+            try:
+                operation = hook.create_data_scan(
+                    project_id=self.project_id,
+                    region=self.region,
+                    data_scan_id=self.data_scan_id,
+                    body=self.body,
+                    retry=self.retry,
+                    timeout=self.timeout,
+                    metadata=self.metadata,
+                )
+                hook.wait_for_operation(timeout=self.timeout, operation=operation)
+                self.log.info("Dataplex Data Quality scan %s created successfully!", self.data_scan_id)
+            except AlreadyExists:
+                self._update_data_scan(hook)
+            except GoogleAPICallError as e:
+                raise AirflowException(f"Error creating Data Quality scan {self.data_scan_id}", e)
 
         return self.data_scan_id
 
+    def _update_data_scan(self, hook: DataplexHook):
+        self.log.info("Dataplex Data Quality scan already exists: %s", {self.data_scan_id})
+        operation = hook.update_data_scan(
+            project_id=self.project_id,
+            region=self.region,
+            data_scan_id=self.data_scan_id,
+            body=self.body,
+            update_mask=self.update_mask,
+            retry=self.retry,
+            timeout=self.timeout,
+            metadata=self.metadata,
+        )
+        hook.wait_for_operation(timeout=self.timeout, operation=operation)
+        self.log.info("Dataplex Data Quality scan %s updated successfully!", self.data_scan_id)
+
 
 class DataplexGetDataQualityScanOperator(GoogleCloudBaseOperator):
     """

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

@@ -19,7 +19,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from airflow.providers.google.cloud.hooks.dataprep import GoogleDataprepHook
 from airflow.providers.google.cloud.links.dataprep import DataprepFlowLink, DataprepJobGroupLink