Backport count() with step param for Py2.6 (issue #152)

Author: edschofield

docs/standard_library_imports.rst

@@ -15,9 +15,9 @@ As of version 0.14, the ``future`` package comes with top-level packages for
 Python 2.x that provide access to the reorganized standard library modules
 under their Python 3.x names.
 
-Direct imports are the preferred mechanism for accesing the renamed standard library
-modules in Python 2/3 compatible code. For example, the following clean Python
-3 code runs unchanged on Python 2 after installing ``future``::
+Direct imports are the preferred mechanism for accesing the renamed standard
+library modules in Python 2/3 compatible code. For example, the following clean
+Python 3 code runs unchanged on Python 2 after installing ``future``::
 
     >>> # Alias for future.builtins on Py2:
     >>> from builtins import str, open, range, dict
@@ -28,8 +28,8 @@ modules in Python 2/3 compatible code. For example, the following clean Python
     >>> import tkinter.dialog
     >>> etc.
 
-Notice that this code actually runs on Python 3 without the presence of the ``future``
-package.
+Notice that this code actually runs on Python 3 without the presence of the
+``future`` package.
 
 Of the 44 modules that were refactored with PEP 3108 (standard library
 reorganization), 30 are supported with direct imports in the above manner. The
@@ -92,21 +92,21 @@ package makes the Python 3.x APIs available on Python 2.x as follows::
     from future.standard_library import install_aliases
     install_aliases()
 
-    from collections import Counter, OrderedDict   # backported to Py2.6
     from collections import UserDict, UserList, UserString
 
     import dbm
     import dbm.dumb
-    import dbm.gnu                         # requires Python dbm support
-    import dbm.ndbm                        # requires Python dbm support
+    import dbm.gnu                # requires Python dbm support
+    import dbm.ndbm               # requires Python dbm support
 
     from itertools import filterfalse, zip_longest
 
-    from subprocess import check_output    # backported to Py2.6
     from subprocess import getoutput, getstatusoutput
 
     from sys import intern
 
+    from math import ceil         # now returns an int
+
     import test.support
 
     import urllib.error
@@ -116,6 +116,22 @@ package makes the Python 3.x APIs available on Python 2.x as follows::
     import urllib.robotparser
 
 
+Backports also exist of the following features from Python 2.7+ for Python 2.6:
+
+- collections.Counter
+- collections.OrderedDict
+- itertools.count (with an optional step parameter)
+
+These can be imported on Python 2.6 as follows::
+
+    from future.standard_library import install_aliases
+    install_aliases()
+
+    from collections import Counter, OrderedDict
+    from itertools import count
+    from subprocess import check_output
+
+
 External standard-library backports
 -----------------------------------
 

docs/whatsnew.rst

@@ -8,12 +8,14 @@ What's New
 What's new in version 0.14.4 (2015-06-03)
 =========================================
 
-This is primarily a bug-fix release. It adds two new minor features and fixes several small bugs.
+This is primarily a bug-fix release. It adds some minor new features and
+fixes several small bugs.
 
 Minor features:
 
 - ``tkinter.ttk`` support (issue #151)
 - ``collections.ChainMap`` backport (issue #150)
+- ``itertools.count`` backport for Py2.6 (issue #152)
 
 Bug fixes:
 

src/future/backports/__init__.py

@@ -6,3 +6,5 @@
 
 if sys.version_info[0] == 3:
     import_top_level_modules()
+
+from .misc import ceil, OrderedDict, Counter, check_output, count

src/future/backports/misc.py

@@ -1,25 +1,25 @@
 """
-Miscellaneous function (re)definitions from the Py3.3 standard library for
-Python 2.6/2.7.
+Miscellaneous function (re)definitions from the Py3.3+ standard library
+for Python 2.6/2.7.
 
-math.ceil
-
-collections.OrderedDict  (for Python 2.6)
-collections.Counter      (for Python 2.6)
+- math.ceil                (for Python 2.7)
+- collections.OrderedDict  (for Python 2.6)
+- collections.Counter      (for Python 2.6)
+- itertools.count          (for Python 2.6, with step parameter)
 """
 
-from math import ceil as oldceil
+from math import ceil
 import subprocess
 
 from future.utils import iteritems, itervalues, PY26
 
 
-def ceil(x):
+def _ceil(x):
     """
     Return the ceiling of x as an int.
     This is the smallest integral value >= x.
     """
-    return int(oldceil(x))
+    return int(ceil(x))
 
 
 # OrderedDict Shim from  Raymond Hettinger, python core dev
@@ -482,16 +482,13 @@ def __and__(self, other):
                 result[elem] = newcount
         return result
 
-try:
-    from collections import OrderedDict, Counter
-except ImportError:
-    # Python 2.6 doesn't have these:
-    OrderedDict = _OrderedDict
-    Counter = _Counter
 
+def _check_output(*popenargs, **kwargs):
+    """
+    For Python 2.6 compatibility: see
+    http://stackoverflow.com/questions/4814970/
+    """
 
-# For Python 2.6 compatibility: see http://stackoverflow.com/questions/4814970/
-def check_output(*popenargs, **kwargs):
     if 'stdout' in kwargs:
         raise ValueError('stdout argument not allowed, it will be overridden.')
     process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
@@ -503,3 +500,27 @@ def check_output(*popenargs, **kwargs):
             cmd = popenargs[0]
         raise subprocess.CalledProcessError(retcode, cmd)
     return output
+
+
+def _count(start=0, step=1):
+    """
+    ``itertools.count`` in Py 2.6 doesn't accept a step
+    parameter. This is an enhanced version of ``itertools.count``
+    for Py2.6 equivalent to ``itertools.count`` in Python 2.7+.
+    """
+    while True:
+        yield start
+        start += step
+
+
+if not PY26:
+    from math import ceil
+    from collections import OrderedDict, Counter
+    from subprocess import check_output
+    from itertools import count
+else:
+    ceil = _ceil
+    OrderedDict = _OrderedDict
+    Counter = _Counter
+    check_output = _check_output
+    count = _count

src/future/standard_library/__init__.py

@@ -196,6 +196,7 @@
          ('math', 'ceil', 'future.backports.misc', 'ceil'),
          ('collections', 'OrderedDict', 'future.backports.misc', 'OrderedDict'),
          ('collections', 'Counter', 'future.backports.misc', 'Counter'),
+         ('itertools', 'count', 'future.backports.misc', 'count'),
 
 # This is no use, since "import urllib.request" etc. still fails:
 #          ('urllib', 'error', 'future.moves.urllib', 'error'),

src/future/types/newrange.py

@@ -21,6 +21,10 @@
 from collections import Sequence, Iterator
 from itertools import islice
 
+from future.backports.misc import count   # with step parameter on Py2.6
+# For backward compatibility with python-future versions < 0.14.4:
+from future.backports.misc import _count
+
 
 class newrange(Sequence):
     """
@@ -142,7 +146,7 @@ class range_iterator(Iterator):
     """An iterator for a :class:`range`.
     """
     def __init__(self, range_):
-        self._stepper = islice(_count(range_.start, range_.step), len(range_))
+        self._stepper = islice(count(range_.start, range_.step), len(range_))
 
     def __iter__(self):
         return self
@@ -151,11 +155,4 @@ def next(self):
         return next(self._stepper)
 
 
-# itertools.count in Py 2.6 doesn't accept a step parameter
-def _count(start=0, step=1):
-    while True:
-        yield start
-        start += step
-
-
 __all__ = ['newrange']

tests/test_future/test_backports.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for various backported functions and classes in ``future.backports``
+"""
+
+from __future__ import absolute_import, unicode_literals, print_function
+
+from future.backports.misc import count, _count
+from future.utils import PY26
+from future.tests.base import unittest, skip26
+
+
+class CountTest(unittest.TestCase):
+    """Test the count function."""
+
+    def _test_count_func(self, func):
+        self.assertEqual(next(func(1)), 1)
+        self.assertEqual(next(func(start=1)), 1)
+
+        c = func()
+        self.assertEqual(next(c), 0)
+        self.assertEqual(next(c), 1)
+        self.assertEqual(next(c), 2)
+        c = func(1, 1)
+        self.assertEqual(next(c), 1)
+        self.assertEqual(next(c), 2)
+        c = func(step=1)
+        self.assertEqual(next(c), 0)
+        self.assertEqual(next(c), 1)
+        c = func(start=1, step=1)
+        self.assertEqual(next(c), 1)
+        self.assertEqual(next(c), 2)
+
+        c = func(-1)
+        self.assertEqual(next(c), -1)
+        self.assertEqual(next(c), 0)
+        self.assertEqual(next(c), 1)
+        c = func(1, -1)
+        self.assertEqual(next(c), 1)
+        self.assertEqual(next(c), 0)
+        self.assertEqual(next(c), -1)
+        c = func(-1, -1)
+        self.assertEqual(next(c), -1)
+        self.assertEqual(next(c), -2)
+        self.assertEqual(next(c), -3)
+
+    def test_count(self):
+        """Test the count function."""
+        self._test_count_func(count)
+
+    def test_own_count(self):
+        """Test own count implementation."""
+        if PY26:
+            self.assertIs(count, _count)
+        else:
+            self.assertNotEqual(count, _count)
+            self._test_count_func(_count)
+
+
+if __name__ == '__main__':
+    unittest.main()