class_docstr: Executes a data factory pipeline.
  
  .. seealso::
      For more information on how to use this operator, take a look at the guide:
      :ref:`howto/operator:AzureDataFactoryRunPipelineOperator`
  
  :param azure_data_factory_conn_id: The connection identifier for connecting to Azure Data Factory.
  :param pipeline_name: The name of the pipeline to execute.
  :param wait_for_termination: Flag to wait on a pipeline run's termination.  By default, this feature is
      enabled but could be disabled to perform an asynchronous wait for a long-running pipeline execution
      using the ``AzureDataFactoryPipelineRunSensor``.
  :param resource_group_name: The resource group name. If a value is not passed in to the operator, the
      ``AzureDataFactoryHook`` will attempt to use the resource group name provided in the corresponding
      connection.
  :param factory_name: The data factory name. If a value is not passed in to the operator, the
      ``AzureDataFactoryHook`` will attempt to use the factory name provided in the corresponding
      connection.
  :param reference_pipeline_run_id: The pipeline run identifier. If this run ID is specified the parameters
      of the specified run will be used to create a new run.
  :param is_recovery: Recovery mode flag. If recovery mode is set to `True`, the specified referenced
      pipeline run and the new run will be grouped under the same ``groupId``.
  :param start_activity_name: In recovery mode, the rerun will start from this activity. If not specified,
      all activities will run.
  :param start_from_failure: In recovery mode, if set to true, the rerun will start from failed activities.
      The property will be used only if ``start_activity_name`` is not specified.
  :param parameters: Parameters of the pipeline run. These parameters are referenced in a pipeline via
      ``@pipeline().parameters.parameterName`` and will be used only if the ``reference_pipeline_run_id`` is
      not specified.
  :param timeout: Time in seconds to wait for a pipeline to reach a terminal status for non-asynchronous
      waits. Used only if ``wait_for_termination`` is True.
  :param check_interval: Time in seconds to check on a pipeline run's status for non-asynchronous waits.
      Used only if ``wait_for_termination`` is True.
  :param deferrable: Run operator in deferrable mode.
code: def __init__(
      self,
      *,
      pipeline_name: str,
      azure_data_factory_conn_id: str = AzureDataFactoryHook.default_conn_name,
      resource_group_name: str,
      factory_name: str,
      wait_for_termination: bool = True,
      reference_pipeline_run_id: str | None = None,
      is_recovery: bool | None = None,
      start_activity_name: str | None = None,
      start_from_failure: bool | None = None,
      parameters: dict[str, Any] | None = None,
      timeout: int = 60 * 60 * 24 * 7,
      check_interval: int = 60,
      deferrable: bool = conf.getboolean(
          "operators", "default_deferrable", fallback=False
      ),
      **kwargs,
  ) -> None:
      super().__init__(**kwargs)
      self.azure_data_factory_conn_id = azure_data_factory_conn_id
      self.pipeline_name = pipeline_name
      self.wait_for_termination = wait_for_termination
      self.resource_group_name = resource_group_name
      self.factory_name = factory_name
      self.reference_pipeline_run_id = reference_pipeline_run_id
      self.is_recovery = is_recovery
      self.start_activity_name = start_activity_name
      self.start_from_failure = start_from_failure
      self.parameters = parameters
      self.timeout = timeout
      self.check_interval = check_interval
      self.deferrable = deferrable
  
imports: from __future__ import annotations
  import time
  import warnings
  from functools import cached_property
  from typing import TYPE_CHECKING, Any, Sequence
  from airflow.configuration import conf
  from airflow.exceptions import AirflowException
  from airflow.hooks.base import BaseHook
  from airflow.models import BaseOperator, BaseOperatorLink, XCom
  from airflow.providers.microsoft.azure.hooks.data_factory import AzureDataFactoryHook, AzureDataFactoryPipelineRunException, AzureDataFactoryPipelineRunStatus, get_field
  from airflow.providers.microsoft.azure.triggers.data_factory import AzureDataFactoryTrigger
  from airflow.utils.log.logging_mixin import LoggingMixin
label_desc: Use image node_id 1 to create a new AzureDataFactoryRunPipelineOperator object from inherited base classes: BaseOperator with example: obj = AzureDataFactoryRunPipelineOperator()