:py:mod:`airflow.providers.google.cloud.operators.looker`
=========================================================

.. py:module:: airflow.providers.google.cloud.operators.looker

.. autoapi-nested-parse::

   This module contains Google Cloud Looker operators.


Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   airflow.providers.google.cloud.operators.looker.LookerStartPdtBuildOperator


.. py:class:: LookerStartPdtBuildOperator(looker_conn_id, model, view, query_params = None, asynchronous = False, cancel_on_kill = True, wait_time = 10, wait_timeout = None, **kwargs)

   Bases: :py:obj:`airflow.models.BaseOperator`

   Submits a PDT materialization job to Looker.

   :param looker_conn_id: Required. The connection ID to use connecting to Looker.
   :param model: Required. The model of the PDT to start building.
   :param view: Required. The view of the PDT to start building.
   :param query_params: Optional. Additional materialization parameters.
   :param asynchronous: Optional. Flag indicating whether to wait for the job
       to finish or return immediately.
       This is useful for submitting long running jobs and
       waiting on them asynchronously using the LookerCheckPdtBuildSensor
   :param cancel_on_kill: Optional. Flag which indicates whether cancel the
       hook's job or not, when on_kill is called.
   :param wait_time: Optional. Number of seconds between checks for job to be
       ready. Used only if ``asynchronous`` is False.
   :param wait_timeout: Optional. How many seconds wait for job to be ready.
       Used only if ``asynchronous`` is False.

   .. py:method:: execute(self, context)

      This is the main method to derive when creating an operator.
      Context is the same dictionary used as when rendering jinja templates.

      Refer to get_template_context for more context.


   .. py:method:: on_kill(self)

      Override this method to cleanup subprocesses when a task instance
      gets killed. Any use of the threading, subprocess or multiprocessing
      module within an operator needs to be cleaned up or it will leave
      ghost processes behind.