PEP8 Compliance - All required whitespace fixes

Author: serkanyersen

MANIFEST

@@ -1,5 +1,4 @@
 # file GENERATED by distutils, do NOT edit
-README
 setup.py
 src/__init__.py
 src/underscore.py

setup.py

@@ -10,4 +10,4 @@
       url='https://github.com/serkanyersen/underscore.py/',
       packages=['underscore'],
       package_dir={'underscore': 'src'}
-     )
+      )

src/underscore.py

@@ -9,18 +9,21 @@
 
 
 class _IdCounter(object):
+
     """ A Global Dictionary for uniq IDs
     """
     count = 0
     pass
 
 
 class __(object):
+
     """
     Use this class to alter __repr__ of
     underscore object. So when you are using
     it on your project it will make sense
     """
+
     def __init__(self, repr, func):
         self._repr = repr
         self._func = func
@@ -52,6 +55,7 @@ def _(obj):
 
 
 class underscore(object):
+
     """
     Instead of creating a class named _ (underscore) I created underscore
     So I can use _ function both statically and dynamically just it
@@ -88,6 +92,7 @@ def __init__(self, obj):
         self.object = obj
 
         class Namespace(object):
+
             """ For simulating full closure support
             """
             pass
@@ -246,7 +251,7 @@ def filter(self, func):
     def reject(self, func):
         """ Return all the elements for which a truth test fails.
         """
-        return self._wrap(list(filter(lambda value: not func(value), self.obj)))
+        return self._wrap(list(filter(lambda val: not func(val), self.obj)))
 
     def all(self, func=None):
         """ Determine whether all of the elements match a truth test.
@@ -315,7 +320,8 @@ def pluck(self, key):
 
     def where(self, attrs=None, first=False):
         """
-        Convenience version of a common use case of `filter`: selecting only objects
+        Convenience version of a common use case of `filter`:
+        selecting only objects
         containing specific `key:value` pairs.
         """
         if attrs is None:
@@ -336,7 +342,8 @@ def by(val, *args):
 
     def findWhere(self, attrs=None):
         """
-        Convenience version of a common use case of `find`: getting the first object
+        Convenience version of a common use case of `find`:
+        getting the first object
         containing specific `key:value` pairs.
         """
         return self._wrap(self._clean.where(attrs, True))
@@ -422,8 +429,8 @@ def by(result, key, value):
 
     def indexBy(self, val=None):
         """
-        Indexes the object's values by a criterion, similar to `groupBy`, but for
-        when you know that your index values will be unique.
+        Indexes the object's values by a criterion, similar to
+        `groupBy`, but for when you know that your index values will be unique.
         """
         if val is None:
             val = lambda *args: args[0]
@@ -746,8 +753,8 @@ def bind(self, context):
 
     def partial(self, *args):
         """
-        Partially apply a function by creating a version that has had some of its
-        arguments pre-filled, without changing its dynamic `this` context.
+        Partially apply a function by creating a version that has had some of
+        its arguments pre-filled, without changing its dynamic `this` context.
         """
         def part(*args2):
             args3 = args + args2
@@ -797,8 +804,7 @@ def defer(self, *args):
         Defers a function, scheduling it to run after
         the current call stack has cleared.
         """
-        ## I know! this isn't really a defer in python. I'm open to suggestions
-        #######################################################################
+        # I know! this isn't really a defer in python. I'm open to suggestions
         return self.delay(1, *args)
 
     def throttle(self, wait):
@@ -953,7 +959,9 @@ def pairs(self):
         return self._wrap(pairs)
 
     def invert(self):
-        """ Invert the keys and values of an object. The values must be serializable.
+        """
+        Invert the keys and values of an object.
+        The values must be serializable.
         """
         keys = self._clean.keys()
         inverted = {}
@@ -1281,7 +1289,9 @@ def identity(self, *args):
         return self._wrap(self.obj)
 
     def property(self):
-        """ For easy creation of iterators that pull specific properties from objects.
+        """
+        For easy creation of iterators that pull
+        specific properties from objects.
         """
         return self._wrap(lambda obj, *args: obj[self.obj])
 
@@ -1302,7 +1312,6 @@ def ret(obj, *args):
 
         return self._wrap(ret)
 
-
     def times(self, func, *args):
         """ Run a function **n** times.
         """
@@ -1583,9 +1592,9 @@ def value(self):
     def makeStatic():
         """ Provide static access to underscore class
         """
+        p = lambda value: inspect.ismethod(value) or inspect.isfunction(value)
         for eachMethod in inspect.getmembers(underscore,
-                                             predicate=lambda value: inspect.ismethod(value) or
-                                             inspect.isfunction(value)):
+                                             predicate=p):
             m = eachMethod[0]
             if not hasattr(_, m):
                 def caller(a):

tests/test_arrays.py

@@ -36,69 +36,92 @@ def test_compact(self):
 
     def test_flatten(self):
         llist = [1, [2], [3, [[[4]]]]]
-        self.assertEqual(_.flatten(llist), [1, 2, 3, 4], 'can flatten nested arrays')
-        self.assertEqual(_.flatten(llist, True), [1, 2, 3, [[[4]]]], 'can shallowly flatten nested arrays')
+        self.assertEqual(_.flatten(llist),
+                         [1, 2, 3, 4], 'can flatten nested arrays')
+        self.assertEqual(_.flatten(llist, True),
+                         [1, 2, 3, [[[4]]]], 'can shallowly'
+                         ' flatten nested arrays')
 
     def test_uniq(self):
         tlist = [1, 2, 1, 3, 1, 4]
-        self.assertEqual([1, 2, 3, 4], _.uniq(tlist), 'can find the unique values of an unsorted array')
+        self.assertEqual([1, 2, 3, 4], _.uniq(tlist),
+                         'can find the unique values of an unsorted array')
 
         tlist = [1, 1, 1, 2, 2, 3]
-        self.assertEqual([1, 2, 3], _.uniq(tlist, True), 'can find the unique values of a sorted array faster')
+        self.assertEqual([1, 2, 3], _.uniq(tlist, True),
+                         'can find the unique values of a sorted array faster')
 
-        tlist = [{"name": 'moe'}, {"name": 'curly'}, {"name": 'larry'}, {"name": 'curly'}]
+        tlist = [{"name": 'moe'}, {"name": 'curly'},
+                 {"name": 'larry'}, {"name": 'curly'}]
         iterator = lambda value, *args: value.get('name')
-        self.assertEqual(["moe", "curly", "larry"], _.uniq(tlist, False, iterator), 'can find the unique values of an array using a custom iterator')
+        self.assertEqual(
+            ["moe", "curly", "larry"], _.uniq(tlist, False, iterator),
+            'can find the unique values of an array using a custom iterator')
 
         tlist = [1, 2, 2, 3, 4, 4]
         iterator = lambda value, *args: value + 1
-        self.assertEqual([2, 3, 4, 5], _.uniq(tlist, True, iterator), 'iterator works with sorted array')
+        self.assertEqual([2, 3, 4, 5], _.uniq(tlist, True, iterator),
+                         'iterator works with sorted array')
 
     def test_without(self):
         tlist = [1, 2, 1, 0, 3, 1, 4]
-        self.assertEqual([2, 3, 4], _.without(tlist, 0, 1), 'can remove all instances of an object')
+        self.assertEqual([2, 3, 4], _.without(tlist, 0, 1),
+                         'can remove all instances of an object')
 
         tlist = [{"one": 1}, {"two": 2}]
 
-        self.assertTrue(len(_.without(tlist, {"one": 1})) == 2, 'uses real object identity for comparisons.')
+        self.assertTrue(len(_.without(tlist, {"one": 1}))
+                        == 2, 'uses real object identity for comparisons.')
         self.assertTrue(len(_.without(tlist, tlist[0])) == 1, 'ditto.')
 
     def test_intersection(self):
         stooges = ['moe', 'curly', 'larry'],
         leaders = ['moe', 'groucho']
-        self.assertEqual(['moe'], _.intersection(stooges, leaders), 'can take the set intersection of two string arrays')
-        self.assertEqual([1, 2], _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]), 'can take the set intersection of two int arrays')
-        self.assertEqual(['moe'], _(stooges).intersection(leaders), 'can perform an OO-style intersection')
+        self.assertEqual(['moe'], _.intersection(stooges, leaders),
+                         'can take the set intersection of two string arrays')
+        self.assertEqual(
+            [1, 2], _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]),
+            'can take the set intersection of two int arrays')
+        self.assertEqual(['moe'], _(stooges).intersection(leaders),
+                         'can perform an OO-style intersection')
 
     def test_union(self):
         result = _.union([1, 2, 3], [2, 30, 1], [1, 40])
-        self.assertEqual([1, 2, 3, 30, 40], result, 'takes the union of a list of arrays')
+        self.assertEqual([1, 2, 3, 30, 40], result,
+                         'takes the union of a list of arrays')
 
         result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]])
-        self.assertEqual([1, 2, 3, 30, 40, [1]], result, 'takes the union of a list of nested arrays')
+        self.assertEqual([1, 2, 3, 30, 40, [1]], result,
+                         'takes the union of a list of nested arrays')
 
     def test_difference(self):
         result = _.difference([1, 2, 3], [2, 30, 40])
         self.assertEqual([1, 3], result, 'takes the difference of two arrays')
 
         result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111])
-        self.assertEqual([3, 4], result, 'takes the difference of three arrays')
+        self.assertEqual([3, 4], result,
+                         'takes the difference of three arrays')
 
     def test_zip(self):
         names = ['moe', 'larry', 'curly']
         ages = [30, 40, 50]
         leaders = [True]
         stooges = list(_(names).zip(ages, leaders))
-        self.assertEqual("[('moe', 30, True), ('larry', 40, None), ('curly', 50, None)]", str(stooges), 'zipped together arrays of different lengths')
+        self.assertEqual("[('moe', 30, True), ('larry', 40, None),"
+                         " ('curly', 50, None)]", str(
+                             stooges), 'zipped together arrays of different lengths')
 
     def test_zipObject(self):
         result = _.zipObject(['moe', 'larry', 'curly'], [30, 40, 50])
         shouldBe = {"moe": 30, "larry": 40, "curly": 50}
-        self.assertEqual(result, shouldBe, "two arrays zipped together into an object")
+        self.assertEqual(result, shouldBe,
+                         "two arrays zipped together into an object")
 
     def test_indexOf(self):
         numbers = [1, 2, 3]
-        self.assertEqual(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function')
+        self.assertEqual(_.indexOf(numbers, 2), 1,
+                         'can compute indexOf, even '
+                         'without the native function')
         self.assertEqual(_.indexOf(None, 2), -1, 'handles nulls properly')
 
         numbers = [10, 20, 30, 40, 50]
@@ -118,21 +141,47 @@ def test_indexOf(self):
 
     def test_lastIndexOf(self):
         numbers = [2, 1, 0, 1, 0, 0, 1, 0, 0, 0]
-        self.assertEqual(_.lastIndexOf(numbers, 1), 6, 'can compute lastIndexOf, even without the native function')
-        self.assertEqual(_.lastIndexOf(numbers, 0), 9, 'lastIndexOf the other element')
-        self.assertEqual(_.lastIndexOf(numbers, 2), 0, 'lastIndexOf the other element')
+        self.assertEqual(_.lastIndexOf(numbers, 1), 6,
+                         'can compute lastIndexOf, '
+                         'even without the native function')
+        self.assertEqual(_.lastIndexOf(numbers, 0), 9,
+                         'lastIndexOf the other element')
+        self.assertEqual(_.lastIndexOf(numbers, 2), 0,
+                         'lastIndexOf the other element')
         self.assertEqual(_.indexOf(None, 2), -1, 'handles nulls properly')
 
     def test_range(self):
-        self.assertEqual(list(_.range(0)), [], 'range with 0 as a first argument generates an empty array')
-        self.assertEqual(list(_.range(4)), [0, 1, 2, 3], 'range with a single positive argument generates an array of elements 0,1,2,...,n-1')
-        self.assertEqual(list(_.range(5, 8)), [5, 6, 7], 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1')
-        self.assertEqual(list(_.range(8, 5)), [], 'range with two arguments a & b, b<a generates an empty array')
-        self.assertEqual(list(_.range(3, 10, 3)), [3, 6, 9], 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c')
-        self.assertEqual(list(_.range(3, 10, 15)), [3], 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a')
-        self.assertEqual(list(_.range(12, 7, -2)), [12, 10, 8], 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b')
-        self.assertEqual(list(_.range(0, -10, -1)), [0, -1, -2, -3, -4, -5, -6, -7, -8, -9], 'final example in the Python docs')
+        self.assertEqual(
+            list(_.range(0)), [], 'range with 0 as a first argument'
+                                  ' generates an empty array')
+        self.assertEqual(list(_.range(4)), [0, 1, 2, 3],
+                         'range with a single positive argument generates'
+                         ' an array of elements 0,1,2,...,n-1')
+        self.assertEqual(list(_.range(5, 8)),
+                         [5, 6, 7], 'range with two arguments a & b,'
+                         ' a<b generates an array of elements '
+                         ' a,a+1,a+2,...,b-2,b-1')
+        self.assertEqual(list(_.range(8, 5)),
+                         [], 'range with two arguments a & b, b<a'
+                         ' generates an empty array')
+        self.assertEqual(list(_.range(3, 10, 3)),
+                         [3, 6, 9], 'range with three arguments a & b'
+                         ' & c, c < b-a, a < b generates an array '
+                         ' of elements a,a+c,a+2c,...,b - (multiplier of a) '
+                         ' < c')
+        self.assertEqual(list(_.range(3, 10, 15)),
+                         [3], 'range with three arguments a & b &'
+                         ' c, c > b-a, a < b generates an array with '
+                         'a single element, equal to a')
+        self.assertEqual(list(_.range(12, 7, -2)), [12, 10, 8],
+                         'range with three arguments a & b & c, a'
+                         ' > b, c < 0 generates an array of elements'
+                         ' a,a-c,a-2c and ends with the number not less than b')
+        self.assertEqual(list(_.range(0, -10, -1)),
+                         [0, -1, -2, -3, -4, -5, -6, -7, -8, -9], 'final'
+                         ' example in the Python docs')
 
 if __name__ == "__main__":
-    print ("run these tests by executing `python -m unittest discover` in unittests folder")
+    print("run these tests by executing `python -m unittest"
+          " discover` in unittests folder")
     unittest.main()