Merge pull request #204 from hashar/pep8-linting

Pep8 linting

1 files changed, 34 insertions, 30 deletions

diff --git a/git/test/performance/test_utils.py b/git/test/performance/test_utils.py
index 8637af48..c8d397fb 100644
--- a/git/test/performance/test_utils.py
+++ b/git/test/performance/test_utils.py
@@ -9,29 +9,33 @@ from lib import (
 
 
 class TestUtilPerformance(TestBigRepoR):
-    
+
     def test_access(self):
         # compare dict vs. slot access
         class Slotty(object):
             __slots__ = "attr"
+
             def __init__(self):
                 self.attr = 1
-                
+
         class Dicty(object):
+
             def __init__(self):
                 self.attr = 1
-                
+
         class BigSlotty(object):
             __slots__ = ('attr', ) + tuple('abcdefghijk')
+
             def __init__(self):
                 for attr in self.__slots__:
                     setattr(self, attr, 1)
-                    
+
         class BigDicty(object):
+
             def __init__(self):
                 for attr in BigSlotty.__slots__:
                     setattr(self, attr, 1)
-        
+
         ni = 1000000
         for cls in (Slotty, Dicty, BigSlotty, BigDicty):
             cli = cls()
@@ -42,7 +46,7 @@ class TestUtilPerformance(TestBigRepoR):
             elapsed = time() - st
             print >> sys.stderr, "Accessed %s.attr %i times in %s s ( %f acc / s)" % (cls.__name__, ni, elapsed, ni / elapsed)
         # END for each class type
-        
+
         # check num of sequence-acceses
         for cls in (list, tuple):
             x = 10
@@ -56,12 +60,12 @@ class TestUtilPerformance(TestBigRepoR):
             elapsed = time() - st
             na = ni * 3
             print >> sys.stderr, "Accessed %s[x] %i times in %s s ( %f acc / s)" % (cls.__name__, na, elapsed, na / elapsed)
-        # END for each sequence 
-        
+        # END for each sequence
+
     def test_instantiation(self):
         ni = 100000
         max_num_items = 4
-        for mni in range(max_num_items+1):
+        for mni in range(max_num_items + 1):
             for cls in (tuple, list):
                 st = time()
                 for i in xrange(ni):
@@ -70,11 +74,11 @@ class TestUtilPerformance(TestBigRepoR):
                     elif mni == 1:
                         cls((1,))
                     elif mni == 2:
-                        cls((1,2))
+                        cls((1, 2))
                     elif mni == 3:
-                        cls((1,2,3))
+                        cls((1, 2, 3))
                     elif mni == 4:
-                        cls((1,2,3,4))
+                        cls((1, 2, 3, 4))
                     else:
                         cls(x for x in xrange(mni))
                     # END handle empty cls
@@ -83,27 +87,27 @@ class TestUtilPerformance(TestBigRepoR):
                 print >> sys.stderr, "Created %i %ss of size %i in %f s ( %f inst / s)" % (ni, cls.__name__, mni, elapsed, ni / elapsed)
             # END for each type
         # END for each item count
-        
+
         # tuple and tuple direct
         st = time()
         for i in xrange(ni):
-            t = (1,2,3,4)
+            t = (1, 2, 3, 4)
         # END for each item
         elapsed = time() - st
         print >> sys.stderr, "Created %i tuples (1,2,3,4) in %f s ( %f tuples / s)" % (ni, elapsed, ni / elapsed)
-        
+
         st = time()
         for i in xrange(ni):
-            t = tuple((1,2,3,4))
+            t = tuple((1, 2, 3, 4))
         # END for each item
         elapsed = time() - st
         print >> sys.stderr, "Created %i tuples tuple((1,2,3,4)) in %f s ( %f tuples / s)" % (ni, elapsed, ni / elapsed)
-        
+
     def test_unpacking_vs_indexing(self):
         ni = 1000000
-        list_items = [1,2,3,4]
-        tuple_items = (1,2,3,4)
-        
+        list_items = [1, 2, 3, 4]
+        tuple_items = (1, 2, 3, 4)
+
         for sequence in (list_items, tuple_items):
             st = time()
             for i in xrange(ni):
@@ -111,14 +115,14 @@ class TestUtilPerformance(TestBigRepoR):
             # END for eac iteration
             elapsed = time() - st
             print >> sys.stderr, "Unpacked %i %ss of size %i in %f s ( %f acc / s)" % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed)
-            
+
             st = time()
             for i in xrange(ni):
                 one, two, three, four = sequence[0], sequence[1], sequence[2], sequence[3]
             # END for eac iteration
             elapsed = time() - st
             print >> sys.stderr, "Unpacked %i %ss of size %i individually in %f s ( %f acc / s)" % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed)
-            
+
             st = time()
             for i in xrange(ni):
                 one, two = sequence[0], sequence[1]
@@ -126,15 +130,15 @@ class TestUtilPerformance(TestBigRepoR):
             elapsed = time() - st
             print >> sys.stderr, "Unpacked %i %ss of size %i individually (2 of 4) in %f s ( %f acc / s)" % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed)
         # END for each sequence
-        
+
     def test_large_list_vs_iteration(self):
         # what costs more: alloc/realloc of lists, or the cpu strain of iterators ?
         def slow_iter(ni):
             for i in xrange(ni):
                 yield i
         # END slow iter - be closer to the real world
-        
-        # alloc doesn't play a role here it seems 
+
+        # alloc doesn't play a role here it seems
         for ni in (500, 1000, 10000, 20000, 40000):
             st = time()
             for i in list(xrange(ni)):
@@ -142,7 +146,7 @@ class TestUtilPerformance(TestBigRepoR):
             # END for each item
             elapsed = time() - st
             print >> sys.stderr, "Iterated %i items from list in %f s ( %f acc / s)" % (ni, elapsed, ni / elapsed)
-            
+
             st = time()
             for i in slow_iter(ni):
                 i
@@ -150,14 +154,14 @@ class TestUtilPerformance(TestBigRepoR):
             elapsed = time() - st
             print >> sys.stderr, "Iterated %i items from iterator in %f s ( %f acc / s)" % (ni, elapsed, ni / elapsed)
         # END for each number of iterations
-        
+
     def test_type_vs_inst_class(self):
         class NewType(object):
             pass
-        
+
         # lets see which way is faster
         inst = NewType()
-        
+
         ni = 1000000
         st = time()
         for i in xrange(ni):
@@ -165,7 +169,7 @@ class TestUtilPerformance(TestBigRepoR):
         # END for each item
         elapsed = time() - st
         print >> sys.stderr, "Created %i items using inst.__class__ in %f s ( %f items / s)" % (ni, elapsed, ni / elapsed)
-        
+
         st = time()
         for i in xrange(ni):
             type(inst)()