software-design/design-pattern.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Click [here]() to access the associated Medium article."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Singleton Pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Instance\n",
      "First Instance\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class SingletonMeta(type):\n",
    "    \"\"\"A metaclass for creating Singleton classes.\"\"\"\n",
    "\n",
    "    _instances = {}\n",
    "\n",
    "    def __call__(cls, *args, **kwargs):\n",
    "        if cls not in cls._instances:\n",
    "            # If an instance doesn't exist, create one and store it\n",
    "            instance = super().__call__(*args, **kwargs)\n",
    "            cls._instances[cls] = instance\n",
    "        return cls._instances[cls]\n",
    "\n",
    "\n",
    "class SingletonClass(metaclass=SingletonMeta):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "\n",
    "# Example usage\n",
    "singleton1 = SingletonClass(\"First Instance\")\n",
    "singleton2 = SingletonClass(\"Second Instance\")\n",
    "\n",
    "print(singleton1.value)  # Output: First Instance\n",
    "print(singleton2.value)  # Output: First Instance\n",
    "print(singleton1 is singleton2)  # Output: True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thread-safe implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance ID: 4429619728, Value: First\n",
      "Instance ID: 4429619728, Value: Second\n"
     ]
    }
   ],
   "source": [
    "import threading\n",
    "\n",
    "\n",
    "class ThreadSafeSingleton:\n",
    "    \"\"\"A thread-safe Singleton implementation.\"\"\"\n",
    "\n",
    "    _instance = None\n",
    "    _lock = threading.Lock()  # A class-level lock to ensure thread safety during instance creation\n",
    "\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        if cls._instance is None:\n",
    "            with cls._lock:  # Ensure only one thread can execute this block at a time\n",
    "                if cls._instance is None:\n",
    "                    cls._instance = super().__new__(cls)\n",
    "        return cls._instance\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "\n",
    "# Example usage\n",
    "def create_singleton_instance(value):\n",
    "    singleton = ThreadSafeSingleton(value)\n",
    "    print(f\"Instance ID: {id(singleton)}, Value: {singleton.value}\")\n",
    "\n",
    "\n",
    "# Simulating threads\n",
    "thread1 = threading.Thread(target=create_singleton_instance, args=(\"First\",))\n",
    "thread2 = threading.Thread(target=create_singleton_instance, args=(\"Second\",))\n",
    "\n",
    "thread1.start()\n",
    "thread2.start()\n",
    "\n",
    "thread1.join()\n",
    "thread2.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Factory Pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drawing a Circle\n",
      "Drawing a Square\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "# Abstract Product\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def draw(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "# Concrete Products\n",
    "class Circle(Shape):\n",
    "    def draw(self):\n",
    "        return \"Drawing a Circle\"\n",
    "\n",
    "\n",
    "class Square(Shape):\n",
    "    def draw(self):\n",
    "        return \"Drawing a Square\"\n",
    "\n",
    "\n",
    "# Factory\n",
    "class ShapeFactory:\n",
    "    @staticmethod\n",
    "    def create_shape(shape_type):\n",
    "        if shape_type == \"circle\":\n",
    "            return Circle()\n",
    "        elif shape_type == \"square\":\n",
    "            return Square()\n",
    "        else:\n",
    "            raise ValueError(f\"Unknown shape type: {shape_type}\")\n",
    "\n",
    "\n",
    "# Example usage\n",
    "circle = ShapeFactory.create_shape(\"circle\")\n",
    "square = ShapeFactory.create_shape(\"square\")\n",
    "\n",
    "print(circle.draw())  # Output: Drawing a Circle\n",
    "print(square.draw())  # Output: Drawing a Square"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorator Pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling function 'add' with arguments (5, 3) \n",
      "Function 'add' returned 8\n"
     ]
    }
   ],
   "source": [
    "# Basic Decorator Function\n",
    "def log_decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(f\"Calling function '{func.__name__}' with arguments {args if args else ''} {kwargs if kwargs else ''}\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print(f\"Function '{func.__name__}' returned {result}\")\n",
    "        return result\n",
    "\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "# Applying the decorator\n",
    "@log_decorator\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "\n",
    "# Example usage\n",
    "result = add(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorating Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<b>Hello, World!</b>\n",
      "<i><b>Hello, World!</b></i>\n"
     ]
    }
   ],
   "source": [
    "class BoldDecorator:\n",
    "    def __init__(self, text):\n",
    "        self.text = text\n",
    "\n",
    "    def render(self):\n",
    "        return f\"<b>{self.text}</b>\"\n",
    "\n",
    "\n",
    "class ItalicDecorator:\n",
    "    def __init__(self, component):\n",
    "        self.component = component\n",
    "\n",
    "    def render(self):\n",
    "        return f\"<i>{self.component.render()}</i>\"\n",
    "\n",
    "\n",
    "# Example usage\n",
    "bold = BoldDecorator(\"Hello, World!\")\n",
    "italic_bold = ItalicDecorator(bold)\n",
    "\n",
    "print(bold.render())  # Output: <b>Hello, World!</b>\n",
    "print(italic_bold.render())  # Output: <i><b>Hello, World!</b></i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strategy Pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paid $100 using Credit Card.\n",
      "Paid $200 using PayPal.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "# Abstract Strategy\n",
    "class PaymentStrategy(ABC):\n",
    "    @abstractmethod\n",
    "    def pay(self, amount):\n",
    "        pass\n",
    "\n",
    "\n",
    "# Concrete Strategies\n",
    "class CreditCardPayment(PaymentStrategy):\n",
    "    def pay(self, amount):\n",
    "        return f\"Paid ${amount} using Credit Card.\"\n",
    "\n",
    "\n",
    "class PayPalPayment(PaymentStrategy):\n",
    "    def pay(self, amount):\n",
    "        return f\"Paid ${amount} using PayPal.\"\n",
    "\n",
    "\n",
    "# Context\n",
    "class PaymentProcessor:\n",
    "    def __init__(self, strategy: PaymentStrategy):\n",
    "        self._strategy = strategy\n",
    "\n",
    "    def set_strategy(self, strategy: PaymentStrategy):\n",
    "        self._strategy = strategy\n",
    "\n",
    "    def process_payment(self, amount):\n",
    "        return self._strategy.pay(amount)\n",
    "\n",
    "\n",
    "# Example usage\n",
    "processor = PaymentProcessor(CreditCardPayment())\n",
    "print(processor.process_payment(100))  # Output: Paid $100 using Credit Card.\n",
    "\n",
    "processor.set_strategy(PayPalPayment())\n",
    "print(processor.process_payment(200))  # Output: Paid $200 using PayPal."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv3.12",
   "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}