Added object creation and SOLID example.

Author: Arjan Egges

.gitignore

@@ -1,2 +1,3 @@
 # misc
-.DS_Store
+.DS_Store
+*.pyc

10 - object creation/object-pool-context.py

@@ -0,0 +1,50 @@
+from typing import List
+
+class PoolManager():
+    def __init__(self, pool):
+        self.pool = pool
+    def __enter__(self):
+        self.obj = self.pool.acquire()
+        return self.obj
+    def __exit__(self, type, value, traceback):
+        self.pool.release(self.obj)
+
+class Reusable:
+    def test(self):
+        print(f"Using object {id(self)}")
+
+class ReusablePool:
+
+    free: List[Reusable]
+    in_use: List[Reusable]
+
+    def __init__(self, size):
+        self.size = size
+        self.free = []
+        self.in_use = []
+        for _ in range(0, size):
+            self.free.append(Reusable())
+
+    def acquire(self) -> Reusable:
+        assert len(self.free) > 0
+        r = self.free[0]
+        self.free.remove(r)
+        self.in_use.append(r)
+        return r
+
+    def release(self, r: Reusable):
+        self.in_use.remove(r)
+        self.free.append(r)
+
+    def set_size(self, size: int):
+        self.size = size
+
+
+# Create reusable pool
+pool= ReusablePool(2)
+
+with PoolManager(pool) as r:
+    r.test()
+
+with PoolManager(pool) as r2:
+    r2.test()

10 - object creation/object-pool.py

@@ -0,0 +1,44 @@
+from typing import List
+
+
+
+class Reusable:
+    def test(self):
+        print(f"Using object {id(self)}")
+
+class ReusablePool:
+
+    free: List[Reusable]
+    in_use: List[Reusable]
+
+    def __init__(self, size):
+        self.size = size
+        self.free = []
+        self.in_use = []
+        for _ in range(0, size):
+            self.free.append(Reusable())
+
+    def acquire(self) -> Reusable:
+        assert len(self.free) > 0
+        r = self.free[0]
+        self.free.remove(r)
+        self.in_use.append(r)
+        return r
+
+    def release(self, r: Reusable):
+        self.in_use.remove(r)
+        self.free.append(r)
+
+    def set_size(self, size: int):
+        self.size = size
+
+pool = ReusablePool(2)
+r = pool.acquire()
+r2 = pool.acquire()
+
+r.test()
+r2.test()
+
+pool.release(r2)
+r3 = pool.acquire()
+r3.test()

10 - object creation/singleton.py

@@ -0,0 +1,20 @@
+class Singleton(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+        
+class Logger(metaclass=Singleton):
+    def __init__(self):
+        print("Creating Logger")
+    
+    def log(self, msg):
+        print(msg)
+
+logger = Logger()
+logger2 = Logger()
+print(logger)
+print(logger2)
+logger.log("Hello")
+logger2.log("Helloooo")

9 - solid/dependency-inversion-after.py

@@ -0,0 +1,113 @@
+from abc import ABC, abstractmethod
+
+class Order:
+    items = []
+    quantities = []
+    prices = []
+    status = "open"
+
+    def add_item(self, name, quantity, price):
+        self.items.append(name)
+        self.quantities.append(quantity)
+        self.prices.append(price)
+
+    def total_price(self):
+        total = 0
+        for i in range(len(self.prices)):
+            total += self.quantities[i] * self.prices[i]
+        return total
+
+class Authorizer(ABC):
+    @abstractmethod
+    def is_authorized(self) -> bool:
+        pass
+
+
+class Authorizer_SMS(Authorizer):
+
+    authorized = False
+
+    def verify_code(self, code):
+        print(f"Verifying SMS code {code}")
+        self.authorized = True
+
+    def is_authorized(self) -> bool:
+        return self.authorized
+
+class Authorizer_Google(Authorizer):
+
+    authorized = False
+
+    def verify_code(self, code):
+        print(f"Verifying Google auth code {code}")
+        self.authorized = True
+
+    def is_authorized(self) -> bool:
+        return self.authorized
+
+class Authorizer_Robot(Authorizer):
+
+    authorized = False
+
+    def not_a_robot(self):
+        self.authorized = True
+
+    def is_authorized(self) -> bool:
+        return self.authorized
+
+
+class PaymentProcessor(ABC):
+
+    @abstractmethod
+    def pay(self, order):
+        pass
+
+
+class DebitPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, security_code, authorizer: Authorizer):
+        self.security_code = security_code
+        self.authorizer = authorizer
+    
+    def pay(self, order):
+        if not self.authorizer.is_authorized():
+            raise Exception("Not authorized")
+        print("Processing debit payment type")
+        print(f"Verifying security code: {self.security_code}")
+        order.status = "paid"
+
+class CreditPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, security_code):
+        self.security_code = security_code
+
+    def pay(self, order):
+        print("Processing credit payment type")
+        print(f"Verifying security code: {self.security_code}")
+        order.status = "paid"
+
+class PaypalPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, email_address, authorizer: Authorizer):
+        self.email_address = email_address
+        self.authorizer = authorizer
+
+    def pay(self, order):
+        if not self.authorizer.is_authorized():
+            raise Exception("Not authorized")
+        print("Processing paypal payment type")
+        print(f"Using email address: {self.email_address}")
+        order.status = "paid"
+
+
+order = Order()
+order.add_item("Keyboard", 1, 50)
+order.add_item("SSD", 1, 150)
+order.add_item("USB cable", 2, 5)
+
+print(order.total_price())
+authorizer = Authorizer_Robot()
+# authorizer.verify_code(465839)
+authorizer.not_a_robot()
+processor = PaypalPaymentProcessor("[email protected]", authorizer)
+processor.pay(order)

9 - solid/dependency-inversion-before.py

@@ -0,0 +1,85 @@
+from abc import ABC, abstractmethod
+
+class Order:
+    items = []
+    quantities = []
+    prices = []
+    status = "open"
+
+    def add_item(self, name, quantity, price):
+        self.items.append(name)
+        self.quantities.append(quantity)
+        self.prices.append(price)
+
+    def total_price(self):
+        total = 0
+        for i in range(len(self.prices)):
+            total += self.quantities[i] * self.prices[i]
+        return total
+
+class SMSAuthorizer:
+
+    authorized = False
+
+    def verify_code(self, code):
+        print(f"Verifying SMS code {code}")
+        self.authorized = True
+
+    def is_authorized(self) -> bool:
+        return self.authorized
+
+
+class PaymentProcessor(ABC):
+
+    @abstractmethod
+    def pay(self, order):
+        pass
+
+
+class DebitPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, security_code, authorizer: SMSAuthorizer):
+        self.security_code = security_code
+        self.authorizer = authorizer
+    
+    def pay(self, order):
+        if not self.authorizer.is_authorized():
+            raise Exception("Not authorized")
+        print("Processing debit payment type")
+        print(f"Verifying security code: {self.security_code}")
+        order.status = "paid"
+
+class CreditPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, security_code):
+        self.security_code = security_code
+
+    def pay(self, order):
+        print("Processing credit payment type")
+        print(f"Verifying security code: {self.security_code}")
+        order.status = "paid"
+
+class PaypalPaymentProcessor(PaymentProcessor):
+
+    def __init__(self, email_address, authorizer: SMSAuthorizer):
+        self.email_address = email_address
+        self.authorizer = authorizer
+
+    def pay(self, order):
+        if not self.authorizer.is_authorized():
+            raise Exception("Not authorized")
+        print("Processing paypal payment type")
+        print(f"Using email address: {self.email_address}")
+        order.status = "paid"
+
+
+order = Order()
+order.add_item("Keyboard", 1, 50)
+order.add_item("SSD", 1, 150)
+order.add_item("USB cable", 2, 5)
+
+print(order.total_price())
+authorizer = SMSAuthorizer()
+# authorizer.verify_code(465839)
+processor = PaypalPaymentProcessor("[email protected]", authorizer)
+processor.pay(order)