Minor enhancements on behavioral patterns

0--key · 0--key · commit ebf5de6527de · 2017-01-22T18:52:42.000+02:00
diff --git a/behavioral/catalog.py b/behavioral/catalog.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """
 A class that uses different static function depending of a parameter passed in
 init. Note the use of a single dictionary instead of multiple conditions
@@ -22,7 +21,7 @@ def __init__(self, param):
         # to be executed but that will be also used to store possible param
         # value
         self._static_method_choices = {'param_value_1': self._static_method_1,
-                                      'param_value_2': self._static_method_2}
+                                       'param_value_2': self._static_method_2}
 
         # simple test to validate param value
         if param in self._static_method_choices.keys():
@@ -72,7 +71,6 @@ def _instance_method_2(self):
     _instance_method_choices = {'param_value_1': _instance_method_1,
                                 'param_value_2': _instance_method_2}
 
-
     def main_method(self):
         """
         will execute either _instance_method_1 or _instance_method_2
@@ -123,6 +121,7 @@ class CatalogStatic:
     catalog of multiple static methods that are executed depending on an init
     parameter
     """
+
     def __init__(self, param):
         # simple test to validate param value
         if param in self._static_method_choices:
@@ -139,7 +138,7 @@ def _static_method_2():
         print("executed method 2!")
 
     _static_method_choices = {'param_value_1': _static_method_1,
-                             'param_value_2': _static_method_2}
+                              'param_value_2': _static_method_2}
 
     def main_method(self):
         """
@@ -148,6 +147,7 @@ def main_method(self):
         """
         self._static_method_choices[self.param].__get__(None, self.__class__)()
 
+
 def main():
     """
     >>> c = Catalog('param_value_1').main_method()
diff --git a/behavioral/chain.py b/behavioral/chain.py
@@ -1,20 +1,23 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """http://www.dabeaz.com/coroutines/"""
 
 import time
 import os
 import sys
 from contextlib import contextmanager
 
+
 class Handler:
+    
     def __init__(self, successor=None):
         self._successor = successor
+
     def handle(self, request):
         res = self._handle(request)
         if not res:
             self._successor.handle(request)
+
     def _handle(self, request):
         raise NotImplementedError('Must provide implementation in subclass.')
 
@@ -25,30 +28,37 @@ def _handle(self, request):
         if 0 < request <= 10:
             print('request {} handled in handler 1'.format(request))
             return True
-            
+
+
 class ConcreteHandler2(Handler):
-    
+
     def _handle(self, request):
         if 10 < request <= 20:
             print('request {} handled in handler 2'.format(request))
             return True
-        
+
+
 class ConcreteHandler3(Handler):
-    
+
     def _handle(self, request):
         if 20 < request <= 30:
             print('request {} handled in handler 3'.format(request))
             return True
+
+
 class DefaultHandler(Handler):
-    
+
     def _handle(self, request):
         print('end of chain, no handler for {}'.format(request))
         return True
 
 
 class Client:
+
     def __init__(self):
-        self.handler = ConcreteHandler1(ConcreteHandler3(ConcreteHandler2(DefaultHandler())))
+        self.handler = ConcreteHandler1(
+            ConcreteHandler3(ConcreteHandler2(DefaultHandler())))
+
     def delegate(self, requests):
         for request in requests:
             self.handler.handle(request)
@@ -61,6 +71,7 @@ def start(*args, **kwargs):
         return cr
     return start
 
+
 @coroutine
 def coroutine1(target):
     while True:
@@ -70,6 +81,7 @@ def coroutine1(target):
         else:
             target.send(request)
 
+
 @coroutine
 def coroutine2(target):
     while True:
@@ -79,6 +91,7 @@ def coroutine2(target):
         else:
             target.send(request)
 
+
 @coroutine
 def coroutine3(target):
     while True:
@@ -88,20 +101,24 @@ def coroutine3(target):
         else:
             target.send(request)
 
+
 @coroutine
 def default_coroutine():
-        while True:
-            request = yield
-            print('end of chain, no coroutine for {}'.format(request))
+    while True:
+        request = yield
+        print('end of chain, no coroutine for {}'.format(request))
+
 
 class ClientCoroutine:
+
     def __init__(self):
         self.target = coroutine1(coroutine3(coroutine2(default_coroutine())))
 
     def delegate(self, requests):
         for request in requests:
             self.target.send(request)
 
+
 def timeit(func):
 
     def count(*args, **kwargs):
@@ -111,6 +128,7 @@ def count(*args, **kwargs):
         return res
     return count
 
+
 @contextmanager
 def suppress_stdout():
     try:
@@ -126,7 +144,7 @@ def suppress_stdout():
     requests = [2, 5, 14, 22, 18, 3, 35, 27, 20]
 
     client1.delegate(requests)
-    print('-'*30)
+    print('-' * 30)
     client2.delegate(requests)
 
     requests *= 10000
diff --git a/behavioral/chaining_method.py b/behavioral/chaining_method.py
@@ -3,6 +3,7 @@
 
 from __future__ import print_function
 
+
 class Person(object):
 
     def __init__(self, name, action):
@@ -13,6 +14,7 @@ def do_action(self):
         print(self.name, self.action.name, end=' ')
         return self.action
 
+
 class Action(object):
 
     def __init__(self, name):
diff --git a/behavioral/command.py b/behavioral/command.py
@@ -4,6 +4,7 @@
 import os
 from os.path import lexists
 
+
 class MoveFileCommand(object):
 
     def __init__(self, src, dest):
diff --git a/behavioral/iterator.py b/behavioral/iterator.py
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
-"""http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/
-
-Implementation of the iterator pattern with a generator"""
+"""
+http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/
+Implementation of the iterator pattern with a generator
+"""
 
 from __future__ import print_function
 
diff --git a/behavioral/mediator.py b/behavioral/mediator.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """http://dpip.testingperspective.com/?p=28"""
 
 import random
diff --git a/behavioral/memento.py b/behavioral/memento.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """http://code.activestate.com/recipes/413838-memento-closure/"""
 
 from copy import copy, deepcopy
@@ -57,6 +56,7 @@ def transaction(*args, **kwargs):
 
 
 class NumObj(object):
+
     def __init__(self, value):
         self.value = value
 
diff --git a/behavioral/observer.py b/behavioral/observer.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """http://code.activestate.com/recipes/131499-observer-pattern/"""
 
 
diff --git a/behavioral/publish_subscribe.py b/behavioral/publish_subscribe.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """
-Reference: http://www.slideshare.net/ishraqabd/publish-subscribe-model-overview-13368808
+Reference:
+http://www.slideshare.net/ishraqabd/publish-subscribe-model-overview-13368808
 Author: https://github.com/HanWenfang
 """
 
diff --git a/behavioral/registry.py b/behavioral/registry.py
@@ -38,15 +38,14 @@ class ClassRegistree(BaseRegisteredClass):
 
         def __init__(self, *args, **kwargs):
             pass
-            
 
     print("After subclassing: ")
     for k in RegistryHolder.REGISTRY:
         print(k)
 
 ###  OUTPUT ###
-# Before subclassing: 
+# Before subclassing:
 # BaseRegisteredClass
-# After subclassing: 
+# After subclassing:
 # BaseRegisteredClass
 # ClassRegistree
diff --git a/behavioral/specification.py b/behavioral/specification.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """
 @author: Gordeev Andrey <gordeev.and.and@gmail.com>
 
@@ -28,6 +27,7 @@ def is_satisfied_by(self, candidate):
 
 
 class CompositeSpecification(Specification):
+
     @abstractmethod
     def is_satisfied_by(self, candidate):
         pass
diff --git a/behavioral/state.py b/behavioral/state.py
@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# -*- coding: utf-8 -*-
 """Implementation of the state pattern"""
 
 # http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/
diff --git a/behavioral/strategy.py b/behavioral/strategy.py
@@ -1,7 +1,8 @@
 #!/usr/bin/env python
-# http://stackoverflow.com/questions/963965/how-is-this-strategy-pattern
-# -written-in-python-the-sample-in-wikipedia
+# -*- coding: utf-8 -*-
 """
+http://stackoverflow.com/questions/963965/how-is-this-strategy-pattern
+ -written-in-python-the-sample-in-wikipedia
 In most of other languages Strategy pattern is implemented via creating some
 base strategy interface/abstract class and subclassing it with a number of
 concrete strategies (as we can see at
diff --git a/behavioral/template.py b/behavioral/template.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 """http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/
 
 An example of the Template pattern in Python"""
diff --git a/behavioral/visitor.py b/behavioral/visitor.py
@@ -1,4 +1,8 @@
-"""http://peter-hoffmann.com/2010/extrinsic-visitor-pattern-python-inheritance.html"""
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+http://peter-hoffmann.com/2010/extrinsic-visitor-pattern-python-inheritance.html
+"""
 
 
 class Node(object):
