



<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>airflow.contrib.operators.gcp_vision_operator &mdash; Airflow Documentation</title>
  

  
  
  
  

  
  <script type="text/javascript" src="../../../../../_static/js/modernizr.min.js"></script>
  
    
      <script type="text/javascript" id="documentation_options" data-url_root="../../../../../" src="../../../../../_static/documentation_options.js"></script>
        <script type="text/javascript" src="../../../../../_static/jquery.js"></script>
        <script type="text/javascript" src="../../../../../_static/underscore.js"></script>
        <script type="text/javascript" src="../../../../../_static/doctools.js"></script>
        <script type="text/javascript" src="../../../../../_static/language_data.js"></script>
    
    <script type="text/javascript" src="../../../../../_static/js/theme.js"></script>

    

  
  <link rel="stylesheet" href="../../../../../_static/css/theme.css" type="text/css" />
  <link rel="stylesheet" href="../../../../../_static/pygments.css" type="text/css" />
    <link rel="index" title="Index" href="../../../../../genindex.html" />
    <link rel="search" title="Search" href="../../../../../search.html" />
    <link rel="next" title="airflow.contrib.operators.gcs_acl_operator" href="../gcs_acl_operator/index.html" />
    <link rel="prev" title="airflow.contrib.operators.gcp_video_intelligence_operator" href="../gcp_video_intelligence_operator/index.html" />
   
  <script>
    document.addEventListener('DOMContentLoaded', function() {
      var el = document.getElementById('changelog');
      if (el !== null ) {
        // [AIRFLOW-...]
        el.innerHTML = el.innerHTML.replace(
            /\[(AIRFLOW-[\d]+)\]/g,
            `<a href="https://issues.apache.org/jira/browse/$1">[$1]</a>`
        );
        // (#...)
        el.innerHTML = el.innerHTML.replace(
            /\(#([\d]+)\)/g,
            `<a href="https://github.com/apache/airflow/pull/$1">(#$1)</a>`
        );
      };
    })
  </script>
  <style>
    .example-header {
      position: relative;
      background: #9AAA7A;
      padding: 8px 16px;
      margin-bottom: 0;
    }
    .example-header--with-button {
      padding-right: 166px;
    }
    .example-header:after{
      content: '';
      display: table;
      clear: both;
    }
    .example-title {
      display:block;
      padding: 4px;
      margin-right: 16px;
      color: white;
      overflow-x: auto;
    }
    .example-header-button {
      top: 8px;
      right: 16px;
      position: absolute;
    }
    .example-header + .highlight-python {
      margin-top: 0 !important;
    }
    .viewcode-button {
      display: inline-block;
      padding: 8px 16px;
      border: 0;
      margin: 0;
      outline: 0;
      border-radius: 2px;
      -webkit-box-shadow: 0 3px 5px 0 rgba(0,0,0,.3);
      box-shadow: 0 3px 6px 0 rgba(0,0,0,.3);
      color: #404040;
      background-color: #e7e7e7;
      cursor: pointer;
      font-size: 16px;
      font-weight: 500;
      line-height: 1;
      text-decoration: none;
      text-overflow: ellipsis;
      overflow: hidden;
      text-transform: uppercase;
      -webkit-transition: background-color .2s;
      transition: background-color .2s;
      vertical-align: middle;
      white-space: nowrap;
    }
    .viewcode-button:visited {
      color: #404040;
    }
    .viewcode-button:hover, .viewcode-button:focus {
      color: #404040;
      background-color: #d6d6d6;
    }
  </style>
<!-- Matomo -->
<script>
  var _paq = window._paq = window._paq || [];
  _paq.push(['disableCookies']);
  _paq.push(['trackPageView']);
  _paq.push(['enableLinkTracking']);
  (function() {
    var u="https://analytics.apache.org/";
    _paq.push(['setTrackerUrl', u+'matomo.php']);
    _paq.push(['setSiteId', '13']);
    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
    g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
  })();
</script>
<!-- End Matomo -->
</head>


<body class="wy-body-for-nav">

   
  <div class="wy-grid-for-nav">
    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search" >
          

          
            <a href="../../../../../index.html" class="icon icon-home"> Airflow
          

          
          </a>

          
            
            
              <div class="version">
                1.10.4
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="../../../../../search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
            
            
              
            
            
              <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../../../../../project.html">Project</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../license.html">License</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../start.html">Quick Start</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../installation.html">Installation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../tutorial.html">Tutorial</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../howto/index.html">How-to Guides</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../ui.html">UI / Screenshots</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../concepts.html">Concepts</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../profiling.html">Data Profiling</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../cli.html">Command Line Interface</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../scheduler.html">Scheduling &amp; Triggers</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../plugins.html">Plugins</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../security.html">Security</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../timezone.html">Time zones</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../api.html">Experimental Rest API</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../integration.html">Integration</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../metrics.html">Metrics</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../kubernetes.html">Kubernetes</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../lineage.html">Lineage</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../changelog.html">Changelog</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../faq.html">FAQ</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../../../macros.html">Macros reference</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../../../../index.html">API Reference</a><ul class="current">
<li class="toctree-l2 current"><a class="reference internal" href="../../../../index.html#operators">Operators</a><ul class="current">
<li class="toctree-l3"><a class="reference internal" href="../../../../index.html#baseoperator">BaseOperator</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../../../index.html#basesensoroperator">BaseSensorOperator</a></li>
<li class="toctree-l3 current"><a class="reference internal" href="../../../../index.html#operators-packages">Operators packages</a><ul class="current">
<li class="toctree-l4"><a class="reference internal" href="../../../operators/index.html"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.operators</span></code></a></li>
<li class="toctree-l4"><a class="reference internal" href="../../../sensors/index.html"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.sensors</span></code></a></li>
<li class="toctree-l4 current"><a class="reference internal" href="../index.html"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.contrib.operators</span></code></a></li>
<li class="toctree-l4"><a class="reference internal" href="../../sensors/index.html"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.contrib.sensors</span></code></a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../../../../index.html#hooks">Hooks</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../../../index.html#executors">Executors</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../../../index.html#models">Models</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../../../index.html#core-and-community-package">Core and community package</a></li>
</ul>
</li>
</ul>

            
          
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="../../../../../index.html">Airflow</a>
        
      </nav>


      <div class="wy-nav-content">
        
        <div class="rst-content">
        
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="../../../../../index.html">Docs</a> &raquo;</li>
        
          <li><a href="../../../../index.html">API Reference</a> &raquo;</li>
        
          <li><a href="../index.html"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.contrib.operators</span></code></a> &raquo;</li>
        
      <li><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.contrib.operators.gcp_vision_operator</span></code></li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="../../../../../_sources/_api/airflow/contrib/operators/gcp_vision_operator/index.rst.txt" rel="nofollow"> View page source</a>
          
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  <div class="section" id="module-airflow.contrib.operators.gcp_vision_operator">
<span id="airflow-contrib-operators-gcp-vision-operator"></span><h1><a class="reference internal" href="#module-airflow.contrib.operators.gcp_vision_operator" title="airflow.contrib.operators.gcp_vision_operator"><code class="xref py py-mod docutils literal notranslate"><span class="pre">airflow.contrib.operators.gcp_vision_operator</span></code></a><a class="headerlink" href="#module-airflow.contrib.operators.gcp_vision_operator" title="Permalink to this headline">¶</a></h1>
<div class="section" id="module-contents">
<h2>Module Contents<a class="headerlink" href="#module-contents" title="Permalink to this headline">¶</a></h2>
<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductSetCreateOperator</code><span class="sig-paren">(</span><em class="sig-param">product_set</em>, <em class="sig-param">location</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">product_set_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetCreateOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Creates a new ProductSet resource.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductsetcreateoperator"><span class="std std-ref">CloudVisionProductSetCreateOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>product_set</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.ProductSet" title="(in google-cloud)"><em>google.cloud.vision_v1.types.ProductSet</em></a>) – (Required) The ProductSet to create. If a dict is provided, it must be of the same
form as the protobuf message <cite>ProductSet</cite>.</p></li>
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the ProductSet should be created. Valid regions
(as of 2019-02-05) are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the ProductSet should be created. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) A user-supplied resource id for this ProductSet.
If set, the server will attempt to use this value as the resource id. If it is
already in use, an error is returned with code ALREADY_EXISTS. Must be at most
128 characters long. It cannot contain the character /.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_set_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetCreateOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetCreateOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetCreateOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductSetGetOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">product_set_id</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetGetOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Gets information associated with a ProductSet.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductsetgetoperator"><span class="std std-ref">CloudVisionProductSetGetOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the ProductSet is located. Valid regions (as of 2019-02-05)
are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this ProductSet.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the ProductSet is located. If set
to None or missing, the default <cite>project_id</cite> from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_set_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetGetOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetGetOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetGetOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductSetUpdateOperator</code><span class="sig-paren">(</span><em class="sig-param">product_set</em>, <em class="sig-param">location=None</em>, <em class="sig-param">product_set_id=None</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">update_mask=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetUpdateOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Makes changes to a <cite>ProductSet</cite> resource. Only display_name can be updated currently.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>To locate the <cite>ProductSet</cite> resource, its <cite>name</cite> in the form
<cite>projects/PROJECT_ID/locations/LOC_ID/productSets/PRODUCT_SET_ID</cite> is necessary.</p>
</div>
<p>You can provide the <cite>name</cite> directly as an attribute of the <cite>product_set</cite> object.
However, you can leave it blank and provide <cite>location</cite> and <cite>product_set_id</cite> instead
(and optionally <cite>project_id</cite> - if not present, the connection default will be used)
and the <cite>name</cite> will be created by the operator itself.</p>
<p>This mechanism exists for your convenience, to allow leaving the <cite>project_id</cite> empty
and having Airflow use the connection default <cite>project_id</cite>.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductsetupdateoperator"><span class="std std-ref">CloudVisionProductSetUpdateOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>product_set</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.ProductSet" title="(in google-cloud)"><em>google.cloud.vision_v1.types.ProductSet</em></a>) – (Required) The ProductSet resource which replaces the one on the
server. If a dict is provided, it must be of the same form as the protobuf
message <cite>ProductSet</cite>.</p></li>
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The region where the ProductSet is located. Valid regions (as of 2019-02-05)
are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The resource id of this ProductSet.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the ProductSet should be created. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>update_mask</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.FieldMask" title="(in google-cloud)"><em>google.cloud.vision_v1.types.FieldMask</em></a>) – (Optional) The <cite>FieldMask</cite> that specifies which fields to update. If update_mask
isn’t specified, all mutable fields are to be updated. Valid mask path is display_name. If a dict is
provided, it must be of the same form as the protobuf message <cite>FieldMask</cite>.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_set_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetUpdateOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetUpdateOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetUpdateOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductSetDeleteOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">product_set_id</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetDeleteOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Permanently deletes a <cite>ProductSet</cite>. <cite>Products</cite> and <cite>ReferenceImages</cite> in the
<cite>ProductSet</cite> are not deleted. The actual image files are not deleted from Google
Cloud Storage.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductsetdeleteoperator"><span class="std std-ref">CloudVisionProductSetDeleteOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the ProductSet is located. Valid regions (as of 2019-02-05)
are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this ProductSet.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the ProductSet should be created.
If set to None or missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_set_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetDeleteOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductSetDeleteOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductSetDeleteOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductCreateOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">product</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">product_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductCreateOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Creates and returns a new product resource.</p>
<p>Possible errors regarding the <cite>Product</cite> object provided:</p>
<ul class="simple">
<li><p>Returns <cite>INVALID_ARGUMENT</cite> if <cite>display_name</cite> is missing or longer than 4096 characters.</p></li>
<li><p>Returns <cite>INVALID_ARGUMENT</cite> if <cite>description</cite> is longer than 4096 characters.</p></li>
<li><p>Returns <cite>INVALID_ARGUMENT</cite> if <cite>product_category</cite> is missing or invalid.</p></li>
</ul>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductcreateoperator"><span class="std std-ref">CloudVisionProductCreateOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the Product should be created. Valid regions
(as of 2019-02-05) are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Product" title="(in google-cloud)"><em>google.cloud.vision_v1.types.Product</em></a>) – (Required) The product to create. If a dict is provided, it must be of the same form as
the protobuf message <cite>Product</cite>.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product should be created. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) A user-supplied resource id for this Product.
If set, the server will attempt to use this value as the resource id. If it is
already in use, an error is returned with code ALREADY_EXISTS. Must be at most
128 characters long. It cannot contain the character /.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductCreateOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductCreateOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductCreateOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductGetOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">product_id</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductGetOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Gets information associated with a <cite>Product</cite>.</p>
<p>Possible errors:</p>
<ul class="simple">
<li><p>Returns <cite>NOT_FOUND</cite> if the <cite>Product</cite> does not exist.</p></li>
</ul>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductgetoperator"><span class="std std-ref">CloudVisionProductGetOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the Product is located. Valid regions (as of 2019-02-05) are:
us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this Product.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to
None or missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductGetOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductGetOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductUpdateOperator</code><span class="sig-paren">(</span><em class="sig-param">product</em>, <em class="sig-param">location=None</em>, <em class="sig-param">product_id=None</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">update_mask=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductUpdateOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Makes changes to a Product resource. Only the display_name, description, and labels fields can be
updated right now.</p>
<p>If labels are updated, the change will not be reflected in queries until the next index time.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>To locate the <cite>Product</cite> resource, its <cite>name</cite> in the form
<cite>projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID</cite> is necessary.</p>
</div>
<p>You can provide the <cite>name</cite> directly as an attribute of the <cite>product</cite> object. However, you can leave it
blank and provide <cite>location</cite> and <cite>product_id</cite> instead (and optionally <cite>project_id</cite> - if not present,
the connection default will be used) and the <cite>name</cite> will be created by the operator itself.</p>
<p>This mechanism exists for your convenience, to allow leaving the <cite>project_id</cite> empty and having Airflow
use the connection default <cite>project_id</cite>.</p>
<p>Possible errors related to the provided <cite>Product</cite>:</p>
<ul class="simple">
<li><p>Returns <cite>NOT_FOUND</cite> if the Product does not exist.</p></li>
<li><dl class="simple">
<dt>Returns <cite>INVALID_ARGUMENT</cite> if <cite>display_name</cite> is present in update_mask but is missing from the request</dt><dd><p>or longer than 4096 characters.</p>
</dd>
</dl>
</li>
<li><dl class="simple">
<dt>Returns <cite>INVALID_ARGUMENT</cite> if <cite>description</cite> is present in update_mask but is longer than 4096</dt><dd><p>characters.</p>
</dd>
</dl>
</li>
<li><p>Returns <cite>INVALID_ARGUMENT</cite> if <cite>product_category</cite> is present in update_mask.</p></li>
</ul>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductupdateoperator"><span class="std std-ref">CloudVisionProductUpdateOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>product</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.ProductSet" title="(in google-cloud)"><em>google.cloud.vision_v1.types.ProductSet</em></a>) – (Required) The Product resource which replaces the one on the server. product.name is
immutable. If a dict is provided, it must be of the same form as the protobuf message <cite>Product</cite>.</p></li>
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The region where the Product is located. Valid regions (as of 2019-02-05) are:
us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The resource id of this Product.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>update_mask</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.FieldMask" title="(in google-cloud)"><em>google.cloud.vision_v1.types.FieldMask</em></a>) – (Optional) The <cite>FieldMask</cite> that specifies which fields to update. If update_mask
isn’t specified, all mutable fields are to be updated. Valid mask paths include product_labels,
display_name, and description. If a dict is provided, it must be of the same form as the protobuf
message <cite>FieldMask</cite>.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductUpdateOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductUpdateOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionProductDeleteOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">product_id</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductDeleteOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Permanently deletes a product and its reference images.</p>
<p>Metadata of the product and all its images will be deleted right away, but search queries against
ProductSets containing the product may still work until all related caches are refreshed.</p>
<p>Possible errors:</p>
<ul class="simple">
<li><p>Returns <cite>NOT_FOUND</cite> if the product does not exist.</p></li>
</ul>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionproductdeleteoperator"><span class="std std-ref">CloudVisionProductDeleteOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the Product is located. Valid regions (as of 2019-02-05) are:
us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this Product.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'project_id', 'product_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductDeleteOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionProductDeleteOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionProductDeleteOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionAnnotateImageOperator</code><span class="sig-paren">(</span><em class="sig-param">request</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAnnotateImageOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Run image detection and annotation for an image or a batch of images.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionannotateimageoperator"><span class="std std-ref">CloudVisionAnnotateImageOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>request</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.7)"><em>list</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest" title="(in google-cloud)"><em>google.cloud.vision_v1.types.AnnotateImageRequest</em></a><em>] </em><em>for batch</em><em> or
</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><em>google.cloud.vision_v1.types.AnnotateImageRequest for single image.</em>) – (Required) Annotation request for image or a batch.
If a dict is provided, it must be of the same form as the protobuf
message class:<cite>google.cloud.vision_v1.types.AnnotateImageRequest</cite></p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['request', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAnnotateImageOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAnnotateImageOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAnnotateImageOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionReferenceImageCreateOperator</code><span class="sig-paren">(</span><em class="sig-param">location</em>, <em class="sig-param">reference_image</em>, <em class="sig-param">product_id</em>, <em class="sig-param">reference_image_id=None</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionReferenceImageCreateOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Creates and returns a new ReferenceImage ID resource.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionreferenceimagecreateoperator"><span class="std std-ref">CloudVisionReferenceImageCreateOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>location</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The region where the Product is located. Valid regions (as of 2019-02-05) are:
us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>reference_image</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.ReferenceImage" title="(in google-cloud)"><em>google.cloud.vision_v1.types.ReferenceImage</em></a>) – (Required) The reference image to create. If an image ID is specified, it is
ignored.
If a dict is provided, it must be of the same form as the protobuf message
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.ReferenceImage" title="(in google-cloud)"><code class="xref py py-class docutils literal notranslate"><span class="pre">google.cloud.vision_v1.types.ReferenceImage</span></code></a></p></li>
<li><p><strong>reference_image_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) A user-supplied resource id for the ReferenceImage to be added.
If set, the server will attempt to use this value as the resource id. If it is already in use, an
error is returned with code ALREADY_EXISTS. Must be at most 128 characters long. It cannot contain
the character <cite>/</cite>.</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The resource id of this Product.</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'reference_image', 'product_id', 'reference_image_id', 'project_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionReferenceImageCreateOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionReferenceImageCreateOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionAddProductToProductSetOperator</code><span class="sig-paren">(</span><em class="sig-param">product_set_id</em>, <em class="sig-param">product_id</em>, <em class="sig-param">location</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAddProductToProductSetOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Adds a Product to the specified ProductSet. If the Product is already present, no change is made.</p>
<p>One Product can be added to at most 100 ProductSets.</p>
<p>Possible errors:</p>
<ul class="simple">
<li><p>Returns <cite>NOT_FOUND</cite> if the Product or the ProductSet doesn’t exist.</p></li>
</ul>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionaddproducttoproductsetoperator"><span class="std std-ref">CloudVisionAddProductToProductSetOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id for the ProductSet to modify.</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this Product.</p></li>
<li><p><strong>location</strong> – (Required) The region where the ProductSet is located. Valid regions (as of 2019-02-05)
are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
<dt class="field-even">Type</dt>
<dd class="field-even"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)">str</a></p>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'product_set_id', 'product_id', 'project_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAddProductToProductSetOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionAddProductToProductSetOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionRemoveProductFromProductSetOperator</code><span class="sig-paren">(</span><em class="sig-param">product_set_id</em>, <em class="sig-param">product_id</em>, <em class="sig-param">location</em>, <em class="sig-param">project_id=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">metadata=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionRemoveProductFromProductSetOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Removes a Product from the specified ProductSet.</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisionremoveproductfromproductsetoperator"><span class="std std-ref">CloudVisionRemoveProductFromProductSetOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>product_set_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id for the ProductSet to modify.</p></li>
<li><p><strong>product_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Required) The resource id of this Product.</p></li>
<li><p><strong>location</strong> – (Required) The region where the ProductSet is located. Valid regions (as of 2019-02-05)
are: us-east1, us-west1, europe-west1, asia-east1</p></li>
<li><p><strong>project_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The project in which the Product is located. If set to None or
missing, the default project_id from the GCP connection is used.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – (Optional) The amount of time, in seconds, to wait for the request to
complete. Note that if retry is specified, the timeout applies to each individual
attempt.</p></li>
<li><p><strong>metadata</strong> (<em>sequence</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>]</em><em>]</em>) – (Optional) Additional metadata that is provided to the method.</p></li>
<li><p><strong>gcp_conn_id</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a>) – (Optional) The connection ID used to connect to Google Cloud Platform.</p></li>
</ul>
</dd>
<dt class="field-even">Type</dt>
<dd class="field-even"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)">str</a></p>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['location', 'product_set_id', 'product_id', 'project_id', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionRemoveProductFromProductSetOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionRemoveProductFromProductSetOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionDetectTextOperator</code><span class="sig-paren">(</span><em class="sig-param">image</em>, <em class="sig-param">max_results=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">language_hints=None</em>, <em class="sig-param">web_detection_params=None</em>, <em class="sig-param">additional_properties=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectTextOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Detects Text in the image</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisiondetecttextoperator"><span class="std std-ref">CloudVisionDetectTextOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>image</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image" title="(in google-cloud)"><em>google.cloud.vision_v1.types.Image</em></a>) – (Required) The image to analyze. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image</a></p></li>
<li><p><strong>max_results</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – (Optional) Number of results to return.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – Number of seconds before timing out.</p></li>
<li><p><strong>language_hints</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.7)"><em>list</em></a><em> or </em><em>google.cloud.vision.v1.ImageContext.language_hints:</em>) – List of languages to use for TEXT_DETECTION.
In most cases, an empty value yields the best results since it enables automatic language detection.
For languages based on the Latin alphabet, setting language_hints is not needed.</p></li>
<li><p><strong>web_detection_params</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><em>google.cloud.vision.v1.ImageContext.web_detection_params</em>) – Parameters for web detection.</p></li>
<li><p><strong>additional_properties</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a>) – Additional properties to be set on the AnnotateImageRequest. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest" title="(in google-cloud)"><code class="xref py py-class docutils literal notranslate"><span class="pre">google.cloud.vision_v1.types.AnnotateImageRequest</span></code></a></p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['image', 'max_results', 'timeout', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectTextOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectTextOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionDetectDocumentTextOperator</code><span class="sig-paren">(</span><em class="sig-param">image</em>, <em class="sig-param">max_results=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">language_hints=None</em>, <em class="sig-param">web_detection_params=None</em>, <em class="sig-param">additional_properties=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectDocumentTextOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Detects Document Text in the image</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisiondetectdocumenttextoperator"><span class="std std-ref">CloudVisionDetectDocumentTextOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>image</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image" title="(in google-cloud)"><em>google.cloud.vision_v1.types.Image</em></a>) – (Required) The image to analyze. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image</a></p></li>
<li><p><strong>max_results</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – Number of results to return.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – Number of seconds before timing out.</p></li>
<li><p><strong>language_hints</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.7)"><em>str</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.7)"><em>list</em></a><em> or </em><em>google.cloud.vision.v1.ImageContext.language_hints:</em>) – List of languages to use for TEXT_DETECTION.
In most cases, an empty value yields the best results since it enables automatic language detection.
For languages based on the Latin alphabet, setting language_hints is not needed.</p></li>
<li><p><strong>web_detection_params</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><em>google.cloud.vision.v1.ImageContext.web_detection_params</em>) – Parameters for web detection.</p></li>
<li><p><strong>additional_properties</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a>) – Additional properties to be set on the AnnotateImageRequest. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest</a></p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['image', 'max_results', 'timeout', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectDocumentTextOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectDocumentTextOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectDocumentTextOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionDetectImageLabelsOperator</code><span class="sig-paren">(</span><em class="sig-param">image</em>, <em class="sig-param">max_results=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">additional_properties=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageLabelsOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Detects Document Text in the image</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisiondetectimagelabelsoperator"><span class="std std-ref">CloudVisionDetectImageLabelsOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>image</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image" title="(in google-cloud)"><em>google.cloud.vision_v1.types.Image</em></a>) – (Required) The image to analyze. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image</a></p></li>
<li><p><strong>max_results</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – Number of results to return.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – Number of seconds before timing out.</p></li>
<li><p><strong>additional_properties</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a>) – Additional properties to be set on the AnnotateImageRequest. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest</a></p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['image', 'max_results', 'timeout', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageLabelsOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageLabelsOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageLabelsOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator">
<em class="property">class </em><code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">CloudVisionDetectImageSafeSearchOperator</code><span class="sig-paren">(</span><em class="sig-param">image</em>, <em class="sig-param">max_results=None</em>, <em class="sig-param">retry=None</em>, <em class="sig-param">timeout=None</em>, <em class="sig-param">additional_properties=None</em>, <em class="sig-param">gcp_conn_id='google_cloud_default'</em>, <em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageSafeSearchOperator"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="../../../models/index.html#airflow.models.BaseOperator" title="airflow.models.BaseOperator"><code class="xref py py-class docutils literal notranslate"><span class="pre">airflow.models.BaseOperator</span></code></a></p>
<p>Detects Document Text in the image</p>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p>For more information on how to use this operator, take a look at the guide:
<a class="reference internal" href="../../../../../howto/operator/gcp/vision.html#howto-operator-cloudvisiondetectimagesafesearchoperator"><span class="std std-ref">CloudVisionDetectImageSafeSearchOperator</span></a></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>image</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a><em> or </em><a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image" title="(in google-cloud)"><em>google.cloud.vision_v1.types.Image</em></a>) – (Required) The image to analyze. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.Image</a></p></li>
<li><p><strong>max_results</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – Number of results to return.</p></li>
<li><p><strong>retry</strong> (<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/core/retry.html#google.api_core.retry.Retry" title="(in google-cloud)"><em>google.api_core.retry.Retry</em></a>) – (Optional) A retry object used to retry requests. If <cite>None</cite> is
specified, requests will not be retried.</p></li>
<li><p><strong>timeout</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – Number of seconds before timing out.</p></li>
<li><p><strong>additional_properties</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.7)"><em>dict</em></a>) – Additional properties to be set on the AnnotateImageRequest. See more:
<a class="reference external" href="https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest">https://googleapis.github.io/google-cloud-python/latest/vision/gapic/v1/types.html#google.cloud.vision_v1.types.AnnotateImageRequest</a></p></li>
</ul>
</dd>
</dl>
<dl class="attribute">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator.template_fields">
<code class="sig-name descname">template_fields</code><em class="property"> = ['image', 'max_results', 'timeout', 'gcp_conn_id']</em><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageSafeSearchOperator.template_fields"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator.template_fields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator.execute">
<code class="sig-name descname">execute</code><span class="sig-paren">(</span><em class="sig-param">self</em>, <em class="sig-param">context</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#CloudVisionDetectImageSafeSearchOperator.execute"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectImageSafeSearchOperator.execute" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="function">
<dt id="airflow.contrib.operators.gcp_vision_operator.prepare_additional_parameters">
<code class="sig-prename descclassname">airflow.contrib.operators.gcp_vision_operator.</code><code class="sig-name descname">prepare_additional_parameters</code><span class="sig-paren">(</span><em class="sig-param">additional_properties</em>, <em class="sig-param">language_hints</em>, <em class="sig-param">web_detection_params</em><span class="sig-paren">)</span><a class="reference internal" href="../../../../../_modules/airflow/contrib/operators/gcp_vision_operator.html#prepare_additional_parameters"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#airflow.contrib.operators.gcp_vision_operator.prepare_additional_parameters" title="Permalink to this definition">¶</a></dt>
<dt>
<code class="sig-name descname">Creates additional_properties parameter based on language_hints, web_detection_params and</code></dt>
<dt>
<code class="sig-name descname">additional_properties parameters specified by the user</code></dt>
<dd></dd></dl>

</div>
</div>


           </div>
           
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="../gcs_acl_operator/index.html" class="btn btn-neutral float-right" title="airflow.contrib.operators.gcs_acl_operator" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="../gcp_video_intelligence_operator/index.html" class="btn btn-neutral float-left" title="airflow.contrib.operators.gcp_video_intelligence_operator" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <p>

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script>

  
  
    
   

</body>
</html>
