Merge pull request #3 from faif/master

merge

Author: Alan Tan

.gitignore

@@ -4,3 +4,5 @@ __pycache__
 *.egg-info/
 .tox/
 venv
+.vscode/
+.python-version

patterns/behavioral/catalog.py

@@ -12,28 +12,31 @@ class Catalog:
     parameter
     """
 
-    def __init__(self, param):
+    def __init__(self, param: str) -> None:
 
         # dictionary that will be used to determine which static method is
         # 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}
+        self._static_method_choices = {
+            "param_value_1": self._static_method_1,
+            "param_value_2": self._static_method_2,
+        }
 
         # simple test to validate param value
         if param in self._static_method_choices.keys():
             self.param = param
         else:
-            raise ValueError("Invalid Value for Param: {0}".format(param))
+            raise ValueError(f"Invalid Value for Param: {param}")
 
     @staticmethod
-    def _static_method_1():
+    def _static_method_1() -> None:
         print("executed method 1!")
 
     @staticmethod
-    def _static_method_2():
+    def _static_method_2() -> None:
         print("executed method 2!")
 
-    def main_method(self):
+    def main_method(self) -> None:
         """will execute either _static_method_1 or _static_method_2
 
         depending on self.param value
@@ -49,24 +52,27 @@ class CatalogInstance:
     parameter
     """
 
-    def __init__(self, param):
-        self.x1 = 'x1'
-        self.x2 = 'x2'
+    def __init__(self, param: str) -> None:
+        self.x1 = "x1"
+        self.x2 = "x2"
         # simple test to validate param value
         if param in self._instance_method_choices:
             self.param = param
         else:
-            raise ValueError("Invalid Value for Param: {0}".format(param))
+            raise ValueError(f"Invalid Value for Param: {param}")
 
-    def _instance_method_1(self):
-        print("Value {}".format(self.x1))
+    def _instance_method_1(self) -> None:
+        print(f"Value {self.x1}")
 
-    def _instance_method_2(self):
-        print("Value {}".format(self.x2))
+    def _instance_method_2(self) -> None:
+        print(f"Value {self.x2}")
 
-    _instance_method_choices = {'param_value_1': _instance_method_1, 'param_value_2': _instance_method_2}
+    _instance_method_choices = {
+        "param_value_1": _instance_method_1,
+        "param_value_2": _instance_method_2,
+    }
 
-    def main_method(self):
+    def main_method(self) -> None:
         """will execute either _instance_method_1 or _instance_method_2
 
         depending on self.param value
@@ -81,25 +87,28 @@ class CatalogClass:
     parameter
     """
 
-    x1 = 'x1'
-    x2 = 'x2'
+    x1 = "x1"
+    x2 = "x2"
 
-    def __init__(self, param):
+    def __init__(self, param: str) -> None:
         # simple test to validate param value
         if param in self._class_method_choices:
             self.param = param
         else:
-            raise ValueError("Invalid Value for Param: {0}".format(param))
+            raise ValueError(f"Invalid Value for Param: {param}")
 
     @classmethod
-    def _class_method_1(cls):
-        print("Value {}".format(cls.x1))
+    def _class_method_1(cls) -> None:
+        print(f"Value {cls.x1}")
 
     @classmethod
-    def _class_method_2(cls):
-        print("Value {}".format(cls.x2))
+    def _class_method_2(cls) -> None:
+        print(f"Value {cls.x2}")
 
-    _class_method_choices = {'param_value_1': _class_method_1, 'param_value_2': _class_method_2}
+    _class_method_choices = {
+        "param_value_1": _class_method_1,
+        "param_value_2": _class_method_2,
+    }
 
     def main_method(self):
         """will execute either _class_method_1 or _class_method_2
@@ -116,28 +125,32 @@ class CatalogStatic:
     parameter
     """
 
-    def __init__(self, param):
+    def __init__(self, param: str) -> None:
         # simple test to validate param value
         if param in self._static_method_choices:
             self.param = param
         else:
-            raise ValueError("Invalid Value for Param: {0}".format(param))
+            raise ValueError(f"Invalid Value for Param: {param}")
 
     @staticmethod
-    def _static_method_1():
+    def _static_method_1() -> None:
         print("executed method 1!")
 
     @staticmethod
-    def _static_method_2():
+    def _static_method_2() -> None:
         print("executed method 2!")
 
-    _static_method_choices = {'param_value_1': _static_method_1, 'param_value_2': _static_method_2}
+    _static_method_choices = {
+        "param_value_1": _static_method_1,
+        "param_value_2": _static_method_2,
+    }
 
-    def main_method(self):
+    def main_method(self) -> None:
         """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__)()
 
 
@@ -163,4 +176,5 @@ def main():
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()

patterns/creational/borg.py

@@ -25,32 +25,41 @@
 https://github.com/onetwopunch/pythonDbTemplate/blob/master/database.py
 
 *References:
-https://fkromer.github.io/python-pattern-references/design/#singleton
+- https://fkromer.github.io/python-pattern-references/design/#singleton
+- https://learning.oreilly.com/library/view/python-cookbook/0596001673/ch05s23.html
+- http://www.aleax.it/5ep.html
 
 *TL;DR
 Provides singleton-like behavior sharing state between instances.
 """
 
 
 class Borg:
-    __shared_state = {}
+    _shared_state = {}
 
     def __init__(self):
-        self.__dict__ = self.__shared_state
-        self.state = 'Init'
-
-    def __str__(self):
-        return self.state
+        self.__dict__ = self._shared_state
 
 
 class YourBorg(Borg):
-    pass
 
+    def __init__(self, state=None):
+        super().__init__()
+        if state:
+            self.state = state
+        else:
+            # initiate the first instance with default state
+            if not hasattr(self, 'state'):
+                self.state = 'Init'
+
+    def __str__(self):
+        return self.state
+        
 
 def main():
     """
-    >>> rm1 = Borg()
-    >>> rm2 = Borg()
+    >>> rm1 = YourBorg()
+    >>> rm2 = YourBorg()
 
     >>> rm1.state = 'Idle'
     >>> rm2.state = 'Running'
@@ -73,15 +82,25 @@ def main():
     >>> rm1 is rm2
     False
 
-    # Shared state is also modified from a subclass instance `rm3`
+    # New instances also get the same shared state
     >>> rm3 = YourBorg()
 
     >>> print('rm1: {0}'.format(rm1))
-    rm1: Init
+    rm1: Zombie
     >>> print('rm2: {0}'.format(rm2))
-    rm2: Init
+    rm2: Zombie
+    >>> print('rm3: {0}'.format(rm3))
+    rm3: Zombie
+
+    # A new instance can explicitly change the state during creation
+    >>> rm4 = YourBorg('Running')
+
+    >>> print('rm4: {0}'.format(rm4))
+    rm4: Running
+
+    # Existing instances reflect that change as well
     >>> print('rm3: {0}'.format(rm3))
-    rm3: Init
+    rm3: Running
     """
 
 

patterns/structural/composite.py

@@ -26,33 +26,37 @@
 Describes a group of objects that is treated as a single instance.
 """
 
+from abc import ABC, abstractmethod
+from typing import List
 
-class Graphic:
-    def render(self):
-        raise NotImplementedError("You should implement this.")
+
+class Graphic(ABC):
+    @abstractmethod
+    def render(self) -> None:
+        raise NotImplementedError("You should implement this!")
 
 
 class CompositeGraphic(Graphic):
-    def __init__(self):
-        self.graphics = []
+    def __init__(self) -> None:
+        self.graphics: List[Graphic] = []
 
-    def render(self):
+    def render(self) -> None:
         for graphic in self.graphics:
             graphic.render()
 
-    def add(self, graphic):
+    def add(self, graphic: Graphic) -> None:
         self.graphics.append(graphic)
 
-    def remove(self, graphic):
+    def remove(self, graphic: Graphic) -> None:
         self.graphics.remove(graphic)
 
 
 class Ellipse(Graphic):
-    def __init__(self, name):
+    def __init__(self, name: str) -> None:
         self.name = name
 
-    def render(self):
-        print("Ellipse: {}".format(self.name))
+    def render(self) -> None:
+        print(f"Ellipse: {self.name}")
 
 
 def main():