merge with faif/master

Author: fkromer

builder.py

@@ -31,6 +31,11 @@ def __init__(self):
     def new_building(self):
         self.building = Building()
 
+    def build_floor(self):
+        raise NotImplementedError
+
+    def build_size(self):
+        raise NotImplementedError
 
 # Concrete Builder
 class BuilderHouse(Builder):

catalog.py

@@ -75,7 +75,7 @@ def _instance_method_2(self):
 
     def main_method(self):
         """
-        will execute either _instance_method_1 or _instance_method_1
+        will execute either _instance_method_1 or _instance_method_2
         depending on self.param value
         """
         self._instance_method_choices[self.param].__get__(self)()
@@ -111,7 +111,7 @@ def _class_method_2(cls):
 
     def main_method(self):
         """
-        will execute either _instance_method_1 or _instance_method_1
+        will execute either _class_method_1 or _class_method_2
         depending on self.param value
         """
         self._class_method_choices[self.param].__get__(None, self.__class__)()
@@ -143,7 +143,7 @@ def _static_method_2():
 
     def main_method(self):
         """
-        will execute either _instance_method_1 or _instance_method_1
+        will execute either _static_method_1 or _static_method_2
         depending on self.param value
         """
         self._static_method_choices[self.param].__get__(None, self.__class__)()

chain.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""http://www.testingperspective.com/wiki/doku.php/collaboration/chetan/designpatternsinpython/chain-of-responsibilitypattern"""
 """http://www.dabeaz.com/coroutines/"""
 
 import time

delegation_pattern.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Reference: https://en.wikipedia.org/wiki/Delegation_pattern
+Author: https://github.com/IuryAlves
+"""
+
+
+class Delegator(object):
+    """
+    >>> delegator = Delegator(Delegate())
+    >>> delegator.do_something("nothing")
+    'Doing nothing'
+    >>> delegator.do_anything()
+
+    """
+    def __init__(self, delegate):
+        self.delegate = delegate
+
+    def __getattr__(self, name):
+        def wrapper(*args, **kwargs):
+            if hasattr(self.delegate, name):
+                attr = getattr(self.delegate, name)
+                if callable(attr):
+                    return attr(*args, **kwargs)
+        return wrapper
+
+
+class Delegate(object):
+
+    def do_something(self, something):
+        return "Doing %s" % something
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

facade.py

@@ -56,7 +56,7 @@ def __init__(self):
         self.tc1 = TC1()
         self.tc2 = TC2()
         self.tc3 = TC3()
-        self.tests = [i for i in (self.tc1, self.tc2, self.tc3)]
+        self.tests = [self.tc1, self.tc2, self.tc3]
 
     def runAll(self):
         [i.run() for i in self.tests]

hsm.py

@@ -0,0 +1,181 @@
+"""
+Implementation of the HSM (hierachrical state machine) or
+NFSM (nested finite state machine) C++ example from
+http://www.eventhelix.com/RealtimeMantra/HierarchicalStateMachine.htm#.VwqLVEL950w
+in Python
+
+- single source 'message type' for state transition changes
+- message type considered, messages (comment) not considered to avoid complexity
+"""
+
+
+class UnsupportedMessageType(BaseException):
+    pass
+
+
+class UnsupportedState(BaseException):
+    pass
+
+
+class UnsupportedTransition(BaseException):
+    pass
+
+
+class HierachicalStateMachine(object):
+
+    def __init__(self):
+        self._active_state = Active(self)  # Unit.Inservice.Active()
+        self._standby_state = Standby(self)  # Unit.Inservice.Standby()
+        self._suspect_state = Suspect(self)  # Unit.OutOfService.Suspect()
+        self._failed_state = Failed(self)  # Unit.OutOfService.Failed()
+        self._current_state = self._standby_state
+        self.states = {'active': self._active_state,
+                       'standby': self._standby_state,
+                       'suspect': self._suspect_state,
+                       'failed': self._failed_state}
+        self.message_types = {'fault trigger': self._current_state.on_fault_trigger,
+                              'switchover': self._current_state.on_switchover,
+                              'diagnostics passed': self._current_state.on_diagnostics_passed,
+                              'diagnostics failed': self._current_state.on_diagnostics_failed,
+                              'operator inservice': self._current_state.on_operator_inservice}
+
+    def _next_state(self, state):
+        try:
+            self._current_state = self.states[state]
+        except KeyError:
+            raise UnsupportedState
+
+    def _send_diagnostics_request(self):
+        return 'send diagnostic request'
+
+    def _raise_alarm(self):
+        return 'raise alarm'
+
+    def _clear_alarm(self):
+        return 'clear alarm'
+
+    def _perform_switchover(self):
+        return 'perform switchover'
+
+    def _send_switchover_response(self):
+        return 'send switchover response'
+
+    def _send_operator_inservice_response(self):
+        return 'send operator inservice response'
+
+    def _send_diagnostics_failure_report(self):
+        return 'send diagnostics failure report'
+
+    def _send_diagnostics_pass_report(self):
+        return 'send diagnostics pass report'
+
+    def _abort_diagnostics(self):
+        return 'abort diagnostics'
+
+    def _check_mate_status(self):
+        return 'check mate status'
+
+    def on_message(self, message_type):  # message ignored
+        if message_type in self.message_types.keys():
+            self.message_types[message_type]()
+        else:
+            raise UnsupportedMessageType
+
+
+class Unit(object):
+
+    def __init__(self, HierachicalStateMachine):
+        self.hsm = HierachicalStateMachine
+
+    def on_switchover(self):
+        raise UnsupportedTransition
+
+    def on_fault_trigger(self):
+        raise UnsupportedTransition
+
+    def on_diagnostics_failed(self):
+        raise UnsupportedTransition
+
+    def on_diagnostics_passed(self):
+        raise UnsupportedTransition
+
+    def on_operator_inservice(self):
+         raise UnsupportedTransition
+
+
+class Inservice(Unit):
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+
+    def on_fault_trigger(self):
+        self._hsm._next_state('suspect')
+        self._hsm._send_diagnostics_request()
+        self._hsm._raise_alarm()
+
+    def on_switchover(self):
+        self._hsm._perform_switchover()
+        self._hsm._check_mate_status()
+        self._hsm._send_switchover_response()
+
+
+class Active(Inservice):
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+
+    def on_fault_trigger(self):
+        super(Active, self).perform_switchover()
+        super(Active, self).on_fault_trigger()
+
+    def on_switchover(self):
+        self._hsm.on_switchover()  # message ignored
+        self._hsm.next_state('standby')
+
+
+class Standby(Inservice):
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+
+    def on_switchover(self):
+        super(Standby, self).on_switchover() #message ignored
+        self._hsm._next_state('active')
+
+
+class OutOfService(Unit):
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+
+    def on_operator_inservice(self):
+        self._hsm.on_switchover()  # message ignored
+        self._hsm.send_operator_inservice_response()
+        self._hsm.next_state('suspect')
+
+
+class Suspect(OutOfService):
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+
+    def on_diagnostics_failed(self):
+        super(Suspect, self).send_diagnostics_failure_report()
+        super(Suspect, self).next_state('failed')
+
+    def on_diagnostics_passed(self):
+        super(Suspect, self).send_diagnostics_pass_report()
+        super(Suspect, self).clear_alarm()  # loss of redundancy alarm
+        super(Suspect, self).next_state('standby')
+
+    def on_operator_inservice(self):
+        super(Suspect, self).abort_diagnostics()
+        super(Suspect, self).on_operator_inservice()  # message ignored
+
+
+class Failed(OutOfService):
+    '''No need to override any method.'''
+
+    def __init__(self, HierachicalStateMachine):
+        self._hsm = HierachicalStateMachine
+