attempt to improve landscape scores. (#6)

Author: hartym

.landscape.yml

@@ -8,3 +8,7 @@ python-targets:
 ignore-paths:
   - docs
   - examples
+pep257:
+  disable:
+    - D205
+    - D210

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright {yyyy} {name of copyright owner}
+   Copyright 2012-2017 Romain Dorgueil
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

bonobo/__init__.py

@@ -1,4 +1,27 @@
+""" Bonobo data-processing toolkit.
+
+    Bonobo is a line-by-line data-processing toolkit for python 3.5+ emphasizing simplicity and atomicity of data
+    transformations using a simple directed graph of python callables.
+
+    Read more at http://docs.bonobo-project.org/
+
+    Copyright 2012-2014 Romain Dorgueil
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+import os
 import sys
+
 from .core import *
 from .io import *
 from .util import *
@@ -8,8 +31,21 @@
 assert PY35, 'Python 3.5+ is required to use Bonobo.'
 
 # Version infos
-try:
-    with open('../version.txt') as f:
-        __version__ = f.read().strip()
-except Exception as e:
-    __version__ = 'dev'
+with open(os.path.realpath(os.path.join(os.path.dirname(__file__), '../version.txt'))) as f:
+    __version__ = f.read().strip()
+
+__all__ = [
+    'Bag',
+    'Graph',
+    'NaiveStrategy',
+    'NotModified',
+    'ProcessPoolExecutorStrategy',
+    'ThreadPoolExecutorStrategy',
+    'head',
+    'inject',
+    'log',
+    'noop',
+    'service',
+    'tee',
+    'to_json',
+]

bonobo/core/__init__.py

@@ -1,3 +1,5 @@
+""" Core required libraries. """
+
 from .bags import Bag
 from .graphs import Graph
 from .services import inject, service

bonobo/core/contexts.py

@@ -21,7 +21,7 @@ def __init__(self, graph, plugins=None):
         for i, component_context in enumerate(self):
             try:
                 component_context.outputs = [self[j].input for j in self.graph.outputs_of(i)]
-            except KeyError as e:
+            except KeyError:
                 continue
             component_context.input.on_begin = partial(component_context.send, Begin, _control=True)
             component_context.input.on_end = partial(component_context.send, End, _control=True)
@@ -55,23 +55,23 @@ def __init__(self, plugin, parent):
     def run(self):
         try:
             get_initializer(self.plugin)(self)
-        except Exception as e:
-            print('error in initializer', type(e), e)
+        except Exception as exc:
+            print('error in initializer', type(exc), exc)
 
         while self.alive:
             # todo with wrap_errors ....
 
             try:
                 self.plugin.run(self)
-            except Exception as e:
-                print('error', type(e), e)
+            except Exception as exc:
+                print('error', type(exc), exc)
 
             sleep(0.25)
 
         try:
             get_finalizer(self.plugin)(self)
-        except Exception as e:
-            print('error in finalizer', type(e), e)
+        except Exception as exc:
+            print('error in finalizer', type(exc), exc)
 
     def shutdown(self):
         self.alive = False
@@ -193,26 +193,40 @@ def step(self):
             while True:
                 try:
                     output = next(outputs)
-                except StopIteration as e:
+                except StopIteration:
                     break
                 self.send(_resolve(input_bag, output))
 
-    def run(self):
-        assert self.state is New, ('A {} can only be run once, and thus is expected to be in {} state at the '
-                                   'beginning of a run().').format(type(self).__name__, New)
+    def initialize(self):
+        assert self.state is New, ('A {} can only be run once, and thus is expected to be in {} state at '
+                                   'initialization time.').format(type(self).__name__, New)
 
         self.state = Running
+
         try:
             get_initializer(self.component)(self)
         except Exception as e:
             self.handle_error(e, traceback.format_exc())
 
+    def finalize(self):
+        assert self.state is Running, ('A {} must be in {} state at finalization time.').format(
+            type(self).__name__, Running)
+
+        self.state = Terminated
+        try:
+            get_finalizer(self.component)(self)
+        except Exception as e:
+            self.handle_error(e, traceback.format_exc())
+
+    def run(self):
+        self.initialize()
+
         while True:
             try:
                 self.step()
-            except KeyboardInterrupt as e:
+            except KeyboardInterrupt:
                 raise
-            except InactiveReadableError as e:
+            except InactiveReadableError:
                 sleep(1)
                 # Terminated, exit loop.
                 break  # BREAK !!!
@@ -221,14 +235,7 @@ def run(self):
             except Exception as e:
                 self.handle_error(e, traceback.format_exc())
 
-        assert self.state is Running, ('A {} must be in {} state when finalization starts.').format(
-            type(self).__name__, Running)
-
-        self.state = Terminated
-        try:
-            get_finalizer(self.component)(self)
-        except Exception as e:
-            self.handle_error(e, traceback.format_exc())
+        self.finalize()
 
     def handle_error(self, exc, tb):
         self.stats['err'] += 1

bonobo/core/graphs.py

@@ -20,8 +20,8 @@ def add_component(self, c):
         self.components.append(c)
         return i
 
-    def add_chain(self, *components, input=Begin):
+    def add_chain(self, *components, _input=Begin):
         for component in components:
-            next = self.add_component(component)
-            self.outputs_of(input, create=True).add(next)
-            input = next
+            _next = self.add_component(component)
+            self.outputs_of(_input, create=True).add(_next)
+            _input = _next

bonobo/core/strategies/executor.py

@@ -3,9 +3,7 @@
 from concurrent.futures import ProcessPoolExecutor
 from concurrent.futures import ThreadPoolExecutor
 
-from bonobo.core.bags import Bag
 from bonobo.core.strategies.base import Strategy
-from bonobo.util.tokens import Begin, End
 
 
 class ExecutorStrategy(Strategy):

bonobo/ext/__init__.py

@@ -0,0 +1 @@
+""" Extensions, not required. """

bonobo/ext/console/__init__.py

@@ -2,6 +2,6 @@
 from .plugin import ConsoleOutputPlugin
 
 __all__ = [
-    ConsoleOutputPlugin,
-    console_run,
+    'ConsoleOutputPlugin',
+    'console_run',
 ]

bonobo/ext/jupyter/__init__.py

@@ -7,7 +7,6 @@ def _jupyter_nbextension_paths():
 
 
 __all__ = [
-    JupyterOutputPlugin,
-    _jupyter_nbextension_paths,
-    jupyter_run,
+    'JupyterOutputPlugin',
+    'jupyter_run',
 ]