solid_design_principles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Single Responsibility Principle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UsersManager:\n",
    "    '''\n",
    "    Class managing user and generate the report\n",
    "    '''\n",
    "    def __init__(self, users_data) -> None:\n",
    "        self.data = users_data\n",
    "\n",
    "    def add_user(self, user):\n",
    "        self.data.append(user)\n",
    "\n",
    "    def remove_user(self, user):\n",
    "        self.data.remove(user)\n",
    "\n",
    "    def report_generation(self):\n",
    "        print('Users Report:')\n",
    "        for user in self.data:\n",
    "            print(user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Users Report:\n",
      "Alice\n",
      "Charlie\n"
     ]
    }
   ],
   "source": [
    "users_manager = UsersManager(['Alice', 'Bob'])\n",
    "users_manager.add_user('Charlie')\n",
    "users_manager.remove_user('Bob')\n",
    "users_manager.report_generation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UsersManager:\n",
    "    '''\n",
    "    Class managing user i.e. adding/removing user\n",
    "    '''\n",
    "    def __init__(self, users_data) -> None:\n",
    "        self.data = users_data\n",
    "\n",
    "    def add_user(self, user):\n",
    "        self.data.append(user)\n",
    "\n",
    "    def remove_user(self, user):\n",
    "        self.data.remove(user)\n",
    "\n",
    "class ReportGenerator:\n",
    "    '''\n",
    "    Class to generate the users report.\n",
    "    '''\n",
    "    @staticmethod\n",
    "    def report(users_data):\n",
    "        print('Users report')\n",
    "        for user in users_data:\n",
    "            print(user)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Users report\n",
      "Alice\n",
      "Charlie\n"
     ]
    }
   ],
   "source": [
    "users_manager = UsersManager(['Alice', 'Bob'])\n",
    "users_manager.add_user('Charlie')\n",
    "users_manager.remove_user('Bob')\n",
    "ReportGenerator.report(users_manager.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Open Closed Principle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing credit card payment of 100\n"
     ]
    }
   ],
   "source": [
    "class PaymentProcessor:\n",
    "    '''\n",
    "    On new payment method, class need to be modified\n",
    "    '''\n",
    "    def process_payment(self, payment_type, amount):\n",
    "        if payment_type == \"credit_card\":\n",
    "            self.process_credit_card_payment(amount)\n",
    "        else:\n",
    "            raise ValueError(\"Unsupported payment type\")\n",
    "\n",
    "    def process_credit_card_payment(self, amount):\n",
    "        print(f\"Processing credit card payment of {amount}\")\n",
    "\n",
    "\n",
    "processor = PaymentProcessor()\n",
    "processor.process_payment(\"credit_card\", 100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing credit card payment of 100\n",
      "Process PayPal payment of 200\n",
      "Process Bitcoin payment of 300\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "class PaymentMethod(ABC):\n",
    "    '''\n",
    "    A common interface for all payments methods.\n",
    "    '''\n",
    "    @abstractmethod\n",
    "    def process_payment(self, amount):\n",
    "        pass\n",
    "\n",
    "\n",
    "class CreditCardPayment(PaymentMethod):\n",
    "    def process_payment(self, amount):\n",
    "        print(f'Processing credit card payment of {amount}')\n",
    "\n",
    "class PayPalPayment(PaymentMethod):\n",
    "    def process_payment(self, amount):\n",
    "        print(f'Process PayPal payment of {amount}')\n",
    "\n",
    "class BitcoinPayment(PaymentMethod):\n",
    "    def process_payment(self, amount):\n",
    "        print(f'Process Bitcoin payment of {amount}')\n",
    "\n",
    "\n",
    "class PaymentProcessor:\n",
    "    '''\n",
    "    Class open for extension i.e. you can add new payment\n",
    "    methods but closed for modification i.e. you don't need \n",
    "    to change the existing code to add new functionality.\n",
    "\n",
    "    '''\n",
    "    def __init__(self) -> None:\n",
    "        self.payment_method = {}\n",
    "\n",
    "    def register_payment_method(self, payment_type, payment_method):\n",
    "        self.payment_method[payment_type] = payment_method\n",
    "\n",
    "    def process_payment(self, payment_type, amount):\n",
    "        if payment_type in self.payment_method:\n",
    "            self.payment_method[payment_type].process_payment(amount)\n",
    "        else:\n",
    "            raise ValueError(f'Unsupported payment type: {payment_type}')\n",
    "    \n",
    "\n",
    "\n",
    "processor = PaymentProcessor()\n",
    "processor.register_payment_method('credit_card', CreditCardPayment())\n",
    "processor.register_payment_method('paypal', PayPalPayment())\n",
    "processor.register_payment_method('bitcoin', BitcoinPayment())\n",
    "\n",
    "processor.process_payment('credit_card', 100)\n",
    "processor.process_payment('paypal', 200)\n",
    "processor.process_payment('bitcoin', 300)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Liskov Substitution Principle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sparrow is flying\n",
      "Penguin can't fly\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def fly(self):\n",
    "        pass\n",
    "\n",
    "class Sparrow(Bird):\n",
    "    def fly(self):\n",
    "        print('Sparrow is flying')\n",
    "\n",
    "class Penguin(Bird):\n",
    "    '''\n",
    "    Bird class have fly behaviour but they can't fly.\n",
    "    '''\n",
    "    def fly(self):\n",
    "        print('Penguin can\\'t fly')\n",
    "\n",
    "\n",
    "def make_bird_fly(bird):\n",
    "    bird.fly()\n",
    "\n",
    "\n",
    "sparrow = Sparrow()\n",
    "penguin = Penguin()\n",
    "\n",
    "make_bird_fly(sparrow)\n",
    "make_bird_fly(penguin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bird is flying\n",
      "This bird can't fly.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class FlyingBird(ABC):\n",
    "    '''\n",
    "    Separating flying behaviour of birds\n",
    "    '''\n",
    "    @abstractmethod\n",
    "    def fly(self):\n",
    "        pass\n",
    "\n",
    "class Bird:\n",
    "    '''\n",
    "    Having only common behaviours in all the birds\n",
    "    '''\n",
    "    def eat(self):\n",
    "        print('Bird is eating')\n",
    "\n",
    "class Sparrow(Bird, FlyingBird):\n",
    "    def fly(self):\n",
    "        print('Bird is flying')\n",
    "\n",
    "class Penguin(Bird):\n",
    "    def swim(self):\n",
    "        print('Bird is swimming')\n",
    "\n",
    "\n",
    "def make_bird_fly(bird):\n",
    "    if isinstance(bird, FlyingBird):\n",
    "        bird.fly()\n",
    "    else:\n",
    "        print('This bird can\\'t fly.')\n",
    "\n",
    "sparrow = Sparrow()\n",
    "penguin = Penguin()\n",
    "\n",
    "make_bird_fly(sparrow)\n",
    "make_bird_fly(penguin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Interface Segregation Principle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Human is working\n",
      "Human is eating\n",
      "Robot is working\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "class Worker(ABC):\n",
    "    @abstractmethod\n",
    "    def work(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        pass\n",
    "\n",
    "class HumanWorker(Worker):\n",
    "    def work(self):\n",
    "        print('Human is working')\n",
    "\n",
    "    def eat(self):\n",
    "        print('Human is eating')\n",
    "\n",
    "\n",
    "class RobotWorker(Worker):\n",
    "    def work(self):\n",
    "        print('Robot is working')\n",
    "\n",
    "    def eat(self):\n",
    "        '''\n",
    "        Not required for robot but we have to implement\n",
    "        '''\n",
    "        pass\n",
    "\n",
    "def manage_worker(worker):\n",
    "    worker.work()\n",
    "    worker.eat()\n",
    "\n",
    "\n",
    "human = HumanWorker()\n",
    "robot = RobotWorker()\n",
    "\n",
    "manage_worker(human)\n",
    "manage_worker(robot)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Human is working\n",
      "Robot is working\n",
      "Human is eating\n"
     ]
    }
   ],
   "source": [
    "class Workable(ABC):\n",
    "    @abstractmethod\n",
    "    def work(self):\n",
    "        pass\n",
    "\n",
    "class Eatable(ABC):\n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        pass\n",
    "\n",
    "class HumanWorker(Workable, Eatable):\n",
    "    def work(self):\n",
    "        print('Human is working')\n",
    "\n",
    "    def eat(self):\n",
    "        print('Human is eating')\n",
    "\n",
    "\n",
    "class RobotWorker(Workable):\n",
    "    def work(self):\n",
    "        print('Robot is working')\n",
    "\n",
    "def manage_worker(worker: Workable):\n",
    "    worker.work()\n",
    "    \n",
    "def manage_human(worker: Eatable):\n",
    "    worker.eat()\n",
    "\n",
    "\n",
    "human = HumanWorker()\n",
    "robot = RobotWorker()\n",
    "\n",
    "manage_worker(human)\n",
    "manage_worker(robot)\n",
    "manage_human(human)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Dependency Inversion Principle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sending email with message: Hello, Dependency Inversion Principle.\n"
     ]
    }
   ],
   "source": [
    "class EmailSender:\n",
    "    def send_email(self, message):\n",
    "        print(f\"sending email with message: {message}\")\n",
    "\n",
    "class NotificationManager:\n",
    "    '''\n",
    "    High level module directly depends on low level module\n",
    "    '''\n",
    "    def __init__(self) -> None:\n",
    "        self.email_sender = EmailSender()\n",
    "\n",
    "    def send(self, message):\n",
    "        self.email_sender.send_email(message)\n",
    "\n",
    "manager = NotificationManager()\n",
    "manager.send(\"Hello, Dependency Inversion Principle.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending email with message: Hello via Email!\n",
      "Sending SMS with message: Hello via SMS!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class NotificationSender(ABC):\n",
    "    @abstractmethod\n",
    "    def send(self, message):\n",
    "        pass\n",
    "\n",
    "class EmailSender(NotificationSender):\n",
    "    '''\n",
    "    Low level module depends on abstraction.\n",
    "    '''\n",
    "    def send(self, message):\n",
    "        print(f'Sending email with message: {message}')\n",
    "\n",
    "\n",
    "class SMSSender(NotificationSender):\n",
    "    def send(self, message):\n",
    "        print(f'Sending SMS with message: {message}')\n",
    "\n",
    "\n",
    "class NotificationManager:\n",
    "    '''\n",
    "    High level module depends on abstraction\n",
    "    '''\n",
    "    def __init__(self, sender: NotificationSender) -> None:\n",
    "        self.sender = sender\n",
    "    \n",
    "    def send(self, message):\n",
    "        self.sender.send(message)\n",
    "\n",
    "\n",
    "email_sender = EmailSender()\n",
    "sms_sender = SMSSender()\n",
    "\n",
    "email_manager = NotificationManager(email_sender)\n",
    "sms_manager = NotificationManager(sms_sender)\n",
    "\n",
    "email_manager.send('Hello via Email!')\n",
    "sms_manager.send('Hello via SMS!')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Example of @staticmethod, @classmethod**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance method accessing: I am an instance attribute\n",
      "Class method accessing: I am a class attribute\n",
      "Static method does not access instance or class attributes\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    class_attribute = \"I am a class attribute\"\n",
    "\n",
    "    def __init__(self, instance_attribute):\n",
    "        self.instance_attribute = instance_attribute\n",
    "\n",
    "    def instance_method(self):\n",
    "        return f\"Instance method accessing: {self.instance_attribute}\"\n",
    "\n",
    "    @classmethod\n",
    "    def class_method(cls):\n",
    "        return f\"Class method accessing: {cls.class_attribute}\"\n",
    "\n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        return \"Static method does not access instance or class attributes\"\n",
    "\n",
    "# Usage\n",
    "obj = MyClass(\"I am an instance attribute\")\n",
    "print(obj.instance_method())  \n",
    "print(MyClass.class_method())  \n",
    "print(MyClass.static_method())  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}