

<!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>Changelog &mdash; Airflow Documentation</title>
  

  
  
  
  

  

  
  
    

  

  <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="FAQ" href="faq.html" />
    <link rel="prev" title="Lineage" href="lineage.html" /> 

  
  <script src="_static/js/modernizr.min.js"></script>
<!-- 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.2
              </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 current"><a class="current reference internal" href="#">Changelog</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-10-2-2019-01-19">Airflow 1.10.2, 2019-01-19</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#new-features">New features</a></li>
<li class="toctree-l3"><a class="reference internal" href="#improvements">Improvements</a></li>
<li class="toctree-l3"><a class="reference internal" href="#bug-fixes">Bug fixes</a></li>
<li class="toctree-l3"><a class="reference internal" href="#doc-only-changes">Doc-only changes</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-10-1-2018-11-13">Airflow 1.10.1, 2018-11-13</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#id1">New features</a></li>
<li class="toctree-l3"><a class="reference internal" href="#id2">Improvements</a></li>
<li class="toctree-l3"><a class="reference internal" href="#id3">Doc-only changes</a></li>
<li class="toctree-l3"><a class="reference internal" href="#id4">Bug fixes</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-10-0-2018-08-03">Airflow 1.10.0, 2018-08-03</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-9-0-2018-01-02">Airflow 1.9.0, 2018-01-02</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-8-2-2017-09-04">Airflow 1.8.2, 2017-09-04</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-8-1-2017-05-09">Airflow 1.8.1, 2017-05-09</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-8-0-2017-03-12">Airflow 1.8.0, 2017-03-12</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-7-2">Airflow 1.7.2</a></li>
<li class="toctree-l2"><a class="reference internal" href="#airflow-1-7-1-2016-05-19">Airflow 1.7.1, 2016-05-19</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="faq.html">FAQ</a></li>
<li class="toctree-l1"><a class="reference internal" href="code.html">API Reference</a></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>Changelog</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/changelog.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="changelog">
<h1>Changelog<a class="headerlink" href="#changelog" title="Permalink to this headline">¶</a></h1>
<div class="section" id="airflow-1-10-2-2019-01-19">
<h2>Airflow 1.10.2, 2019-01-19<a class="headerlink" href="#airflow-1-10-2-2019-01-19" title="Permalink to this headline">¶</a></h2>
<div class="section" id="new-features">
<h3>New features<a class="headerlink" href="#new-features" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-2658] Add GCP specific k8s pod operator (#3532)</li>
<li>[AIRFLOW-2440] Google Cloud SQL import/export operator (#4251)</li>
<li>[AIRFLOW-3212] Add AwsGlueCatalogPartitionSensor (#4112)</li>
<li>[AIRFLOW-2750] Add subcommands to delete and list users</li>
<li>[AIRFLOW-3480] Add GCP Spanner Database Operators (#4353)</li>
<li>[AIRFLOW-3560] Add DayOfWeek Sensor (#4363)</li>
<li>[AIRFLOW-3371] BigQueryHook’s Ability to Create View (#4213)</li>
<li>[AIRFLOW-3332] Add method to allow inserting rows into BQ table (#4179)</li>
<li>[AIRFLOW-3055] add get_dataset and get_datasets_list to bigquery_hook (#3894)</li>
<li>[AIRFLOW-2887] Added BigQueryCreateEmptyDatasetOperator and create_emty_dataset to bigquery_hook (#3876)</li>
<li>[AIRFLOW-2758] Add a sensor for MongoDB</li>
<li>[AIRFLOW-2640] Add Cassandra table sensor</li>
<li>[AIRFLOW-3398] Google Cloud Spanner instance database query operator (#4314)</li>
<li>[AIRFLOW-3310] Google Cloud Spanner deploy / delete operators (#4286)</li>
<li>[AIRFLOW-3406] Implement an Azure CosmosDB operator (#4265)</li>
<li>[AIRFLOW-3434] Allows creating intermediate dirs in SFTPOperator (#4270)</li>
<li>[AIRFLOW-3345] Add Google Cloud Storage (GCS) operators for ACL (#4192)</li>
<li>[AIRFLOW-3266] Add AWS Athena Hook and Operator (#4111)</li>
<li>[AIRFLOW-3346] Add hook and operator for GCP transfer service (#4189)</li>
<li>[AIRFLOW-2983] Add prev_ds_nodash and next_ds_nodash macro (#3821)</li>
<li>[AIRFLOW-3403] Add AWS Athena Sensor (#4244)</li>
<li>[AIRFLOW-3323] Support HTTP basic authentication for Airflow Flower (#4166)</li>
<li>[AIRFLOW-3410] Add feature to allow Host Key Change for SSH Op (#4249)</li>
<li>[AIRFLOW-3275] Add Google Cloud SQL Query operator (#4170)</li>
<li>[AIRFLOW-2691] Manage JS dependencies via npm</li>
<li>[AIRFLOW-2795] Oracle to Oracle Transfer Operator (#3639)</li>
<li>[AIRFLOW-2596] Add Oracle to Azure Datalake Transfer Operator</li>
<li>[AIRFLOW-3220] Add Instance Group Manager Operators for GCE (#4167)</li>
<li>[AIRFLOW-2882] Add import and export for pool cli using JSON</li>
<li>[AIRFLOW-2965] CLI tool to show the next execution datetime (#3834)</li>
<li>[AIRFLOW-2874] Enables FAB’s theme support (#3719)</li>
<li>[AIRFLOW-3336] Add new TriggerRule for 0 upstream failures (#4182)</li>
</ul>
</div>
<div class="section" id="improvements">
<h3>Improvements<a class="headerlink" href="#improvements" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-3680] Consistency update in tests for All GCP-related operators (#4493)</li>
<li>[AIRFLOW-3675] Use googlapiclient for google apis (#4484)</li>
<li>[AIRFLOW-3205] Support multipart uploads to GCS (#4084)</li>
<li>[AIRFLOW-2826] Add GoogleCloudKMSHook (#3677)</li>
<li>[AIRFLOW-3676] Add required permission to CloudSQL export/import example (#4489)</li>
<li>[AIRFLOW-3679] Added Google Cloud Base Hook to documentation (#4487)</li>
<li>[AIRFLOW-3594] Unify different License Header</li>
<li>[AIRFLOW-3197] Remove invalid parameter KeepJobFlowAliveWhenNoSteps in example DAG (#4404)</li>
<li>[AIRFLOW-3504] Refine the functionality of “/health” endpoint (#4309)</li>
<li>[AIRFLOW-3103][AIRFLOW-3147] Update flask-appbuilder (#3937)</li>
<li>[AIRFLOW-3168] More resillient database use in CI (#4014)</li>
<li>[AIRFLOW-3076] Remove preloading of MySQL testdata (#3911)</li>
<li>[AIRFLOW-3035] Allow custom ‘job_error_states’ in dataproc ops (#3884)</li>
<li>[AIRFLOW-3246] Make hmsclient optional in airflow.hooks.hive_hooks (#4080)</li>
<li>[AIRFLOW-3059] Log how many rows are read from Postgres (#3905)</li>
<li>[AIRFLOW-2463] Make task instance context available for hive queries</li>
<li>[AIRFLOW-3190] Make flake8 compliant (#4035)</li>
<li>[AIRFLOW-1998] Implemented DatabricksRunNowOperator for jobs/run-now … (#3813)</li>
<li>[AIRFLOW-2267] Airflow DAG level access (#3197)</li>
<li>[AIRFLOW-2359] Add set failed for DagRun and task in tree view (#3255)</li>
<li>[AIRFLOW-3008] Move Kubernetes example DAGs to contrib</li>
<li>[AIRFLOW-3402] Support global k8s affinity and toleration configs (#4247)</li>
<li>[AIRFLOW-3610] Add region param for EMR jobflow creation (#4418)</li>
<li>[AIRFLOW-3531] Fix test for GCS to GCS Transfer Hook (#4452)</li>
<li>[AIRFLOW-3531] Add gcs to gcs transfer operator. (#4331)</li>
<li>[AIRFLOW-3034]: Readme updates : Add Slack &amp; Twitter, remove Gitter</li>
<li>[AIRFLOW-3028] Update Text &amp; Images in Readme.md</li>
<li>[AIRFLOW-208] Add badge to show supported Python versions (#3839)</li>
<li>[AIRFLOW-2238] Update PR tool to push directly to Github</li>
<li>[AIRFLOW-2238] Flake8 fixes on dev/airflow-pr</li>
<li>[AIRFLOW-2238] Update PR tool to remove outdated info (#3978)</li>
<li>[AIRFLOW-3005] Replace ‘Airbnb Airflow’ with ‘Apache Airflow’ (#3845)</li>
<li>[AIRFLOW-3150] Make execution_date templated in TriggerDagRunOperator (#4359)</li>
<li>[AIRFLOW-1196][AIRFLOW-2399] Add templated field in TriggerDagRunOperator (#4228)</li>
<li>[AIRFLOW-3340] Placeholder support in connections form (#4185)</li>
<li>[AIRFLOW-3446] Add Google Cloud BigTable operators (#4354)</li>
<li>[AIRFLOW-1921] Add support for https and user auth (#2879)</li>
<li>[AIRFLOW-2770] Read <cite>dags_in_image</cite> config value as a boolean (#4319)</li>
<li>[AIRFLOW-3022] Add volume mount to KubernetesExecutorConfig (#3855)</li>
<li>[AIRFLOW-2917] Set AIRFLOW__CORE__SQL_ALCHEMY_CONN only when needed (#3766)</li>
<li>[AIRFLOW-2712] Pass annotations to KubernetesExecutorConfig</li>
<li>[AIRFLOW-461]  Support autodetected schemas in BigQuery run_load (#3880)</li>
<li>[AIRFLOW-2997] Support cluster fields in bigquery (#3838)</li>
<li>[AIRFLOW-2916] Arg <cite>verify</cite> for AwsHook() &amp; S3 sensors/operators (#3764)</li>
<li>[AIRFLOW-491] Add feature to pass extra api configs to BQ Hook (#3733)</li>
<li>[AIRFLOW-2889] Fix typos detected by github.com/client9/misspell (#3732)</li>
<li>[AIRFLOW-850] Add a PythonSensor (#4349)</li>
<li>[AIRFLOW-2747] Explicit re-schedule of sensors (#3596)</li>
<li>[AIRFLOW-3392] Add index on dag_id in sla_miss table (#4235)</li>
<li>[AIRFLOW-3001] Add index ‘ti_dag_date’ to taskinstance (#3885)</li>
<li>[AIRFLOW-2861] Add index on log table (#3709)</li>
<li>[AIRFLOW-3518] Performance fixes for topological_sort of Tasks (#4322)</li>
<li>[AIRFLOW-3521] Fetch more than 50 items in <cite>airflow-jira compare</cite> script (#4300)</li>
<li>[AIRFLOW-1919] Add option to query for DAG runs given a DAG ID</li>
<li>[AIRFLOW-3444] Explicitly set transfer operator description. (#4279)</li>
<li>[AIRFLOW-3411]  Add OpenFaaS hook (#4267)</li>
<li>[AIRFLOW-2785] Add context manager entry points to mongoHook</li>
<li>[AIRFLOW-2524] Add SageMaker doc to AWS integration section (#4278)</li>
<li>[AIRFLOW-3479] Keeps records in Log Table when DAG is deleted (#4287)</li>
<li>[AIRFLOW-2948] Arg check &amp; better doc - SSHOperator &amp; SFTPOperator (#3793)</li>
<li>[AIRFLOW-2245] Add remote_host of SSH/SFTP operator as templated field (#3765)</li>
<li>[AIRFLOW-2670] Update SSH Operator’s Hook to respect timeout (#3666)</li>
<li>[AIRFLOW-3380] Add metrics documentation (#4219)</li>
<li>[AIRFLOW-3361] Log the task_id in the PendingDeprecationWarning from BaseOperator (#4030)</li>
<li>[AIRFLOW-3213] Create ADLS to GCS operator (#4134)</li>
<li>[AIRFLOW-3395] added the REST API endpoints to the doc (#4236)</li>
<li>[AIRFLOW-3294] Update connections form and integration docs (#4129)</li>
<li>[AIRFLOW-3236] Create AzureDataLakeStorageListOperator (#4094)</li>
<li>[AIRFLOW-3062] Add Qubole in integration docs (#3946)</li>
<li>[AIRFLOW-3306] Disable flask-sqlalchemy modification tracking. (#4146)</li>
<li>[AIRFLOW-2867] Refactor Code to conform standards (#3714)</li>
<li>[AIRFLOW-2753] Add dataproc_job_id instance var holding actual DP jobId</li>
<li>[AIRFLOW-3132] Enable specifying auto_remove option for DockerOperator (#3977)</li>
<li>[AIRFLOW-2731] Raise psutil restriction to &lt;6.0.0</li>
<li>[AIRFLOW-3384] Allow higher versions of Sqlalchemy and Jinja2 (#4227)</li>
<li>[Airflow-2760] Decouple DAG parsing loop from scheduler loop (#3873)</li>
<li>[AIRFLOW-3004] Add config disabling scheduler cron (#3899)</li>
<li>[AIRFLOW-3175] Fix docstring format in airflow/jobs.py (#4025)</li>
<li>[AIRFLOW-3589] Visualize reschedule state in all views (#4408)</li>
<li>[AIRFLOW-2698] Simplify Kerberos code (#3563)</li>
<li>[AIRFLOW-2499] Dockerise CI pipeline (#3393)</li>
<li>[AIRFLOW-3432] Add test for feature “Delete DAG in UI” (#4266)</li>
<li>[AIRFLOW-3301] Update DockerOperator CI test for PR #3977 (#4138)</li>
<li>[AIRFLOW-3478] Make sure that the session is closed</li>
<li>[AIRFLOW-3687] Add missing &#64;apply_defaults decorators (#4498)</li>
<li>[AIRFLOW-3691] Update notice to 2019 (#4503)</li>
<li>[AIRFLOW-3689] Update pop-up message when deleting DAG in RBAC UI (#4505)</li>
<li>[AIRFLOW-2801] Skip test_mark_success_no_kill in PostgreSQL on CI (#3642)</li>
<li>[AIRFLOW-3693] Replace psycopg2-binary by psycopg2 (#4508)</li>
<li>[AIRFLOW-3700] Change the lowest allowed version of “requests” (#4517)</li>
<li>[AIRFLOW-3704] Support SSL Protection When Redis is Used as Broker for CeleryExecutor (#4521)</li>
<li>[AIRFLOW-3681] All GCP operators have now optional GCP Project ID (#4500)</li>
<li>[Airflow 2782] Upgrades Dagre D3 version to latest possible</li>
<li>[Airflow 2783] Implement eslint for JS code check (#3641)</li>
<li>[AIRFLOW-2805] Display multiple timezones on UI (#3687)</li>
<li>[AIRFLOW-3302] Small CSS fixes (#4140)</li>
<li>[Airflow-2766] Respect shared datetime across tabs</li>
<li>[AIRFLOW-2776] Compress tree view JSON</li>
<li>[AIRFLOW-2407] Use feature detection for reload() (#3298)</li>
<li>[AIRFLOW-3452] Removed an unused/dangerous display-none (#4295)</li>
<li>[AIRFLOW-3348] Update run statistics on dag refresh (#4197)</li>
<li>[AIRFLOW-3125] Monitor Task Instances creation rates (#3966)</li>
</ul>
</div>
<div class="section" id="bug-fixes">
<h3>Bug fixes<a class="headerlink" href="#bug-fixes" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-3191] Fix not being able to specify execution_date when creating dagrun (#4037)</li>
<li>[AIRFLOW-3657] Fix zendesk integration (#4466)</li>
<li>[AIRFLOW-3605] Load plugins from entry_points (#4412)</li>
<li>[AIRFLOW-3646] Rename plugins_manager.py to test_xx to trigger tests (#4464)</li>
<li>[AIRFLOW-3655] Escape links generated in model views (#4463)</li>
<li>[AIRFLOW-3662] Add dependency for Enum (#4468)</li>
<li>[AIRFLOW-3630] Cleanup of GCP Cloud SQL Connection (#4451)</li>
<li>[AIRFLOW-1837] Respect task start_date when different from dag’s (#4010)</li>
<li>[AIRFLOW-2829] Brush up the CI script for minikube</li>
<li>[AIRFLOW-3519] Fix example http operator (#4455)</li>
<li>[AIRFLOW-2811] Fix scheduler_ops_metrics.py to work (#3653)</li>
<li>[AIRFLOW-2751] add job properties update in hive to druid operator.</li>
<li>[AIRFLOW-2918] Remove unused imports</li>
<li>[AIRFLOW-2918] Fix Flake8 violations (#3931)</li>
<li>[AIRFLOW-2771] Add except type to broad S3Hook try catch clauses</li>
<li>[AIRFLOW-2918] Fix Flake8 violations (#3772)</li>
<li>[AIRFLOW-2099] Handle getsource() calls gracefully</li>
<li>[AIRFLOW-3397] Fix integrety error in rbac AirflowSecurityManager (#4305)</li>
<li>[AIRFLOW-3281] Fix Kubernetes operator with git-sync (#3770)</li>
<li>[AIRFLOW-2615] Limit DAGs parsing to once only</li>
<li>[AIRFLOW-2952] Fix Kubernetes CI (#3922)</li>
<li>[AIRFLOW-2933] Enable Codecov on Docker-CI Build (#3780)</li>
<li>[AIRFLOW-2082] Resolve a bug in adding password_auth to api as auth method (#4343)</li>
<li>[AIRFLOW-3612] Remove incubation/incubator mention (#4419)</li>
<li>[AIRFLOW-3581] Fix next_ds/prev_ds semantics for manual runs (#4385)</li>
<li>[AIRFLOW-3527] Update Cloud SQL Proxy to have shorter path for UNIX socket (#4350)</li>
<li>[AIRFLOW-3316] For gcs_to_bq: add missing init of schema_fields var (#4430)</li>
<li>[AIRFLOW-3583] Fix AirflowException import (#4389)</li>
<li>[AIRFLOW-3578] Fix Type Error for BigQueryOperator (#4384)</li>
<li>[AIRFLOW-2755] Added <cite>kubernetes.worker_dags_folder</cite> configuration (#3612)</li>
<li>[AIRFLOW-2655] Fix inconsistency of default config of kubernetes worker</li>
<li>[AIRFLOW-2645][AIRFLOW-2617] Add worker_container_image_pull_policy</li>
<li>[AIRFLOW-2661] fix config dags_volume_subpath and logs_volume_subpath</li>
<li>[AIRFLOW-3550] Standardize GKE hook (#4364)</li>
<li>[AIRFLOW-2863] Fix GKEClusterHook catching wrong exception (#3711)</li>
<li>[AIRFLOW-2939][AIRFLOW-3568] Fix TypeError in GCSToS3Op &amp; S3ToGCSOp (#4371)</li>
<li>[AIRFLOW-3327] Add support for location in BigQueryHook (#4324)</li>
<li>[AIRFLOW-3438] Fix default values in BigQuery Hook &amp; BigQueryOperator (…</li>
<li>[AIRFLOW-3355] Fix BigQueryCursor.execute to work with Python3 (#4198)</li>
<li>[AIRFLOW-3447] Add 2 options for ts_nodash Macro (#4323)</li>
<li>[AIRFLOW-1552] Airflow Filter_by_owner not working with password_auth (#4276)</li>
<li>[AIRFLOW-3484] Fix Over-logging in the k8s executor (#4296)</li>
<li>[AIRFLOW-3309] Add MongoDB connection (#4154)</li>
<li>[AIRFLOW-3414] Fix reload_module in DagFileProcessorAgent (#4253)</li>
<li>[AIRFLOW-1252] API accept JSON when invoking a trigger dag (#2334)</li>
<li>[AIRFLOW-3425] Fix setting default scope in hook (#4261)</li>
<li>[AIRFLOW-3416] Fixes Python 3 compatibility with CloudSqlQueryOperator (#4254)</li>
<li>[AIRFLOW-3263] Ignore exception when ‘run’ kills already killed job (#4108)</li>
<li>[AIRFLOW-3264] URL decoding when parsing URI for connection (#4109)</li>
<li>[AIRFLOW-3365][AIRFLOW-3366] Allow celery_broker_transport_options to be set with environment variables (#4211)</li>
<li>[AIRFLOW-2642] fix wrong value git-sync initcontainer env GIT_SYNC_ROOT (#3519)</li>
<li>[AIRFLOW-3353] Pin redis verison (#4195)</li>
<li>[AIRFLOW-3251] KubernetesPodOperator now uses ‘image_pull_secrets’ argument when creating Pods (#4188)</li>
<li>[AIRFLOW-2705] Move class-level moto decorator to method-level</li>
<li>[AIRFLOW-3233] Fix deletion of DAGs in the UI (#4069)</li>
<li>[AIRFLOW-2908] Allow retries with KubernetesExecutor. (#3758)</li>
<li>[AIRFLOW-1561] Fix scheduler to pick up example DAGs without other DAGs (#2635)</li>
<li>[AIRFLOW-3352] Fix expose_config not honoured on RBAC UI (#4194)</li>
<li>[AIRFLOW-3592] Fix logs when task is in rescheduled state (#4492)</li>
<li>[AIRFLOW-3634] Fix GCP Spanner Test (#4440)</li>
<li>[AIRFLOW-XXX] Fix PythonVirtualenvOperator tests (#3968)</li>
<li>[AIRFLOW-3239] Fix/refine tests for api/common/experimental/ (#4255)</li>
<li>[AIRFLOW-2951] Update dag_run table end_date when state change (#3798)</li>
<li>[AIRFLOW-2756] Fix bug in set DAG run state workflow (#3606)</li>
<li>[AIRFLOW-3690] Fix bug to set state of a task for manually-triggered DAGs (#4504)</li>
<li>[AIRFLOW-3319] KubernetsExecutor: Need in try_number in labels if getting them later (#4163)</li>
<li>[AIRFLOW-3724] Fix the broken refresh button on Graph View in RBAC UI</li>
<li>[AIRFLOW-3732] Fix issue when trying to edit connection in RBAC UI</li>
<li>[AIRFLOW-2866] Fix missing CSRF token head when using RBAC UI (#3804)</li>
<li>[AIRFLOW-3259] Fix internal server error when displaying charts (#4114)</li>
<li>[AIRFLOW-3271] Fix issue with persistence of RBAC Permissions modified via UI (#4118)</li>
<li>[AIRFLOW-3141] Handle duration View for missing dag (#3984)</li>
<li>[AIRFLOW-2766] Respect shared datetime across tabs</li>
<li>[AIRFLOW-1413] Fix FTPSensor failing on error message with unexpected (#2450)</li>
<li>[AIRFLOW-3378] KubernetesPodOperator does not delete on timeout failure (#4218)</li>
<li>[AIRFLOW-3245] Fix list processing in resolve_template_files (#4086)</li>
<li>[AIRFLOW-2703] Catch transient DB exceptions from scheduler’s heartbeat it does not crash (#3650)</li>
<li>[AIRFLOW-1298] Clear UPSTREAM_FAILED using the clean cli (#3886)</li>
</ul>
</div>
<div class="section" id="doc-only-changes">
<h3>Doc-only changes<a class="headerlink" href="#doc-only-changes" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-XXX] GCP operators documentation clarifications (#4273)</li>
<li>[AIRFLOW-XXX] Docs: Fix paths to GCS transfer operator (#4479)</li>
<li>[AIRFLOW-XXX] Add missing GCP operators to Docs (#4260)</li>
<li>[AIRFLOW-XXX] Fix Docstrings for Operators (#3820)</li>
<li>[AIRFLOW-XXX] Fix inconsistent comment in example_python_operator.py (#4337)</li>
<li>[AIRFLOW-XXX] Fix incorrect parameter in SFTPOperator example (#4344)</li>
<li>[AIRFLOW-XXX] Add missing remote logging field (#4333)</li>
<li>[AIRFLOW-XXX] Revise template variables documentation (#4172)</li>
<li>[AIRFLOW-XXX] Fix typo in docstring of gcs_to_bq (#3833)</li>
<li>[AIRFLOW-XXX] Fix display of SageMaker operators/hook docs (#4263)</li>
<li>[AIRFLOW-XXX] Better instructions for airflow flower (#4214)</li>
<li>[AIRFLOW-XXX] Make pip install commands consistent (#3752)</li>
<li>[AIRFLOW-XXX] Add <cite>BigQueryGetDataOperator</cite> to Integration Docs (#4063)</li>
<li>[AIRFLOW-XXX] Don’t spam test logs with “bad cron expression” messages (#3973)</li>
<li>[AIRFLOW-XXX] Update committer list based on latest TLP discussion (#4427)</li>
<li>[AIRFLOW-XXX] Fix incorrect statement in contributing guide (#4104)</li>
<li>[AIRFLOW-XXX] Fix Broken Link in CONTRIBUTING.md</li>
<li>[AIRFLOW-XXX] Update Contributing Guide - Git Hooks (#4120)</li>
<li>[AIRFLOW-3426] Correct Python Version Documentation Reference (#4259)</li>
<li>[AIRFLOW-2663] Add instructions to install SSH dependencies</li>
<li>[AIRFLOW-XXX] Clean up installation extra packages table (#3750)</li>
<li>[AIRFLOW-XXX] Remove redundant space in Kerberos (#3866)</li>
<li>[AIRFLOW-3086] Add extras group for google auth to setup.py (#3917)</li>
<li>[AIRFLOW-XXX] Add Kubernetes Dependency in Extra Packages Doc (#4281)</li>
<li>[AIRFLOW-3696] Add Version info to Airflow Documentation (#4512)</li>
<li>[AIRFLOW-XXX] Correct Typo in sensor’s exception (#4545)</li>
<li>[AIRFLOW-XXX] Fix a typo of config (#4544)</li>
<li>[AIRFLOW-XXX] Fix BashOperator Docstring (#4052)</li>
<li>[AIRFLOW-3018] Fix Minor issues in Documentation</li>
<li>[AIRFLOW-XXX] Fix Minor issues with Azure Cosmos Operator (#4289)</li>
<li>[AIRFLOW-3382] Fix incorrect docstring in DatastoreHook (#4222)</li>
<li>[AIRFLOW-XXX] Fix copy&amp;paste mistake (#4212)</li>
<li>[AIRFLOW-3260] Correct misleading BigQuery error (#4098)</li>
<li>[AIRFLOW-XXX] Fix Typo in SFTPOperator docstring (#4016)</li>
<li>[AIRFLOW-XXX] Fixing the issue in Documentation (#3998)</li>
<li>[AIRFLOW-XXX] Fix undocumented params in S3_hook</li>
<li>[AIRFLOW-XXX] Fix SlackWebhookOperator execute method comment (#3963)</li>
<li>[AIRFLOW-3070] Refine web UI authentication-related docs (#3863)</li>
</ul>
</div>
</div>
<div class="section" id="airflow-1-10-1-2018-11-13">
<h2>Airflow 1.10.1, 2018-11-13<a class="headerlink" href="#airflow-1-10-1-2018-11-13" title="Permalink to this headline">¶</a></h2>
<div class="section" id="id1">
<h3>New features<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-2524] Airflow integration with AWS Sagemaker</li>
<li>[AIRFLOW-2657] Add ability to delete DAG from web ui</li>
<li>[AIRFLOW-2780] Adds IMAP Hook to interact with a mail server</li>
<li>[AIRFLOW-2794] Add delete support for Azure blob</li>
<li>[AIRFLOW-2912] Add operators for Google Cloud Functions</li>
<li>[AIRFLOW-2974] Add Start/Restart/Terminate methods Databricks Hook</li>
<li>[AIRFLOW-2989] No Parameter to change bootDiskType for DataprocClusterCreateOperator</li>
<li>[AIRFLOW-3078] Basic operators for Google Compute Engine</li>
<li>[AIRFLOW-3147] Update Flask-AppBuilder version</li>
<li>[AIRFLOW-3231] Basic operators for Google Cloud SQL (deploy / patch / delete)</li>
<li>[AIRFLOW-3276] Google Cloud SQL database create / patch / delete operators</li>
</ul>
</div>
<div class="section" id="id2">
<h3>Improvements<a class="headerlink" href="#id2" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-393] Add progress callbacks for FTP downloads</li>
<li>[AIRFLOW-520] Show Airflow version on web page</li>
<li>[AIRFLOW-843] Exceptions now available in context during on_failure_callback</li>
<li>[AIRFLOW-2476] Update tabulate dependency to v0.8.2</li>
<li>[AIRFLOW-2592] Bump Bleach dependency</li>
<li>[AIRFLOW-2622] Add “confirm=False” option to SFTPOperator</li>
<li>[AIRFLOW-2662] support affinity &amp; nodeSelector policies for kubernetes executor/operator</li>
<li>[AIRFLOW-2709] Improve error handling in Databricks hook</li>
<li>[AIRFLOW-2723] Update lxml dependancy to &gt;= 4.0.</li>
<li>[AIRFLOW-2763] No precheck mechanism in place during worker initialisation for the connection to metadata database</li>
<li>[AIRFLOW-2789] Add ability to create single node cluster to DataprocClusterCreateOperator</li>
<li>[AIRFLOW-2797] Add ability to create Google Dataproc cluster with custom image</li>
<li>[AIRFLOW-2854] kubernetes_pod_operator add more configuration items</li>
<li>[AIRFLOW-2855] Need to Check Validity of Cron Expression When Process DAG File/Zip File</li>
<li>[AIRFLOW-2904] Clean an unnecessary line in airflow/executors/celery_executor.py</li>
<li>[AIRFLOW-2921] A trivial incorrectness in CeleryExecutor()</li>
<li>[AIRFLOW-2922] Potential deal-lock bug in CeleryExecutor()</li>
<li>[AIRFLOW-2932] GoogleCloudStorageHook - allow compression of file</li>
<li>[AIRFLOW-2949] Syntax Highlight for Single Quote</li>
<li>[AIRFLOW-2951] dag_run end_date Null after a dag is finished</li>
<li>[AIRFLOW-2956] Kubernetes tolerations for pod operator</li>
<li>[AIRFLOW-2997] Support for clustered tables in Bigquery hooks/operators</li>
<li>[AIRFLOW-3006] Fix error when schedule_interval=”None”</li>
<li>[AIRFLOW-3008] Move Kubernetes related example DAGs to contrib/example_dags</li>
<li>[AIRFLOW-3025] Allow to specify dns and dns-search parameters for DockerOperator</li>
<li>[AIRFLOW-3067] (www_rbac) Flask flash messages are not displayed properly (no background color)</li>
<li>[AIRFLOW-3069] Decode output of S3 file transform operator</li>
<li>[AIRFLOW-3072] Assign permission get_logs_with_metadata to viewer role</li>
<li>[AIRFLOW-3090] INFO logs are too verbose</li>
<li>[AIRFLOW-3103] Update Flask-Login</li>
<li>[AIRFLOW-3112] Align SFTP hook with SSH hook</li>
<li>[AIRFLOW-3119] Enable loglevel on celery worker and inherit from airflow.cfg</li>
<li>[AIRFLOW-3137] Make ProxyFix middleware optional</li>
<li>[AIRFLOW-3173] Add _cmd options for more password config options</li>
<li>[AIRFLOW-3177] Change scheduler_heartbeat metric from gauge to counter</li>
<li>[AIRFLOW-3193] Pin docker requirement version to v3</li>
<li>[AIRFLOW-3195] Druid Hook: Log ingestion spec and task id</li>
<li>[AIRFLOW-3197] EMR Hook is missing some parameters to valid on the AWS API</li>
<li>[AIRFLOW-3232] Make documentation for GCF Functions operator more readable</li>
<li>[AIRFLOW-3262] Can’t get log containing Response when using SimpleHttpOperator</li>
<li>[AIRFLOW-3265] Add support for “unix_socket” in connection extra for Mysql Hook</li>
</ul>
</div>
<div class="section" id="id3">
<h3>Doc-only changes<a class="headerlink" href="#id3" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-1441] Tutorial Inconsistencies Between Example Pipeline Definition and Recap</li>
<li>[AIRFLOW-2682] Add how-to guide(s) for how to use basic operators like BashOperator and PythonOperator</li>
<li>[AIRFLOW-3104] .airflowignore feature is not mentioned at all in documentation</li>
<li>[AIRFLOW-3237] Refactor example DAGs</li>
<li>[AIRFLOW-3187] Update airflow.gif file with a slower version</li>
<li>[AIRFLOW-3159] Update Airflow documentation on GCP Logging</li>
<li>[AIRFLOW-3030] Command Line docs incorrect subdir</li>
<li>[AIRFLOW-2990] Docstrings for Hooks/Operators are in incorrect format</li>
<li>[AIRFLOW-3127] Celery SSL Documentation is out-dated</li>
<li>[AIRFLOW-2779] Add license headers to doc files</li>
<li>[AIRFLOW-2779] Add project version to license</li>
</ul>
</div>
<div class="section" id="id4">
<h3>Bug fixes<a class="headerlink" href="#id4" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>[AIRFLOW-839] docker_operator.py attempts to log status key without first checking existence</li>
<li>[AIRFLOW-1104] Concurrency check in scheduler should count queued tasks as well as running</li>
<li>[AIRFLOW-1163] Add support for x-forwarded-* headers to support access behind AWS ELB</li>
<li>[AIRFLOW-1195] Cleared tasks in SubDagOperator do not trigger Parent dag_runs</li>
<li>[AIRFLOW-1508] Skipped state not part of State.task_states</li>
<li>[AIRFLOW-1762] Use key_file in SSHHook.create_tunnel()</li>
<li>[AIRFLOW-1837] Differing start_dates on tasks not respected by scheduler.</li>
<li>[AIRFLOW-1874] Support standard SQL in Check, ValueCheck and IntervalCheck BigQuery operators</li>
<li>[AIRFLOW-1917] print() from python operators end up with extra new line</li>
<li>[AIRFLOW-1970] Database cannot be initialized if an invalid fernet key is provided</li>
<li>[AIRFLOW-2145] Deadlock after clearing a running task</li>
<li>[AIRFLOW-2216] Cannot specify a profile for AWS Hook to load with s3 config file</li>
<li>[AIRFLOW-2574] initdb fails when mysql password contains percent sign</li>
<li>[AIRFLOW-2707] Error accessing log files from web UI</li>
<li>[AIRFLOW-2716] Replace new Python 3.7 keywords</li>
<li>[AIRFLOW-2744] RBAC app doesn’t integrate plugins (blueprints etc)</li>
<li>[AIRFLOW-2772] BigQuery hook does not allow specifying both the partition field name and table name at the same time</li>
<li>[AIRFLOW-2778] Bad Import in collect_dag in DagBag</li>
<li>[AIRFLOW-2786] Variables view fails to render if a variable has an empty key</li>
<li>[AIRFLOW-2799] Filtering UI objects by datetime is broken</li>
<li>[AIRFLOW-2800] Remove airflow/ low-hanging linting errors</li>
<li>[AIRFLOW-2825] S3ToHiveTransfer operator may not may able to handle GZIP file with uppercase ext in S3</li>
<li>[AIRFLOW-2848] dag_id is missing in metadata table “job” for LocalTaskJob</li>
<li>[AIRFLOW-2860] DruidHook: time variable is not updated correctly when checking for timeout</li>
<li>[AIRFLOW-2865] Race condition between on_success_callback and LocalTaskJob’s cleanup</li>
<li>[AIRFLOW-2893] Stuck dataflow job due to jobName mismatch.</li>
<li>[AIRFLOW-2895] Prevent scheduler from spamming heartbeats/logs</li>
<li>[AIRFLOW-2900] Code not visible for Packaged DAGs</li>
<li>[AIRFLOW-2905] Switch to regional dataflow job service.</li>
<li>[AIRFLOW-2907] Sendgrid - Attachments - ERROR - Object of type ‘bytes’ is not JSON serializable</li>
<li>[AIRFLOW-2938] Invalid ‘extra’ field in connection can raise an AttributeError when attempting to edit</li>
<li>[AIRFLOW-2979] Deprecated Celery Option not in Options list</li>
<li>[AIRFLOW-2981] TypeError in dataflow operators when using GCS jar or py_file</li>
<li>[AIRFLOW-2984] Cannot convert naive_datetime when task has a naive start_date/end_date</li>
<li>[AIRFLOW-2994] flatten_results in BigQueryOperator/BigQueryHook should default to None</li>
<li>[AIRFLOW-3002] ValueError in dataflow operators when using GCS jar or py_file</li>
<li>[AIRFLOW-3012] Email on sla miss is send only to first address on the list</li>
<li>[AIRFLOW-3046] ECS Operator mistakenly reports success when task is killed due to EC2 host termination</li>
<li>[AIRFLOW-3064] No output from <cite>airflow test</cite> due to default logging config</li>
<li>[AIRFLOW-3072] Only admin can view logs in RBAC UI</li>
<li>[AIRFLOW-3079] Improve initdb to support MSSQL Server</li>
<li>[AIRFLOW-3089] Google auth doesn’t work under http</li>
<li>[AIRFLOW-3099] Errors raised when some blocs are missing in airflow.cfg</li>
<li>[AIRFLOW-3109] Default user permission should contain ‘can_clear’</li>
<li>[AIRFLOW-3111] Confusing comments and instructions for log templates in UPDATING.md and default_airflow.cfg</li>
<li>[AIRFLOW-3124] Broken webserver debug mode (RBAC)</li>
<li>[AIRFLOW-3136] Scheduler Failing the Task retries run while processing Executor Events</li>
<li>[AIRFLOW-3138] Migration cc1e65623dc7 creates issues with postgres</li>
<li>[AIRFLOW-3161] Log Url link does not link to task instance logs in RBAC UI</li>
<li>[AIRFLOW-3162] HttpHook fails to parse URL when port is specified</li>
<li>[AIRFLOW-3183] Potential Bug in utils/dag_processing/DagFileProcessorManager.max_runs_reached()</li>
<li>[AIRFLOW-3203] Bugs in DockerOperator &amp; Some operator test scripts were named incorrectly</li>
<li>[AIRFLOW-3238] Dags, removed from the filesystem, are not deactivated on initdb</li>
<li>[AIRFLOW-3268] Cannot pass SSL dictionary to mysql connection via URL</li>
<li>[AIRFLOW-3277] Invalid timezone transition handling for cron schedules</li>
<li>[AIRFLOW-3295] Require encryption in DaskExecutor when certificates are configured.</li>
<li>[AIRFLOW-3297] EmrStepSensor marks cancelled step as successful</li>
</ul>
</div>
</div>
<div class="section" id="airflow-1-10-0-2018-08-03">
<h2>Airflow 1.10.0, 2018-08-03<a class="headerlink" href="#airflow-1-10-0-2018-08-03" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-2870] Use abstract TaskInstance for migration</li>
<li>[AIRFLOW-2859] Implement own UtcDateTime (#3708)</li>
<li>[AIRFLOW-2140] Don’t require kubernetes for the SparkSubmit hook</li>
<li>[AIRFLOW-2869] Remove smart quote from default config</li>
<li>[AIRFLOW-2857] Fix Read the Docs env</li>
<li>[AIRFLOW-2817] Force explicit choice on GPL dependency</li>
<li>[AIRFLOW-2716] Replace async and await py3.7 keywords</li>
<li>[AIRFLOW-2810] Fix typo in Xcom model timestamp</li>
<li>[AIRFLOW-2710] Clarify fernet key value in documentation</li>
<li>[AIRFLOW-2606] Fix DB schema and SQLAlchemy model</li>
<li>[AIRFLOW-2646] Fix setup.py not to install snakebite on Python3</li>
<li>[AIRFLOW-2604] Add index to task_fail</li>
<li>[AIRFLOW-2650] Mark SchedulerJob as succeed when hitting Ctrl-c</li>
<li>[AIRFLOW-2678] Fix db schema unit test to remove checking fab models</li>
<li>[AIRFLOW-2624] Fix webserver login as anonymous</li>
<li>[AIRFLOW-2654] Fix incorret URL on refresh in Graph View of FAB UI</li>
<li>[AIRFLOW-2668] Handle missing optional cryptography dependency</li>
<li>[AIRFLOW-2681] Include last dag run of externally triggered DAGs in UI.</li>
<li>[AIRFLOW-1840] Support back-compat on old celery config</li>
<li>[AIRFLOW-2612][AIRFLOW-2534] Clean up Hive-related tests</li>
<li>[AIRFLOW-2608] Implements/Standardize custom exceptions for experimental APIs</li>
<li>[AIRFLOW-2607] Fix failing TestLocalClient</li>
<li>[AIRFLOW-2638] dbapi_hook: support REPLACE INTO</li>
<li>[AIRFLOW-2542][AIRFLOW-1790] Rename AWS Batch Operator queue to job_queue</li>
<li>[AIRFLOW-2567] Extract result from the kubernetes pod as Xcom</li>
<li>[AIRFLOW-XXX] Adding REA Group to readme</li>
<li>[AIRFLOW-2601] Allow user to specify k8s config</li>
<li>[AIRFLOW-2559] Azure Fileshare hook</li>
<li>[AIRFLOW-1786] Enforce correct behavior for soft-fail sensors</li>
<li>[AIRFLOW-2355] Airflow trigger tag parameters in subdag</li>
<li>[AIRFLOW-2613] Fix Airflow searching .zip bug</li>
<li>[AIRFLOW-2627] Add a sensor for Cassandra</li>
<li>[AIRFLOW-2634][AIRFLOW-2534] Remove dependency for impyla</li>
<li>[AIRFLOW-2611] Fix wrong dag volume mount path for kubernetes executor</li>
<li>[AIRFLOW-2562] Add Google Kubernetes Engine Operators</li>
<li>[AIRFLOW-2630] Fix classname in test_sql_sensor.py</li>
<li>[AIRFLOW-2534] Fix bug in HiveServer2Hook</li>
<li>[AIRFLOW-2586] Stop getting AIRFLOW_HOME value from config file in bash operator</li>
<li>[AIRFLOW-2605] Fix autocommit for MySqlHook</li>
<li>[AIRFLOW-2539][AIRFLOW-2359] Move remaing log config to configuration file</li>
<li>[AIRFLOW-1656] Tree view dags query changed</li>
<li>[AIRFLOW-2617] add imagePullPolicy config for kubernetes executor</li>
<li>[AIRFLOW-2429] Fix security/task/sensors/ti_deps folders flake8 error</li>
<li>[AIRFLOW-2550] Implements API endpoint to list DAG runs</li>
<li>[AIRFLOW-2512][AIRFLOW-2522] Use google-auth instead of oauth2client</li>
<li>[AIRFLOW-2429] Fix operators folder flake8 error</li>
<li>[AIRFLOW-2585] Fix several bugs in CassandraHook and CassandraToGCSOperator</li>
<li>[AIRFLOW-2597] Restore original dbapi.run() behavior</li>
<li>[AIRFLOW-2590] Fix commit in DbApiHook.run() for no-autocommit DB</li>
<li>[AIRFLOW-1115] fix github oauth api URL</li>
<li>[AIRFLOW-2587] Add TIMESTAMP type mapping to MySqlToHiveTransfer</li>
<li>[AIRFLOW-2591][AIRFLOW-2581] Set default value of autocommit to False in DbApiHook.run()</li>
<li>[AIRFLOW-59] Implement bulk_dump and bulk_load for the Postgres hook</li>
<li>[AIRFLOW-2533] Fix path to DAG’s on kubernetes executor workers</li>
<li>[AIRFLOW-2581] RFLOW-2581] Fix DbApiHook autocommit</li>
<li>[AIRFLOW-2578] Add option to use proxies in JiraHook</li>
<li>[AIRFLOW-2575] Make gcs to gcs operator work with large files</li>
<li>[AIRFLOW-437] Send TI context in kill zombies</li>
<li>[AIRFLOW-2566] Change backfill to rerun failed tasks</li>
<li>[AIRFLOW-1021] Fix double login for new users with LDAP</li>
<li>[AIRFLOW-XXX] Typo fix</li>
<li>[AIRFLOW-2561] Fix typo in EmailOperator</li>
<li>[AIRFLOW-2573] Cast BigQuery TIMESTAMP field to float</li>
<li>[AIRFLOW-2560] Adding support for internalIpOnly to DataprocClusterCreateOperator</li>
<li>[AIRFLOW-2565] templatize cluster_label</li>
<li>[AIRFLOW-83] add mongo hook and operator</li>
<li>[AIRFLOW-2558] Clear task/dag is clearing all executions</li>
<li>[AIRFLOW-XXX] Fix doc typos</li>
<li>[AIRFLOW-2513] Change <cite>bql</cite> to <cite>sql</cite> for BigQuery Hooks &amp; Ops</li>
<li>[AIRFLOW-2557] Fix pagination for s3</li>
<li>[AIRFLOW-2545] Eliminate DeprecationWarning</li>
<li>[AIRFLOW-2500] Fix MySqlToHiveTransfer to transfer unsigned type properly</li>
<li>[AIRFLOW-2462] Change PasswordUser setter to correct syntax</li>
<li>[AIRFLOW-2525] Fix a bug introduced by commit dabf1b9</li>
<li>[AIRFLOW-2553] Add webserver.pid to .gitignore</li>
<li>[AIRFLOW-1863][AIRFLOW-2529] Add dag run selection widgets to gantt view</li>
<li>[AIRFLOW-2504] Log username correctly and add extra to search columns</li>
<li>[AIRFLOW-2551] Encode binary data with base64 standard rather than base64 url</li>
<li>[AIRFLOW-2537] Add reset-dagrun option to backfill command</li>
<li>[AIRFLOW-2526] dag_run.conf can override params</li>
<li>[AIRFLOW-2544][AIRFLOW-1967] Guard against next major release of Celery, Flower</li>
<li>[AIRFLOW-XXX] Add Yieldr to who is using airflow</li>
<li>[AIRFLOW-2547] Describe how to run tests using Docker</li>
<li>[AIRFLOW-2538] Update faq doc on how to reduce airflow scheduler latency</li>
<li>[AIRFLOW-2529] Improve graph view performance and usability</li>
<li>[AIRFLOW-2517] backfill support passing key values through CLI</li>
<li>[AIRFLOW-2532] Support logs_volume_subpath for KubernetesExecutor</li>
<li>[AIRFLOW-2466] consider task_id in _change_state_for_tis_without_dagrun</li>
<li>[AIRFLOW-2519] Fix CeleryExecutor with SQLAlchemy</li>
<li>[AIRFLOW-2402] Fix RBAC task log</li>
<li>[AIRFLOW-XXX] Add M4U to user list</li>
<li>[AIRFLOW-2536] docs about how to deal with airflow initdb failure</li>
<li>[AIRFLOW-2530] KubernetesOperator supports multiple clusters</li>
<li>[AIRFLOW-1499] Eliminate duplicate and unneeded code</li>
<li>[AIRFLOW-2521] backfill - make variable name and logging messages more acurate</li>
<li>[AIRFLOW-2429] Fix hook, macros folder flake8 error</li>
<li>[Airflow-XXX] add Prime to company list</li>
<li>[AIRFLOW-2525] Fix PostgresHook.copy_expert to work with “COPY FROM”</li>
<li>[AIRFLOW-2515] Add dependency on thrift_sasl to hive extra</li>
<li>[AIRFLOW-2523] Add how-to for managing GCP connections</li>
<li>[AIRFLOW-2510] Introduce new macros: prev_ds and next_ds</li>
<li>[AIRFLOW-1730] Unpickle value of XCom queried from DB</li>
<li>[AIRFLOW-2518] Fix broken ToC links in integration.rst</li>
<li>[AIRFLOW-1472] Fix SLA misses triggering on skipped tasks.</li>
<li>[AIRFLOW-2520] CLI - make backfill less verbose</li>
<li>[AIRFLOW-2107] add time_partitioning to run_query on BigQueryBaseCursor</li>
<li>[AIRFLOW-1057][AIRFLOW-1380][AIRFLOW-2362][2362] AIRFLOW Update DockerOperator to new API</li>
<li>[AIRFLOW-2415] Make airflow DAG templating render numbers</li>
<li>[AIRFLOW-2473] Fix wrong skip condition for TransferTests</li>
<li>[AIRFLOW-2472] Implement MySqlHook.bulk_dump</li>
<li>[AIRFLOW-2419] Use default view for subdag operator</li>
<li>[AIRFLOW-2498] Fix Unexpected argument in SFTP Sensor</li>
<li>[AIRFLOW-2509] Separate config docs into how-to guides</li>
<li>[AIRFLOW-2429] Add BaseExecutor back</li>
<li>[AIRFLOW-2429] Fix dag, example_dags, executors flake8 error</li>
<li>[AIRFLOW-2502] Change Single triple quotes to double for docstrings</li>
<li>[AIRFLOW-2503] Fix broken links in CONTRIBUTING.md</li>
<li>[AIRFLOW-2501] Refer to devel instructions in docs contrib guide</li>
<li>[AIRFLOW-2429] Fix contrib folder’s flake8 errors</li>
<li>[AIRFLOW-2471] Fix HiveCliHook.load_df to use unused parameters</li>
<li>[AIRFLOW-2495] Update celery to 4.1.1</li>
<li>[AIRFLOW-2429] Fix api, bin, config_templates folders flake8 error</li>
<li>[AIRFLOW-2493] Mark template_fields of all Operators in the API document as “templated”</li>
<li>[AIRFLOW-2489] Update FlaskAppBuilder to 1.11.1</li>
<li>[AIRFLOW-2448] Enhance HiveCliHook.load_df to work with datetime</li>
<li>[AIRFLOW-2487] Enhance druid ingestion hook</li>
<li>[AIRFLOW-2397] Support affinity policies for Kubernetes executor/operator</li>
<li>[AIRFLOW-2482] Add test for rewrite method in GCS Hook</li>
<li>[AIRFLOW-2481] Fix flaky Kubernetes test</li>
<li>[AIRFLOW-2479] Improve doc FAQ section</li>
<li>[AIRFLOW-2485] Fix Incorrect logging for Qubole Sensor</li>
<li>[AIRFLOW-2486] Remove unnecessary slash after port</li>
<li>[AIRFLOW-2429] Make Airflow flake8 compliant</li>
<li>[AIRFLOW-2491] Resolve flask version conflict</li>
<li>[AIRFLOW-2484] Remove duplicate key in MySQL to GCS Op</li>
<li>[ARIFLOW-2458] Add cassandra-to-gcs operator</li>
<li>[AIRFLOW-2477] Improve time units for task duration and landing times charts for RBAC UI</li>
<li>[AIRFLOW-2474] Only import snakebite if using py2</li>
<li>[AIRFLOW-48] Parse connection uri querystring</li>
<li>[AIRFLOW-2467][AIRFLOW-2] Update import direct warn message to use the module name</li>
<li>[AIRFLOW-XXX] Fix order of companies</li>
<li>[AIRFLOW-2452] Document field_dict must be OrderedDict</li>
<li>[AIRFLOW-2420] Azure Data Lake Hook</li>
<li>[AIRFLOW-2213] Add Quoble check operator</li>
<li>[AIRFLOW-2465] Fix wrong module names in the doc</li>
<li>[AIRFLOW-1929] Modifying TriggerDagRunOperator to accept execution_date</li>
<li>[AIRFLOW-2460] Users can now use volume mounts and volumes</li>
<li>[AIRFLOW-2110][AIRFLOW-2122] Enhance Http Hook</li>
<li>[AIRFLOW-XXX] Updated contributors list</li>
<li>[AIRFLOW-2435] Add launch_type to ECSOperator to allow FARGATE</li>
<li>[AIRFLOW-2451] Remove extra slash (‘/’) char when using wildcard in gcs_to_gcs operator</li>
<li>[AIRFLOW-2461] Add support for cluster scaling on dataproc operator</li>
<li>[AIRFLOW-2376] Fix no hive section error</li>
<li>[AIRFLOW-2425] Add lineage support</li>
<li>[AIRFLOW-2430] Extend query batching to additional slow queries</li>
<li>[AIRFLOW-2453] Add default nil value for kubernetes/git_subpath</li>
<li>[AIRFLOW-2396] Add support for resources in kubernetes operator</li>
<li>[AIRFLOW-2169] Encode binary data with base64 before importing to BigQuery</li>
<li>[AIRFLOW-XXX] Add spotahome in user list</li>
<li>[AIRFLOW-2457] Update FAB version requirement</li>
<li>[AIRFLOW-2454][Airflow 2454] Support imagePullPolicy for k8s</li>
<li>[AIRFLOW-2450] update supported k8s versions to 1.9 and 1.10</li>
<li>[AIRFLOW-2333] Add Segment Hook and TrackEventOperator</li>
<li>[AIRFLOW-2442][AIRFLOW-2] Airflow run command leaves database connections open</li>
<li>[AIRFLOW-2016] assign template_fields for Dataproc Workflow Template sub-classes, not base class</li>
<li>[AIRFLOW-2446] Add S3ToRedshiftTransfer into the “Integration” doc</li>
<li>[AIRFLOW-2449] Fix operators.py to run all test cases</li>
<li>[AIRFLOW-2424] Add dagrun status endpoint and increased k8s test coverage</li>
<li>[AIRFLOW-2441] Fix bugs in HiveCliHook.load_df</li>
<li>[AIRFLOW-2358][AIRFLOW-201804] Make the Kubernetes example optional</li>
<li>[AIRFLOW-2436] Remove cli_logger in initdb</li>
<li>[AIRFLOW-2444] Remove unused option(include_adhoc) in cli backfill command</li>
<li>[AIRFLOW-2447] Fix TestHiveMetastoreHook to run all cases</li>
<li>[AIRFLOW-2445] Allow templating in kubernetes operator</li>
<li>[AIRFLOW-2086][AIRFLOW-2393] Customize default dagrun number in tree view</li>
<li>[AIRFLOW-2437] Add PubNub to list of current airflow users</li>
<li>[AIRFLOW-XXX] Add Quantopian to list of Airflow users</li>
<li>[AIRFLOW-1978] Add WinRM windows operator and hook</li>
<li>[AIRFLOW-2427] Add tests to named hive sensor</li>
<li>[AIRFLOW-2412] Fix HiveCliHook.load_file to address HIVE-10541</li>
<li>[AIRFLOW-2431] Add the navigation bar color parameter for RBAC UI</li>
<li>[AIRFLOW-2407] Resolve Python undefined names</li>
<li>[AIRFLOW-1952] Add the navigation bar color parameter</li>
<li>[AIRFLOW-2222] Implement GoogleCloudStorageHook.rewrite</li>
<li>[AIRFLOW-2426] Add Google Cloud Storage Hook tests</li>
<li>[AIRFLOW-2418] Bump Flask-WTF</li>
<li>[AIRFLOW-2417] Wait for pod is not running to end task</li>
<li>[AIRFLOW-1914] Add other charset support to email utils</li>
<li>[AIRFLOW-XXX] Update README.md with <a class="reference external" href="mailto:Craig&#37;&#52;&#48;Work">Craig<span>&#64;</span>Work</a></li>
<li>[AIRFLOW-1899] Fix Kubernetes tests</li>
<li>[AIRFLOW-1812] Update logging example</li>
<li>[AIRFLOW-2313] Add TTL parameters for Dataproc</li>
<li>[AIRFLOW-2411] add dataproc_jars to templated_fields</li>
<li>[AIRFLOW-XXX] Add Reddit to Airflow users</li>
<li>[AIRFLOW-XXX] Fix wrong table header in scheduler.rst</li>
<li>[AIRFLOW-2409] Supply password as a parameter</li>
<li>[AIRFLOW-2410][AIRFLOW-75] Set the timezone in the RBAC Web UI</li>
<li>[AIRFLOW-2394] default cmds and arguments in kubernetes operator</li>
<li>[AIRFLOW-2406] Add Apache2 License Shield to Readme</li>
<li>[AIRFLOW-2404] Add additional documentation for unqueued task</li>
<li>[AIRFLOW-2400] Add Ability to set Environment Variables for K8s</li>
<li>[AIRFLOW-XXX] Add Twine Labs as an Airflow user</li>
<li>[AIRFLOW-1853] Show only the desired number of runs in tree view</li>
<li>[AIRFLOW-2401] Document the use of variables in Jinja template</li>
<li>[AIRFLOW-2403] Fix License Headers</li>
<li>[AIRFLOW-1313] Fix license header</li>
<li>[AIRFLOW-2398] Add BounceX to list of current airflow users</li>
<li>[AIRFLOW-2363] Fix return type bug in TaskHandler</li>
<li>[AIRFLOW-2389] Create a pinot db api hook</li>
<li>[AIRFLOW-2390] Resolve FlaskWTFDeprecationWarning</li>
<li>[AIRFLOW-1933] Fix some typos</li>
<li>[AIRFLOW-1960] Add support for secrets in kubernetes operator</li>
<li>[AIRFLOW-1313] Add vertica_to_mysql operator</li>
<li>[AIRFLOW-1575] Add AWS Kinesis Firehose Hook for inserting batch records</li>
<li>[AIRFLOW-2266][AIRFLOW-2343] Remove google-cloud-dataflow dependency</li>
<li>[AIRFLOW-2370] Implement –use_random_password in create_user</li>
<li>[AIRFLOW-2348] Strip path prefix from the destination_object when source_object contains a wildcard[]</li>
<li>[AIRFLOW-2391] Fix to Flask 0.12.2</li>
<li>[AIRFLOW-2381] Fix the flaky ApiPasswordTests test</li>
<li>[AIRFLOW-2378] Add Groupon to list of current users</li>
<li>[AIRFLOW-2382] Fix wrong description for delimiter</li>
<li>[AIRFLOW-2380] Add support for environment variables in Spark submit operator.</li>
<li>[AIRFLOW-2377] Improve Sendgrid sender support</li>
<li>[AIRFLOW-2331] Support init action timeout on dataproc cluster create</li>
<li>[AIRFLOW-1835] Update docs: Variable file is json</li>
<li>[AIRFLOW-1781] Make search case-insensitive in LDAP group</li>
<li>[AIRFLOW-2042] Fix browser menu appearing over the autocomplete menu</li>
<li>[AIRFLOW-XXX] Remove wheelhouse files from travis not owned by travis</li>
<li>[AIRFLOW-2336] Use hmsclient in hive_hook</li>
<li>[AIRFLOW-2041] Correct Syntax in python examples</li>
<li>[AIRFLOW-74] SubdagOperators can consume all celeryd worker processes</li>
<li>[AIRFLOW-2369] Fix gcs tests</li>
<li>[AIRFLOW-2365] Fix autocommit attribute check</li>
<li>[AIRFLOW-2068] MesosExecutor allows optional Docker image</li>
<li>[AIRFLOW-1652] Push DatabricksRunSubmitOperator metadata into XCOM</li>
<li>[AIRFLOW-2234] Enable insert_rows for PrestoHook</li>
<li>[AIRFLOW-2208][Airflow-22208] Link to same DagRun graph from TaskInstance view</li>
<li>[AIRFLOW-1153] Allow HiveOperators to take hiveconfs</li>
<li>[AIRFLOW-775] Fix autocommit settings with Jdbc hook</li>
<li>[AIRFLOW-2364] Warn when setting autocommit on a connection which does not support it</li>
<li>[AIRFLOW-2357] Add persistent volume for the logs</li>
<li>[AIRFLOW-766] Skip conn.commit() when in Auto-commit</li>
<li>[AIRFLOW-2351] Check for valid default_args start_date</li>
<li>[AIRFLOW-1433] Set default rbac to initdb</li>
<li>[AIRFLOW-2270] Handle removed tasks in backfill</li>
<li>[AIRFLOW-2344] Fix <cite>connections -l</cite> to work with pipe/redirect</li>
<li>[AIRFLOW-2300] Add S3 Select functionarity to S3ToHiveTransfer</li>
<li>[AIRFLOW-1314] Cleanup the config</li>
<li>[AIRFLOW-1314] Polish some of the Kubernetes docs/config</li>
<li>[AIRFLOW-1314] Improve error handling</li>
<li>[AIRFLOW-1999] Add per-task GCP service account support</li>
<li>[AIRFLOW-1314] Rebasing against master</li>
<li>[AIRFLOW-1314] Small cleanup to address PR comments (#24)</li>
<li>[AIRFLOW-1314] Add executor_config and tests</li>
<li>[AIRFLOW-1314] Improve k8s support</li>
<li>[AIRFLOW-1314] Use VolumeClaim for transporting DAGs</li>
<li>[AIRFLOW-1314] Create integration testing environment</li>
<li>[AIRFLOW-1314] Git Mode to pull in DAGs for Kubernetes Executor</li>
<li>[AIRFLOW-1314] Add support for volume mounts &amp; Secrets in Kubernetes Executor</li>
<li>[AIRFLOW=1314] Basic Kubernetes Mode</li>
<li>[AIRFLOW-2326][AIRFLOW-2222] remove contrib.gcs_copy_operator</li>
<li>[AIRFLOW-2328] Fix empty GCS blob in S3ToGoogleCloudStorageOperator</li>
<li>[AIRFLOW-2350] Fix grammar in UPDATING.md</li>
<li>[AIRFLOW-2302] Fix documentation</li>
<li>[AIRFLOW-2345] pip is not used in this setup.py</li>
<li>[AIRFLOW-2347] Add Banco de Formaturas to Readme</li>
<li>[AIRFLOW-2346] Add Investorise as official user of Airflow</li>
<li>[AIRFLOW-2330] Do not append destination prefix if not given</li>
<li>[AIRFLOW-2240][DASK] Added TLS/SSL support for the dask-distributed scheduler.</li>
<li>[AIRFLOW-2309] Fix duration calculation on TaskFail</li>
<li>[AIRFLOW-2335] fix issue with jdk8 download for ci</li>
<li>[AIRFLOW-2184] Add druid_checker_operator</li>
<li>[AIRFLOW-2299] Add S3 Select functionarity to S3FileTransformOperator</li>
<li>[AIRFLOW-2254] Put header as first row in unload</li>
<li>[AIRFLOW-610] Respect _cmd option in config before defaults</li>
<li>[AIRFLOW-2287] Fix incorrect ASF headers</li>
<li>[AIRFLOW-XXX] Add Zego as an Apache Airflow user</li>
<li>[AIRFLOW-952] fix save empty extra field in UI</li>
<li>[AIRFLOW-1325] Add ElasticSearch log handler and reader</li>
<li>[AIRFLOW-2301] Sync files of an S3 key with a GCS path</li>
<li>[AIRFLOW-2293] Fix S3FileTransformOperator to work with boto3</li>
<li>[AIRFLOW-3212][AIRFLOW-2314] Remove only leading slash in GCS path</li>
<li>[AIRFLOW-1509][AIRFLOW-442] SFTP Sensor</li>
<li>[AIRFLOW-2291] Add optional params to ML Engine</li>
<li>[AIRFLOW-1774] Allow consistent templating of arguments in MLEngineBatchPredictionOperator</li>
<li>[AIRFLOW-2302] Add missing operators and hooks</li>
<li>[AIRFLOW-2312] Docs Typo Correction: Corresponding</li>
<li>[AIRFLOW-1623] Trigger on_kill method in operators</li>
<li>[AIRFLOW-2162] When impersonating another user, pass env variables to sudo</li>
<li>[AIRFLOW-2304] Update quickstart doc to mention scheduler part</li>
<li>[AIRFLOW-1633] docker_operator needs a way to set shm_size</li>
<li>[AIRFLOW-1340] Add S3 to Redshift transfer operator</li>
<li>[AIRFLOW-2303] Lists the keys inside an S3 bucket</li>
<li>[AIRFLOW-2209] restore flask_login imports</li>
<li>[AIRFLOW-2306] Add Bonnier Broadcasting to list of current users</li>
<li>[AIRFLOW-2305][AIRFLOW-2027] Fix CI failure caused by []</li>
<li>[AIRFLOW-2281] Add support for Sendgrid categories</li>
<li>[AIRFLOW-2027] Only trigger sleep in scheduler after all files have parsed</li>
<li>[AIRFLOW-2256] SparkOperator: Add Client Standalone mode and retry mechanism</li>
<li>[AIRFLOW-2284] GCS to S3 operator</li>
<li>[AIRFLOW-2287] Update license notices</li>
<li>[AIRFLOW-2296] Add Cinimex DataLab to Readme</li>
<li>[AIRFLOW-2298] Add Kalibrr to who uses airflow</li>
<li>[AIRFLOW-2292] Fix docstring for S3Hook.get_wildcard_key</li>
<li>[AIRFLOW-XXX] Update PR template</li>
<li>[AIRFLOW-XXX] Remove outdated migrations.sql</li>
<li>[AIRFLOW-2287] Add license header to docs/Makefile</li>
<li>[AIRFLOW-2286] Add tokopedia to the readme</li>
<li>[AIRFLOW-2273] Add Discord webhook operator/hook</li>
<li>[AIRFLOW-2282] Fix grammar in UPDATING.md</li>
<li>[AIRFLOW-2200] Add snowflake operator with tests</li>
<li>[AIRFLOW-2178] Add handling on SLA miss errors</li>
<li>[AIRFLOW-2169] Fix type ‘bytes’ is not JSON serializable in python3</li>
<li>[AIRFLOW-2215] Pass environment to subproces.Popen in base_task_runner</li>
<li>[AIRFLOW-2253] Add Airflow CLI instrumentation</li>
<li>[AIRFLOW-2274] Fix Dataflow tests</li>
<li>[AIRFLOW-2269] Add Custom Ink as an Airflow user</li>
<li>[AIRFLOW-2259] Dataflow Hook Index out of range</li>
<li>[AIRFLOW-2233] Update updating.md to include the info of hdfs_sensors renaming</li>
<li>[AIRFLOW-2217] Add Slack webhook operator</li>
<li>[AIRFLOW-1729] improve dagBag time</li>
<li>[AIRFLOW-2264] Improve create_user cli help message</li>
<li>[AIRFLOW-2260] [AIRFLOW-2260] SSHOperator add command template .sh files</li>
<li>[AIRFLOW-2261] Check config/env for remote base log folder</li>
<li>[AIRFLOW-2258] Allow import of Parquet-format files into BigQuery</li>
<li>[AIRFLOW-1430] Include INSTALL instructions to avoid GPL</li>
<li>[AIRFLOW-1430] Solve GPL dependency</li>
<li>[AIRFLOW-2251] Add Thinknear as an Airflow user</li>
<li>[AIRFLOW-2244] bugfix: remove legacy LongText code from models.py</li>
<li>[AIRFLOW-2247] Fix RedshiftToS3Transfer not to fail with ValueError</li>
<li>[AIRFLOW-2249] Add side-loading support for Zendesk Hook</li>
<li>[AIRFLOW-XXX] Add Qplum to Airflow users</li>
<li>[AIRFLOW-2228] Enhancements in ValueCheckOperator</li>
<li>[AIRFLOW-1206] Typos</li>
<li>[AIRFLOW-2060] Update pendulum version to 1.4.4</li>
<li>[AIRFLOW-2248] Fix wrong param name in RedshiftToS3Transfer doc</li>
<li>[AIRFLOW-1433][AIRFLOW-85] New Airflow Webserver UI with RBAC support</li>
<li>[AIRFLOW-1235] Fix webserver’s odd behaviour</li>
<li>[AIRFLOW-1460] Allow restoration of REMOVED TI’s</li>
<li>[airflow-2235] Fix wrong docstrings in two operators</li>
<li>[AIRFLOW-XXX] Fix chronological order for companies using Airflow</li>
<li>[AIRFLOW-2124] Upload Python file to a bucket for Dataproc</li>
<li>[AIRFLOW-2212] Fix ungenerated sensor API reference</li>
<li>[AIRFLOW-2226] Rename google_cloud_storage_default to google_cloud_default</li>
<li>[AIRFLOW-2211] Rename hdfs_sensors.py to hdfs_sensor.py for consistency</li>
<li>[AIRFLOW-2225] Update document to include DruidDbApiHook</li>
<li>[Airflow-2202] Add filter support in HiveMetastoreHook().max_partition()</li>
<li>[AIRFLOW-2220] Remove duplicate numeric list entry in security.rst</li>
<li>[AIRFLOW-XXX] Update tutorial documentation</li>
<li>[AIRFLOW-2215] Update celery task to preserve environment variables and improve logging on exception</li>
<li>[AIRFLOW-2185] Use state instead of query param</li>
<li>[AIRFLOW-2183] Refactor DruidHook to enable sql</li>
<li>[AIRFLOW-2203] Defer cycle detection</li>
<li>[AIRFLOW-2203] Remove Useless Commands.</li>
<li>[AIRFLOW-2203] Cache signature in apply_defaults</li>
<li>[AIRFLOW-2203] Speed up Operator Resources</li>
<li>[AIRFLOW-2203] Cache static rules (trigger/weight)</li>
<li>[AIRFLOW-2203] Store task ids as sets not lists</li>
<li>[AIRFLOW-2205] Remove unsupported args from JdbcHook doc</li>
<li>[AIRFLOW-2207] Fix flaky test that uses app.cached_app()</li>
<li>[AIRFLOW-2206] Remove unsupported args from JdbcOperator doc</li>
<li>[AIRFLOW-2140] Add Kubernetes scheduler to SparkSubmitOperator</li>
<li>[AIRFLOW-XXX] Add Xero to list of users</li>
<li>[AIRFLOW-2204] Fix webserver debug mode</li>
<li>[AIRFLOW-102] Fix test_complex_template always succeeds</li>
<li>[AIRFLOW-442] Add SFTPHook</li>
<li>[AIRFLOW-2169] Add schema to MySqlToGoogleCloudStorageOperator</li>
<li>[AIRFLOW-2184][AIRFLOW-2138] Google Cloud Storage allow wildcards</li>
<li>[AIRFLOW-1588] Cast Variable value to string</li>
<li>[AIRFLOW-2199] Fix invalid reference to logger</li>
<li>[AIRFLOW-2191] Change scheduler heartbeat logs from info to debug</li>
<li>[AIRFLOW-2106] SalesForce hook sandbox option</li>
<li>[AIRFLOW-2197] Silence hostname_callable config error message</li>
<li>[AIRFLOW-2150] Use lighter call in HiveMetastoreHook().max_partition()</li>
<li>[AIRFLOW-2186] Change the way logging is carried out in few ops</li>
<li>[AIRFLOW-2181] Convert password_auth and test_password_endpoints from DOS to UNIX</li>
<li>[AIRFLOW-2187] Fix Broken Travis CI due to AIRFLOW-2123</li>
<li>[AIRFLOW-2175] Check that filepath is not None</li>
<li>[AIRFLOW-2173] Don’t check task IDs for concurrency reached check</li>
<li>[AIRFLOW-2168] Remote logging for Azure Blob Storage</li>
<li>[AIRFLOW-XXX] Add DocuTAP to list of users</li>
<li>[AIRFLOW-2176] Change the way logging is carried out in BQ Get Data Operator</li>
<li>[AIRFLOW-2177] Add mock test for GCS Download op</li>
<li>[AIRFLOW-2123] Install CI dependencies from setup.py</li>
<li>[AIRFLOW-2129] Presto hook calls _parse_exception_message but defines _get_pretty_exception_message</li>
<li>[AIRFLOW-2174] Fix typos and wrongly rendered documents</li>
<li>[AIRFLOW-2171] Store delegated credentials</li>
<li>[AIRFLOW-2166] Restore BQ run_query dialect param</li>
<li>[AIRFLOW-2163] Add HBC Digital to users of airflow</li>
<li>[AIRFLOW-2065] Fix race-conditions when creating loggers</li>
<li>[AIRFLOW-2147] Plugin manager: added ‘sensors’ attribute</li>
<li>[AIRFLOW-2059] taskinstance query is awful, un-indexed, and does not scale</li>
<li>[AIRFLOW-2159] Fix a few typos in salesforce_hook</li>
<li>[AIRFLOW-2132] Add step to initialize database</li>
<li>[AIRFLOW-2160] Fix bad rowid deserialization</li>
<li>[AIRFLOW-2161] Add Vevo to list of companies using Airflow</li>
<li>[AIRFLOW-2149] Add link to apache Beam documentation to create self executing Jar</li>
<li>[AIRFLOW-2151] Allow getting the session from AwsHook</li>
<li>[AIRFLOW-2097] tz referenced before assignment</li>
<li>[AIRFLOW-2152] Add Multiply to list of companies using Airflow</li>
<li>[AIRFLOW-1551] Add operator to trigger Jenkins job</li>
<li>[AIRFLOW-2034] Fix mixup between %s and {} when using str.format Convention is to use .format for string formating oustide logging, else use lazy format See comment in related issue <a class="reference external" href="https://github.com/apache/airflow/pull/2823/files">https://github.com/apache/airflow/pull/2823/files</a> Identified problematic case using following command line .git/COMMIT_EDITMSG:<cite>grep -r ‘%s’./* | grep ‘.format(‘</cite></li>
<li>[AIRFLOW-2102] Add custom_args to Sendgrid personalizations</li>
<li>[AIRFLOW-1035][AIRFLOW-1053] import unicode_literals to parse Unicode in HQL</li>
<li>[AIRFLOW-2127] Keep loggers during DB migrations</li>
<li>[AIRFLOW-2146] Resolve issues with BQ using DbApiHook methods</li>
<li>[AIRFLOW-2087] Scheduler Report shows incorrect Total task number</li>
<li>[AIRFLOW-2139] Remove unncecessary boilerplate to get DataFrame using pandas_gbq</li>
<li>[AIRFLOW-2125] Using binary package psycopg2-binary</li>
<li>[AIRFLOW-2142] Include message on mkdir failure</li>
<li>[AIRFLOW-1615] SSHHook: use port specified by Connection</li>
<li>[AIRFLOW-2122] Handle boolean values in sshHook</li>
<li>[AIRFLOW-XXX] Add Tile to the list of users</li>
<li>[AIRFLOW-2130] Add missing Operators to API Reference docs</li>
<li>[AIRFLOW-XXX] Add timeout units (seconds)</li>
<li>[AIRFLOW-2134] Add Alan to the list of companies that use Airflow</li>
<li>[AIRFLOW-2133] Remove references to GitHub issues in CONTRIBUTING</li>
<li>[AIRFLOW-2131] Remove confusing AirflowImport docs</li>
<li>[AIRFLOW-1852] Allow hostname to be overridable.</li>
<li>[AIRFLOW-2126] Add Bluecore to active users</li>
<li>[AIRFLOW-1618] Add feature to create GCS bucket</li>
<li>[AIRFLOW-2108] Fix log indentation in BashOperator</li>
<li>[AIRFLOW-2115] Fix doc links to PythonHosted</li>
<li>[AIRFLOW-XXX] Add contributor from Easy company</li>
<li>[AIRFLOW-1882] Add ignoreUnknownValues option to gcs_to_bq operator</li>
<li>[AIRFLOW-2089] Add on kill for SparkSubmit in Standalone Cluster</li>
<li>[AIRFLOW-2113] Address missing DagRun callbacks Given that the handle_callback method belongs to the DAG object, we are able to get the list of task directly with get_task and reduce the communication with the database, making airflow more lightweight.</li>
<li>[AIRFLOW-2112] Fix svg width for Recent Tasks on UI.</li>
<li>[AIRFLOW-2116] Set CI Cloudant version to &lt;2.0</li>
<li>[AIRFLOW-XXX] Add PMC to list of companies using Airflow</li>
<li>[AIRFLOW-2100] Fix Broken Documentation Links</li>
<li>[AIRFLOW-1404] Add ‘flatten_results’ &amp; ‘maximum_bytes_billed’ to BQ Operator</li>
<li>[AIRFLOW-800] Initialize valid Google BigQuery Connection</li>
<li>[AIRFLOW-1319] Fix misleading SparkSubmitOperator and SparkSubmitHook docstring</li>
<li>[AIRFLOW-1983] Parse environment parameter as template</li>
<li>[AIRFLOW-2095] Add operator to create External BigQuery Table</li>
<li>[AIRFLOW-2085] Add SparkJdbc operator</li>
<li>[AIRFLOW-1002] Add ability to clean all dependencies of removed DAG</li>
<li>[AIRFLOW-2094] Jinjafied project_id, region &amp; zone in DataProc{*} Operators</li>
<li>[AIRFLOW-2092] Fixed incorrect parameter in docstring for FTPHook</li>
<li>[AIRFLOW-XXX] Add SocialCops to Airflow users</li>
<li>[AIRFLOW-2088] Fix duplicate keys in MySQL to GCS Helper function</li>
<li>[AIRFLOW-2091] Fix incorrect docstring parameter in BigQuery Hook</li>
<li>[AIRFLOW-2090] Fix typo in DataStore Hook</li>
<li>[AIRFLOW-1157] Fix missing pools crashing the scheduler</li>
<li>[AIRFLOW-713] Jinjafy {EmrCreateJobFlow,EmrAddSteps}Operator attributes</li>
<li>[AIRFLOW-2083] Docs: Use “its” instead of “it’s” where appropriate</li>
<li>[AIRFLOW-2066] Add operator to create empty BQ table</li>
<li>[AIRFLOW-XXX] add Karmic to list of companies</li>
<li>[AIRFLOW-2073] Make FileSensor fail when the file doesn’t exist</li>
<li>[AIRFLOW-2078] Improve task_stats and dag_stats performance</li>
<li>[AIRFLOW-2080] Use a log-out icon instead of a power button</li>
<li>[AIRFLOW-2077] Fetch all pages of list_objects_v2 response</li>
<li>[AIRFLOW-XXX] Add TM to list of companies</li>
<li>[AIRFLOW-1985] Impersonation fixes for using <cite>run_as_user</cite></li>
<li>[AIRFLOW-2018][AIRFLOW-2] Make Sensors backward compatible</li>
<li>[AIRFLOW-XXX] Fix typo in concepts doc (dag_md)</li>
<li>[AIRFLOW-2069] Allow Bytes to be uploaded to S3</li>
<li>[AIRFLOW-2074] Fix log var name in GHE auth</li>
<li>[AIRFLOW-1927] Convert naive datetimes for TaskInstances</li>
<li>[AIRFLOW-1760] Password auth for experimental API</li>
<li>[AIRFLOW-2038] Add missing kubernetes dependency for dev</li>
<li>[AIRFLOW-2040] Escape special chars in task instance logs URL</li>
<li>[AIRFLOW-1968][AIRFLOW-1520] Add role_arn and aws_account_id/aws_iam_role support back to aws hook</li>
<li>[AIRFLOW-2048] Fix task instance failure string formatting</li>
<li>[AIRFLOW-2046] Fix kerberos error to work with python 3.x</li>
<li>[AIRFLOW-2063] Add missing docs for GCP</li>
<li>[AIRFLOW-XXX] Fix typo in docs</li>
<li>[AIRFLOW-1793] Use docker_url instead of invalid base_url</li>
<li>[AIRFLOW-2055] Elaborate on slightly ambiguous documentation</li>
<li>[AIRFLOW-2039] BigQueryOperator supports priority property</li>
<li>[AIRFLOW-2053] Fix quote character bug in BQ hook</li>
<li>[AIRFLOW-2057] Add Overstock to list of companies</li>
<li>[AIRFLOW-XXX] Add Plaid to Airflow users</li>
<li>[AIRFLOW-2044] Add SparkSubmitOperator to documentation</li>
<li>[AIRFLOW-2037] Add methods to get Hash values of a GCS object</li>
<li>[AIRFLOW-2050] Fix Travis permission problem</li>
<li>[AIRFLOW-2043] Add Intercom to list of companies</li>
<li>[AIRFLOW-2023] Add debug logging around number of queued files</li>
<li>[AIRFLOW-XXX] Add Pernod-ricard as a airflow user</li>
<li>[AIRFLOW-1453] Add ‘steps’ into template_fields in EmrAddSteps</li>
<li>[AIRFLOW-2015] Add flag for interactive runs</li>
<li>[AIRFLOW-1895] Fix primary key integrity for mysql</li>
<li>[AIRFLOW-2030] Fix KeyError:<cite>i</cite> in DbApiHook for insert</li>
<li>[AIRFLOW-1943] Add External BigQuery Table feature</li>
<li>[AIRFLOW-2033] Add Google Cloud Storage List Operator</li>
<li>[AIRFLOW-2006] Add local log catching to kubernetes operator</li>
<li>[AIRFLOW-2031] Add missing gcp_conn_id in the example in DataFlow docstrings</li>
<li>[AIRFLOW-2029] Fix AttributeError in BigQueryPandasConnector</li>
<li>[AIRFLOW-2028] Add JobTeaser to official users list</li>
<li>[AIRFLOW-2016] Add support for Dataproc Workflow Templates</li>
<li>[AIRFLOW-2025] Reduced Logging verbosity</li>
<li>[AIRFLOW-1267][AIRFLOW-1874] Add dialect parameter to BigQueryHook</li>
<li>[AIRFLOW-XXX] Fixed a typo</li>
<li>[AIRFLOW-XXX] Typo node to nodes</li>
<li>[AIRFLOW-2019] Update DataflowHook for updating Streaming type job</li>
<li>[AIRFLOW-2017][Airflow 2017] adding query output to PostgresOperator</li>
<li>[AIRFLOW-1889] Split sensors into separate files</li>
<li>[AIRFLOW-1950] Optionally pass xcom_pull task_ids</li>
<li>[AIRFLOW-1755] Allow mount below root</li>
<li>[AIRFLOW-511][Airflow 511] add success/failure callbacks on dag level</li>
<li>[AIRFLOW-192] Add weight_rule param to BaseOperator</li>
<li>[AIRFLOW-2008] Use callable for python column defaults</li>
<li>[AIRFLOW-1984] Fix to AWS Batch operator</li>
<li>[AIRFLOW-2000] Support non-main dataflow job class</li>
<li>[AIRFLOW-2003] Use flask-caching instead of flask-cache</li>
<li>[AIRFLOW-2002] Do not swallow exception on logging import</li>
<li>[AIRFLOW-2004] Import flash from flask not flask.login</li>
<li>[AIRFLOW-1997] Fix GCP operator doc strings</li>
<li>[AIRFLOW-1996] Update DataflowHook waitfordone for Streaming type job[]</li>
<li>[AIRFLOW-1995][Airflow 1995] add on_kill method to SqoopOperator</li>
<li>[AIRFLOW-1770] Allow HiveOperator to take in a file</li>
<li>[AIRFLOW-1994] Change background color of Scheduled state Task Instances</li>
<li>[AIRFLOW-1436][AIRFLOW-1475] EmrJobFlowSensor considers Cancelled step as Successful</li>
<li>[AIRFLOW-1517] Kubernetes operator PR fixes</li>
<li>[AIRFLOW-1517] addressed PR comments</li>
<li>[AIRFLOW-1517] started documentation of k8s operator</li>
<li>[AIRFLOW-1517] Restore authorship of resources</li>
<li>[AIRFLOW-1517] Remove authorship of resources</li>
<li>[AIRFLOW-1517] Add minikube for kubernetes integration tests</li>
<li>[AIRFLOW-1517] Restore authorship of resources</li>
<li>[AIRFLOW-1517] fixed license issues</li>
<li>[AIRFLOW-1517] Created more accurate failures for kube cluster issues</li>
<li>[AIRFLOW-1517] Remove authorship of resources</li>
<li>[AIRFLOW-1517] Add minikube for kubernetes integration tests</li>
<li>[AIRFLOW-1988] Change BG color of None state TIs</li>
<li>[AIRFLOW-790] Clean up TaskInstances without DagRuns</li>
<li>[AIRFLOW-1949] Fix var upload, str() produces “b’…’” which is not json</li>
<li>[AIRFLOW-1930] Convert func.now() to timezone.utcnow()</li>
<li>[AIRFLOW-1688] Support load.time_partitioning in bigquery_hook</li>
<li>[AIRFLOW-1975] Make TriggerDagRunOperator callback optional</li>
<li>[AIRFLOW-1480] Render template attributes for ExternalTaskSensor fields</li>
<li>[AIRFLOW-1958] Add <a href="#id5"><span class="problematic" id="id6">**</span></a>kwargs to send_email</li>
<li>[AIRFLOW-1976] Fix for missing log/logger attribute FileProcessHandler</li>
<li>[AIRFLOW-1982] Fix Executor event log formatting</li>
<li>[AIRFLOW-1971] Propagate hive config on impersonation</li>
<li>[AIRFLOW-1969] Always use HTTPS URIs for Google OAuth2</li>
<li>[AIRFLOW-1954] Add DataFlowTemplateOperator</li>
<li>[AIRFLOW-1963] Add config for HiveOperator mapred_queue</li>
<li>[AIRFLOW-1946][AIRFLOW-1855] Create a BigQuery Get Data Operator</li>
<li>[AIRFLOW-1953] Add labels to dataflow operators</li>
<li>[AIRFLOW-1967] Update Celery to 4.0.2</li>
<li>[AIRFLOW-1964] Add Upsight to list of Airflow users</li>
<li>[AIRFLOW-XXX] Changelog for 1.9.0</li>
<li>[AIRFLOW-1470] Implement BashSensor operator</li>
<li>[AIRFLOW-XXX] Pin sqlalchemy dependency</li>
<li>[AIRFLOW-1955] Do not reference unassigned variable</li>
<li>[AIRFLOW-1957] Add contributor to BalanceHero in Readme</li>
<li>[AIRFLOW-1517] Restore authorship of secrets and init container</li>
<li>[AIRFLOW-1517] Remove authorship of secrets and init container</li>
<li>[AIRFLOW-1935] Add BalanceHero to readme</li>
<li>[AIRFLOW-1939] add astronomer contributors</li>
<li>[AIRFLOW-1517] Kubernetes Operator</li>
<li>[AIRFLOW-1928] Fix &#64;once with catchup=False</li>
<li>[AIRFLOW-1937] Speed up scheduling by committing in batch</li>
<li>[AIRFLOW-1821] Enhance default logging config by removing extra loggers</li>
<li>[AIRFLOW-1904] Correct DAG fileloc to the right filepath</li>
<li>[AIRFLOW-1909] Update docs with supported versions of MySQL server</li>
<li>[AIRFLOW-1915] Relax flask-wtf dependency specification</li>
<li>[AIRFLOW-1920] Update CONTRIBUTING.md to reflect enforced linting rules</li>
<li>[AIRFLOW-1942] Update Sphinx docs to remove deprecated import structure</li>
<li>[AIRFLOW-1846][AIRFLOW-1697] Hide Ad Hoc Query behind secure_mode config</li>
<li>[AIRFLOW-1948] Include details for on_kill failure</li>
<li>[AIRFLOW-1938] Clean up unused exception</li>
<li>[AIRFLOW-1932] Add GCP Pub/Sub Pull and Ack</li>
<li>[AIRFLOW-XXX] Purge coveralls</li>
<li>[AIRFLOW-XXX] Remove unused coveralls token</li>
<li>[AIRFLOW-1938] Remove tag version check in setup.py</li>
<li>[AIRFLOW-1916] Don’t upload logs to remote from <cite>run –raw</cite></li>
<li>[AIRFLOW-XXX] Fix failing PubSub tests on Python3</li>
<li>[AIRFLOW-XXX] Upgrade to python 3.5 and disable dask tests</li>
<li>[AIRFLOW-1913] Add new GCP PubSub operators</li>
<li>[AIRFLOW-1525] Fix minor LICENSE and NOTICE issues</li>
<li>[AIRFLOW-1687] fix fernet error without encryption</li>
<li>[AIRFLOW-1912] airflow.processor should not propagate logging</li>
<li>[AIRFLOW-1911] Rename celeryd_concurrency</li>
<li>[AIRFLOW-1885] Fix IndexError in ready_prefix_on_cmdline</li>
<li>[AIRFLOW-1854] Improve Spark Submit operator for standalone cluster mode</li>
<li>[AIRFLOW-1908] Fix celery broker options config load</li>
<li>[AIRFLOW-1907] Pass max_ingestion_time to Druid hook</li>
<li>[AIRFLOW-1909] Add away to list of users</li>
<li>[AIRFLOW-1893][AIRFLOW-1901] Propagate PYTHONPATH when using impersonation</li>
<li>[AIRFLOW-1892] Modify BQ hook to extract data filtered by column</li>
<li>[AIRFLOW-1829] Support for schema updates in query jobs</li>
<li>[AIRFLOW-1840] Make celery configuration congruent with Celery 4</li>
<li>[AIRFLOW-1878] Fix stderr/stdout redirection for tasks</li>
<li>[AIRFLOW-1897][AIRFLOW-1873] Task Logs for running instance not visible in WebUI</li>
<li>[AIRFLOW-1896] FIX bleach &lt;&gt; html5lib incompatibility</li>
<li>[AIRFLOW-1884][AIRFLOW-1059] Reset orphaned task state for external dagruns</li>
<li>[AIRFLOW-XXX] Fix typo in comment</li>
<li>[AIRFLOW-1869] Do not emit spurious warning on missing logs</li>
<li>[AIRFLOW-1888] Add AWS Redshift Cluster Sensor</li>
<li>[AIRFLOW-1887] Renamed endpoint url variable</li>
<li>[AIRFLOW-1873] Set TI.try_number to right value depending TI state</li>
<li>[AIRFLOW-1891] Fix non-ascii typo in default configuration template</li>
<li>[AIRFLOW-1879] Handle ti log entirely within ti</li>
<li>[AIRFLOW-1869] Write more error messages into gcs and file logs</li>
<li>[AIRFLOW-1876] Write subtask id to task log header</li>
<li>[AIRFLOW-1554] Fix wrong DagFileProcessor termination method call</li>
<li>[AIRFLOW-342] Do not use amqp, rpc as result backend</li>
<li>[AIRFLOW-966] Make celery broker_transport_options configurable</li>
<li>[AIRFLOW-1881] Make operator log in task log</li>
<li>[AIRFLOW-XXX] Added DataReply to the list of Airflow Users</li>
<li>[AIRFLOW-1883] Get File Size for objects in Google Cloud Storage</li>
<li>[AIRFLOW-1872] Set context for all handlers including parents</li>
<li>[AIRFLOW-1855][AIRFLOW-1866] Add GCS Copy Operator to copy multiple files</li>
<li>[AIRFLOW-1870] Enable flake8 tests</li>
<li>[AIRFLOW-1785] Enable Python 3 tests</li>
<li>[AIRFLOW-1850] Copy cmd before masking</li>
<li>[AIRFLOW-1665] Reconnect on database errors</li>
<li>[AIRFLOW-1559] Dispose SQLAlchemy engines on exit</li>
<li>[AIRFLOW-1559] Close file handles in subprocesses</li>
<li>[AIRFLOW-1559] Make database pooling optional</li>
<li>[AIRFLOW-1848][Airflow-1848] Fix DataFlowPythonOperator py_file extension doc comment</li>
<li>[AIRFLOW-1843] Add Google Cloud Storage Sensor with prefix</li>
<li>[AIRFLOW-1803] Time zone documentation</li>
<li>[AIRFLOW-1826] Update views to use timezone aware objects</li>
<li>[AIRFLOW-1827] Fix api endpoint date parsing</li>
<li>[AIRFLOW-1806] Use naive datetime when using cron</li>
<li>[AIRFLOW-1809] Update tests to use timezone aware objects</li>
<li>[AIRFLOW-1806] Use naive datetime for cron scheduling</li>
<li>[AIRFLOW-1807] Force use of time zone aware db fields</li>
<li>[AIRFLOW-1808] Convert all utcnow() to time zone aware</li>
<li>[AIRFLOW-1804] Add time zone configuration options</li>
<li>[AIRFLOW-1802] Convert database fields to timezone aware</li>
<li>[AIRFLOW-XXX] Add dask lock files to excludes</li>
<li>[AIRFLOW-1790] Add support for AWS Batch operator</li>
<li>[AIRFLOW-XXX] Update README.md</li>
<li>[AIRFLOW-1820] Remove timestamp from metric name</li>
<li>[AIRFLOW-1810] Remove unused mysql import in migrations.</li>
<li>[AIRFLOW-1838] Properly log collect_dags exception</li>
<li>[AIRFLOW-1842] Fixed Super class name for the gcs to gcs copy operator</li>
<li>[AIRFLOW-1845] Modal background now covers long or tall pages</li>
<li>[AIRFLOW-1229] Add link to Run Id, incl execution_date</li>
<li>[AIRFLOW-1842] Add gcs to gcs copy operator with renaming if required</li>
<li>[AIRFLOW-1841] change False to None in operator and hook</li>
<li>[AIRFLOW-1839] Fix more bugs in S3Hook boto -&gt; boto3 migration</li>
<li>[AIRFLOW-1830] Support multiple domains in Google authentication backend</li>
<li>[AIRFLOW-1831] Add driver-classpath spark submit</li>
<li>[AIRFLOW-1795] Correctly call S3Hook after migration to boto3</li>
<li>[AIRFLOW-1811] Fix render Druid operator</li>
<li>[AIRFLOW-1819] Fix slack operator unittest bug</li>
<li>[AIRFLOW-1805] Allow Slack token to be passed through connection</li>
<li>[AIRFLOW-1816] Add region param to Dataproc operators</li>
<li>[AIRFLOW-868] Add postgres_to_gcs operator and unittests</li>
<li>[AIRFLOW-1613] make mysql_to_gcs_operator py3 compatible</li>
<li>[AIRFLOW-1817] use boto3 for s3 dependency</li>
<li>[AIRFLOW-1813] Bug SSH Operator empty buffer</li>
<li>[AIRFLOW-1801][AIRFLOW-288] Url encode execution dates</li>
<li>[AIRFLOW-1563] Catch OSError while symlinking the latest log directory</li>
<li>[AIRFLOW-1794] Remove uses of Exception.message for Python 3</li>
<li>[AIRFLOW-1799] Fix logging line which raises errors</li>
<li>[AIRFLOW-1102] Upgrade Gunicorn &gt;=19.4.0</li>
<li>[AIRFLOW-1756] Fix S3TaskHandler to work with Boto3-based S3Hook</li>
<li>[AIRFLOW-1797] S3Hook.load_string didn’t work on Python3</li>
<li>[AIRFLOW-646] Add docutils to setup_requires</li>
<li>[AIRFLOW-1792] Missing intervals DruidOperator</li>
<li>[AIRFLOW-1789][AIRFLOW-1712] Log SSHOperator stderr to log.warning</li>
<li>[AIRFLOW-1787] Fix task instance batch clear and set state bugs</li>
<li>[AIRFLOW-1780] Fix long output lines with unicode from hanging parent</li>
<li>[AIRFLOW-387] Close SQLAlchemy sessions properly</li>
<li>[AIRFLOW-1779] Add keepalive packets to ssh hook</li>
<li>[AIRFLOW-1669] Fix Docker and pin Moto to 1.1.19</li>
<li>[AIRFLOW-71] Add support for private Docker images</li>
<li>[AIRFLOW-XXX] Give a clue what the ‘ds’ variable is</li>
<li>[AIRFLOW-XXX] Correct typos in the faq docs page</li>
<li>[AIRFLOW-1571] Add AWS Lambda Hook</li>
<li>[AIRFLOW-1675] Fix docstrings for API docs</li>
<li>[AIRFLOW-1712][AIRFLOW-756][AIRFLOW-751] Log SSHOperator output</li>
<li>[AIRFLOW-1776] Capture stdout and stderr for logging</li>
<li>[AIRFLOW-1765] Make experimental API securable without needing Kerberos.</li>
<li>[AIRFLOW-1764] The web interface should not use the experimental API</li>
<li>[AIRFLOW-1771] Rename heartbeat to avoid confusion</li>
<li>[AIRFLOW-1769] Add support for templates in VirtualenvOperator</li>
<li>[AIRFLOW-1763] Fix S3TaskHandler unit tests</li>
<li>[AIRFLOW-1315] Add Qubole File &amp; Partition Sensors</li>
<li>[AIRFLOW-1018] Make processor use logging framework</li>
<li>[AIRFLOW-1695] Add RedshiftHook using boto3</li>
<li>[AIRFLOW-1706] Fix query error for MSSQL backend</li>
<li>[AIRFLOW-1711] Use ldap3 dict for group membership</li>
<li>[AIRFLOW-1723] Make sendgrid a plugin</li>
<li>[AIRFLOW-1757] Add missing options to SparkSubmitOperator</li>
<li>[AIRFLOW-1734][Airflow 1734] Sqoop hook/operator enhancements</li>
<li>[AIRFLOW-1761] Fix type in scheduler.rst</li>
<li>[AIRFLOW-1731] Set pythonpath for logging</li>
<li>[AIRFLOW-1641] Handle executor events in the scheduler</li>
<li>[AIRFLOW-1744] Make sure max_tries can be set</li>
<li>[AIRFLOW-1732] Improve dataflow hook logging</li>
<li>[AIRFLOW-1736] Add HotelQuickly to Who Uses Airflow</li>
<li>[AIRFLOW-1657] Handle failing qubole operator</li>
<li>[AIRFLOW-1677] Fix typo in example_qubole_operator</li>
<li>[AIRFLOW-926] Fix JDBC Hook</li>
<li>[AIRFLOW-1520] Boto3 S3Hook, S3Log</li>
<li>[AIRFLOW-1716] Fix multiple __init__ def in SimpleDag</li>
<li>[AIRFLOW-XXX] Fix DateTime in Tree View</li>
<li>[AIRFLOW-1719] Fix small typo</li>
<li>[AIRFLOW-1432] Charts label for Y axis not visible</li>
<li>[AIRFLOW-1743] Verify ldap filters correctly</li>
<li>[AIRFLOW-1745] Restore default signal disposition</li>
<li>[AIRFLOW-1741] Correctly hide second chart on task duration page</li>
<li>[AIRFLOW-1728] Add networkUri, subnet, tags to Dataproc operator</li>
<li>[AIRFLOW-1726] Add copy_expert psycopg2 method to PostgresHook</li>
<li>[AIRFLOW-1330] Add conn_type argument to CLI when adding connection</li>
<li>[AIRFLOW-1698] Remove SCHEDULER_RUNS env var in systemd</li>
<li>[AIRFLOW-1694] Stop using itertools.izip</li>
<li>[AIRFLOW-1692] Change test_views filename to support Windows</li>
<li>[AIRFLOW-1722] Fix typo in scheduler autorestart output filename</li>
<li>[AIRFLOW-1723] Support sendgrid in email backend</li>
<li>[AIRFLOW-1718] Set num_retries on Dataproc job request execution</li>
<li>[AIRFLOW-1727] Add unit tests for DataProcHook</li>
<li>[AIRFLOW-1631] Fix timing issue in unit test</li>
<li>[AIRFLOW-1631] Fix local executor unbound parallelism</li>
<li>[AIRFLOW-1724] Add Fundera to Who uses Airflow?</li>
<li>[AIRFLOW-1683] Cancel BigQuery job on timeout.</li>
<li>[AIRFLOW-1714] Fix misspelling: s/seperate/separate/</li>
<li>[AIRFLOW-1681] Add batch clear in task instance view</li>
<li>[AIRFLOW-1696] Fix dataproc version label error</li>
<li>[AIRFLOW-1613] Handle binary field in MySqlToGoogleCloudStorageOperator</li>
<li>[AIRFLOW-1697] Mode to disable charts endpoint</li>
<li>[AIRFLOW-1691] Add better Google cloud logging documentation</li>
<li>[AIRFLOW-1690] Add detail to gcs error messages</li>
<li>[AIRFLOW-1682] Make S3TaskHandler write to S3 on close</li>
<li>[AIRFLOW-1634] Adds task_concurrency feature</li>
<li>[AIRFLOW-1676] Make GCSTaskHandler write to GCS on close</li>
<li>[AIRFLOW-1678] Fix erroneously repeated word in function docstrings</li>
<li>[AIRFLOW-1323] Made Dataproc operator parameter names consistent</li>
<li>[AIRFLOW-1590] fix unused module and variable</li>
<li>[AIRFLOW-1671] Add &#64;apply_defaults back to gcs download operator</li>
<li>[AIRFLOW-988] Fix repeating SLA miss callbacks</li>
<li>[AIRFLOW-1611] Customize logging</li>
<li>[AIRFLOW-1668] Expose keepalives_idle for Postgres connections</li>
<li>[AIRFLOW-1658] Kill Druid task on timeout</li>
<li>[AIRFLOW-1669][AIRFLOW-1368] Fix Docker import</li>
<li>[AIRFLOW-891] Make webserver clock include date</li>
<li>[AIRFLOW-1560] Add AWS DynamoDB hook and operator for inserting batch items</li>
<li>[AIRFLOW-1654] Show tooltips for link icons in DAGs view</li>
<li>[AIRFLOW-1660] Change webpage width to full-width</li>
<li>[AIRFLOW-1664] write file as binary instead of str</li>
<li>[AIRFLOW-1659] Fix invalid obj attribute bug in file_task_handler.py</li>
<li>[AIRFLOW-1635] Allow creating GCP connection without requiring a JSON file</li>
<li>[AIRFLOW-1650] Fix custom celery config loading</li>
<li>[AIRFLOW-1647] Fix Spark-sql hook</li>
<li>[AIRFLOW-1587] Fix CeleryExecutor import error</li>
<li>[Airflow-1640][AIRFLOW-1640] Add qubole default connection</li>
<li>[AIRFLOW-1576] Added region param to Dataproc{*}Operators</li>
<li>[AIRFLOW-1643] Add healthjump to officially using list</li>
<li>[AIRFLOW-1626] Add Azri Solutions to Airflow users</li>
<li>[AIRFLOW-1636] Add AWS and EMR connection type</li>
<li>[AIRFLOW-1527] Refactor celery config</li>
<li>[AIRFLOW-1639] Fix Fernet error handling</li>
<li>[AIRFLOW-1637] Fix Travis CI build status link</li>
<li>[AIRFLOW-1628] Fix docstring of sqlsensor</li>
<li>[AIRFLOW-1331] add SparkSubmitOperator option</li>
<li>[AIRFLOW-1627] Only query pool in SubDAG init when necessary</li>
<li>[AIRFLOW-1629] Make extra a textarea in edit connections form</li>
<li>[AIRFLOW-1368] Automatically remove Docker container on exit</li>
<li>[AIRFLOW-289] Make airflow timezone independent</li>
<li>[AIRFLOW-1356] Add <cite>–celery_hostname</cite> to <cite>airflow worker</cite></li>
<li>[AIRFLOW-1247] Fix ignore_all_dependencies argument ignored</li>
<li>[AIRFLOW-1621] Add tests for server side paging</li>
<li>[AIRFLOW-1591] Avoid attribute error when rendering logging filename</li>
<li>[AIRFLOW-1031] Replace hard-code to DagRun.ID_PREFIX</li>
<li>[AIRFLOW-1604] Rename logger to log</li>
<li>[AIRFLOW-1512] Add PythonVirtualenvOperator</li>
<li>[AIRFLOW-1617] Fix XSS vulnerability in Variable endpoint</li>
<li>[AIRFLOW-1497] Reset hidden fields when changing connection type</li>
<li>[AIRFLOW-1619] Add poll_sleep parameter to GCP dataflow operator</li>
<li>[AIRFLOW-XXX] Remove landscape.io config</li>
<li>[AIRFLOW-XXX] Remove non working service badges</li>
<li>[AIRFLOW-1177] Fix Variable.setdefault w/existing JSON</li>
<li>[AIRFLOW-1600] Fix exception handling in get_fernet</li>
<li>[AIRFLOW-1614] Replace inspect.stack() with sys._getframe()</li>
<li>[AIRFLOW-1519] Add server side paging in DAGs list</li>
<li>[AIRFLOW-1309] Allow hive_to_druid to take tblproperties</li>
<li>[AIRFLOW-1613] Make MySqlToGoogleCloudStorageOperator compaitible with python3</li>
<li>[AIRFLOW-1603] add PAYMILL to companies list</li>
<li>[AIRFLOW-1609] Fix gitignore to ignore all venvs</li>
<li>[AIRFLOW-1601] Add configurable task cleanup time</li>
</ul>
</div>
<div class="section" id="airflow-1-9-0-2018-01-02">
<h2>Airflow 1.9.0, 2018-01-02<a class="headerlink" href="#airflow-1-9-0-2018-01-02" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-1525] Fix minor LICENSE and NOTICE issues</li>
<li>[AIRFLOW-XXX] Bump version to 1.9.0</li>
<li>[AIRFLOW-1897][AIRFLOW-1873] Task Logs for running instance not visible in WebUI</li>
<li>[AIRFLOW-XXX] Make sure session is committed</li>
<li>[AIRFLOW-1896] FIX bleach &lt;&gt; html5lib incompatibility</li>
<li>[AIRFLOW-XXX] Fix log handler test</li>
<li>[AIRFLOW-1873] Set TI.try_number to right value depending TI state</li>
<li>[AIRFLOW-1554] Fix wrong DagFileProcessor termination method call</li>
<li>[AIRFLOW-1872] Set context for all handlers including parents</li>
<li>[AIRFLOW-XXX] Add dask lock files to excludes</li>
<li>[AIRFLOW-1839] Fix more bugs in S3Hook boto -&gt; boto3 migration</li>
<li>[AIRFLOW-1795] Correctly call S3Hook after migration to boto3</li>
<li>[AIRFLOW-1813] Bug SSH Operator empty buffer</li>
<li>[AIRFLOW-1794] Remove uses of Exception.message for Python 3</li>
<li>[AIRFLOW-1799] Fix logging line which raises errors</li>
<li>[AIRFLOW-1102] Upgrade Gunicorn &gt;=19.4.0</li>
<li>[AIRFLOW-1756] Fix S3TaskHandler to work with Boto3-based S3Hook</li>
<li>[AIRFLOW-1797] S3Hook.load_string didn’t work on Python3</li>
<li>[AIRFLOW-1792] Missing intervals DruidOperator</li>
<li>[AIRFLOW-1789][AIRFLOW-1712] Log SSHOperator stderr to log.warning</li>
<li>[AIRFLOW-1669] Fix Docker and pin Moto to 1.1.19</li>
<li>[AIRFLOW-71] Add support for private Docker images</li>
<li>[AIRFLOW-1779] Add keepalive packets to ssh hook</li>
<li>[AIRFLOW-XXX] Give a clue what the ‘ds’ variable is</li>
<li>[AIRFLOW-XXX] Correct typos in the faq docs page</li>
<li>[AIRFLOW-1571] Add AWS Lambda Hook</li>
<li>[AIRFLOW-1675] Fix docstrings for API docs</li>
<li>[AIRFLOW-1712][AIRFLOW-756][AIRFLOW-751] Log SSHOperator output</li>
<li>[AIRFLOW-1776] Capture stdout and stderr for logging</li>
<li>[AIRFLOW-1765] Make experimental API securable without needing Kerberos.</li>
<li>[AIRFLOW-1764] The web interface should not use the experimental API</li>
<li>[AIRFLOW-1634] Adds task_concurrency feature</li>
<li>[AIRFLOW-1018] Make processor use logging framework</li>
<li>[AIRFLOW-1695] Add RedshiftHook using boto3</li>
<li>[AIRFLOW-1706] Fix query error for MSSQL backend</li>
<li>[AIRFLOW-1711] Use ldap3 dict for group membership</li>
<li>[AIRFLOW-1757] Add missing options to SparkSubmitOperator</li>
<li>[AIRFLOW-1734][Airflow 1734] Sqoop hook/operator enhancements</li>
<li>[AIRFLOW-1731] Set pythonpath for logging</li>
<li>[AIRFLOW-1641] Handle executor events in the scheduler</li>
<li>[AIRFLOW-1744] Make sure max_tries can be set</li>
<li>[AIRFLOW-1330] Add conn_type argument to CLI when adding connection</li>
<li>[AIRFLOW-926] Fix JDBC Hook</li>
<li>[AIRFLOW-1520] Boto3 S3Hook, S3Log</li>
<li>[AIRFLOW-XXX] Fix DateTime in Tree View</li>
<li>[AIRFLOW-1432] Charts label for Y axis not visible</li>
<li>[AIRFLOW-1743] Verify ldap filters correctly</li>
<li>[AIRFLOW-1745] Restore default signal disposition</li>
<li>[AIRFLOW-1741] Correctly hide second chart on task duration page</li>
<li>[AIRFLOW-1726] Add copy_expert psycopg2 method to PostgresHook</li>
<li>[AIRFLOW-1698] Remove SCHEDULER_RUNS env var in systemd</li>
<li>[AIRFLOW-1694] Stop using itertools.izip</li>
<li>[AIRFLOW-1692] Change test_views filename to support Windows</li>
<li>[AIRFLOW-1722] Fix typo in scheduler autorestart output filename</li>
<li>[AIRFLOW-1691] Add better Google cloud logging documentation</li>
<li>[AIRFLOW-1690] Add detail to gcs error messages</li>
<li>[AIRFLOW-1682] Make S3TaskHandler write to S3 on close</li>
<li>[AIRFLOW-1676] Make GCSTaskHandler write to GCS on close</li>
<li>[AIRFLOW-1635] Allow creating GCP connection without requiring a JSON file</li>
<li>[AIRFLOW-1323] Made Dataproc operator parameter names consistent</li>
<li>[AIRFLOW-1590] fix unused module and variable</li>
<li>[AIRFLOW-988] Fix repeating SLA miss callbacks</li>
<li>[AIRFLOW-1611] Customize logging</li>
<li>[AIRFLOW-1668] Expose keepalives_idle for Postgres connections</li>
<li>[AIRFLOW-1658] Kill Druid task on timeout</li>
<li>[AIRFLOW-1669][AIRFLOW-1368] Fix Docker import</li>
<li>[AIRFLOW-1560] Add AWS DynamoDB hook and operator for inserting batch items</li>
<li>[AIRFLOW-1654] Show tooltips for link icons in DAGs view</li>
<li>[AIRFLOW-1660] Change webpage width to full-width</li>
<li>[AIRFLOW-1664] write file as binary instead of str</li>
<li>[AIRFLOW-1659] Fix invalid obj attribute bug in file_task_handler.py</li>
<li>[AIRFLOW-1650] Fix custom celery config loading</li>
<li>[AIRFLOW-1647] Fix Spark-sql hook</li>
<li>[AIRFLOW-1587] Fix CeleryExecutor import error</li>
<li>[AIRFLOW-1636] Add AWS and EMR connection type</li>
<li>[AIRFLOW-1527] Refactor celery config</li>
<li>[AIRFLOW-1639] Fix Fernet error handling</li>
<li>[AIRFLOW-1628] Fix docstring of sqlsensor</li>
<li>[AIRFLOW-1331] add SparkSubmitOperator option</li>
<li>[AIRFLOW-1627] Only query pool in SubDAG init when necessary</li>
<li>[AIRFLOW-1629] Make extra a textarea in edit connections form</li>
<li>[AIRFLOW-1621] Add tests for server side paging</li>
<li>[AIRFLOW-1519] Add server side paging in DAGs list</li>
<li>[AIRFLOW-289] Make airflow timezone independent</li>
<li>[AIRFLOW-1356] Add <cite>–celery_hostname</cite> to <cite>airflow worker</cite></li>
<li>[AIRFLOW-1591] Avoid attribute error when rendering logging filename</li>
<li>[AIRFLOW-1031] Replace hard-code to DagRun.ID_PREFIX</li>
<li>[AIRFLOW-1604] Rename logger to log</li>
<li>[AIRFLOW-1512] Add PythonVirtualenvOperator</li>
<li>[AIRFLOW-1617] Fix XSS vulnerability in Variable endpoint</li>
<li>[AIRFLOW-1497] Reset hidden fields when changing connection type</li>
<li>[AIRFLOW-1177] Fix Variable.setdefault w/existing JSON</li>
<li>[AIRFLOW-1600] Fix exception handling in get_fernet</li>
<li>[AIRFLOW-1614] Replace inspect.stack() with sys._getframe()</li>
<li>[AIRFLOW-1613] Make MySqlToGoogleCloudStorageOperator compaitible with python3</li>
<li>[AIRFLOW-1609] Fix gitignore to ignore all venvs</li>
<li>[AIRFLOW-1601] Add configurable task cleanup time</li>
<li>[AIRFLOW-XXX] Bumping Airflow 1.9.0alpha0 version</li>
<li>[AIRFLOW-1608] Handle pending job state in GCP Dataflow hook</li>
<li>[AIRFLOW-1606] Use non static DAG.sync_to_db</li>
<li>[AIRFLOW-1606][Airflow-1606][AIRFLOW-1605][AIRFLOW-160] DAG.sync_to_db is now a normal method</li>
<li>[AIRFLOW-1602] LoggingMixin in DAG class</li>
<li>[AIRFLOW-1593] expose load_string in WasbHook</li>
<li>[AIRFLOW-1597] Add GameWisp as Airflow user</li>
<li>[AIRFLOW-1594] Don’t install test packages into python root.[]</li>
<li>[AIRFLOW-1582] Improve logging within Airflow</li>
<li>[AIRFLOW-1476] add INSTALL instruction for source releases</li>
<li>[AIRFLOW-XXX] Save username and password in airflow-pr</li>
<li>[AIRFLOW-1522] Increase text size for var field in variables for MySQL</li>
<li>[AIRFLOW-950] Missing AWS integrations on documentation::integrations</li>
<li>[AIRFLOW-XXX] 1.8.2 release notes</li>
<li>[AIRFLOW-1573] Remove <cite>thrift &lt; 0.10.0</cite> requirement</li>
<li>[AIRFLOW-1584] Remove insecure /headers endpoint</li>
<li>[AIRFLOW-1586] Add mapping for date type to mysql_to_gcs operator</li>
<li>[AIRFLOW-1579] Adds support for jagged rows in Bigquery hook for BQ load jobs</li>
<li>[AIRFLOW-1577] Add token support to DatabricksHook</li>
<li>[AIRFLOW-1580] Error in string formating</li>
<li>[AIRFLOW-1567] Updated docs for Google ML Engine operators/hooks</li>
<li>[AIRFLOW-1574] add ‘to’ attribute to templated vars of email operator</li>
<li>[AIRFLOW-1572] add carbonite to company list</li>
<li>[AIRFLOW-1568] Fix typo in BigQueryHook</li>
<li>[AIRFLOW-1493][AIRFLOW-XXXX][WIP] fixed dumb thing</li>
<li>[AIRFLOW-1567][Airflow-1567] Renamed cloudml hook and operator to mlengine</li>
<li>[AIRFLOW-1568] Add datastore export/import operators</li>
<li>[AIRFLOW-1564] Use Jinja2 to render logging filename</li>
<li>[AIRFLOW-1562] Spark-sql logging contains deadlock</li>
<li>[AIRFLOW-1556][Airflow 1556] Add support for SQL parameters in BigQueryBaseCursor</li>
<li>[AIRFLOW-108] Add CreditCards.com to companies list</li>
<li>[AIRFLOW-1541] Add channel to template fields of slack_operator</li>
<li>[AIRFLOW-1535] Add service account/scopes in dataproc</li>
<li>[AIRFLOW-1384] Add to README.md CaDC/ARGO</li>
<li>[AIRFLOW-1546] add Zymergen 80to org list in README</li>
<li>[AIRFLOW-1545] Add Nextdoor to companies list</li>
<li>[AIRFLOW-1544] Add DataFox to companies list</li>
<li>[AIRFLOW-1529] Add logic supporting quoted newlines in Google BigQuery load jobs</li>
<li>[AIRFLOW-1521] Fix emplate rendering for BigqueryTableDeleteOperator</li>
<li>[AIRFLOW-1324] Generalize Druid operator and hook</li>
<li>[AIRFLOW-1516] Fix error handling getting fernet</li>
<li>[AIRFLOW-1420][AIRFLOW-1473] Fix deadlock check</li>
<li>[AIRFLOW-1495] Fix migration on index on job_id</li>
<li>[AIRFLOW-1483] Making page size consistent in list</li>
<li>[AIRFLOW-1495] Add TaskInstance index on job_id</li>
<li>[AIRFLOW-855] Replace PickleType with LargeBinary in XCom</li>
<li>[AIRFLOW-1505] Document when Jinja substitution occurs</li>
<li>[AIRFLOW-1504] Log dataproc cluster name</li>
<li>[AIRFLOW-1239] Fix unicode error for logs in base_task_runner</li>
<li>[AIRFLOW-1280] Fix Gantt chart height</li>
<li>[AIRFLOW-1507] Template parameters in file_to_gcs operator</li>
<li>[AIRFLOW-1452] workaround lock on method</li>
<li>[AIRFLOW-1385] Make Airflow task logging configurable</li>
<li>[AIRFLOW-940] Handle error on variable decrypt</li>
<li>[AIRFLOW-1492] Add gauge for task successes/failures</li>
<li>[AIRFLOW-1443] Update Airflow configuration documentation</li>
<li>[AIRFLOW-1486] Unexpected S3 writing log error</li>
<li>[AIRFLOW-1487] Added links to all companies officially using Airflow</li>
<li>[AIRFLOW-1489] Fix typo in BigQueryCheckOperator</li>
<li>[AIRFLOW-1349] Fix backfill to respect limits</li>
<li>[AIRFLOW-1478] Chart owner column should be sortable</li>
<li>[AIRFLOW-1397][AIRFLOW-1] No Last Run column data displyed in Airflow UI 1.8.1</li>
<li>[AIRFLOW-1474] Add dag_id regex feature for <cite>airflow clear</cite> command</li>
<li>[AIRFLOW-1445] Changing HivePartitionSensor UI color to lighter shade</li>
<li>[AIRFLOW-1359] Use default_args in Cloud ML eval</li>
<li>[AIRFLOW-1389] Support createDisposition in BigQueryOperator</li>
<li>[AIRFLOW-1349] Refactor BackfillJob _execute</li>
<li>[AIRFLOW-1459] Fixed broken integration .rst formatting</li>
<li>[AIRFLOW-1448] Revert “Fix cli reading logfile in memory”</li>
<li>[AIRFLOW-1398] Allow ExternalTaskSensor to wait on multiple runs of a task</li>
<li>[AIRFLOW-1399] Fix cli reading logfile in memory</li>
<li>[AIRFLOW-1442] Remove extra space from ignore_all_deps generated command</li>
<li>[AIRFLOW-1438] Change batch size per query in scheduler</li>
<li>[AIRFLOW-1439] Add max billing tier for the BQ Hook and Operator</li>
<li>[AIRFLOW-1437] Modify BigQueryTableDeleteOperator</li>
<li>[Airflow 1332] Split logs based on try number</li>
<li>[AIRFLOW-1385] Create abstraction for Airflow task logging</li>
<li>[AIRFLOW-756][AIRFLOW-751] Replace ssh hook, operator &amp; sftp operator with paramiko based</li>
<li>[AIRFLOW-1393][[AIRFLOW-1393] Enable Py3 tests in contrib/spark_submit_hook[</li>
<li>[AIRFLOW-1345] Dont expire TIs on each scheduler loop</li>
<li>[AIRFLOW-1059] Reset orphaned tasks in batch for scheduler</li>
<li>[AIRFLOW-1255] Fix SparkSubmitHook output deadlock</li>
<li>[AIRFLOW-1359] Add Google CloudML utils for model evaluation</li>
<li>[AIRFLOW-1247] Fix ignore all dependencies argument ignored</li>
<li>[AIRFLOW-1401] Standardize cloud ml operator arguments</li>
<li>[AIRFLOW-1394] Add quote_character param to GCS hook and operator</li>
<li>[AIRFLOW-1402] Cleanup SafeConfigParser DeprecationWarning</li>
<li>[AIRFLOW-1326][[AIRFLOW-1326][AIRFLOW-1184] Don’t split argument array – it’s already an array.[</li>
<li>[AIRFLOW-1384] Add ARGO/CaDC as a Airflow user</li>
<li>[AIRFLOW-1357] Fix scheduler zip file support</li>
<li>[AIRFLOW-1382] Add working dir option to DockerOperator</li>
<li>[AIRFLOW-1388] Add Cloud ML Engine operators to integration doc</li>
<li>[AIRFLOW-1387] Add unicode string prefix</li>
<li>[AIRFLOW-1366] Add max_tries to task instance</li>
<li>[AIRFLOW-1300] Enable table creation with TBLPROPERTIES</li>
<li>[AIRFLOW-1271] Add Google CloudML Training Operator</li>
<li>[AIRFLOW-300] Add Google Pubsub hook and operator</li>
<li>[AIRFLOW-1343] Fix dataproc label format</li>
<li>[AIRFLOW-1367] Pass Content-ID To reference inline images in an email, we need to be able to add &lt;img src=”cid:{}”/&gt; to the HTML. However currently the Content-ID (cid) is not passed, so we need to add it</li>
<li>[AIRFLOW-1265] Fix celery executor parsing CELERY_SSL_ACTIVE</li>
<li>[AIRFLOW-1272] Google Cloud ML Batch Prediction Operator</li>
<li>[AIRFLOW-1352][AIRFLOW-1335] Revert MemoryHandler change ()[]</li>
<li>[AIRFLOW-1350] Add query_uri param to Hive/SparkSQL DataProc operator</li>
<li>[AIRFLOW-1334] Check if tasks are backfill on scheduler in a join</li>
<li>[AIRFLOW-1343] Add Airflow default label to the dataproc operator</li>
<li>[AIRFLOW-1273] Add Google Cloud ML version and model operators</li>
<li>[AIRFLOW-1273]AIRFLOW-1273] Add Google Cloud ML version and model operators</li>
<li>[AIRFLOW-1321] Fix hidden field key to ignore case</li>
<li>[AIRFLOW-1337] Make log_format key names lowercase</li>
<li>[AIRFLOW-1338][AIRFLOW-782] Add GCP dataflow hook runner change to UPDATING.md</li>
<li>[AIRFLOW-801] Remove outdated docstring on BaseOperator</li>
<li>[AIRFLOW-1344] Fix text encoding bug when reading logs for Python 3.5</li>
<li>[AIRFLOW-1338] Fix incompatible GCP dataflow hook</li>
<li>[AIRFLOW-1333] Enable copy function for Google Cloud Storage Hook</li>
<li>[AIRFLOW-1337] Allow log format customization via airflow.cfg</li>
<li>[AIRFLOW-1320] Update LetsBonus users in README</li>
<li>[AIRFLOW-1335] Use MemoryHandler for buffered logging</li>
<li>[AIRFLOW-1339] Add Drivy to the list of users</li>
<li>[AIRFLOW-1275] Put ‘airflow pool’ into API</li>
<li>[AIRFLOW-1296] Propagate SKIPPED to all downstream tasks</li>
<li>[AIRFLOW-1317] Fix minor issues in API reference</li>
<li>[AIRFLOW-1308] Disable nanny usage for Dask</li>
<li>[AIRFLOW-1172] Support nth weekday of the month cron expression</li>
<li>[AIRFLOW-936] Add clear/mark success for DAG in the UI</li>
<li>[AIRFLOW-1294] Backfills can loose tasks to execute</li>
<li>[AIRFLOW-1299] Support imageVersion in Google Dataproc cluster</li>
<li>[AIRFLOW-1291] Update NOTICE and LICENSE files to match ASF requirements</li>
<li>[AIRFLOW-1301] Add New Relic to list of companies</li>
<li>[AIRFLOW-1289] Removes restriction on number of scheduler threads</li>
<li>[AIRFLOW-1024] Ignore celery executor errors (#49)</li>
<li>[AIRFLOW-1265] Fix exception while loading celery configurations</li>
<li>[AIRFLOW-1290] set docs author to ‘Apache Airflow’</li>
<li>[AIRFLOW-1242] Allowing project_id to have a colon in it.</li>
<li>[AIRFLOW-1282] Fix known event column sorting</li>
<li>[AIRFLOW-1166] Speed up _change_state_for_tis_without_dagrun</li>
<li>[AIRFLOW-1208] Speed-up cli tests</li>
<li>[AIRFLOW-1192] Some enhancements to qubole_operator</li>
<li>[AIRFLOW-1281] Sort variables by key field by default</li>
<li>[AIRFLOW-1277] Forbid KE creation with empty fields</li>
<li>[AIRFLOW-1276] Forbid event creation with end_data earlier than start_date</li>
<li>[AIRFLOW-1263] Dynamic height for charts</li>
<li>[AIRFLOW-1266] Increase width of gantt y axis</li>
<li>[AIRFLOW-1244] Forbid creation of a pool with empty name</li>
<li>[AIRFLOW-1274][HTTPSENSOR] Rename parameter params to data</li>
<li>[AIRFLOW-654] Add SSL Config Option for CeleryExecutor w/ RabbitMQ - Add BROKER_USE_SSL config to give option to send AMQP messages over SSL - Can be set using usual airflow options (e.g. airflow.cfg, env vars, etc.)</li>
<li>[AIRFLOW-1256] Add United Airlines to readme</li>
<li>[AIRFLOW-1251] Add eRevalue to Airflow users</li>
<li>[AIRFLOW-908] Print hostname at the start of cli run</li>
<li>[AIRFLOW-1237] Fix IN-predicate sqlalchemy warning</li>
<li>[AIRFLOW-1243] DAGs table has no default entries to show</li>
<li>[AIRFLOW-1245] Fix random failure in test_trigger_dag_for_date</li>
<li>[AIRFLOW-1248] Fix wrong conf name for worker timeout</li>
<li>[AIRFLOW-1197] : SparkSubmitHook on_kill error</li>
<li>[AIRFLOW-1191] : SparkSubmitHook custom cmd</li>
<li>[AIRFLOW-1234] Cover utils.operator_helpers with UTs</li>
<li>[AIRFLOW-1217] Enable Sqoop logging</li>
<li>[AIRFLOW-645] Support HTTPS connections in HttpHook</li>
<li>[AIRFLOW-1231] Use flask_wtf.CSRFProtect</li>
<li>[AIRFLOW-1232] Remove deprecated readfp warning</li>
<li>[AIRFLOW-1233] Cover utils.json with unit tests</li>
<li>[AIRFLOW-1227] Remove empty column on the Logs view</li>
<li>[AIRFLOW-1226] Remove empty column on the Jobs view</li>
<li>[AIRFLOW-1221] Fix templating bug with DatabricksSubmitRunOperator</li>
<li>[AIRFLOW-1210] Enable DbApiHook unit tests</li>
<li>[AIRFLOW-1199] Fix create modal</li>
<li>[AIRFLOW-1200] Forbid creation of a variable with an empty key</li>
<li>[AIRFLOW-1207] Enable utils.helpers unit tests</li>
<li>[AIRFLOW-1213] Add hcatalog parameters to sqoop</li>
<li>[AIRFLOW-1201] Update deprecated ‘nose-parameterized’</li>
<li>[AIRFLOW-1186] Sort dag.get_task_instances by execution_date</li>
<li>[AIRFLOW-1203] Pin Google API client version to fix OAuth issue</li>
<li>[AIRFLOW-1145] Fix closest_date_partition function with before set to True If we’re looking for the closest date before, we should take the latest date in the list of date before.</li>
<li>[AIRFLOW-1180] Fix flask-wtf version for test_csrf_rejection</li>
<li>[AIRFLOW-993] Update date inference logic</li>
<li>[AIRFLOW-1170] DbApiHook insert_rows inserts parameters separately</li>
<li>[AIRFLOW-1041] Do not shadow xcom_push method[]</li>
<li>[AIRFLOW-860][AIRFLOW-935] Fix plugin executor import cycle and executor selection</li>
<li>[AIRFLOW-1189] Fix get a DataFrame using BigQueryHook failing</li>
<li>[AIRFLOW-1184] SparkSubmitHook does not split args</li>
<li>[AIRFLOW-1182] SparkSubmitOperator template field</li>
<li>[AIRFLOW-823] Allow specifying execution date in task_info API</li>
<li>[AIRFLOW-1175] Add Pronto Tools to Airflow user list</li>
<li>[AIRFLOW-1150] Fix scripts execution in sparksql hook[]</li>
<li>[AIRFLOW-1141] remove crawl_for_tasks</li>
<li>[AIRFLOW-1193] Add Checkr to company using Airflow</li>
<li>[AIRFLOW-1168] Add closing() to all connections and cursors</li>
<li>[AIRFLOW-1188] Add max_bad_records param to GoogleCloudStorageToBigQueryOperator</li>
<li>[AIRFLOW-1187][AIRFLOW-1185] Fix PyPi package names in documents</li>
<li>[AIRFLOW-1185] Fix PyPi URL in templates</li>
<li>[AIRFLOW-XXX] Updating CHANGELOG, README, and UPDATING after 1.8.1 release</li>
<li>[AIRFLOW-1181] Add delete and list functionality to gcs_hook</li>
<li>[AIRFLOW-1179] Fix Pandas 0.2x breaking Google BigQuery change</li>
<li>[AIRFLOW-1167] Support microseconds in FTPHook modification time</li>
<li>[AIRFLOW-1173] Add Robinhood to who uses Airflow</li>
<li>[AIRFLOW-945][AIRFLOW-941] Remove psycopg2 connection workaround</li>
<li>[AIRFLOW-1140] DatabricksSubmitRunOperator should template the “json” field.</li>
<li>[AIRFLOW-1160] Update Spark parameters for Mesos</li>
<li>[AIRFLOW 1149][AIRFLOW-1149] Allow for custom filters in Jinja2 templates</li>
<li>[AIRFLOW-1036] Randomize exponential backoff</li>
<li>[AIRFLOW-1155] Add Tails.com to community</li>
<li>[AIRFLOW-1142] Do not reset orphaned state for backfills</li>
<li>[AIRFLOW-492] Make sure stat updates cannot fail a task</li>
<li>[AIRFLOW-1119] Fix unload query so headers are on first row[]</li>
<li>[AIRFLOW-1089] Add Spark application arguments</li>
<li>[AIRFLOW-1125] Document encrypted connections</li>
<li>[AIRFLOW-1122] Increase stroke width in UI</li>
<li>[AIRFLOW-1138] Add missing licenses to files in scripts directory</li>
<li>(AIRFLOW-11-38) [AIRFLOW-1136] Capture invalid arguments for Sqoop</li>
<li>[AIRFLOW-1127] Move license notices to LICENSE</li>
<li>[AIRFLOW-1118] Add evo.company to Airflow users</li>
<li>[AIRFLOW-1121][AIRFLOW-1004] Fix <cite>airflow webserver –pid</cite> to write out pid file</li>
<li>[AIRFLOW-1124] Do not set all tasks to scheduled in backfill</li>
<li>[AIRFLOW-1120] Update version view to include Apache prefix</li>
<li>[AIRFLOW-1091] Add script that can compare jira target against merges</li>
<li>[AIRFLOW-1107] Add support for ftps non-default port</li>
<li>[AIRFLOW-1000] Rebrand distribution to Apache Airflow</li>
<li>[AIRFLOW-1094] Run unit tests under contrib in Travis</li>
<li>[AIRFLOW-1112] Log which pool when pool is full in scheduler</li>
<li>[AIRFLOW-1106] Add Groupalia/Letsbonus to the ReadMe</li>
<li>[AIRFLOW-1109] Use kill signal to kill processes and log results</li>
<li>[AIRFLOW-1074] Don’t count queued tasks for concurrency limits</li>
<li>[AIRFLOW-1095] Make ldap_auth memberOf come from configuration</li>
<li>[AIRFLOW-1090] Add HBO</li>
<li>[AIRFLOW-1035] Use binary exponential backoff</li>
<li>[AIRFLOW-1081] Improve performance of duration chart</li>
<li>[AIRFLOW-1078] Fix latest_runs endpoint for old flask versions</li>
<li>[AIRFLOW-1085] Enhance the SparkSubmitOperator</li>
<li>[AIRFLOW-1050] Do not count up_for_retry as not ready</li>
<li>[AIRFLOW-1028] Databricks Operator for Airflow</li>
<li>[AIRFLOW-1075] Security docs cleanup</li>
<li>[AIRFLOW-1033][AIFRLOW-1033] Fix ti_deps for no schedule dags</li>
<li>[AIRFLOW-1016] Allow HTTP HEAD request method on HTTPSensor</li>
<li>[AIRFLOW-970] Load latest_runs on homepage async</li>
<li>[AIRFLOW-111] Include queued tasks in scheduler concurrency check</li>
<li>[AIRFLOW-1001] Fix landing times if there is no following schedule</li>
<li>[AIRFLOW-1065] Add functionality for Azure Blob Storage over wasb://</li>
<li>[AIRFLOW-947] Improve exceptions for unavailable Presto cluster</li>
<li>[AIRFLOW-1067] use example.com in examples</li>
<li>[AIRFLOW-1064] Change default sort to job_id for TaskInstanceModelView</li>
<li>[AIRFLOW-1030][AIRFLOW-1] Fix hook import for HttpSensor</li>
<li>[AIRFLOW-1051] Add a test for resetdb to CliTests</li>
<li>[AIRFLOW-1004][AIRFLOW-276] Fix <cite>airflow webserver -D</cite> to run in background</li>
<li>[AIRFLOW-1062] Fix DagRun#find to return correct result</li>
<li>[AIRFLOW-1011] Fix bug in BackfillJob._execute() for SubDAGs</li>
<li>[AIRFLOW-1038] Specify celery serialization options explicitly</li>
<li>[AIRFLOW-1054] Fix broken import in test_dag</li>
<li>[AIRFLOW-1007] Use Jinja sandbox for chart_data endpoint</li>
<li>[AIRFLOW-719] Fix race condition in ShortCircuit, Branch and LatestOnly</li>
<li>[AIRFLOW-1043] Fix doc strings of operators</li>
<li>[AIRFLOW-840] Make ticket renewer python3 compatible</li>
<li>[AIRFLOW-985] Extend the sqoop operator and hook</li>
<li>[AIRFLOW-1034] Make it possible to connect to S3 in sigv4 regions</li>
<li>[AIRFLOW-1045] Make log level configurable via airflow.cfg</li>
<li>[AIRFLOW-1047] Sanitize strings passed to Markup</li>
<li>[AIRFLOW-1040] Fix some small typos in comments and docstrings</li>
<li>[AIRFLOW-1017] get_task_instance shouldn’t throw exception when no TI</li>
<li>[AIRFLOW-1006] Add config_templates to MANIFEST</li>
<li>[AIRFLOW-999] Add support for Redis database</li>
<li>[AIRFLOW-1009] Remove SQLOperator from Concepts page</li>
<li>[AIRFLOW-1006] Move config templates to separate files</li>
<li>[AIRFLOW-1005] Improve Airflow startup time</li>
<li>[AIRFLOW-1010] Add convenience script for signing releases</li>
<li>[AIRFLOW-995] Remove reference to actual Airflow issue</li>
<li>[AIRFLOW-681] homepage doc link should pointing to apache repo not airbnb repo</li>
<li>[AIRFLOW-705][AIRFLOW-706] Fix run_command bugs</li>
<li>[AIRFLOW-990] Fix Py27 unicode logging in DockerOperator</li>
<li>[AIRFLOW-963] Fix non-rendered code examples</li>
<li>[AIRFLOW-969] Catch bad python_callable argument</li>
<li>[AIRFLOW-984] Enable subclassing of SubDagOperator</li>
<li>[AIRFLOW-997] Update setup.cfg to point to Apache</li>
<li>[AIRFLOW-994] Add MiNODES to the official airflow user list</li>
<li>[AIRFLOW-995][AIRFLOW-1] Update GitHub PR Template</li>
<li>[AIRFLOW-989] Do not mark dag run successful if unfinished tasks</li>
<li>[AIRFLOW-903] New configuration setting for the default dag view</li>
<li>[AIRFLOW-979] Add GovTech GDS</li>
<li>[AIRFLOW-933] Replace eval with literal_eval to prevent RCE</li>
<li>[AIRFLOW-974] Fix mkdirs race condition</li>
<li>[AIRFLOW-917] Fix formatting of error message</li>
<li>[AIRFLOW-770] Refactor BaseHook so env vars are always read</li>
<li>[AIRFLOW-900] Double trigger should not kill original task instance</li>
<li>[AIRFLOW-900] Fixes bugs in LocalTaskJob for double run protection</li>
<li>[AIRFLOW-932][AIRFLOW-932][AIRFLOW-921][AIRFLOW-910] Do not mark tasks removed when backfilling[</li>
<li>[AIRFLOW-961] run onkill when SIGTERMed</li>
<li>[AIRFLOW-910] Use parallel task execution for backfills</li>
<li>[AIRFLOW-967] Wrap strings in native for py2 ldap compatibility</li>
<li>[AIRFLOW-958] Improve tooltip readability</li>
<li>AIRFLOW-959 Cleanup and reorganize .gitignore</li>
<li>AIRFLOW-960 Add .editorconfig file</li>
<li>[AIRFLOW-931] Do not set QUEUED in TaskInstances</li>
<li>[AIRFLOW-956] Get docs working on readthedocs.org</li>
<li>[AIRFLOW-954] Fix configparser ImportError</li>
<li>[AIRFLOW-941] Use defined parameters for psycopg2</li>
<li>[AIRFLOW-943] Update Digital First Media in users list</li>
<li>[AIRFLOW-942] Add mytaxi to Airflow users</li>
<li>[AIRFLOW-939] add .swp to gitginore</li>
<li>[AIRFLOW-719] Prevent DAGs from ending prematurely</li>
<li>[AIRFLOW-938] Use test for True in task_stats queries</li>
<li>[AIRFLOW-937] Improve performance of task_stats</li>
<li>[AIRFLOW-933] use ast.literal_eval rather eval because ast.literal_eval does not execute input.</li>
<li>[AIRFLOW-925] Revert airflow.hooks change that cherry-pick picked</li>
<li>[AIRFLOW-919] Running tasks with no start date shouldn’t break a DAGs UI</li>
<li>[AIRFLOW-802][AIRFLOW-1] Add spark-submit operator/hook</li>
<li>[AIRFLOW-725] Use keyring to store credentials for JIRA</li>
<li>[AIRFLOW-916] Remove deprecated readfp function</li>
<li>[AIRFLOW-911] Add coloring and timing to tests</li>
<li>[AIRFLOW-906] Update Code icon from lightning bolt to file</li>
<li>[AIRFLOW-897] Prevent dagruns from failing with unfinished tasks</li>
<li>[AIRFLOW-896] Remove unicode to 8-bit conversion in BigQueryOperator</li>
<li>[AIRFLOW-899] Tasks in SCHEDULED state should be white in the UI instead of black</li>
<li>[AIRFLOW-895] Address Apache release incompliancies</li>
<li>[AIRFLOW-893][AIRFLOW-510] Fix crashing webservers when a dagrun has no start date</li>
<li>[AIRFLOW-880] Make webserver serve logs in a sane way for remote logs</li>
<li>[AIRFLOW-889] Fix minor error in the docstrings for BaseOperator</li>
<li>[AIRFLOW-809][AIRFLOW-1] Use __eq__ ColumnOperator When Testing Booleans</li>
<li>[AIRFLOW-875] Add template to HttpSensor params</li>
<li>[AIRFLOW-866] Add FTPSensor</li>
<li>[AIRFLOW-881] Check if SubDagOperator is in DAG context manager</li>
<li>[AIRFLOW-885] Add change.org to the users list</li>
<li>[AIRFLOW-836] Use POST and CSRF for state changing endpoints</li>
<li>[AIRFLOW-862] Fix Unit Tests for DaskExecutor</li>
<li>[AIRFLOW-887] Support future v0.16</li>
<li>[AIRFLOW-886] Pass result to post_execute() hook</li>
<li>[AIRFLOW-871] change logging.warn() into warning()</li>
<li>[AIRFLOW-882] Remove unnecessary dag&gt;&gt;op assignment in docs</li>
<li>[AIRFLOW-861] make pickle_info endpoint be login_required</li>
<li>[AIRFLOW-869] Refactor mark success functionality</li>
<li>[AIRFLOW-877] Remove .sql template extension from GCS download operator</li>
<li>[AIRFLOW-826] Add Zendesk hook</li>
<li>[AIRFLOW-842] do not query the DB with an empty IN clause</li>
<li>[AIRFLOW-834] change raise StopIteration into return</li>
<li>[AIRFLOW-832] Let debug server run without SSL</li>
<li>[AIRFLOW-862] Add DaskExecutor</li>
<li>[AIRFLOW-858] Configurable database name for DB operators</li>
<li>[AIRFLOW-863] Example DAGs should have recent start dates</li>
<li>[AIRFLOW-853] use utf8 encoding for stdout line decode</li>
<li>[AIRFLOW-857] Use library assert statements instead of conditionals</li>
<li>[AIRFLOW-856] Make sure execution date is set for local client</li>
<li>[AIRFLOW-854] Add OKI as Airflow user</li>
<li>[AIRFLOW-830][AIRFLOW-829][AIRFLOW-88] Reduce Travis log verbosity</li>
<li>[AIRFLOW-814] Fix Presto*CheckOperator.__init__</li>
<li>[AIRFLOW-793] Enable compressed loading in S3ToHiveTransfer</li>
<li>[AIRFLOW-844] Fix cgroups directory creation</li>
<li>[AIRFLOW-831] Restore import to fix broken tests</li>
<li>[AIRFLOW-794] Access DAGS_FOLDER and SQL_ALCHEMY_CONN exclusively from settings</li>
<li>[AIRFLOW-694] Fix config behaviour for empty envvar</li>
<li>[AIRFLOW-365] Set dag.fileloc explicitly and use for Code view</li>
<li>[AIRFLOW-781] Allow DataFlowOperators to accept jobs stored in GCS</li>
</ul>
</div>
<div class="section" id="airflow-1-8-2-2017-09-04">
<h2>Airflow 1.8.2, 2017-09-04<a class="headerlink" href="#airflow-1-8-2-2017-09-04" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-809][AIRFLOW-1] Use __eq__ ColumnOperator When Testing Booleans</li>
<li>[AIRFLOW-1296] Propagate SKIPPED to all downstream tasks</li>
<li>Re-enable caching for hadoop components</li>
<li>Pin Hive and Hadoop to a specific version and create writable warehouse dir</li>
<li>[AIRFLOW-1308] Disable nanny usage for Dask</li>
<li>Updating CHANGELOG for 1.8.2rc1</li>
<li>[AIRFLOW-1294] Backfills can loose tasks to execute</li>
<li>[AIRFLOW-1291] Update NOTICE and LICENSE files to match ASF requirements</li>
<li>[AIRFLOW-XXX] Set version to 1.8.2rc1</li>
<li>[AIRFLOW-1160] Update Spark parameters for Mesos</li>
<li>[AIRFLOW 1149][AIRFLOW-1149] Allow for custom filters in Jinja2 templates</li>
<li>[AIRFLOW-1119] Fix unload query so headers are on first row[]</li>
<li>[AIRFLOW-1089] Add Spark application arguments</li>
<li>[AIRFLOW-1078] Fix latest_runs endpoint for old flask versions</li>
<li>[AIRFLOW-1074] Don’t count queued tasks for concurrency limits</li>
<li>[AIRFLOW-1064] Change default sort to job_id for TaskInstanceModelView</li>
<li>[AIRFLOW-1038] Specify celery serialization options explicitly</li>
<li>[AIRFLOW-1036] Randomize exponential backoff</li>
<li>[AIRFLOW-993] Update date inference logic</li>
<li>[AIRFLOW-1167] Support microseconds in FTPHook modification time</li>
<li>[AIRFLOW-1179] Fix Pandas 0.2x breaking Google BigQuery change</li>
<li>[AIRFLOW-1263] Dynamic height for charts</li>
<li>[AIRFLOW-1266] Increase width of gantt y axis</li>
<li>[AIRFLOW-1290] set docs author to ‘Apache Airflow’</li>
<li>[AIRFLOW-1282] Fix known event column sorting</li>
<li>[AIRFLOW-1166] Speed up _change_state_for_tis_without_dagrun</li>
<li>[AIRFLOW-1192] Some enhancements to qubole_operator</li>
<li>[AIRFLOW-1281] Sort variables by key field by default</li>
<li>[AIRFLOW-1244] Forbid creation of a pool with empty name</li>
<li>[AIRFLOW-1243] DAGs table has no default entries to show</li>
<li>[AIRFLOW-1227] Remove empty column on the Logs view</li>
<li>[AIRFLOW-1226] Remove empty column on the Jobs view</li>
<li>[AIRFLOW-1199] Fix create modal</li>
<li>[AIRFLOW-1200] Forbid creation of a variable with an empty key</li>
<li>[AIRFLOW-1186] Sort dag.get_task_instances by execution_date</li>
<li>[AIRFLOW-1145] Fix closest_date_partition function with before set to True If we’re looking for the closest date before, we should take the latest date in the list of date before.</li>
<li>[AIRFLOW-1180] Fix flask-wtf version for test_csrf_rejection</li>
<li>[AIRFLOW-1170] DbApiHook insert_rows inserts parameters separately</li>
<li>[AIRFLOW-1150] Fix scripts execution in sparksql hook[]</li>
<li>[AIRFLOW-1168] Add closing() to all connections and cursors</li>
<li>[AIRFLOW-XXX] Updating CHANGELOG, README, and UPDATING after 1.8.1 release</li>
</ul>
</div>
<div class="section" id="airflow-1-8-1-2017-05-09">
<h2>Airflow 1.8.1, 2017-05-09<a class="headerlink" href="#airflow-1-8-1-2017-05-09" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-1142] SubDAG Tasks Not Executed Even Though All Dependencies Met</li>
<li>[AIRFLOW-1138] Add licenses to files in scripts directory</li>
<li>[AIRFLOW-1127] Move license notices to LICENSE instead of NOTICE</li>
<li>[AIRFLOW-1124] Do not set all task instances to scheduled on backfill</li>
<li>[AIRFLOW-1120] Update version view to include Apache prefix</li>
<li>[AIRFLOW-1062] DagRun#find returns wrong result if external_trigger=False is specified</li>
<li>[AIRFLOW-1054] Fix broken import on test_dag</li>
<li>[AIRFLOW-1050] Retries ignored - regression</li>
<li>[AIRFLOW-1033] TypeError: can’t compare datetime.datetime to None</li>
<li>[AIRFLOW-1017] get_task_instance should return None instead of throw an exception for non-existent TIs</li>
<li>[AIRFLOW-1011] Fix bug in BackfillJob._execute() for SubDAGs</li>
<li>[AIRFLOW-1004] <cite>airflow webserver -D</cite> runs in foreground</li>
<li>[AIRFLOW-1001] Landing Time shows “unsupported operand type(s) for -: ‘datetime.datetime’ and ‘NoneType’” on example_subdag_operator</li>
<li>[AIRFLOW-1000] Rebrand to Apache Airflow instead of Airflow</li>
<li>[AIRFLOW-989] Clear Task Regression</li>
<li>[AIRFLOW-974] airflow.util.file mkdir has a race condition</li>
<li>[AIRFLOW-906] Update Code icon from lightning bolt to file</li>
<li>[AIRFLOW-858] Configurable database name for DB operators</li>
<li>[AIRFLOW-853] ssh_execute_operator.py stdout decode default to ASCII</li>
<li>[AIRFLOW-832] Fix debug server</li>
<li>[AIRFLOW-817] Trigger dag fails when using CLI + API</li>
<li>[AIRFLOW-816] Make sure to pull nvd3 from local resources</li>
<li>[AIRFLOW-815] Add previous/next execution dates to available default variables.</li>
<li>[AIRFLOW-813] Fix unterminated unit tests in tests.job (tests/job.py)</li>
<li>[AIRFLOW-812] Scheduler job terminates when there is no dag file</li>
<li>[AIRFLOW-806] UI should properly ignore DAG doc when it is None</li>
<li>[AIRFLOW-794] Consistent access to DAGS_FOLDER and SQL_ALCHEMY_CONN</li>
<li>[AIRFLOW-785] ImportError if cgroupspy is not installed</li>
<li>[AIRFLOW-784] Cannot install with funcsigs &gt; 1.0.0</li>
<li>[AIRFLOW-780] The UI no longer shows broken DAGs</li>
<li>[AIRFLOW-777] dag_is_running is initlialized to True instead of False</li>
<li>[AIRFLOW-719] Skipped operations make DAG finish prematurely</li>
<li>[AIRFLOW-694] Empty env vars do not overwrite non-empty config values</li>
<li>[AIRFLOW-492] Insert into dag_stats table results into failed task while task itself succeeded</li>
<li>[AIRFLOW-139] Executing VACUUM with PostgresOperator</li>
<li>[AIRFLOW-111] DAG concurrency is not honored</li>
<li>[AIRFLOW-88] Improve clarity Travis CI reports</li>
</ul>
</div>
<div class="section" id="airflow-1-8-0-2017-03-12">
<h2>Airflow 1.8.0, 2017-03-12<a class="headerlink" href="#airflow-1-8-0-2017-03-12" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-900] Double trigger should not kill original task instance</li>
<li>[AIRFLOW-900] Fixes bugs in LocalTaskJob for double run protection</li>
<li>[AIRFLOW-932] Do not mark tasks removed when backfilling</li>
<li>[AIRFLOW-961] run onkill when SIGTERMed</li>
<li>[AIRFLOW-910] Use parallel task execution for backfills</li>
<li>[AIRFLOW-967] Wrap strings in native for py2 ldap compatibility</li>
<li>[AIRFLOW-941] Use defined parameters for psycopg2</li>
<li>[AIRFLOW-719] Prevent DAGs from ending prematurely</li>
<li>[AIRFLOW-938] Use test for True in task_stats queries</li>
<li>[AIRFLOW-937] Improve performance of task_stats</li>
<li>[AIRFLOW-933] use ast.literal_eval rather eval because ast.literal_eval does not execute input.</li>
<li>[AIRFLOW-925] Revert airflow.hooks change that cherry-pick picked</li>
<li>[AIRFLOW-919] Running tasks with no start date shouldn’t break a DAGs UI</li>
<li>[AIRFLOW-802] Add spark-submit operator/hook</li>
<li>[AIRFLOW-897] Prevent dagruns from failing with unfinished tasks</li>
<li>[AIRFLOW-861] make pickle_info endpoint be login_required</li>
<li>[AIRFLOW-853] use utf8 encoding for stdout line decode</li>
<li>[AIRFLOW-856] Make sure execution date is set for local client</li>
<li>[AIRFLOW-830][AIRFLOW-829][AIRFLOW-88] Reduce Travis log verbosity</li>
<li>[AIRFLOW-831] Restore import to fix broken tests</li>
<li>[AIRFLOW-794] Access DAGS_FOLDER and SQL_ALCHEMY_CONN exclusively from settings</li>
<li>[AIRFLOW-694] Fix config behaviour for empty envvar</li>
<li>[AIRFLOW-365] Set dag.fileloc explicitly and use for Code view</li>
<li>[AIRFLOW-931] Do not set QUEUED in TaskInstances</li>
<li>[AIRFLOW-899] Tasks in SCHEDULED state should be white in the UI instead of black</li>
<li>[AIRFLOW-895] Address Apache release incompliancies</li>
<li>[AIRFLOW-893][AIRFLOW-510] Fix crashing webservers when a dagrun has no start date</li>
<li>[AIRFLOW-793] Enable compressed loading in S3ToHiveTransfer</li>
<li>[AIRFLOW-863] Example DAGs should have recent start dates</li>
<li>[AIRFLOW-869] Refactor mark success functionality</li>
<li>[AIRFLOW-856] Make sure execution date is set for local client</li>
<li>[AIRFLOW-814] Fix Presto*CheckOperator.__init__</li>
<li>[AIRFLOW-844] Fix cgroups directory creation</li>
<li>[AIRFLOW-816] Use static nvd3 and d3</li>
<li>[AIRFLOW-821] Fix py3 compatibility</li>
<li>[AIRFLOW-817] Check for None value of execution_date in endpoint</li>
<li>[AIRFLOW-822] Close db before exception</li>
<li>[AIRFLOW-815] Add prev/next execution dates to template variables</li>
<li>[AIRFLOW-813] Fix unterminated unit tests in SchedulerJobTest</li>
<li>[AIRFLOW-813] Fix unterminated scheduler unit tests</li>
<li>[AIRFLOW-806] UI should properly ignore DAG doc when it is None</li>
<li>[AIRFLOW-812] Fix the scheduler termination bug.</li>
<li>[AIRFLOW-780] Fix dag import errors no longer working</li>
<li>[AIRFLOW-783] Fix py3 incompatibility in BaseTaskRunner</li>
<li>[AIRFLOW-810] Correct down_revision dag_id/state index creation</li>
<li>[AIRFLOW-807] Improve scheduler performance for large DAGs</li>
<li>[AIRFLOW-798] Check return_code before forcing termination</li>
<li>[AIRFLOW-139] Let psycopg2 handle autocommit for PostgresHook</li>
<li>[AIRFLOW-776] Add missing cgroups devel dependency</li>
<li>[AIRFLOW-777] Fix expression to check if a DagRun is in running state</li>
<li>[AIRFLOW-785] Don’t import CgroupTaskRunner at global scope</li>
<li>[AIRFLOW-784] Pin funcsigs to 1.0.0</li>
<li>[AIRFLOW-624] Fix setup.py to not import airflow.version as version</li>
<li>[AIRFLOW-779] Task should fail with specific message when deleted</li>
<li>[AIRFLOW-778] Fix completey broken MetastorePartitionSensor</li>
<li>[AIRFLOW-739] Set pickle_info log to debug</li>
<li>[AIRFLOW-771] Make S3 logs append instead of clobber</li>
<li>[AIRFLOW-773] Fix flaky datetime addition in api test</li>
<li>[AIRFLOW-219][AIRFLOW-398] Cgroups + impersonation</li>
<li>[AIRFLOW-683] Add jira hook, operator and sensor</li>
<li>[AIRFLOW-762] Add Google DataProc delete operator</li>
<li>[AIRFLOW-760] Update systemd config</li>
<li>[AIRFLOW-759] Use previous dag_run to verify depend_on_past</li>
<li>[AIRFLOW-757] Set child_process_log_directory default more sensible</li>
<li>[AIRFLOW-692] Open XCom page to super-admins only</li>
<li>[AIRFLOW-737] Fix HDFS Sensor directory.</li>
<li>[AIRFLOW-747] Fix retry_delay not honoured</li>
<li>[AIRFLOW-558] Add Support for dag.catchup=(True|False) Option</li>
<li>[AIRFLOW-489] Allow specifying execution date in trigger_dag API</li>
<li>[AIRFLOW-738] Commit deleted xcom items before insert</li>
<li>[AIRFLOW-729] Add Google Cloud Dataproc cluster creation operator</li>
<li>[AIRFLOW-728] Add Google BigQuery table sensor</li>
<li>[AIRFLOW-741] Log to debug instead of info for app.py</li>
<li>[AIRFLOW-731] Fix period bug for NamedHivePartitionSensor</li>
<li>[AIRFLOW-740] Pin jinja2 to &lt; 2.9.0</li>
<li>[AIRFLOW-663] Improve time units for task performance charts</li>
<li>[AIRFLOW-665] Fix email attachments</li>
<li>[AIRFLOW-734] Fix SMTP auth regression when not using user/pass</li>
<li>[AIRFLOW-702] Fix LDAP Regex Bug</li>
<li>[AIRFLOW-717] Add Cloud Storage updated sensor</li>
<li>[AIRFLOW-695] Retries do not execute because dagrun is in FAILED state</li>
<li>[AIRFLOW-673] Add operational metrics test for SchedulerJob</li>
<li>[AIRFLOW-727] try_number is not increased</li>
<li>[AIRFLOW-715] A more efficient HDFS Sensor:</li>
<li>[AIRFLOW-716] Allow AVRO BigQuery load-job without schema</li>
<li>[AIRFLOW-718] Allow the query URI for DataProc Pig</li>
<li>Log needs to be part of try/catch block</li>
<li>[AIRFLOW-721] Descendant process can disappear before termination</li>
<li>[AIRFLOW-403] Bash operator’s kill method leaves underlying processes running</li>
<li>[AIRFLOW-657] Add AutoCommit Parameter for MSSQL</li>
<li>[AIRFLOW-641] Improve pull request instructions</li>
<li>[AIRFLOW-685] Add test for MySqlHook.bulk_load()</li>
<li>[AIRFLOW-686] Match auth backend config section</li>
<li>[AIRFLOW-691] Add SSH KeepAlive option to SSH_hook</li>
<li>[AIRFLOW-709] Use same engine for migrations and reflection</li>
<li>[AIRFLOW-700] Update to reference to web authentication documentation</li>
<li>[AIRFLOW-649] Support non-sched DAGs in LatestOnlyOp</li>
<li>[AIRFLOW-712] Fix AIRFLOW-667 to use proper HTTP error properties</li>
<li>[AIRFLOW-710] Add OneFineStay as official user</li>
<li>[AIRFLOW-703][AIRFLOW-1] Stop Xcom being cleared too early</li>
<li>[AIRFLOW-679] Stop concurrent task instances from running</li>
<li>[AIRFLOW-704][AIRFLOW-1] Fix invalid syntax in BQ hook</li>
<li>[AIRFLOW-667] Handle BigQuery 503 error</li>
<li>[AIRFLOW-680] Disable connection pool for commands</li>
<li>[AIRFLOW-678] Prevent scheduler from double triggering TIs</li>
<li>[AIRFLOW-677] Kill task if it fails to heartbeat</li>
<li>[AIRFLOW-674] Ability to add descriptions for DAGs</li>
<li>[AIRFLOW-682] Bump MAX_PERIODS to make mark_success work for large DAGs</li>
<li>Use jdk selector to set required jdk</li>
<li>[AIRFLOW-647] Restore dag.get_active_runs</li>
<li>[AIRFLOW-662] Change seasons to months in project description</li>
<li>[AIRFLOW-656] Add dag/task/date index to xcom table</li>
<li>[AIRFLOW-658] Improve schema_update_options in GCP</li>
<li>[AIRFLOW-41] Fix pool oversubscription</li>
<li>[AIRFLOW-489] Add API Framework</li>
<li>[AIRFLOW-653] Add some missing endpoint tests</li>
<li>[AIRFLOW-652] Remove obsolete endpoint</li>
<li>[AIRFLOW-345] Add contrib ECSOperator</li>
<li>[AIRFLOW-650] Adding Celect to user list</li>
<li>[AIRFLOW-510] Filter Paused Dags, show Last Run &amp; Trigger Dag</li>
<li>[AIRFLOW-643] Improve date handling for sf_hook</li>
<li>[AIRFLOW-638] Add schema_update_options to GCP ops</li>
<li>[AIRFLOW-640] Install and enable nose-ignore-docstring</li>
<li>[AIRFLOW-639]AIRFLOW-639] Alphasort package names</li>
<li>[AIRFLOW-375] Fix pylint errors</li>
<li>[AIRFLOW-347] Show empty DAG runs in tree view</li>
<li>[AIRFLOW-628] Adding SalesforceHook to contrib/hooks</li>
<li>[AIRFLOW-514] hive hook loads data from pandas DataFrame into hive and infers types</li>
<li>[AIRFLOW-565] Fixes DockerOperator on Python3.x</li>
<li>[AIRFLOW-635] Encryption option for S3 hook</li>
<li>[AIRFLOW-137] Fix max_active_runs on clearing tasks</li>
<li>[AIRFLOW-343] Fix schema plumbing in HiveServer2Hook</li>
<li>[AIRFLOW-130] Fix ssh operator macosx</li>
<li>[AIRFLOW-633] Show TI attributes in TI view</li>
<li>[AIRFLOW-626][AIRFLOW-1] HTML Content does not show up when sending email with attachment</li>
<li>[AIRFLOW-533] Set autocommit via set_autocommit</li>
<li>[AIRFLOW-629] stop pinning lxml</li>
<li>[AIRFLOW-464] Add setdefault method to Variable</li>
<li>[AIRFLOW-626][AIRFLOW-1] HTML Content does not show up when sending email with attachment</li>
<li>[AIRFLOW-591] Add datadog hook &amp; sensor</li>
<li>[AIRFLOW-561] Add RedshiftToS3Transfer operator</li>
<li>[AIRFLOW-570] Pass root to date form on gantt</li>
<li>[AIRFLOW-504] Store fractional seconds in MySQL tables</li>
<li>[AIRFLOW-623] LDAP attributes not always a list</li>
<li>[AIRFLOW-611] source_format in BigQueryBaseCursor</li>
<li>[AIRFLOW-619] Fix exception in Gannt chart</li>
<li>[AIRFLOW-618] Cast DateTimes to avoid sqllite errors</li>
<li>[AIRFLOW-422] Add JSON endpoint for task info</li>
<li>[AIRFLOW-616][AIRFLOW-617] Minor fixes to PR tool UX</li>
<li>[AIRFLOW-179] Fix DbApiHook with non-ASCII chars</li>
<li>[AIRFLOW-566] Add timeout while fetching logs</li>
<li>[AIRFLOW-615] Set graph glyphicon first</li>
<li>[AIRFLOW-609] Add application_name to PostgresHook</li>
<li>[AIRFLOW-604] Revert .first() to .one()</li>
<li>[AIRFLOW-370] Create AirflowConfigException in exceptions.py</li>
<li>[AIRFLOW-582] Fixes TI.get_dagrun filter (removes start_date)</li>
<li>[AIRFLOW-568] Fix double task_stats count if a DagRun is active</li>
<li>[AIRFLOW-585] Fix race condition in backfill execution loop</li>
<li>[AIRFLOW-580] Prevent landscape warning on .format</li>
<li>[AIRFLOW-597] Check if content is None, not false-equivalent</li>
<li>[AIRFLOW-586] test_dag_v1 fails from 0 to 3 a.m.</li>
<li>[AIRFLOW-453] Add XCom Admin Page</li>
<li>[AIRFLOW-588] Add Google Cloud Storage Object sensor[]</li>
<li>[AIRFLOW-592] example_xcom import Error</li>
<li>[AIRFLOW-587] Fix incorrect scope for Google Auth[]</li>
<li>[AIRFLOW-589] Add templatable job_name[]</li>
<li>[AIRFLOW-227] Show running config in config view</li>
<li>[AIRFLOW-319]AIRFLOW-319] xcom push response in HTTP Operator</li>
<li>[AIRFLOW-385] Add symlink to latest scheduler log directory</li>
<li>[AIRFLOW-583] Fix decode error in gcs_to_bq</li>
<li>[AIRFLOW-96] s3_conn_id using environment variable</li>
<li>[AIRFLOW-575] Clarify tutorial and FAQ about <cite>schedule_interval</cite> always inheriting from DAG object</li>
<li>[AIRFLOW-577] Output BigQuery job for improved debugging</li>
<li>[AIRFLOW-560] Get URI &amp; SQLA engine from Connection</li>
<li>[AIRFLOW-518] Require DataProfilingMixin for Variables CRUD</li>
<li>[AIRFLOW-553] Fix load path for filters.js</li>
<li>[AIRFLOW-554] Add Jinja support to Spark-sql</li>
<li>[AIRFLOW-550] Make ssl config check empty string safe</li>
<li>[AIRFLOW-500] Use id for github allowed teams</li>
<li>[AIRFLOW-556] Add UI PR guidelines</li>
<li>[AIRFLOW-358][AIRFLOW-430] Add <cite>connections</cite> cli</li>
<li>[AIRFLOW-548] Load DAGs immediately &amp; continually</li>
<li>[AIRFLOW-539] Updated BQ hook and BQ operator to support Standard SQL.</li>
<li>[AIRFLOW-378] Add string casting to params of spark-sql operator</li>
<li>[AIRFLOW-544] Add Pause/Resume toggle button</li>
<li>[AIRFLOW-333][AIRFLOW-258] Fix non-module plugin components</li>
<li>[AIRFLOW-542] Add tooltip to DAGs links icons</li>
<li>[AIRFLOW-530] Update docs to reflect connection environment var has to be in uppercase</li>
<li>[AIRFLOW-525] Update template_fields in Qubole Op</li>
<li>[AIRFLOW-480] Support binary file download from GCS</li>
<li>[AIRFLOW-198] Implement latest_only_operator</li>
<li>[AIRFLOW-91] Add SSL config option for the webserver</li>
<li>[AIRFLOW-191] Fix connection leak with PostgreSQL backend</li>
<li>[AIRFLOW-512] Fix ‘bellow’ typo in docs &amp; comments</li>
<li>[AIRFLOW-509][AIRFLOW-1] Create operator to delete tables in BigQuery</li>
<li>[AIRFLOW-498] Remove hard-coded gcp project id</li>
<li>[AIRFLOW-505] Support unicode characters in authors’ names</li>
<li>[AIRFLOW-494] Add per-operator success/failure metrics</li>
<li>[AIRFLOW-488] Fix test_simple fail</li>
<li>[AIRFLOW-468] Update Panda requirement to 0.17.1</li>
<li>[AIRFLOW-159] Add cloud integration section + GCP documentation</li>
<li>[AIRFLOW-477][AIRFLOW-478] Restructure security section for clarity</li>
<li>[AIRFLOW-467] Allow defining of project_id in BigQueryHook</li>
<li>[AIRFLOW-483] Change print to logging statement</li>
<li>[AIRFLOW-475] make the segment granularity in Druid hook configurable</li>
</ul>
</div>
<div class="section" id="airflow-1-7-2">
<h2>Airflow 1.7.2<a class="headerlink" href="#airflow-1-7-2" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>[AIRFLOW-463] Link Airflow icon to landing page</li>
<li>[AIRFLOW-149] Task Dependency Engine + Why Isn’t My Task Running View</li>
<li>[AIRFLOW-361] Add default failure handler for the Qubole Operator</li>
<li>[AIRFLOW-353] Fix dag run status update failure</li>
<li>[AIRFLOW-447] Store source URIs in Python 3 compatible list</li>
<li>[AIRFLOW-443] Make module names unique when importing</li>
<li>[AIRFLOW-444] Add Google authentication backend</li>
<li>[AIRFLOW-446][AIRFLOW-445] Adds missing dataproc submit options</li>
<li>[AIRFLOW-431] Add CLI for CRUD operations on pools</li>
<li>[AIRFLOW-329] Update Dag Overview Page with Better Status Columns</li>
<li>[AIRFLOW-360] Fix style warnings in models.py</li>
<li>[AIRFLOW-425] Add white fill for null state tasks in tree view.</li>
<li>[AIRFLOW-69] Use dag runs in backfill jobs</li>
<li>[AIRFLOW-415] Make dag_id not found error clearer</li>
<li>[AIRFLOW-416] Use ordinals in README’s company list</li>
<li>[AIRFLOW-369] Allow setting default DAG orientation</li>
<li>[AIRFLOW-410] Add 2 Q/A to the FAQ in the docs</li>
<li>[AIRFLOW-407] Add different colors for some sensors</li>
<li>[AIRFLOW-414] Improve error message for missing FERNET_KEY</li>
<li>[AIRFLOW-406] Sphinx/rst fixes</li>
<li>[AIRFLOW-412] Fix lxml dependency</li>
<li>[AIRFLOW-413] Fix unset path bug when backfilling via pickle</li>
<li>[AIRFLOW-78] Airflow clear leaves dag_runs</li>
<li>[AIRFLOW-402] Remove NamedHivePartitionSensor static check, add docs</li>
<li>[AIRFLOW-394] Add an option to the Task Duration graph to show cumulative times</li>
<li>[AIRFLOW-404] Retry download if unpacking fails for hive</li>
<li>[AIRFLOW-276] Gunicorn rolling restart</li>
<li>[AIRFLOW-399] Remove dags/testdruid.py</li>
<li>[AIRFLOW-400] models.py/DAG.set_dag_runs_state() does not correctly set state</li>
<li>[AIRFLOW-395] Fix colon/equal signs typo for resources in default config</li>
<li>[AIRFLOW-397] Documentation: Fix typo “instatiating” to “instantiating”</li>
<li>[AIRFLOW-395] Remove trailing commas from resources in config</li>
<li>[AIRFLOW-388] Add a new chart for Task_Tries for each DAG</li>
<li>[AIRFLOW-322] Fix typo in FAQ section</li>
<li>[AIRFLOW-375] Pylint fixes</li>
<li>limit scope to user email only AIRFLOW-386</li>
<li>[AIRFLOW-383] Cleanup example qubole operator dag</li>
<li>[AIRFLOW-160] Parse DAG files through child processes</li>
<li>[AIRFLOW-381] Manual UI Dag Run creation: require dag_id field</li>
<li>[AIRFLOW-373] Enhance CLI variables functionality</li>
<li>[AIRFLOW-379] Enhance Variables page functionality: import/export variables</li>
<li>[AIRFLOW-331] modify the LDAP authentication config lines in  ‘Security’ sample codes</li>
<li>[AIRFLOW-356][AIRFLOW-355][AIRFLOW-354] Replace nobr, enable DAG only exists locally message, change edit DAG icon</li>
<li>[AIRFLOW-362] Import __future__ division</li>
<li>[AIRFLOW-359] Pin flask-login to 0.2.11</li>
<li>[AIRFLOW-261] Add bcc and cc fields to EmailOperator</li>
<li>[AIRFLOW-348] Fix code style warnings</li>
<li>[AIRFLOW-349] Add metric for number of zombies killed</li>
<li>[AIRFLOW-340] Remove unused dependency on Babel</li>
<li>[AIRFLOW-339]: Ability to pass a flower conf file</li>
<li>[AIRFLOW-341][operators] Add resource requirement attributes to operators</li>
<li>[AIRFLOW-335] Fix simple style errors/warnings</li>
<li>[AIRFLOW-337] Add __repr__ to VariableAccessor and VariableJsonAccessor</li>
<li>[AIRFLOW-334] Fix using undefined variable</li>
<li>[AIRFLOW-315] Fix blank lines code style warnings</li>
<li>[AIRFLOW-306] Add Spark-sql Hook and Operator</li>
<li>[AIRFLOW-327] Add rename method to the FTPHook</li>
<li>[AIRFLOW-321] Fix a wrong code example about tests/dags</li>
<li>[AIRFLOW-316] Always check DB state for Backfill Job execution</li>
<li>[AIRFLOW-264] Adding workload management for Hive</li>
<li>[AIRFLOW-297] support exponential backoff option for retry delay</li>
<li>[AIRFLOW-31][AIRFLOW-200] Add note to updating.md</li>
<li>[AIRFLOW-307] There is no __neq__ python magic method.</li>
<li>[AIRFLOW-309] Add requirements of develop dependencies to docs</li>
<li>[AIRFLOW-307] Rename __neq__ to __ne__ python magic method.</li>
<li>[AIRFLOW-313] Fix code style for sqoop_hook.py</li>
<li>[AIRFLOW-311] Fix wrong path in CONTRIBUTING.md</li>
<li>[AIRFLOW-24] DataFlow Java Operator</li>
<li>[AIRFLOW-308] Add link to refresh DAG within DAG view header</li>
<li>[AIRFLOW-314] Fix BigQuery cursor run_table_upsert method</li>
<li>[AIRFLOW-298] fix incubator diclaimer in docs</li>
<li>[AIRFLOW-284] HiveServer2Hook fix for cursor scope for get_results</li>
<li>[AIRFLOW-260] More graceful exit when issues can’t be closed</li>
<li>[AIRFLOW-260] Handle case when no version is found</li>
<li>[AIRFLOW-228] Handle empty version list in PR tool</li>
<li>[AIRFLOW-302] Improve default squash commit message</li>
<li>[AIRFLOW-187] Improve prompt styling</li>
<li>[AIRFLOW-187] Fix typo in argument name</li>
<li>[AIRFLOW-187] Move “Close XXX” message to end of squash commit</li>
<li>[AIRFLOW-247] Add EMR hook, operators and sensors. Add AWS base hook</li>
<li>[AIRFLOW-301] Fix broken unit test</li>
<li>[AIRFLOW-100] Add execution_date_fn to ExternalTaskSensor</li>
<li>[AIRFLOW-282] Remove PR Tool logic that depends on version formatting</li>
<li>[AIRFLOW-291] Add index for state in TI table</li>
<li>[AIRFLOW-269] Add some unit tests for PostgreSQL</li>
<li>[AIRFLOW-296] template_ext is being treated as a string rather than a tuple in qubole operator</li>
<li>[AIRFLOW-286] Improve FTPHook to implement context manager interface</li>
<li>[AIRFLOW-243] Create NamedHivePartitionSensor</li>
<li>[AIRFLOW-246] Improve dag_stats endpoint query</li>
<li>[AIRFLOW-189] Highlighting of Parent/Child nodes in Graphs</li>
<li>[ARFLOW-255] Check dagrun timeout when comparing active runs</li>
<li>[AIRFLOW-281] Add port to mssql_hook</li>
<li>[AIRFLOW-285] Use Airflow 2.0 style imports for all remaining hooks/operators</li>
<li>[AIRFLOW-40] Add LDAP group filtering feature.</li>
<li>[AIRFLOW-277] Multiple deletions does not work in Task Instances view if using SQLite backend</li>
<li>[AIRFLOW-200] Make hook/operator imports lazy, and print proper exceptions</li>
<li>[AIRFLOW-283] Make store_to_xcom_key a templated field in GoogleCloudStorageDownloadOperator</li>
<li>[AIRFLOW-278] Support utf-8 ecoding for SQL</li>
<li>[AIRFLOW-280] clean up tmp druid table no matter if an ingestion job succeeds or not</li>
<li>[AIRFLOW-274] Add XCom functionality to GoogleCloudStorageDownloadOperator</li>
<li>[AIRFLOW-273] Create an svg version of the airflow logo.</li>
<li>[AIRFLOW-275] Update contributing guidelines</li>
<li>[AIRFLOW-244] Modify hive operator to inject analysis data</li>
<li>[AIRFLOW-162] Allow variable to be accessible into templates</li>
<li>[AIRFLOW-248] Add Apache license header to all files</li>
<li>[AIRFLOW-263] Remove temp backtick file</li>
<li>[AIRFLOW-252] Raise Sqlite exceptions when deleting tasks instance in WebUI</li>
<li>[AIRFLOW-180] Fix timeout behavior for sensors</li>
<li>[AIRFLOW-262] Simplify commands in MANIFEST.in</li>
<li>[AIRFLOW-31] Add zope dependency</li>
<li>[AIRFLOW-6] Remove dependency on Highcharts</li>
<li>[AIRFLOW-234] make task that aren’t <cite>running</cite> self-terminate</li>
<li>[AIRFLOW-256] Fix test_scheduler_reschedule heartrate</li>
<li>Add Python 3 compatibility fix</li>
<li>[AIRFLOW-31] Use standard imports for hooks/operators</li>
<li>[AIRFLOW-173] Initial implementation of FileSensor</li>
<li>[AIRFLOW-224] Collect orphaned tasks and reschedule them</li>
<li>[AIRFLOW-239] Fix tests indentation</li>
<li>[AIRFLOW-225] Better units for task duration graph</li>
<li>[AIRFLOW-241] Add testing done section to PR template</li>
<li>[AIRFLOW-222] Show duration of task instances in ui</li>
<li>[AIRFLOW-231] Do not eval user input in PrestoHook</li>
<li>[AIRFLOW-216] Add Sqoop Hook and Operator</li>
<li>[AIRFLOW-171] Add upgrade notes on email and S3 to 1.7.1.2</li>
<li>[AIRFLOW-238] Make compatible with flask-admin 1.4.1</li>
<li>[AIRFLOW-230] [HiveServer2Hook] adding multi statements support</li>
<li>[AIRFLOW-142] setup_env.sh doesn’t download hive tarball if hdp is specified as distro</li>
<li>[AIRFLOW-223] Make parametrable the IP on which Flower binds to</li>
<li>[AIRFLOW-218] Added option to enable webserver gunicorn access/err logs</li>
<li>[AIRFLOW-213] Add “Closes #X” phrase to commit messages</li>
<li>[AIRFLOW-68] Align start_date with the schedule_interval</li>
<li>[AIRFLOW-9] Improving docs to meet Apache’s standards</li>
<li>[AIRFLOW-131] Make XCom.clear more selective</li>
<li>[AIRFLOW-214] Fix occasion of detached taskinstance</li>
<li>[AIRFLOW-206] Add commit to close PR</li>
<li>[AIRFLOW-206] Always load local log files if they exist</li>
<li>[AIRFLOW-211] Fix JIRA “resolve” vs “close” behavior</li>
<li>[AIRFLOW-64] Add note about relative DAGS_FOLDER</li>
<li>[AIRFLOW-114] Sort plugins dropdown</li>
<li>[AIRFLOW-209] Add scheduler tests and improve lineage handling</li>
<li>[AIRFLOW-207] Improve JIRA auth workflow</li>
<li>[AIRFLOW-187] Improve PR tool UX</li>
<li>[AIRFLOW-155] Documentation of Qubole Operator</li>
<li>Optimize and refactor process_dag</li>
<li>[AIRFLOW-185] Handle empty versions list</li>
<li>[AIRFLOW-201] Fix for HiveMetastoreHook + kerberos</li>
<li>[AIRFLOW-202]: Fixes stray print line</li>
<li>[AIRFLOW-196] Fix bug that exception is not handled in HttpSensor</li>
<li>[AIRFLOW-195] : Add toggle support to subdag clearing in the CLI</li>
<li>[AIRFLOW-23] Support for Google Cloud DataProc</li>
<li>[AIRFLOW-25] Configuration for Celery always required</li>
<li>[AIRFLOW-190] Add codecov and remove download count</li>
<li>[AIRFLOW-168] Correct evaluation of &#64;once schedule</li>
<li>[AIRFLOW-183] Fetch log from remote when worker returns 4xx/5xx response</li>
<li>[AIRFLOW-181] Fix failing unpacking of hadoop by redownloading</li>
<li>[AIRFLOW-176] remove unused formatting key</li>
<li>[AIRFLOW-167]: Add dag_state option in cli</li>
<li>[AIRFLOW-178] Fix bug so that zip file is detected in DAG folder</li>
<li>[AIRFLOW-176] Improve PR Tool JIRA workflow</li>
<li>AIRFLOW-45: Support Hidden Airflow Variables</li>
<li>[AIRFLOW-175] Run git-reset before checkout in PR tool</li>
<li>[AIRFLOW-157] Make PR tool Py3-compat; add JIRA command</li>
<li>[AIRFLOW-170] Add missing &#64;apply_defaults</li>
</ul>
</div>
<div class="section" id="airflow-1-7-1-2016-05-19">
<h2>Airflow 1.7.1, 2016-05-19<a class="headerlink" href="#airflow-1-7-1-2016-05-19" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li>Fix : Don’t treat premature tasks as could_not_run tasks</li>
<li>AIRFLOW-92 Avoid unneeded upstream_failed session closes apache/airflow#1485</li>
<li>Add logic to lock DB and avoid race condition</li>
<li>Handle queued tasks from multiple jobs/executors</li>
<li>AIRFLOW-52 Warn about overwriting tasks in a DAG</li>
<li>Fix corner case with joining processes/queues (#1473)</li>
<li>[AIRFLOW-52] Fix bottlenecks when working with many tasks</li>
<li>Add columns to toggle extra detail in the connection list view.</li>
<li>Log the number of errors when importing DAGs</li>
<li>Log dagbag metrics dupplicate messages in queue into Statsd (#1406)</li>
<li>Clean up issue template (#1419)</li>
<li>correct missed arg.foreground to arg.daemon in cli</li>
<li>Reinstate imports for github enterprise auth</li>
<li>Use os.execvp instead of subprocess.Popen for the webserver</li>
<li>Revert from using “–foreground” to “–daemon”</li>
<li>Implement a Cloudant hook</li>
<li>Add missing args to <cite>airflow clear</cite></li>
<li>Fixed a bug in the scheduler: num_runs used where runs intended</li>
<li>Add multiprocessing support to the scheduler</li>
<li>Partial fix to make sure next_run_date cannot be None</li>
<li>Support list/get/set variables in the CLI</li>
<li>Properly handle BigQuery booleans in BigQuery hook.</li>
<li>Added the ability to view XCom variables in webserver</li>
<li>Change DAG.tasks from a list to a dict</li>
<li>Add support for zipped dags</li>
<li>Stop creating hook on instantiating of S3 operator</li>
<li>User subquery in views to find running DAGs</li>
<li>Prevent DAGs from being reloaded on every scheduler iteration</li>
<li>Add a missing word to docs</li>
<li>Document the parameters of <cite>DbApiHook</cite></li>
<li>added oracle operator with existing oracle hook</li>
<li>Add PyOpenSSL to Google cloud gcp_api.</li>
<li>Remove executor error unit test</li>
<li>Add DAG inference, deferral, and context manager</li>
<li>Don’t return error when writing files to Google cloud storage.</li>
<li>Fix GCS logging for gcp_api.</li>
<li>Ensure attr is in scope for error message</li>
<li>Fixing misnamed PULL_REQUEST_TEMPLATE</li>
<li>Extract non_pooled_task_slot_count into a configuration param</li>
<li>Update plugins.rst for clarity on the example (#1309)</li>
<li>Fix s3 logging issue</li>
<li>Add twitter feed example dag</li>
<li>Github ISSUE_TEMPLATE &amp; PR_TEMPLATE cleanup</li>
<li>Reduce logger verbosity</li>
<li>Adding a PR Template</li>
<li>Add Lucid to list of users</li>
<li>Fix usage of asciiart</li>
<li>Use session instead of outdated main_session for are_dependencies_met</li>
<li>Fix celery flower port allocation</li>
<li>Fix for missing edit actions due to flask-admin upgrade</li>
<li>Fix typo in comment in prioritize_queued method</li>
<li>Add HipchatOperator</li>
<li>Include all example dags in backfill unit test</li>
<li>Make sure skipped jobs are actually skipped</li>
<li>Fixing a broken example dag, example_skip_dag.py</li>
<li>Add consistent and thorough signal handling and logging</li>
<li>Allow Operators to specify SKIPPED status internally</li>
<li>Update docstring for executor trap unit test</li>
<li>Doc: explain the usage of Jinja templating for templated params</li>
<li>Don’t schedule runs before the DAG’s start_date</li>
<li>Fix infinite retries with pools, with test</li>
<li>Fix handling of deadlocked jobs</li>
<li>Show only Airflow’s deprecation warnings</li>
<li>Set DAG_FOLDER for unit tests</li>
<li>Missing comma in setup.py</li>
<li>Deprecate <a href="#id7"><span class="problematic" id="id8">*</span></a>args and <a href="#id9"><span class="problematic" id="id10">**</span></a>kwargs in BaseOperator</li>
<li>Raise deep scheduler exceptions to force a process restart.</li>
<li>Change inconsistent example DAG owners</li>
<li>Fix module path of send_email_smtp in configuration</li>
<li>added Gentner Lab to list of users</li>
<li>Increase timeout time for unit test</li>
<li>Fix reading strings from conf</li>
<li>CHORE - Remove Trailing Spaces</li>
<li>Fix SSHExecuteOperator crash when using a custom ssh port</li>
<li>Add note about airflow components to template</li>
<li>Rewrite BackfillJob logic for clarity</li>
<li>Add unit tests</li>
<li>Fix miscellaneous bugs and clean up code</li>
<li>Fix logic for determining DagRun states</li>
<li>Make SchedulerJob not run EVERY queued task</li>
<li>Improve BackfillJob handling of queued/deadlocked tasks</li>
<li>Introduce ignore_depends_on_past parameters</li>
<li>Use Popen with CeleryExecutor</li>
<li>Rename user table to users to avoid conflict with postgres</li>
<li>Beware of negative pool slots.</li>
<li>Add support for calling_format from boto to S3_Hook</li>
<li>Add pypi meta data and sync version number</li>
<li>Set dags_are_paused_at_creation’s default value to True</li>
<li>Resurface S3Log class eaten by rebase/push -f</li>
<li>Add missing session.commit() at end of initdb</li>
<li>Validate that subdag tasks have pool slots available, and test</li>
<li>Use urlparse for remote GCS logs, and add unit tests</li>
<li>Make webserver worker timeout configurable</li>
<li>Fixed scheduling for &#64;once interval</li>
<li>Use psycopg2’s API for serializing postgres cell values</li>
<li>Make the provide_session decorator more robust</li>
<li>update link to Lyft’s website</li>
<li>use num_shards instead of partitions to be consistent with batch ingestion</li>
<li>Add documentation links to README</li>
<li>Update docs with separate configuration section</li>
<li>Fix airflow.utils deprecation warning code being Python 3 incompatible</li>
<li>Extract dbapi cell serialization into its own method</li>
<li>Set Postgres autocommit as supported only if server version is &lt; 7.4</li>
<li>Use refactored utils module in unit test imports</li>
<li>Add changelog for 1.7.0</li>
<li>Use LocalExecutor on Travis if possible</li>
<li>remove unused logging,errno, MiniHiveCluster imports</li>
<li>remove extra import of logging lib</li>
<li>Fix required gcloud version</li>
<li>Refactoring utils into smaller submodules</li>
<li>Properly measure number of task retry attempts</li>
<li>Add function to get configuration as dict, plus unit tests</li>
<li>Merge branch ‘master’ into hivemeta_sasl</li>
<li>Add wiki link to README.md</li>
<li>[hotfix] make email.Utils &gt; email.utils for py3</li>
<li>Add the missing “Date” header to the warning e-mails</li>
<li>Add the missing “Date” header to the warning e-mails</li>
<li>Check name of SubDag class instead of class itself</li>
<li>[hotfix] removing repo_token from .coveralls.yml</li>
<li>Set the service_name in coverals.yml</li>
<li>Fixes #1223</li>
<li>Update Airflow docs for remote logging</li>
<li>Add unit tests for trapping Executor errors</li>
<li>Make sure Executors properly trap errors</li>
<li>Fix HttpOpSensorTest to use fake resquest session</li>
<li>Linting</li>
<li>Add an example on pool usage in the documentation</li>
<li>Add two methods to bigquery hook’s base cursor: run_table_upsert, which adds a table or updates an existing table; and run_grant_dataset_view_access, which grants view access to a given dataset for a given table.</li>
<li>Tasks references upstream and downstream tasks using strings instead of references</li>
<li>Fix typos in models.py</li>
<li>Fix broken links in documentation</li>
<li>[hotfix] fixing the Scheduler CLI to make dag_id optional</li>
<li>Update link to Common Pitfalls wiki page in README</li>
<li>Allow disabling periodic committing when inserting rows with DbApiHook</li>
<li>added Glassdoor to “who uses airflow”</li>
<li>Fix typo preventing from launching webserver</li>
<li>Documentation badge</li>
<li>Fixing ISSUE_TEMPLATE name to include .md suffix</li>
<li>Adding an ISSUE_TEMPLATE to ensure that issues are adequately defined</li>
<li>Linting &amp; debugging</li>
<li>Refactoring the CLI to be data-driven</li>
<li>Updating the Bug Reporting protocol in the Contributing.md file</li>
<li>Fixing the docs</li>
<li>clean up references to old session</li>
<li>remove session reference</li>
<li>resolve conflict</li>
<li>clear xcom data when task instance starts</li>
<li>replace main_session with &#64;provide_session</li>
<li>Add extras to installation.rst</li>
<li>Changes to Contributing to reflect more closely the current state of development.</li>
<li>Modifying README to link to the wiki committer list</li>
<li>docs: fixes a spelling mistake in default config</li>
<li>Set killMode to ‘control-group’ for webservice.service</li>
<li>Set KillMode to ‘control-group’ for worker.service</li>
<li>Linting</li>
<li>Fix WebHdfsSensor</li>
<li>Adding more licenses to pass checks</li>
<li>fixing landscape’s config</li>
<li>[hotfix] typo that made it in master</li>
<li>[hotfix] fixing landscape requirement detection</li>
<li>Make testing on hive conditional</li>
<li>Merge remote-tracking branch ‘upstream/master’ into minicluster</li>
<li>Update README.md</li>
<li>Throwing in a few license to pass the build</li>
<li>Adding a reqs.txt for landscape.io</li>
<li>Pointing to a reqs file</li>
<li>Some linting</li>
<li>Adding a .landscape.yml file</li>
<li>badge for pypi version</li>
<li>Add license and ignore for sql and csv</li>
<li>Use correct connection id</li>
<li>Use correct table name</li>
<li>Provide data for ci tests</li>
<li>new badge for showing staleness of reqs</li>
<li>removing requirements.txt as it is uni-dimensional</li>
<li>Make it work on py3</li>
<li>Remove decode for logging</li>
<li>Also keep py2 compatible</li>
<li>More py3 fixes</li>
<li>Convert to bytes for py3 compat</li>
<li>Make sure to be py3 compatible</li>
<li>Use unicodecsv to make it py3 compatible</li>
<li>Replace tab with spaces Remove unused import</li>
<li>Merge remote-tracking branch ‘upstream/master’</li>
<li>Support decimal types in MySQL to GCS</li>
<li>Make sure to write binary as string can be unicode</li>
<li>Ignore metastore</li>
<li>More impyla fixes</li>
<li>Test HivemetaStore if python 2</li>
<li>Allow users to set hdfs_namenode_principal in HDFSHook config</li>
<li>Add tests for Hiveserver2 and fix some issues from impyla</li>
<li>Merge branch ‘impyla’ into minicluster</li>
<li>This patch allows for testing of hive operators and hooks. Sasl is used (NoSasl in connection string is not possible). Tests have been adjusted.</li>
<li>Treat SKIPPED and SUCCESS the same way when evaluating depends_on_past=True</li>
<li>fix bigquery hook</li>
<li>version cap for gcp_api</li>
<li>Fix typo when returning VerticaHook</li>
<li>Adding fernet key to use it as part of stdout commands</li>
<li>Adding support for ssl parameters.  (picking up from jthomas123)</li>
<li>more detail in error message.</li>
<li>make sure paths don’t conflict bc of trailing /</li>
<li>change gcs_hook to self.hook</li>
<li>refactor remote log read/write and add GCS support</li>
<li>Only use multipart upload in S3Hook if file is large enough</li>
<li>Merge branch ‘airbnb/master’</li>
<li>Add GSSAPI SASL to HiveMetaStoreHook.</li>
<li>Add warning for deprecated setting</li>
<li>Use kerberos_service_name = ‘hive’ as standard instead of ‘impala’.</li>
<li>Use GSSAPI instead of KERBEROS and provide backwards compatibility</li>
<li>ISSUE-1123 Use impyla instead of pyhs2</li>
<li>set celery_executor to use queue name as exchange</li>
</ul>
</div>
</div>


           </div>
           
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="faq.html" class="btn btn-neutral float-right" title="FAQ" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="lineage.html" class="btn btn-neutral" title="Lineage" 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" 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>

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

</body>
</html>
