<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    
      <meta name="description" content="Archive: 2019 12">
    

    <meta name="author" content="The Apache Software Foundation">

    
      <meta name="keywords" content="python,libcloud,cloud,cloud computing,rackspace,amazon ec2,cloudfiles,openstack,cloudstack" />
    

    
      <title>Archive: 2019 &raquo; December | Apache Libcloud</title>
    

    <!-- fav icons -->
    <link rel="shortcut icon" href="/images/favicon.png" />
    <link rel="apple-touch-icon" href="/images/apple-touch-icon.png" />
    <link rel="apple-touch-icon-precomposed" href="/images/apple-touch-icon.png" />

    <link href="/blog/atom.xml" type="application/atom+xml" rel="alternate" title="Apache Libcloud Blog Feed" />

    <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,400italic' rel='stylesheet' type='text/css'>
    <link href='https://fonts.googleapis.com/css?family=Inconsolata' rel='stylesheet' type='text/css'>

    <!-- Facebook OpenGraph tags -->
    <meta content="Apache Libcloud" property="og:site_name">
    
      <meta content="Archive: 2019 &raquo; December" property="og:title">
    

    

    
      <meta content="Archive: 2019 12" property="og:description">
    

    
      <meta content="website" property="og:type">
    

    
      <meta content="https://libcloud.apache.org/blog/archives/2019/12/" property="og:url">
    
    

    

    <link href='/assets/global-49923225b15584efebd7a337daac5102.css' rel='stylesheet' type='text/css' />
  </head>

  <body data-spy="scroll" data-target=".sidebar-nav" data-offset="80">
    <nav class="navbar navbar-fixed-top navbar-inverse" role="navigation">
      <div class="container">
        <div class="navbar-header">
          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-ex1-collapse">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="/index.html"><img src="/images/libcloud_logo.png" class="navbar-logo" /> Apache Libcloud</a>
        </div>
        <div class="collapse navbar-collapse navbar-ex1-collapse">
          <ul class="nav navbar-nav">
            
            
              
              <li ><a href="/" >Home</a></li>
            
              
              <li ><a href="/about.html" >About</a></li>
            
              
              <li ><a href="/getting-started.html" >Quick Start</a></li>
            
              
              <li ><a href="https://libcloud.readthedocs.org/en/stable/" target="_blank">Documentation</a></li>
            
              
              <li ><a href="/downloads.html" >Downloads</a></li>
            
              
              <li ><a href="/community.html" >Community</a></li>
            
              
              <li ><a href="/blog/" >Blog</a></li>
            
          </ul>

          <div class="material-switch pull-right">
              <input id="theme-switch" name="theme-switch" type="checkbox" onclick="modeSwitcher()"/>
              <label for="theme-switch" class="label-default"></label>
              <span id="theme-toggle" class="theme-switch">Dark mode</span>
          </div>

        </div><!-- /.navbar-collapse -->
      </div><!-- /.container -->
    </nav>

    <div class="container main-container">
      

  <div class="post">
  
    <h2><a href="/blog/2019/12/09/libcloud-2-7-0-released.html">Libcloud 2.7.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 09, 2019</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.7.0.</p>

<p>Among various smaller bug fixes, this release also includes a couple of big
new features.</p>

<p>Highlights include:</p>

<ul>
  <li>Initial type annotations / hints support for the base Libcloud compute API.</li>
  <li>S3 driver class has been updated to support <code class="language-plaintext highlighter-rouge">region</code> argument in the same
manner as other drivers which support multiple regions (no more messy class
per region approach). For backward compatibility reasons, “class per region”
approach will still be supported until the next major release.</li>
  <li>New <code class="language-plaintext highlighter-rouge">start_node()</code> and <code class="language-plaintext highlighter-rouge">stop_node()</code> method have been added to the base
Libcloud compute API and the existing drivers which implement
<code class="language-plaintext highlighter-rouge">ex_start_node()</code> and <code class="language-plaintext highlighter-rouge">ex_stop_node()</code> methods have been updated to
implement those new methods. Old <code class="language-plaintext highlighter-rouge">ex_</code> methods will continue to work for
backward compatibility reasons.</li>
</ul>

<p>Full change log can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-7-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-7-0</a>.</p>

<h3 id="dropping-support-for-python-27-and-python-34">Dropping support for Python 2.7 and Python 3.4</h3>

<p>Libcloud was among some of the other early larger Python projects which have
supported Python 2.x and Python 3.x simultaneously using a single code base
from 2011.</p>

<p>Over the years, the landscape has changed a lot. A lot of the users now use
Python 3 as a default and a lot of the popular Python projects now not only
support Python 3, but also make Python 3 the only supported Python version.</p>

<p>In addition to that, <a href="https://pythonclock.org/">Python 2.7 will not be maintained past January 2020</a>.</p>

<p>We have decided to sign the <a href="https://python3statement.org/">Python 3 statement</a> and drop support for Python
2.7 and Python 3.4 in the next major release (v3.0.0) which will coincide
with Python 2.7 EOL early next year.</p>

<p>This means that Libcloud v2.7.0 will be the last major release which still
supports Python 2.7 and 3.4.</p>

<p>The change itself is still work in progress. People who are interested in it
can check the following PR <a href="https://github.com/apache/libcloud/pull/1377">https://github.com/apache/libcloud/pull/1377</a>.</p>

<h4 id="how-does-this-affect-me">How does this affect me?</h4>

<p>If you still need to use Python 2.7 or Python 3.4 after Libcloud v3.0.0 is
out, you will be able to do that by utilizing one of the older Libcloud
releases which still supports that Python version.</p>

<p>All the new feature development and improvements will land in new release
which support Python &gt;= 3.5 only, but we may still do a release in the
v2.7.x release series if a major bug or a security issue is found.</p>

<h4 id="how-does-this-affect-the-libcloud-development-team">How does this affect the Libcloud development team?</h4>

<p>Supporting Python 2.x and Python 3.x through a single code base was never
totally trivial.</p>

<p>This is especially true for our project which doesn’t use <code class="language-plaintext highlighter-rouge">six</code> Python 2
/ 3 compatibility library, but uses custom glue / wrapper code for that.</p>

<p>There are multiple reasons why we didn’t use <code class="language-plaintext highlighter-rouge">six</code> - one is that we still
needed to support Python 2.5 which is not supported by <code class="language-plaintext highlighter-rouge">six</code> and another
one is that we didn’t want to introduce another dependency on the end user in
the days where Python packaging was still very much in the infancy.</p>

<p>Dropping support for Python 2.7 and Python 3.4 will allow us to streamline our
code and remove a lot of the code which is not needed anymore.</p>

<p>This will result in easier development and cleaner code.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.7.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.7.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.7.0/">https://libcloud.readthedocs.org/en/v2.7.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.7.0/changelog.html">CHANGES file</a>.</p>


  </div>

  <div class="row section post-meta">
    <div class="col-md-12 post-tags">
      <p>Tags: <a href="/blog/tags/news.html" rel="tag">news</a>, <a href="/blog/tags/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>



<p class="navigation">
  

  
</p>



      <hr />

      <footer>
        <div class="row">
          <div class="col-lg-12 text-center">
            <div class="footer-links">
  <p><a href="http://www.apache.org/licenses/">License</a> | <a
  href="/security.html">Security</a> | <a
  href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a> |
  <a href="http://www.apache.org/foundation/thanks.html">Thanks</a> |
  <a href="/credits.html">Credits</a> | <a href="/media.html">Media</a>
</div>

<div class="footer-text">
  <p class="">Copyright &copy; 2009-2022 <a href="https://www.apache.org/" target="_blank">The Apache Software Foundation</a></p>
  <p class="">Apache Libcloud, Libcloud, Apache, the Apache feather, and the Apache Libcloud project logo are trademarks of the Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
  <p class="">Site last updated on 2022-03-29 21:34:03 +0000</p>
</div>

          </div>
        </div>
      </footer>

    </div><!-- /.container -->

    <!-- JavaScript -->
    <script src='/assets/global-9d3ec4fa3c143ff7102734d40de1aad8.js' type='text/javascript'></script>

    

    <script type="text/javascript">
  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-23580482-1']);
  _gaq.push(['_trackPageview']);

  (function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();
</script>

  </body>
</html>
