update

Author: Mu5alaf

Python/abstract_factory/main.py

@@ -0,0 +1,48 @@
+class Dog:
+    
+    """one of the objects to be returuned"""
+    
+    def speak(self):
+        return "woof!"
+    
+    def color(self):
+        return "black"
+    
+    def __str__(self):
+        return "Dog"
+
+class DogFactory:
+    """Concrete Factory"""
+    
+    def get_pet(self):
+        """returns a dog objects"""
+        return Dog()
+    def get_food(self):
+        """returns a dog food objects"""
+        return "Dog food"
+
+class petStore:
+    """petStore houses our abstract factory"""
+    
+    def __init__(self,pet_factory=None):
+        """pet_factory our abstract factory"""
+        self._pet_factory = pet_factory
+        
+    def show_pet(self):
+        """utility method to display the details of objects returen """
+        
+        pet = self._pet_factory.get_pet()
+        pet_food = self._pet_factory.get_food()
+        
+        print("our pets is '{}'".format(pet))
+        print("our pets say hello by '{}'".format(pet.speak()))
+        print("its food is '{}'".format(pet_food))
+
+#create a concrete factory
+factory = DogFactory()
+
+#create a pet store housing our abstract factory
+shop = petStore(factory)
+
+#invoke the utility method to  show the details of our pet
+shop.show_pet()

Python/builder/main.py

@@ -0,0 +1,49 @@
+class Director():
+    """Director"""
+    
+    def __init__(self, builder):
+        self._builder = builder
+    
+    def construct_car(self):
+        self._builder.create_new_car()
+        self._builder.add_model()
+        self._builder.add_tires()
+        self._builder.add_engine()
+        
+    def get_car(self):
+        return self._builder.car
+
+class Builder():
+    """Abstract Builder"""
+    def __init__(self):
+        self.car = None
+    def create_new_car(self):
+        self.car = Car()
+        
+class SkyLarkBuilder(Builder):
+    """concrete builder >> provide parts and tools to work on the pairs"""
+    
+    def add_model (self):
+        self.car.model = "SKylark"
+        
+    def add_tires(self):
+        self.car.tires = "Reqular tires"
+    
+    def add_engine(self):
+        self.car.engine = "Trubo Engine"
+
+class Car():
+    """Product"""
+    def __init__(self):
+        self.model = None
+        self.tires = None
+        self.engine = None
+    
+    def __str__(self):
+        return '{} | {} | {}'.format(self.model, self.tires, self.engine)
+
+builder = SkyLarkBuilder()
+director = Director(builder)
+director.construct_car()
+car = director.get_car()
+print(car)

Python/factory/main.py

@@ -0,0 +1,43 @@
+class Dog:
+    
+    """Dog class"""
+    
+    def __init__(self,name):
+        self._name = name
+        
+    def speak(self):
+        return "woof!"
+    def color(self):
+        return "black"
+
+def get_pet(pet="dog"):
+    
+    """The Factory Method"""
+    
+    pets = dict(dog=Dog("Hope"))
+    return pets[pet]
+        
+class Cat:
+    
+    """Cat class"""
+    
+    def __init__(self,name):
+        self._name = name
+        
+    def speak(self):
+        return "meow!!"
+    def color(self):
+        return "yellow"
+
+def get_pet(pet="cat"):
+        
+    """The Factory Method"""
+        
+    pets = dict(dog=Dog("Hope"),cat=Cat("Peace"))
+    return pets[pet]
+
+d = get_pet("dog")
+print(d.speak(),d.color())
+
+c = get_pet("cat")
+print(c.speak(),c.color())

Python/prototype/main.py

@@ -0,0 +1,35 @@
+import copy
+
+class Prototype:
+    
+    def __init__(self):
+        self._objects = {}
+    
+    def register_object(self, name, obj):
+        """Register an object"""
+        self._objects[name] = obj
+    
+    def unregister_object(self, name):
+        "unregister object"
+        del self._objects[name]
+        
+    def clone(self,name, **attr):
+        """Clone a registerd object and update its attributes"""
+        obj = copy.deepcopy(self._objects.get(name))
+        obj.__dict__.update(attr)
+        return obj
+
+class Car:
+    def __init__(self):
+        self.name = "Skylark"
+        self.color = "red"
+        self.option = "EX"
+    def __str__(self):
+        return "{} | {} | {}".format(self.name,self.color,self.option)
+    
+c = Car()
+Prototype = Prototype()
+Prototype.register_object('skylark', c)
+
+c1 = Prototype.clone('skylark')
+print(c1)

Python/singletone/main.py

@@ -1,40 +1,23 @@
-class SingletonMeta(type):
+class Borg:
     """
-    The Singleton class can be implemented in different ways in Python. Some
-    possible methods include: base class, decorator, metaclass. We will use the
-    metaclass because it is best suited for this purpose.
+    the Borg design pattern
     """
-
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        """
-        Possible changes to the value of the `__init__` argument do not affect
-        the returned instance.
-        """
-        if cls not in cls._instances:
-            instance = super().__call__(*args, **kwargs)
-            cls._instances[cls] = instance
-        return cls._instances[cls]
-
-
-class Singleton(metaclass=SingletonMeta):
-    def some_business_logic(self):
-        """
-        Finally, any singleton should define some business logic, which can be
-        executed on its instance.
-        """
-
-        # ...
-
-
-if __name__ == "__main__":
-    # The client code.
-
-    s1 = Singleton()
-    s2 = Singleton()
-
-    if id(s1) == id(s2):
-        print("Singleton works, both variables contain the same instance.")
-    else:
-        print("Singleton failed, variables contain different instances.")
+    _shared_data = {} # attribute dictionary
+    
+    def __init__(self):
+        self.__dict__ = self._shared_data # make an  attribute dictionary
+        
+class Singleton(Borg):
+    """the singleton class"""
+    def __init__(self, **kwargs):
+        Borg.__init__(self)
+        self._shared_data.update(kwargs) #update the attribute dictionary by inserting a new key value pair
+        
+    def __str__(self):
+        return str(self._shared_data) # returns the attribute dictionary for printing
+        
+x  = Singleton()
+s1 = Singleton(HTTP = "Hyper Test Transfer Protocol")
+s2 = Singleton(HTTPS = "Hyper Test Transfer Protocol Secure")
+
+print(x)

README.md

@@ -17,3 +17,46 @@
 
 - Behavioral patterns
     These patterns are concerned with algorithms and the assignment of responsibilities between objects.
+
+## Creational patterns
+
+<img src="./image/factory-method-en.png" alt="Picture" width="800" height="600">
+
+1- Factory pattern
+    - is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.
+
+**Check**
+[title](https://refactoring.guru/design-patterns/factory-method)
+
+<img src="./image/abstract-factory-en.png" alt="Picture" width="800" height="600">
+
+2- Abstract Factory
+    - is a creational design pattern that lets you produce families of related objects without specifying their concrete classes.
+
+**Check**
+[title](https://refactoring.guru/design-patterns/abstract-factory)
+
+
+<img src="./image/singleton.png" alt="Picture" width="800" height="600">
+
+3- Singleton
+    - is a creational design pattern that lets you ensure that a class has only one instance, while providing a global access point to this instance.
+
+**Check**
+[title](https://refactoring.guru/design-patterns/singleton)
+
+<img src="./image/builder-en.png" alt="Picture" width="800" height="600">
+
+4- Builder
+    - is a creational design pattern that lets you construct complex objects step by step. The pattern allows you to produce different types and representations of an object using the same construction code.
+
+**Check**
+[title](https://refactoring.guru/design-patterns/builder)
+
+<img src="./image/prototype.png" alt="Picture" width="800" height="600">
+
+5- Prototype
+    - is a creational design pattern that lets you copy existing objects without making your code dependent on their classes.
+
+**Check**
+[title](https://refactoring.guru/design-patterns/prototype)