Added SOLID - Exercise

Author: MitkoVtori

OOP/7.SOLID/SOLID - Exercise/01. Workers.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+
+
+class BaseWorker(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def work():
+        pass
+
+
+class Worker(BaseWorker):
+
+    @staticmethod
+    def work():
+        print("I'm working!!")
+
+
+class Manager:
+
+    def __init__(self):
+        self.worker = None
+
+    def set_worker(self, worker):
+        assert isinstance(worker, BaseWorker), '`worker` must be of type {}'.format(Worker)
+
+        self.worker = worker
+
+    def manage(self):
+        if self.worker is not None:
+            self.worker.work()
+
+class SuperWorker(BaseWorker):
+
+    @staticmethod
+    def work():
+        print("I work very hard!!!")
+
+
+class LazyWorker(BaseWorker):
+    ''' This is a bonus class. It is not in the conditions. '''
+
+    @staticmethod
+    def work():
+        print("Let me sleep!")
+
+
+worker = Worker()
+manager = Manager()
+manager.set_worker(worker)
+manager.manage()
+
+super_worker = SuperWorker()
+lazy_worker = LazyWorker() # bonus instance
+try:
+    manager.set_worker(super_worker)
+    manager.manage()
+
+    manager.set_worker(lazy_worker)
+    manager.manage() # bonus print
+except AssertionError:
+    print("manager fails to support super_worker....")

OOP/7.SOLID/SOLID - Exercise/02. Workers - Updated.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+import time
+
+
+class Workable(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def work():
+        pass
+
+
+class Eatable(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def eat():
+        pass
+
+
+class Worker(Workable, Eatable):
+
+    @staticmethod
+    def work():
+        print("I'm normal worker. I'm working.")
+
+    @staticmethod
+    def eat():
+        print("Lunch break....(5 secs)")
+        time.sleep(5)
+
+class SuperWorker(Workable, Eatable):
+
+    @staticmethod
+    def work():
+        print("I'm super worker. I work very hard!")
+
+    @staticmethod
+    def eat():
+        print("Lunch break....(3 secs)")
+        time.sleep(3)
+
+
+class Robot(Workable):
+
+    @staticmethod
+    def work():
+        print("I'm a robot. I'm working....")
+
+
+class BaseManager(ABC):
+
+    def __init__(self):
+        self.worker = None
+
+    @abstractmethod
+    def set_worker(self, worker):
+        pass
+
+
+class WorkManager(BaseManager):
+
+    def set_worker(self, worker):
+        assert isinstance(worker, Workable), f"`worker` must be of type {Workable}"
+
+        self.worker = worker
+
+    def manage(self):
+        self.worker.work()
+
+
+class BreakManager(BaseManager):
+
+    def set_worker(self, worker):
+        assert isinstance(worker, Eatable), f"`worker` must be of type {Eatable}"
+
+        self.worker = worker
+
+    def lunch_break(self):
+        self.worker.eat()
+
+
+work_manager = WorkManager()
+break_manager = BreakManager()
+
+worker = Worker()
+work_manager.set_worker(worker)
+break_manager.set_worker(worker)
+work_manager.manage()
+break_manager.lunch_break()
+
+super_worker = SuperWorker()
+work_manager.set_worker(super_worker)
+break_manager.set_worker(super_worker)
+work_manager.manage()
+break_manager.lunch_break()
+
+robot = Robot()
+work_manager.set_worker(robot)
+work_manager.manage()
+
+# try:
+#     break_manager.set_worker(robot)
+# except AssertionError:
+#     print("Robots don't eat")

OOP/7.SOLID/SOLID - Exercise/03. Prisoner.py

@@ -0,0 +1,37 @@
+class Person:
+
+    def __init__(self, position):
+        self.position = position
+
+
+class FreePerson(Person):
+
+    def __init__(self, position):
+        super().__init__(position)
+
+    def walk_north(self, dist):
+        self.position[1] += dist
+
+    def walk_east(self, dist):
+        self.position[0] += dist
+
+
+class Prisoner(Person):
+    PRISON_LOCATION = [3, 3]
+
+    def __init__(self):
+        super().__init__(self.PRISON_LOCATION[::])
+        self.is_free = False
+
+
+prisoner = Prisoner()
+print("The prisoner trying to walk to north by 10 and east by -3.")
+
+try:
+    prisoner.walk_north(10)
+    prisoner.walk_east(-3)
+except:
+    pass
+
+print(f"The location of the prison: {tuple(prisoner.PRISON_LOCATION)}")
+print(f"The current position of the prisoner: {tuple(prisoner.position)}")

OOP/7.SOLID/SOLID - Exercise/04. Shapes.py

@@ -0,0 +1,75 @@
+from abc import ABC, abstractmethod
+from math import pi
+
+
+class Shape(ABC):
+
+    @abstractmethod
+    def calculate_area(self):
+        pass
+
+
+class Rectangle(Shape):
+
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+    def calculate_area(self):
+        return self.width * self.height
+
+
+class Square(Shape):
+
+    def __init__(self, side):
+        self.side = side
+
+    def calculate_area(self):
+        return self.side * self.side
+
+
+class Triangle(Shape):
+
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+    def calculate_area(self):
+        return (self.width * self.height) / 2
+
+
+class Circle(Shape):
+
+    def __init__(self, radius):
+        self.radius = radius
+
+    def calculate_area(self):
+        return self.radius * self.radius * pi
+
+
+class AreaCalculator:
+
+    def __init__(self, shapes):
+
+        assert isinstance(shapes, list), "`shapes` should be of type `list`."
+        self.shapes = shapes
+
+    @property
+    def total_area(self):
+        total = 0
+        for shape in self.shapes:
+            total += shape.calculate_area()
+
+        return total
+
+
+shapes = [Rectangle(1, 6), Triangle(2, 3)]
+calculator = AreaCalculator(shapes)
+print("The total area is: ", calculator.total_area)
+
+
+
+# ''' MY TESTS '''
+# shapes = [Rectangle(2, 3), Square(5), Triangle(4, 6), Circle(2)]
+# calculator = AreaCalculator(shapes)
+# print("The \"ALL\" shapes total area is: ", calculator.total_area)

OOP/7.SOLID/SOLID - Exercise/05. Emails.py

@@ -0,0 +1,91 @@
+from abc import ABC, abstractmethod
+
+
+class IContent(ABC):
+
+    def __init__(self, text):
+        self.text = text
+
+    @abstractmethod
+    def format(self):
+        pass
+
+
+class MyContent(IContent):
+
+    def format(self):
+        return f"<MyML>{self.text}</MyML>"
+
+
+class EncryptedContent(IContent):
+
+    def format(self):
+        result = ""
+        for letter in self.text:
+            result += chr(ord(letter) + 5)
+        return result
+
+
+class MaskedContent(IContent):
+
+    def format(self):
+        return '*' * len(self.text)
+
+
+class IEmail(ABC):
+
+    @abstractmethod
+    def set_sender(self, sender):
+        pass
+
+    @abstractmethod
+    def set_receiver(self, receiver):
+        pass
+
+    @abstractmethod
+    def set_content(self, content):
+        pass
+
+
+class Email(IEmail):
+
+    def __init__(self, protocol):
+        self.protocol = protocol
+        self.__sender = None
+        self.__receiver = None
+        self.__content = None
+
+    def set_sender(self, sender):
+        self.__sender = sender
+
+    def set_receiver(self, receiver):
+        self.__receiver = receiver
+
+    def set_content(self, content):
+        self.__content = content
+
+    def __repr__(self):
+        template = "Sender: I\'m {sender}\nReceiver: I\'m {receiver}\nContent:\n{content}"
+
+        return template.format(sender=self.__sender, receiver=self.__receiver, content=self.__content.format())
+
+
+email = Email('IM')
+email.set_sender('qmal')
+email.set_receiver('james')
+content = MyContent('Hello, there!')
+email.set_content(content)
+print(email)
+
+
+# 'More tests'
+# print()
+# content = EncryptedContent('Hello, there!')
+# email.set_content(content)
+# print(email)
+#
+# print()
+#
+# content = MaskedContent('Hello, there!')
+# email.set_content(content)
+# print(email)