lectures/04-typing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `Практикум по программированию на языке Python`\n",
    "<br>\n",
    "\n",
    "## `Занятие 4: Основы ООП: типизация и полиморфизм, классы данных`\n",
    "<br><br>\n",
    "\n",
    "### `Роман Ищенко (roman.ischenko@gmail.com)`\n",
    "`По материалам Мурата Апишева (mel-lain@yandex.ru)`\n",
    "\n",
    "#### `Москва, 2024`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Напоминание: принципы ООП`\n",
    "\n",
    "- **Абстракция** - выделение важных свойств объекта и игнорирование прочих<br><br>\n",
    "\n",
    "- **Инкапсуляция** - хранение данных и методов работы с ними внутри одного класса с доступом к данным только через методы<br><br>\n",
    "\n",
    "- **Наследование** - возможность создания наследников, получающих все свойства родителей с возможностью их переопределения и расширения<br><br>\n",
    "\n",
    "- **Полиморфизм** - возможность использования объектов разных типов с общим интерфейсом без информации об их внутреннем устройстве"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Напоминание: класс, объект, интерфейс`\n",
    "\n",
    "- __Класс__ представляет собой тип данных (как int или str)\n",
    "- Это способ описания некоторой сущности, её состояния и возможного поведения\n",
    "- Поведение при этом зависит от состояния и может его изменять<br><br>\n",
    "- __Объект__ - это конретный представитель класса (как переменная этого типа)\n",
    "- У объекта своё состояние, изменяемое поведением\n",
    "- Поведение полностью определяется правилами, описанными в классе<br><br>\n",
    "- __Интерфейс__ - это класс, описывающий только поведение, без состояния\n",
    "- Создать объект типа интерфейса невозможно (если есть их поддержка на уровне языка)\n",
    "- Поведение полностью определяется правилами, описанными в классе\n",
    "- Вместо этого описываются классы, которые реализуют этот интерфейс и, в то же время, имеют состояние\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Абстрактные классы`\n",
    "\n",
    "- Абстрактные классы представляют собой удобное промежуточное состояние между чистым интерфейсом и полноценным классом\n",
    "- Эмулировать абстрактные классы можно с помощью методов, которые бросают исключение в своей реализации по-умолчанию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Abstract1:\n",
    "    def method(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "#Abstract1().method() -> NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Подход плох тем, что возможность создать объект класса всё равно сохраняется и ошибка произойдёт в момент обращения к методу\n",
    "- Альтернатива - класс `ABC` (на самом деле его метакласс `ABCMeta`) и декораторы `abstractmethod` из библиотеки `abc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Cls at 0x1056f7340>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Abstract(ABC):\n",
    "    @abstractmethod\n",
    "    def my_abstract_method(self):\n",
    "        ...\n",
    "\n",
    "#Abstract() -> TypeError: Can't instantiate abstract class Abstract with abstract method my_abstract_method\n",
    "\n",
    "class Cls(Abstract):\n",
    "    def my_abstract_method(self):\n",
    "        ...\n",
    "\n",
    "Cls()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Абстрактные классы`\n",
    "\n",
    "- Для версий Python ниже 3.8 есть различные версии декораторов (`@abstractstaticmethod`, `@abstractproperty`, `@abstractclassmethod`), на текущий момент язык поддерживает комбинирование декораторов (`@abstractmethod` должен находиться внутри):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Abstract(ABC):\n",
    "    @staticmethod\n",
    "    @abstractmethod\n",
    "    def my_abstract_staticmethod():\n",
    "        ...\n",
    "\n",
    "    @classmethod\n",
    "    @abstractmethod\n",
    "    def my_abstract_classmethod(cls):\n",
    "        ...\n",
    "\n",
    "    @property\n",
    "    @abstractmethod\n",
    "    def my_abstract_property(self):\n",
    "        ...\n",
    "\n",
    "    @my_abstract_property.setter\n",
    "    @abstractmethod\n",
    "    def my_abstract_property(self, val):\n",
    "        ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Аннотация типов`\n",
    "\n",
    "- Последний принцип ООП, который требуется рассмотреть - полиморфизм\n",
    "- Для обсуждение интерфейсов и полиморфизма нужно детальнее рассмотреть аннотирование типов и статическую проверку типизации\n",
    "- До появления аннотирования понятие интерфейса в Python не имело особого смысла\n",
    "\n",
    "\n",
    "- __Виды типизации__ (одна из классификаций):\n",
    "\n",
    "    1. Утиная (duck-typing)\n",
    "    2. Номинальная (nominal type system)\n",
    "    3. Структурная (structural type system)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Подход 1: утиная типизация`\n",
    "\n",
    "- \"Если что-то ведёт себя как утка, значит это - утка\"\n",
    "- Эта концепция возникает в языках с динамической типизацией (Python, JavaScript) и означает, что при использовании объекта\n",
    "    - его конкретный класс не имеет значения\n",
    "    - важны его атрибуты (поля и методы)\n",
    "- Т.е. объект принимается без каких-либо проверок, и если он имеет нужные атрибуты - код выполнится корректно, если не имеет - нет"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __eq__(self, val):\n",
    "        return True\n",
    "\n",
    "# The object with __eq__ method is expected\n",
    "print(A() == 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Пример выше показывает, что утиная типизация при отсутствии контроля типов может привести к неприятным последствиям\n",
    "- На утиной типизации основан механизм _полиморфизма_ в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Полиморфизм`\n",
    "\n",
    "- Полиморфизм позволяет работать с объектами, основываясь только на их интерфейсе, без знания типа\n",
    "- В C++ требуется, чтобы объекты полиморфных классов имели общего предка\n",
    "- В общем случае в Python это необязательно, достаточно, чтобы объекты поддерживали один интерфейс (duck-typing)\n",
    "\n",
    "Опишем для примера два класса геометрических фигур:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square:\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "    \n",
    "    def area(self):\n",
    "        return self.side ** 2\n",
    "\n",
    "class Triangle:\n",
    "    def __init__(self, a, b, c):\n",
    "        self.a, self.b, self.c = a, b, c\n",
    "\n",
    "    def area(self):\n",
    "        s = (self.a + self.b + self.c) / 2.0\n",
    "        return (s *(s - self.a) * (s - self.b) * (s - self.c)) ** 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Полиморфизм`\n",
    "\n",
    "Теперь опишем функцию, которая ожидает объекты, умеющие вычислять свою площадь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_areas(figures):\n",
    "    for figure in figures:\n",
    "        print(figure.area(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем запускать, не беспокоясь о том, что именно представляют собой входные объекты:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 1.479019945774904 "
     ]
    }
   ],
   "source": [
    "compute_areas([Square(10), Triangle(1, 3, 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Подход 2: номинальная типизация`\n",
    "\n",
    "- Совместимость типов определяется через явные декларации в коде (имена типов и иерархия наследования)\n",
    "- Такой подход используется повсеместно в языках со статической типизацией (C++, Java)\n",
    "- В случае Python этого можно добиться с помощью статической проверки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def feed(self) -> None: print('OK')\n",
    "\n",
    "class Duck(Bird):\n",
    "    def feed(self) -> None: print('OK')\n",
    "\n",
    "class Goose:\n",
    "    def feed(self) -> None: print('OK')\n",
    "\n",
    "def feed(bird: Bird) -> None:\n",
    "    bird.feed()\n",
    "\n",
    "feed(Bird())\n",
    "feed(Duck())\n",
    "#feed(Goose()) -> static check error (OK in runtime due to duck typing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Напоминание: аннотации типов`\n",
    "\n",
    "- Ранее были рассмотрены базовые примеры аннотаций для скалярных и контейнерных (generic) типов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Set\n",
    "\n",
    "def print_scalar(obj: int) -> None:\n",
    "    print(obj)\n",
    "\n",
    "def print_set(obj: Set[int]) -> None:\n",
    "    print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Возможности `typing` существенно шире. Например, он\n",
    "    - вводит новые типы (Union и т.п.)\n",
    "    - позволяет определять собственные generic-классы\n",
    "\n",
    "\n",
    "- Но для полноценного использования и изучения сперва нужно добавить статическую проверку типов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль MyPy: статическая проверка типов`\n",
    "\n",
    "- Модуль `mypy` - стандартный инструмент для статической проверки аннотированного кода на Python (ещё есть `pytype` и `pyright`)\n",
    "- Установка и использование стандартные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install mypy\n",
    "\n",
    "def check_last():\n",
    "    with open('temp.txt', 'w') as fout:\n",
    "        fout.write(In[len(In)-2])\n",
    "    !mypy temp.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.25"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(n: int = 10) -> int:\n",
    "    return n ** 2\n",
    "\n",
    "func(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:4: \u001b[1m\u001b[31merror:\u001b[m Argument 1 to \u001b[m\u001b[1m\"func\"\u001b[m has incompatible type \u001b[m\u001b[1m\"float\"\u001b[m; expected \u001b[m\u001b[1m\"int\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 1 error in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Тип Union`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Union, List, Set\n",
    "\n",
    "def func(x: Union[List[int], Set[str]]) -> None:\n",
    "    ...\n",
    "\n",
    "func([1, 2, 3])\n",
    "func({1, 2, 3})\n",
    "func({'s', 't', 'r'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:7: \u001b[1m\u001b[31merror:\u001b[m Argument 1 to <set> has incompatible type \u001b[m\u001b[1m\"int\"\u001b[m; expected \u001b[m\u001b[1m\"str\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "temp.txt:7: \u001b[1m\u001b[31merror:\u001b[m Argument 2 to <set> has incompatible type \u001b[m\u001b[1m\"int\"\u001b[m; expected \u001b[m\u001b[1m\"str\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "temp.txt:7: \u001b[1m\u001b[31merror:\u001b[m Argument 3 to <set> has incompatible type \u001b[m\u001b[1m\"int\"\u001b[m; expected \u001b[m\u001b[1m\"str\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 3 errors in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Тип Any`\n",
    "\n",
    "- Тип `Any` говорит о том, что в этом месте может быть произвольный тип, и проверка кода игнорирует все, связанное с переменной типа `Any`\n",
    "\n",
    "\n",
    "- Для `Any` верны следующие утверждения:\n",
    "    - любой объект является объектом типа `Any`\n",
    "    - любой класс является подклассом типа `Any`\n",
    "    - `Any` и `object` являются подклассами друг друга\n",
    "\n",
    "\n",
    "- Несмотря на схожесть, `Any` и `object` - это не одно и то же - тип `object` ограничивает множество операций теми, что допускает `object`, а `Any` допускает всё:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any\n",
    "\n",
    "def func_any(x: Any) -> None: x.nothing()\n",
    "def func_object(x: object) -> None: x.nothing()\n",
    "\n",
    "# func_any(None)\n",
    "# func_object(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:4: \u001b[1m\u001b[31merror:\u001b[m \u001b[m\u001b[1m\"object\"\u001b[m has no attribute \u001b[m\u001b[1m\"nothing\"\u001b[m  \u001b[m\u001b[33m[attr-defined]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 1 error in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Тип Optional`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, List\n",
    "\n",
    "def func(x: Optional[List[int]]) -> None:\n",
    "    ...\n",
    "\n",
    "func([1, 2, 3])\n",
    "func(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success: no issues found in 1 source file\r\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python 3.10+ допускается синтаксис с \"|\" (в то же смысле, что и в TypeScript):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x: list[int] | None) -> None:\n",
    "    ...\n",
    "\n",
    "func([1, 2, 3])\n",
    "func(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[32mSuccess: no issues found in 1 source file\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Тип Literal`\n",
    "\n",
    "- Тип `Literal` параметризуется не другим типом, а конкретным значением"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Literal\n",
    "\n",
    "def func(x: Literal[3], y: Literal['something']) -> None:\n",
    "    ...\n",
    "\n",
    "func(3, 'something')\n",
    "func(4, 'nothing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:7: \u001b[1m\u001b[31merror:\u001b[m Argument 1 to \u001b[m\u001b[1m\"func\"\u001b[m has incompatible type \u001b[m\u001b[1m\"Literal[4]\"\u001b[m; expected \u001b[m\u001b[1m\"Literal[3]\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "temp.txt:7: \u001b[1m\u001b[31merror:\u001b[m Argument 2 to \u001b[m\u001b[1m\"func\"\u001b[m has incompatible type \u001b[m\u001b[1m\"Literal['nothing']\"\u001b[m; expected \u001b[m\u001b[1m\"Literal['something']\"\u001b[m  \u001b[m\u001b[33m[arg-type]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 2 errors in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Определение собственных generic типов`\n",
    "\n",
    "- Функция `TypeVar` позволяет получить ссылку на тип переменной, имя которой было подано в качестве параметра\n",
    "- Ссылка на тип параметра позволяет создавать новые generic типы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import TypeVar, Generic, List\n",
    "\n",
    "T = TypeVar('T')\n",
    "\n",
    "class Stack(Generic[T]):\n",
    "    def __init__(self) -> None:\n",
    "        self.items: List[T] = []  \n",
    "\n",
    "    def push(self, item: T) -> None:\n",
    "        self.items.append(item)\n",
    "\n",
    "stack: Stack[int] = Stack()\n",
    "stack.push(10)\n",
    "stack.push('10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:10: \u001b[1m\u001b[31merror:\u001b[m Name \u001b[m\u001b[1m\"show\"\u001b[m is not defined  \u001b[m\u001b[33m[name-defined]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 1 error in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Подход 3: структурная типизация`\n",
    "\n",
    "- Совместимость типов определяется на основе структуры типов, а не на явных декларациях\n",
    "- Этот подход аналогичен утиной типизации за исключением того, что проверка является статической, а не динамической, это обеспечивает корректность типов без необходимости явных наследований, что повышает гибкость кода и независимость модулей и классов\n",
    "- Структурная типизация используется в TypeScript и Go\n",
    "\n",
    "\n",
    "- Python допускает использование структурной типизации с версии 3.8, для чего требуются аннотирование типов и _протоколы_\n",
    "- Протокол по сути является интерфейсом, которому объект должен удовлетворять для совместимости типов\n",
    "\n",
    "\n",
    "- В модуле `typing` есть много стандартных протоколов, например:\n",
    "    - Mapping\n",
    "    - Iterable\n",
    "    - Callable\n",
    "    - Hashable\n",
    "    - Reversible\n",
    "    - ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Примеры использования протоколов`\n",
    "\n",
    "- Протокол `Callable` требует наличия у реализации интерфейса метода `__call__`\n",
    "- Протокол `Mapping` требует наличия у реализации интерфейса метода `__getitem__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Callable\n",
    "\n",
    "def func(f: Callable[[int, int], bool]) -> bool:\n",
    "    return f(1,2)\n",
    "\n",
    "func(lambda x, y: x == y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Mapping\n",
    "\n",
    "def func(m: Mapping[str, int], key: str) -> bool:\n",
    "    return m[key]\n",
    "\n",
    "func({'k': 0}, 'k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Определение собственного протокола`\n",
    "\n",
    "- Этот и следующий пример взяты из статьи [https://habr.com/ru/post/557898](https://habr.com/ru/post/557898)\n",
    "\n",
    "Определим протокол и корректную его реализацию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Protocol\n",
    "\n",
    "class Figure(Protocol):\n",
    "    name: str\n",
    "\n",
    "    def calculate_area(self) -> float: pass\n",
    "\n",
    "    def calculate_perimeter(self) -> float: pass\n",
    "\n",
    "def show(figure: Figure) -> None:\n",
    "    print(f'S ({figure.name}) = {figure.calculate_area()}')\n",
    "    print(f'P ({figure.name}) = {figure.calculate_perimeter()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S (square) = 9.8596\n",
      "P (square) = 12.56\n"
     ]
    }
   ],
   "source": [
    "class Square:\n",
    "    name = 'square'\n",
    "\n",
    "    def __init__(self, size: float): self.size = size\n",
    "    def calculate_area(self) -> float: return self.size * self.size\n",
    "    def calculate_perimeter(self) -> float: return 4 * self.size\n",
    "        \n",
    "    def set_color(self, color: str) -> None: self.color = color\n",
    "\n",
    "show(Square(size=3.14))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Определение собственного протокола`\n",
    "\n",
    "Определим некорректную реализацию и отловим ошибку на этапе статической проверки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Circle' object has no attribute 'calculate_area'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[32], line 17\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcalculate_perimeter\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mfloat\u001b[39m:\n\u001b[1;32m     15\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mPI \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mradius\n\u001b[0;32m---> 17\u001b[0m \u001b[43mshow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mCircle\u001b[49m\u001b[43m(\u001b[49m\u001b[43mradius\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# -> AttributeError: 'Circle' object has no attribute 'calculate_area'\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[29], line 11\u001b[0m, in \u001b[0;36mshow\u001b[0;34m(figure)\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mshow\u001b[39m(figure: Figure) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 11\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mS (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfigure\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) = \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcalculate_area\u001b[49m()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m     12\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mP (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfigure\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) = \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfigure\u001b[38;5;241m.\u001b[39mcalculate_perimeter()\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Circle' object has no attribute 'calculate_area'"
     ]
    }
   ],
   "source": [
    "#from typing import Protocol\n",
    "\n",
    "#class Figure(Protocol): <class body>\n",
    "\n",
    "#def show(figure: Figure) -> None: <function body>\n",
    "\n",
    "class Circle:\n",
    "    PI = 3.1415926\n",
    "    name = \"Circle\"\n",
    "\n",
    "    def __init__(self, radius: float):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_perimeter(self) -> float:\n",
    "        return 2 * self.PI * self.radius\n",
    "\n",
    "show(Circle(radius=1)) # -> AttributeError: 'Circle' object has no attribute 'calculate_area'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:17: \u001b[1m\u001b[31merror:\u001b[m Name \u001b[m\u001b[1m\"show\"\u001b[m is not defined  \u001b[m\u001b[33m[name-defined]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 1 error in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Неявные и явные реализации протокола`\n",
    "\n",
    "- Явная реализация соответствует номинальной типизации\n",
    "- Неявная - структурной\n",
    "\n",
    "Явная типизация аналогична работе с абстрактными классами, можно использовать реализации методов по-умолчанию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "from abc import abstractmethod\n",
    "from typing import Protocol\n",
    "\n",
    "class Readable(Protocol):\n",
    "    @abstractmethod\n",
    "    def read(self) -> str: pass\n",
    "\n",
    "    def get_size(self) -> int: return 1000\n",
    "\n",
    "class File(Readable):\n",
    "    def read(self) -> str: return 'file content'\n",
    "\n",
    "print(File().get_size())  # Выведет 1000\n",
    "\n",
    "class WrongFile(Readable):\n",
    "    def read(self) -> int: return 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp.txt:16: \u001b[1m\u001b[31merror:\u001b[m Return type \u001b[m\u001b[1m\"int\"\u001b[m of \u001b[m\u001b[1m\"read\"\u001b[m incompatible with return type \u001b[m\u001b[1m\"str\"\u001b[m in supertype \u001b[m\u001b[1m\"Readable\"\u001b[m  \u001b[m\u001b[33m[override]\u001b[m\n",
      "\u001b[1m\u001b[31mFound 1 error in 1 file (checked 1 source file)\u001b[m\n"
     ]
    }
   ],
   "source": [
    "check_last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Forward references`\n",
    "\n",
    "- Иногда в коде возникает необходимость сослаться на тип, который ещё не был определён\n",
    "\n",
    "\n",
    "__Примеры:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    def bar(self) -> Foo:\n",
    "        return Foo()\n",
    "\n",
    "# NameError: name 'Foo' is not defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    def bar(self) -> Bar:\n",
    "        return Bar()\n",
    "\n",
    "class Bar:\n",
    "    def foo(self) -> Foo:\n",
    "        return Foo()\n",
    "\n",
    "# NameError: name 'Bar' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Forward references`\n",
    "\n",
    "- Решение проблемы является использования строкового представления имени типа вместо самого типа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    def bar(self) -> 'Foo':\n",
    "        return Foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    def bar(self) -> 'Bar':\n",
    "        return Bar()\n",
    "\n",
    "class Bar:\n",
    "    def foo(self) -> Foo:\n",
    "        return Foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Начиная с Python 3.7 заботу об этом может взять на себя импорт `from __future__ import annotations`\n",
    "- Он автоматически производит замену всех типов на имена-строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "class Foo:\n",
    "    def bar(self) -> Foo:\n",
    "        return Foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Хранение типизированных данных`\n",
    "\n",
    "- Хранение типизированных данных требует строгости и аккуратности\n",
    "- В простейших случаях можно воспользоваться словарём или кортежем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_data = (0, 'string')\n",
    "dict_data = {'int_field': 0, 'str_field': 'string'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- отсутствие именованного типа может привести к ошибке, нужно помнить, что переменная ссылается на нужную стркутуру\n",
    "- необходимо следить за ключами словаря и порядком аргументов кортежа, это автоматически не проверяется\n",
    "\n",
    "\n",
    "- Возможный вариант - _именованные кортежи_ (Namedtuple):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Data = namedtuple('Data', ['int_field', 'str_field'])\n",
    "named_tuple_data = Data(0, 'string')\n",
    "named_tuple_data.int_field\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- При таком подходе:\n",
    "    - кортежи являются неизменяемыми\n",
    "    - по кортежам можно итерироваться\n",
    "- Минус\n",
    "    - кортежи с разными наборами ключей, но одинаковыми значениями будут считаться одинаковыми"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 string\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "Data2 = namedtuple('Data2', ['int_field_2', 'str_field_2'])\n",
    "\n",
    "print(*named_tuple_data)\n",
    "print(Data2(0, 'string') == named_tuple_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Классы данных`\n",
    "\n",
    "- Эти проблемы решаются созданием для данных отдельного типа\n",
    "\n",
    "\n",
    "- Пример типичного класса данных, описанного стандартными средствами языка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Data:\n",
    "    def __init__(self, int_field: int, str_field: str):\n",
    "        self.int_field = int_field\n",
    "        self.str_field = str_field\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}(int_field={self.int_field:d}, str_field='{self.str_field:s}')\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.__repr__()\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.int_field == other.int_field and self.str_field == other.str_field"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Многие вещи выглядят типовыми и повторяющимися"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Классы данных`\n",
    "\n",
    "- Для решения проблем хранения типизированных данных в Python 3.7 были добавлены _классы данных_\n",
    "- Этот механизм позволяет автоматически генерировать классы с типизированными полями со значениями по-умолчанию\n",
    "- Пример того же класса данных, описанного с помощью декоратора `@dataclass`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Data:\n",
    "    int_field: int\n",
    "    str_field: str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Этот класс обладает аналогичной функциональностью\n",
    "- Аннотации типов в `dataclass` обязательны, поля без типов будут проигнорированы\n",
    "\n",
    "\n",
    "- Полям можно задавать значения по-умолчанию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data(int_field=10, str_field='string')"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@dataclass\n",
    "class Data:\n",
    "    int_field: int = 10\n",
    "    str_field: str = 'string'\n",
    "\n",
    "Data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Классы данных`\n",
    "\n",
    "- Есть параметры для управление генерацией класса (все методы, определённые пользователем, перетирают реализации по-умолчанию):<br><br>\n",
    "    - `frozen` - сделать класс неизменяемым или нет (по-умолчанию `False`)\n",
    "    - `init` - сгенерировать для класса метод `__init__` (по-умолчанию `True`)\n",
    "    - `repr` - сгенерировать для класса метод `__repr__` (по-умолчанию `True`)\n",
    "    - `eq` - сгенерировать для класса метод `__eq__`, сраниваются типы и значения как кортежи (по-умолчанию `True`)\n",
    "    - `order` - сгенерировать методы `__lt__`, `__le__`, `__gt__` и `__ge__`, сравнивая значения как кортежи (по-умолчанию `False`)\n",
    "    - `unsafe_hash` - использовать небезопасные поля в подсчёте хэша объекта в методе `__hash__` (по-умолчанию `False`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@dataclass(frozen=True, order=True)\n",
    "class Data:\n",
    "    int_field: int = 10\n",
    "    str_field: str = 'string'\n",
    "\n",
    "#Data().int_field = 5 -> FrozenInstanceError: cannot assign to field 'int_field'\n",
    "\n",
    "Data(10) < Data(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Классы данных можно преобразовывать в словари и кортежи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'int_field': 20, 'str_field': 'string'}\n",
      "(20, 'string')\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import asdict, astuple\n",
    "\n",
    "print(asdict(Data(20)))\n",
    "print(astuple(Data(20)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Создание изменяемых полей`\n",
    "\n",
    "- Создавать поля с изменяемыми типами и значениями по-умолчанию не так просто, как константные"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Data:\n",
    "    list_field: List[int] = []\n",
    "\n",
    "# -> ValueError: mutable default <class 'list'> for field list_field is not allowed: use default_factory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Корректное решение проблемы подсказывается в сообщении об ошибке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import field\n",
    "\n",
    "@dataclass\n",
    "class Data:\n",
    "    list_field: List[int] = field(default_factory=list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пост-инициализация`\n",
    "\n",
    "- При создании объекта может потребоваться выполнить после `__init__` по-умолчанию некоторую логику, не переписывая весь метод\n",
    "- Для этого можно определить метод `__post_init__`, который `__init__` (если он определён) всегда вызывает после себя\n",
    "- Можно задавать параметры для пост-инициализации: это поля типа `InitVar`, которые передаются в `__post_init__`\n",
    "- В остальном классе эти поля игнорируются"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created Data object with float value 3.14\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import InitVar\n",
    "\n",
    "@dataclass\n",
    "class Data:\n",
    "    float_field: float\n",
    "    int_field: InitVar[int]\n",
    "\n",
    "    def __post_init__(self, int_field: int) -> None:\n",
    "        print(f'Created Data object with float value {self.float_field:.{int_field}f}')\n",
    "\n",
    "d = Data(3.141562, 2)\n",
    "#d.int_field -> AttributeError: 'Data' object has no attribute 'int_field'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Наследование классов данных`\n",
    "\n",
    "- Классы данных наследуются от `object` и могут использоваться для получения новых классов путём наследования\n",
    "- При этом наследуюемый класс тоже нужно помечать декоратором `@dataclass`\n",
    "- Декоратор проходит по всем родительским классам (при множественном наследовании порядок MRO), для каждого класса поля сохраняются в упорядоченный словарь, остаются самые последние версии полей\n",
    "- По этой причине, если поле в родительском классе определялось со значением по-умолчанию, то и в дочернем классе должно быть так (или останется старое значение)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class DataA:\n",
    "    field_a: str = 'default'\n",
    "    field_b: str = None\n",
    "\n",
    "@dataclass\n",
    "class DataB(DataA):\n",
    "    field_a: int\n",
    "    field_b: str\n",
    "    field_c: int = None\n",
    "\n",
    "#DataB.__init__ -> __init__(self, field_a: 'int' = 'default', field_b: 'str' = None, field_c: 'int' = None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Типизированные словари TypedDict`\n",
    "\n",
    "- Схожими возможностями обладают _типизированные словари_ (`TypedDict`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'int_field': 10, 'str_field': 'string'}\n"
     ]
    }
   ],
   "source": [
    "from typing import TypedDict\n",
    "\n",
    "class Data(TypedDict):\n",
    "    int_field: int\n",
    "    str_field: str\n",
    "\n",
    "print(Data(int_field=10, str_field='string'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Использование классов данных является предпочтительнее по нескольким причинам:<br><br>\n",
    "    - классы поддерживают номинальную типизацию, а `TypedDict` - только структурную, т.е. `isinstance` использовать нельзя, нужно проверять соответствие полей во время выполнения кода, а это для больших структур может оказаться затратной процедурой<br><br>\n",
    "    - классы удобнее с точки зрения предоставляемого интерфейса (например, наличие properties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Сторонние альтернативы классам данных`\n",
    "\n",
    "- Использование классов данных не требует дополнительных зависимостей, что иногда может быть важным<br><br>\n",
    "- Но классы данных, как и прочие решения из стандартной библиотеки, не идеальны, например, не справляются с валидацией данных без написания громоздкого дополнительного кода<br><br>\n",
    "- Есть более развитые сторонние библиотеки для работы с типизированными данными, наиболее популярны `attrs` и `pydantic`<br><br>\n",
    "- На самом деле `attrs` появилась до Python 3.7, и классы данных создавались под её влиянием и с помощью её разработчиков<br><br>\n",
    "- [Ссылка](https://stefan.sofa-rockers.org/2020/05/29/attrs-dataclasses-pydantic) на хорошую статью про сравнение классов данных и библиотек `attrs` и `pydantic`<br><br>\n",
    "\n",
    "- Рассмотрим подробнее модуль `pydantic`, поскольку в связке с Fast API он особенно полезен при web-разработке<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль pydantic`\n",
    "\n",
    "- Создание объектов производится наследованием от базового класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data(int_field=10, str_field='string', list_field=None)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Optional, List\n",
    "from pydantic import BaseModel\n",
    "\n",
    "class Data(BaseModel):\n",
    "    int_field: int\n",
    "    str_field: str\n",
    "    list_field: Optional[List[str]] = None\n",
    "\n",
    "Data(**{'int_field': 10, 'str_field': 'string'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Типы входных данных автоматически валидируются:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValidationError",
     "evalue": "1 validation error for Data\nint_field\n  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='string', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.6/v/int_parsing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValidationError\u001b[0m                           Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[45], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mData\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mint_field\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstring\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstr_field\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstring\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m#ValidationError: 1 validation error for Data\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;66;03m#int_field\u001b[39;00m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;66;03m#  value is not a valid integer (type=type_error.integer)\u001b[39;00m\n",
      "File \u001b[0;32m~/.local/share/virtualenvs/lecture-bqnltRE_/lib/python3.10/site-packages/pydantic/main.py:171\u001b[0m, in \u001b[0;36mBaseModel.__init__\u001b[0;34m(self, **data)\u001b[0m\n\u001b[1;32m    169\u001b[0m \u001b[38;5;66;03m# `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks\u001b[39;00m\n\u001b[1;32m    170\u001b[0m __tracebackhide__ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__pydantic_validator__\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalidate_python\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mself_instance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValidationError\u001b[0m: 1 validation error for Data\nint_field\n  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='string', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.6/v/int_parsing"
     ]
    }
   ],
   "source": [
    "Data(**{'int_field': 'string', 'str_field': 'string'})\n",
    "\n",
    "#ValidationError: 1 validation error for Data\n",
    "#int_field\n",
    "#  value is not a valid integer (type=type_error.integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- И даже исправляются, если преобразование известно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data(int_field=10, str_field='string', list_field=None)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(**{'int_field': '10', 'str_field': 'string'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Вложенные pydantic-классы`\n",
    "\n",
    "- Легко создавать и использовать рекурсивные модели данных с утиной типизацией:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo=Foo(count=4, size=None) bars=[Bar(apple='x1', banana='y'), Bar(apple='x2', banana='y')] \n",
      "\n",
      "{'foo': {'count': 4, 'size': None}, 'bars': [{'apple': 'x1', 'banana': 'y'}, {'apple': 'x2', 'banana': 'y'}]}\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "from pydantic import BaseModel\n",
    "\n",
    "class Foo(BaseModel):\n",
    "    count: int\n",
    "    size: float = None\n",
    "\n",
    "class Bar(BaseModel):\n",
    "    apple = 'x'\n",
    "    banana = 'y'\n",
    "\n",
    "class Spam(BaseModel):\n",
    "    foo: Foo\n",
    "    bars: List[Bar]\n",
    "\n",
    "m = Spam(foo={'count': 4}, bars=[{'apple': 'x1'}, {'apple': 'x2'}])\n",
    "\n",
    "print(m, '\\n')\n",
    "print(m.dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Валидация входных данных`\n",
    "\n",
    "- Проверять можно не только типы, но значения входных данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValidationError",
     "evalue": "2 validation errors for Data\nstr_field\n  String should have at least 2 characters [type=string_too_short, input_value='', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.6/v/string_too_short\nint_field\n  Input should be less than or equal to 150 [type=less_than_equal, input_value=200, input_type=int]\n    For further information visit https://errors.pydantic.dev/2.6/v/less_than_equal",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValidationError\u001b[0m                           Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[47], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m     str_field: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m=\u001b[39m Field(min_length\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, max_length\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m)\n\u001b[1;32m      5\u001b[0m     int_field: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m Field(le\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m150\u001b[39m)\n\u001b[0;32m----> 7\u001b[0m \u001b[43mData\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstr_field\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mint_field\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m200\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;66;03m#ValidationError: 2 validation errors for Data\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m#str_field\u001b[39;00m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;66;03m#  ensure this value has at least 2 characters (type=value_error.any_str.min_length; limit_value=2)\u001b[39;00m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;66;03m#int_field\u001b[39;00m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;66;03m#  ensure this value is less than or equal to 150 (type=value_error.number.not_le; limit_value=150)\u001b[39;00m\n",
      "File \u001b[0;32m~/.local/share/virtualenvs/lecture-bqnltRE_/lib/python3.10/site-packages/pydantic/main.py:171\u001b[0m, in \u001b[0;36mBaseModel.__init__\u001b[0;34m(self, **data)\u001b[0m\n\u001b[1;32m    169\u001b[0m \u001b[38;5;66;03m# `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks\u001b[39;00m\n\u001b[1;32m    170\u001b[0m __tracebackhide__ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__pydantic_validator__\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalidate_python\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mself_instance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValidationError\u001b[0m: 2 validation errors for Data\nstr_field\n  String should have at least 2 characters [type=string_too_short, input_value='', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.6/v/string_too_short\nint_field\n  Input should be less than or equal to 150 [type=less_than_equal, input_value=200, input_type=int]\n    For further information visit https://errors.pydantic.dev/2.6/v/less_than_equal"
     ]
    }
   ],
   "source": [
    "from pydantic import Field\n",
    "\n",
    "class Data(BaseModel):\n",
    "    str_field: str = Field(min_length=2, max_length=5)\n",
    "    int_field: int = Field(le=150)\n",
    "\n",
    "Data(str_field='', int_field=200)\n",
    "\n",
    "#ValidationError: 2 validation errors for Data\n",
    "#str_field\n",
    "#  ensure this value has at least 2 characters (type=value_error.any_str.min_length; limit_value=2)\n",
    "#int_field\n",
    "#  ensure this value is less than or equal to 150 (type=value_error.number.not_le; limit_value=150)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- у типа `Field` есть много параметров для валидации, например:<br><br>\n",
    "    - `regex` : проверка соответствия строки заданному регулярному выражению\n",
    "    - `multiple_of` : проверка того, что целое число является множителем заданного числа\n",
    "    - `max_items` / `min_items` : проверка числа элементов в параметра-коллекциях\n",
    "    - `allow_mutation` : разрешение или запрет изменения содержимого поля"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Валидация входных данных`\n",
    "\n",
    "- Для более сложных случаев описываются методы валидации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/tp/tk36j3t10050l48xnj_4g18m0000gn/T/ipykernel_44318/2298511795.py:7: PydanticDeprecatedSince20: Pydantic V1 style `@validator` validators are deprecated. You should migrate to Pydantic V2 style `@field_validator` validators, see the migration guide for more details. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.6/migration/\n",
      "  @validator('str_field')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Data(str_field='9999999999')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pydantic import BaseModel, validator\n",
    "from typing import Optional\n",
    "\n",
    "class Data(BaseModel):\n",
    "    str_field: str\n",
    "        \n",
    "    @validator('str_field')\n",
    "    def str_field_validator(cls, value):\n",
    "        if len(value) != 10:\n",
    "            raise ValueError('Phone number must have 10 digits')\n",
    "        return value\n",
    "\n",
    "Data(str_field='9999999999')\n",
    "#ValidationError: 1 validation error for Data\n",
    "#str_field\n",
    "#  Phone number must have 10 digits (type=value_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Дополнительные типы`\n",
    "\n",
    "- `pydanctic` предназначен для работы с реальными данными, поэтому в нём есть встроенные полезные типы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import (\n",
    "    FilePath, HttpUrl, EmailStr, color,\n",
    "    IPvAnyAddress, NegativeInt, PositiveFloat,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "color=Color('purple', rgb=(128, 0, 128))\n",
      "color=Color('cyan', rgb=(0, 255, 255))\n",
      "color=Color('#00fffb', rgb=(0, 255, 251))\n"
     ]
    }
   ],
   "source": [
    "from pydantic import BaseModel, ValidationError\n",
    "\n",
    "class Data(BaseModel):\n",
    "    color: color.Color\n",
    "\n",
    "print(Data(color='purple'))\n",
    "print(Data(color='hsl(180, 100%, 50%)'))\n",
    "print(Data(color='hsl(179, 100%, 50%)'))\n",
    "\n",
    "#print(Data(color='hello')) ->\n",
    "\n",
    "#ValidationError: 1 validation error for Data\n",
    "#color\n",
    "#  value is not a valid color: string not recognised as a valid color ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Парсинг переменных окружения`\n",
    "\n",
    "- `pydantic` позволяет парсить данные из файлов типа `.env` и напрямую приводить их к объектам типа `BaseSettings `\n",
    "- Для этого нужно дополнительно установить модуль `python-dotenv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('.env', 'w') as fout:\n",
    "    fout.write('''\n",
    "        login=RoiS\n",
    "        password=Password\n",
    "    \\n''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "login='MelLain' password='Password'\n"
     ]
    }
   ],
   "source": [
    "from pydantic import BaseSettings\n",
    "\n",
    "class Settings(BaseSettings):\n",
    "    login: str\n",
    "    password: str\n",
    "\n",
    "    class Config:\n",
    "        env_file = '.env'\n",
    "        env_file_encoding = 'utf-8'\n",
    "\n",
    "print(Settings())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Генерация схемы данных`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"$defs\": {\n",
      "    \"Counter\": {\n",
      "      \"properties\": {\n",
      "        \"count\": {\n",
      "          \"title\": \"Count\",\n",
      "          \"type\": \"integer\"\n",
      "        },\n",
      "        \"size\": {\n",
      "          \"default\": null,\n",
      "          \"title\": \"Size\",\n",
      "          \"type\": \"number\"\n",
      "        }\n",
      "      },\n",
      "      \"required\": [\n",
      "        \"count\"\n",
      "      ],\n",
      "      \"title\": \"Counter\",\n",
      "      \"type\": \"object\"\n",
      "    },\n",
      "    \"Gender\": {\n",
      "      \"enum\": [\n",
      "        \"male\",\n",
      "        \"female\",\n",
      "        \"other\",\n",
      "        \"not_given\"\n",
      "      ],\n",
      "      \"title\": \"Gender\",\n",
      "      \"type\": \"string\"\n",
      "    }\n",
      "  },\n",
      "  \"properties\": {\n",
      "    \"counter\": {\n",
      "      \"$ref\": \"#/$defs/Counter\"\n",
      "    },\n",
      "    \"Gender\": {\n",
      "      \"allOf\": [\n",
      "        {\n",
      "          \"$ref\": \"#/$defs/Gender\"\n",
      "        }\n",
      "      ],\n",
      "      \"default\": null\n",
      "    },\n",
      "    \"snap\": {\n",
      "      \"default\": 42,\n",
      "      \"exclusiveMaximum\": 50,\n",
      "      \"exclusiveMinimum\": 30,\n",
      "      \"title\": \"The Snap\",\n",
      "      \"type\": \"integer\"\n",
      "    }\n",
      "  },\n",
      "  \"required\": [\n",
      "    \"counter\"\n",
      "  ],\n",
      "  \"title\": \"Main\",\n",
      "  \"type\": \"object\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from enum import Enum\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class Counter(BaseModel):\n",
    "    count: int\n",
    "    size: float = None\n",
    "\n",
    "class Gender(str, Enum):\n",
    "    male = 'male'\n",
    "    female = 'female'\n",
    "    other = 'other'\n",
    "    not_given = 'not_given'\n",
    "\n",
    "class Model(BaseModel):\n",
    "    counter: Counter = Field(...)\n",
    "    gender: Gender = Field(None, alias='Gender')\n",
    "    snap: int = Field(42, title='The Snap', gt=30, lt=50)\n",
    "\n",
    "    class Config:\n",
    "        title = 'Main'\n",
    "\n",
    "print(Model.schema_json(indent=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Спасибо за внимание!`"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}