tutorials/Abstract class vs. protocols.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4f6ca0da",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff3bf2d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-26T15:52:23.080354Z",
     "start_time": "2024-04-26T15:52:23.073428Z"
    }
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "<font color=black>\n",
    "\n",
    "**What?** Abstract class vs. protocol\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee73448",
   "metadata": {},
   "source": [
    "# Motivation\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59610228",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- In Python there are two ways to define an interface/contracts, i.e. describing what methods and attributes a class will contain:\n",
    "    - **Abstract Base Classes** (ABCs) which relies on nominal subtyping and a strict class hierarchy. You always have abstract method here.\n",
    "    - **Protocols** uses structural subtyping or \"Duck typing\" (i.e. the class only has to have the same methods and attributes, no subclassing necessary).\n",
    "- In a way protocols is the same as ABC but allows you to use duct typing instead of nominal typing.\n",
    "\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f94fb67",
   "metadata": {},
   "source": [
    "# Addressing ABC Shortcomings\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeca8ac3",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black> \n",
    "\n",
    "- Protocols address some of the limitations of ABCs. Since Protocols do not rely on explicit inheritance, they offer the flexibility of defining interfaces for classes that may not be related through inheritance. This opens up opportunities for code reuse and composition in situations where multiple inheritance is required or where modifying class hierarchies is not practical.\n",
    "- Additionally, Protocols can be used to define interfaces for built-in types, third-party libraries, or classes that are not under your control. This capability is particularly valuable in situations where modifying existing classes or their inheritance hierarchy is not an option.\n",
    "\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "579bf9a9",
   "metadata": {},
   "source": [
    "# Duck Typing and Protocols\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae836a9",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black> \n",
    "\n",
    "- Python is a dynamically typed language that follows the “duck typing” principle, i.e. type of objects is determined by their behavior rather than their explicit type or class hierarchy.\n",
    "- Protocols align well with this philosophy by allowing you to specify the expected methods and attributes that an object should have, enabling effective duck typing.\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5474d796",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-26T16:11:40.631959Z",
     "start_time": "2024-04-26T16:11:40.627990Z"
    }
   },
   "source": [
    "# Protocols\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705a7a9b",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- It is common practice to use `...` in the body of methods in a Protocol instead of `pass` as we would do in the ABC, although either will work in both places.\n",
    "- Protocols allows you to define contracts for behavior without imposing rigid class hierarchies.\n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6718d1fd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-26T16:32:14.106763Z",
     "start_time": "2024-04-26T16:32:14.102394Z"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Protocol\n",
    "\n",
    "\n",
    "class Printable(Protocol):\n",
    "    def __str__(self) -> str:\n",
    "        ...\n",
    "\n",
    "\n",
    "def print_object(obj: Printable) -> None:\n",
    "    print(str(obj))\n",
    "\n",
    "\n",
    "class MyClass:\n",
    "    def __str__(self) -> str:\n",
    "        return \"This is an instance of MyClass\"\n",
    "\n",
    "\n",
    "class MyOtherClass:\n",
    "    def __repr__(self) -> str:\n",
    "        return \"This is an instance of MyOtherClass\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "57589b5f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-26T16:32:16.164246Z",
     "start_time": "2024-04-26T16:32:16.160988Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is an instance of MyClass\n",
      "This is an instance of MyOtherClass\n"
     ]
    }
   ],
   "source": [
    "# Output: This is an instance of MyClass\n",
    "print_object(MyClass())\n",
    "# No error, as MyOtherClass satisfies the Printable Protocol\n",
    "print_object(MyOtherClass())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57b9341f",
   "metadata": {},
   "source": [
    "# When to use\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b62d83ee",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- **Protocols**:\n",
    "    - Protocols focus on defining expected behavior without imposing class hierarchies.\n",
    "    - They promote flexibility, adaptability, and code reusability.\n",
    "    - Protocols are particularly useful in scenarios where multiple inheritance is needed or modifying class hierarchies is impractical.\n",
    "    - They align well with duck typing and allow for interface definition across different types and libraries.\n",
    "\n",
    "- **ABCs**:\n",
    "    - ABCs are designed to enforce the implementation of a specific interface by subclasses.\n",
    "    - They provide a mechanism for structuring and organizing code based on shared behavior.\n",
    "    - ABCs ensure interface adherence and offer a level of contract enforcement.\n",
    "    - ABCs are suitable when you have control over the class hierarchy and want to define a consistent interface across subclasses.\n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9ea2f6",
   "metadata": {},
   "source": [
    "# Conclusions\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6588571e",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-danger\">\n",
    "<font color=black>\n",
    "\n",
    "- ABCs provide a structured approach to contract enforcement within a class hierarchy.\n",
    "- Protocols offer flexibility and adaptability in defining interfaces, allowing for retroactive implementation and compatibility across different types.\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea57818f",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5530900",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "<font color=black>\n",
    "\n",
    "- https://jellis18.github.io/post/2022-01-11-abc-vs-protocol/\n",
    "- https://medium.com/@pouyahallaj/introduction-1616b3a4a637\n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad375fae",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}