-

cool-RR · cool-RR · commit cd41595d35a2 · 2012-05-31T14:52:28.000+03:00
diff --git a/python_toolbox/cute_iter_tools.py b/python_toolbox/cute_iter_tools.py
@@ -168,7 +168,7 @@ def iter_with(iterable, context_manager):
         
 def izip_longest(*iterables, **kwargs):
     '''
-    izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object
+    izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) -> izip_longest object
     
     Return an `izip_longest` object whose `.next()` method returns a `tuple`
     where the i-th element comes from the i-th iterable argument. The `.next()`
diff --git a/python_toolbox/emitters/emitter.py b/python_toolbox/emitters/emitter.py
@@ -149,9 +149,9 @@ def _recalculate_total_callable_outputs_recursively(self):
         # inputs `A` and `B`. `A` has input `B`. A callable output `func` was
         # just removed from `self`, so this function got called. We update the
         # cache here, then take the first input layer, which is `A` and `B` in
-        # some order. Say `B` is first. Now, we do `recalculate` on `B`, but `A`
-        # still got the cache with `func`, and `B` will take that. I need to
-        # test this.
+        # some order. Say `B` is first. Now, we do `recalculate` on `B`, but
+        # `A` still got the cache with `func`, and `B` will take that. I need
+        # to test this.
         # 
         # I have an idea how to solve it: In the getter of the cache, check the
         # cache exists, otherwise rebuild. The reason we didn't do it up to now
diff --git a/python_toolbox/emitters/emitter_system/emitter_system.py b/python_toolbox/emitters/emitter_system/emitter_system.py
@@ -35,19 +35,19 @@ class EmitterSystem(object):
     
     `EmitterSystem` offers a few advantages over using plain emitters.
     
-    There are the `bottom_emitter` and `top_emitter`, which allow, respectively,
-    to keep track of each `emit`ting that goes on, and to generate an `emit`ting
-    that affects all emitters in the system.
+    There are the `bottom_emitter` and `top_emitter`, which allow,
+    respectively, to keep track of each `emit`ting that goes on, and to
+    generate an `emit`ting that affects all emitters in the system.
     
     The `EmitterSystem` also offers a context manager,
     `.freeze_cache_rebuilding`. When you do actions using this context manager,
     the emitters will not rebuild their cache when changing their
     inputs/outputs. When the outermost context manager has exited, all the
     caches for these emitters will get rebuilt.
     '''
-    # possible future idea: there is the idea of optimizing by cutting redundant
-    # links between boxes. I'm a bit suspicious of it. The next logical step is
-    # to make inputs and outputs abstract.
+    # possible future idea: there is the idea of optimizing by cutting
+    # redundant links between boxes. I'm a bit suspicious of it. The next
+    # logical step is to make inputs and outputs abstract.
     def __init__(self):
         
         self.emitters = set()
diff --git a/python_toolbox/infinity.py b/python_toolbox/infinity.py
@@ -171,8 +171,8 @@ def __eq__(self, other):
         
         elif isinstance(other, float):
             # We're checking to see if `other` is equal to `float('inf')` or
-            # `-float('inf')`. But we must `try` it carefully, because in Python
-            # 2.5 there is no `float('inf')`.
+            # `-float('inf')`. But we must `try` it carefully, because in
+            # Python 2.5 there is no `float('inf')`.
             #
             # Todo: It seems this takes precedence over `float.__eq__`,
             # fortunately. How come this happens?
diff --git a/test_python_toolbox/test_address_tools/test_describe.py b/test_python_toolbox/test_address_tools/test_describe.py
@@ -31,8 +31,8 @@ def test_on_locally_defined_class():
     
     if python_toolbox.__version_info__ <= (0, 1, 0):
         raise nose.SkipTest("This test doesn't pass in `python_toolbox` "
-                            "version 0.1 and below, because `describe` doesn't "
-                            "support nested classes yet.")
+                            "version 0.1 and below, because `describe` :"
+                            "doesn't support nested classes yet.")
     
     result = describe(A.B)
     assert result == prefix + 'A.B'
diff --git a/test_python_toolbox/test_persistent/test_cross_process_persistent.py b/test_python_toolbox/test_persistent/test_cross_process_persistent.py
@@ -89,11 +89,12 @@ def __init__(self):
             '''Dict mapping from ints to CPPs.'''
             
         def run(self):
-            for number, item in queue_tools.iterate(self.work_queue, block=True):
+            for number, item in queue_tools.iterate(self.work_queue,
+                                                    block=True):
                 if number in self.library:
                     assert self.library[number] is item
-                    other_items = [value for (key, value) in self.library.items()
-                                   if key != number]
+                    other_items = [value for (key, value) in
+                                   self.library.items() if key != number]
                     for other_item in other_items:
                         assert other_item is not item
                     self.processed_items_queue.put(item)
diff --git a/test_python_toolbox/test_random_tools/test_random_partitions.py b/test_python_toolbox/test_random_tools/test_random_partitions.py
@@ -28,7 +28,8 @@ def assert_correct_members(partitions):
         assert_correct_members(partitions)
         
     for n_partitions in range(1, len(r)):
-        partitions = random_tools.random_partitions(r, n_partitions=n_partitions)
+        partitions = random_tools.random_partitions(r,
+                                                    n_partitions=n_partitions)
         assert len(partitions) == n_partitions
         assert_correct_members(partitions)
         
diff --git a/test_python_toolbox/third_party/forked_mapping_tests.py b/test_python_toolbox/third_party/forked_mapping_tests.py
@@ -534,8 +534,8 @@ def test_pop(self):
         d = self._empty_mapping()
         k, v = 'abc', 'def'
 
-        # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
-        # see SF bug #689659
+        # verify longs/ints get same value when key > 32 bits (for 64-bit
+        # archs) see SF bug #689659
         x = 4503599627370496L
         y = 4503599627370496
         h = self._full_mapping({x: 'anything', y: 'something else'})
