API : make __iter__ be finite

It is far simpler for users that want infinite cycling to wrap
the ``Cycler`` in a call to `itertools.cycle` than it is for the user
that wants a finite iterator to sort out how to get the finite version.

This simplifies the API and makes it a bit more guessable/intuitive.

Author: tacaswell

cycler.py

@@ -2,7 +2,7 @@
                         unicode_literals)
 
 import six
-from itertools import product, cycle
+from itertools import product
 from six.moves import zip
 from operator import mul
 import copy
@@ -58,37 +58,12 @@ def __init__(self, left, right=None, op=None):
     def keys(self):
         return set(self._keys)
 
-    def finite_iter(self):
-        """
-        Return a finite iterator over the configurations in
-        this cycle.
-        """
-        if self._right is None:
-            try:
-                return self._left.finite_iter()
-            except AttributeError:
-                return iter(self._left)
-        return self._compose()
-
-    def to_list(self):
-        """
-        Return a list of the dictionaries yielded by
-        this Cycler.
-
-        Returns
-        -------
-        cycle : list
-            All of the dictionaries yielded by this Cycler in order.
-        """
-        return list(self.finite_iter())
-
     def _compose(self):
         """
         Compose the 'left' and 'right' components of this cycle
         with the proper operation (zip or product as of now)
         """
-        for a, b in self._op(self._left.finite_iter(),
-                             self._right.finite_iter()):
+        for a, b in self._op(self._left, self._right):
             out = dict()
             out.update(a)
             out.update(b)
@@ -120,7 +95,10 @@ def _from_iter(cls, label, itr):
         return ret
 
     def __iter__(self):
-        return cycle(self.finite_iter())
+        if self._right is None:
+            return iter(self._left)
+
+        return self._compose()
 
     def __add__(self, other):
         return Cycler(self, other, zip)
@@ -156,7 +134,7 @@ def __repr__(self):
         op_map = {zip: '+', product: '*'}
         if self._right is None:
             lab = self.keys.pop()
-            itr = list(v[lab] for v in self.finite_iter())
+            itr = list(v[lab] for v in self)
             return "cycler({lab!r}, {itr!r})".format(lab=lab, itr=itr)
         else:
             op = op_map.get(self._op, '?')
@@ -192,6 +170,6 @@ def cycler(label, itr):
             return copy.copy(itr)
         else:
             lab = keys.pop()
-            itr = list(v[lab] for v in itr.finite_iter())
+            itr = list(v[lab] for v in itr)
 
     return Cycler._from_iter(label, itr)

test_cycler.py

@@ -11,8 +11,7 @@
 
 def _cycler_helper(c, length, keys, values):
     assert_equal(len(c), length)
-    assert_equal(len(c), len(list(c.finite_iter())))
-    assert_equal(len(c), len(c.to_list()))
+    assert_equal(len(c), len(list(c)))
     assert_equal(c.keys, set(keys))
 
     for k, vals in zip(keys, values):