Improve design patterns code

Author: andrelbd1

design_patterns/command/code.py

@@ -1,33 +1,38 @@
 from abc import ABCMeta
 
+
 class Command(metaclass=ABCMeta):
-    def __init__(self,recv):
-        self.recv=recv
+    def __init__(self, recv):
+        self.recv = recv
 
     def execute(self):
         pass
 
+
 class ConcreteCommand(Command):
-    def __init__(self,recv):
-        self.recv=recv
+    def __init__(self, recv):
+        self.recv = recv
 
     def execute(self):
         self.recv.action()
 
+
 class Receiver:
     def action(self):
         print("Receiver Action")
 
+
 class Invoker:
-    def command(self,cmd):
-        self.cmd=cmd
-    
+    def command(self, cmd):
+        self.cmd = cmd
+
     def execute(self):
         self.cmd.execute()
 
+
 if __name__ == "__main__":
-    recv=Receiver()
-    cmd=ConcreteCommand(recv)
-    invoker=Invoker()
+    recv = Receiver()
+    cmd = ConcreteCommand(recv)
+    invoker = Invoker()
     invoker.command(cmd)
-    invoker.execute()
+    invoker.execute()

design_patterns/command/real.py

@@ -1,47 +1,52 @@
 from abc import ABCMeta, abstractmethod
 
+
 class Order(metaclass=ABCMeta):
     @abstractmethod
     def execute(self):
         pass
 
+
 class BuyStockOrder(Order):
-    def __init__(self,stock):
-        self.stock=stock
-    
+    def __init__(self, stock):
+        self.stock = stock
+
     def execute(self):
         self.stock.buy()
 
+
 class SellStockOrder(Order):
-    def __init__(self,stock):
-        self.stock=stock
-    
+    def __init__(self, stock):
+        self.stock = stock
+
     def execute(self):
         self.stock.sell()
 
+
 class StockTrade:
     def buy(self):
         print("You will buy stocks")
 
     def sell(self):
         print("You will sell stocks")
 
+
 class Agent:
     def __init__(self):
-        self.__orderQueue=[]
+        self.__orderQueue = []
 
-    def placeOrder(self,order):
+    def placeOrder(self, order):
         self.__orderQueue.append(order)
         order.execute()
 
 
-if __name__=="__main__":
-    #Cliente
-    stock=StockTrade()
-    buyStock=BuyStockOrder(stock)
-    sellStock=SellStockOrder(stock)
+if __name__ == "__main__":
+    # Client
+    stock = StockTrade()
+    buyStock = BuyStockOrder(stock)
+    sellStock = SellStockOrder(stock)
 
-    #Chamador
-    agent=Agent()
+    # Agent
+    agent = Agent()
     agent.placeOrder(buyStock)
-    agent.placeOrder(sellStock)
+    agent.placeOrder(sellStock)

design_patterns/command/wizard.py

@@ -1,23 +1,25 @@
 class Wizard():
-    def __init__(self,src,rootdir):
-        self.choices=[]
-        self.rootdir=rootdir
-        self.src=src
+    def __init__(self, src, rootdir):
+        self.choices = []
+        self.rootdir = rootdir
+        self.src = src
 
-    def preferences(self,command):
+    def preferences(self, command):
         self.choices.append(command)
 
     def execute(self):
         for choice in self.choices:
             if list(choice.values())[0]:
-                print("Copying binaries --",self.src,"to ",self.rootdir)
+                print(f"Copying binaries -- {self.src} to {self.rootdir}")
             else:
                 print("No Operation")
 
+
 if __name__ == '__main__':
-    ##Código do cliente
-    wizard = Wizard('python3.8.zip','/usr/bin')
-    ##Os usuários escolhem instalar somente Python
-    wizard.preferences({'python':True})
-    wizard.preferences({'java':False})
-    wizard.execute()
+    # Client code
+    wizard = Wizard('python3.8.zip', '/usr/bin')
+
+    # Users prefer to install only Python
+    wizard.preferences({'python': True})
+    wizard.preferences({'java': False})
+    wizard.execute()

design_patterns/facade/code.py

@@ -65,5 +65,6 @@ def __del__(self):
         print("You:: Thanks to Event Manager, all preparations done! Phew!")
 
 
-you = You()
-you.askEventManager()
+if __name__ == "__main__":
+    you = You()
+    you.askEventManager()

design_patterns/factory/abstract_factory.py

@@ -1,21 +1,24 @@
 from abc import ABCMeta, abstractmethod
 
+
 class PizzaFactory(metaclass=ABCMeta):
     @abstractmethod
     def createVegPizza(self):
         pass
-    
+
     @abstractmethod
     def createNonVegPizza(self):
         pass
 
+
 class IndianPizzaFactory(PizzaFactory):
     def createVegPizza(self):
         return DeluxVeggiePizza()
 
     def createNonVegPizza(self):
         return ChickenPizza()
 
+
 class USPizzaFactory(PizzaFactory):
     def createVegPizza(self):
         return MexicanVegPizza()
@@ -24,35 +27,38 @@ def createNonVegPizza(self):
         return HamPizza()
 
 
-
 class VegPizza(metaclass=ABCMeta):
     @abstractmethod
     def prepare(self, VegPizza):
         pass
 
+
 class NonVegPizza(metaclass=ABCMeta):
     @abstractmethod
     def serve(self, VegPizza):
         pass
 
+
 class DeluxVeggiePizza(VegPizza):
     def prepare(self):
         print("Prepare", type(self).__name__)
 
+
 class ChickenPizza(NonVegPizza):
     def serve(self, VegPizza):
-        print(type(self).__name__," is served with Chicken on ", type(VegPizza).__name__)
+        print(type(self).__name__, " is served with Chicken on ", type(VegPizza).__name__)
+
 
 class MexicanVegPizza(VegPizza):
     def prepare(self):
         print("Prepare", type(self).__name__)
 
+
 class HamPizza(NonVegPizza):
-    def serve(self,VegPizza):
+    def serve(self, VegPizza):
         print(type(self).__name__, " is served with Ham on ", type(VegPizza).__name__)
 
 
-
 class PizzaStore:
     def __init__(self):
         pass
@@ -65,5 +71,7 @@ def makePizza(self):
             self.VegPizza.prepare()
             self.NonVegPizza.serve(self.VegPizza)
 
-pizza = PizzaStore()
-pizza.makePizza()
+
+if __name__ == "__main__":
+    pizza = PizzaStore()
+    pizza.makePizza()

design_patterns/factory/factory_method.py

@@ -1,31 +1,35 @@
 from abc import ABCMeta, abstractmethod
 
+
 class Section(metaclass=ABCMeta):
     @abstractmethod
     def describe(self):
         pass
 
+
 class PersonalSection(Section):
     def describe(self):
         print("Personal Section")
 
+
 class AlbumSection(Section):
     def describe(self):
         print("Album Section")
 
+
 class PatentSection(Section):
     def describe(self):
         print("Patent Section")
 
+
 class PublicationSection(Section):
     def describe(self):
         print("Publication Section")
 
 
-
 class Profile(metaclass=ABCMeta):
     def __init__(self):
-        self.sections=[]
+        self.sections = []
         self.createProfile()
 
     @abstractmethod
@@ -38,12 +42,14 @@ def getSections(self):
     def addSections(self, section):
         self.sections.append(section)
 
+
 class linkedin(Profile):
     def createProfile(self):
         self.addSections(PersonalSection())
         self.addSections(PatentSection())
         self.addSections(PublicationSection())
 
+
 class facebook(Profile):
     def createProfile(self):
         self.addSections(PersonalSection())
@@ -54,4 +60,4 @@ def createProfile(self):
     profile_type = input("Which Profile you'd like to create? [Linkedin or Facebook]")
     profile = eval(profile_type.lower())()
     print("Creating Profile..", type(profile).__name__)
-    print("Profile has sections --", profile.getSections())
+    print("Profile has sections --", profile.getSections())

design_patterns/factory/simple_factory.py

@@ -1,24 +1,28 @@
 from abc import ABCMeta, abstractmethod
 
+
 class Animal(metaclass=ABCMeta):
     @abstractmethod
     def do_say(self):
         pass
 
+
 class Dog(Animal):
     def do_say(self):
         print("Au!!")
 
+
 class Cat(Animal):
     def do_say(self):
         print("Miau!!")
 
+
 class ForestFactory(object):
     def make_sound(self, object_type):
         return eval(object_type)().do_say()
 
 
-if __name__=='__main__':
-    ff=ForestFactory()
-    animal=input("Which animal should make sound Dog or Cat?")
-    ff.make_sound(animal)
+if __name__ == '__main__':
+    ff = ForestFactory()
+    animal = input("Which animal should make sound Dog or Cat?")
+    ff.make_sound(animal)

design_patterns/observer/code.py

@@ -2,7 +2,7 @@ class Subject:
     def __init__(self):
         self.__observers = []
 
-    def register(self,observer):
+    def register(self, observer):
         self.__observers.append(observer)
 
     def notifyAll(self, *args, **kwargs):
@@ -15,18 +15,19 @@ def __init__(self, subject):
         subject.register(self)
 
     def listen(self, subject, *args):
-        print(type(self).__name__,':: Got',args,'From',subject)
+        print(type(self).__name__, ':: Got', args, 'From', subject)
 
 
 class Observer2:
     def __init__(self, subject):
         subject.register(self)
 
     def listen(self, subject, *args):
-        print(type(self).__name__,':: Got',args,'From',subject)
+        print(type(self).__name__, ':: Got', args, 'From', subject)
 
 
-subject = Subject()
-observer1 = Observer1(subject)
-observer2 = Observer2(subject)
-subject.notifyAll('notification')
+if __name__ == "__main__":
+    subject = Subject()
+    observer1 = Observer1(subject)
+    observer2 = Observer2(subject)
+    subject.notifyAll('notification')