Seminars/07-oop/oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `Практикум по программированию на языке Python`\n",
    "<br>\n",
    "\n",
    "## `Занятие 7: Основы ООП: проектирование кода, шаблоны проектирования`\n",
    "<br><br>\n",
    "\n",
    "### `Роман Ищенко (sir.rois@yandex.ru)`\n",
    "\n",
    "#### `Москва, 2023`"
   ]
  },
  {
   "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",
    "- __Наследование__ - класс наследует класс<br><br>\n",
    "    - __Реализация__ - класс реализует интерфейс<br><br>\n",
    "- __Ассоциация__ - горизонтальная связь между объектами двух классов (может быть \"один ко многим\")<br><br>\n",
    "    - __Композиция__ - вложенность объекта одного класса в другой (главный управляет жизненным циклом зависимого)<br><br>\n",
    "    - __Агрегация__ - вложенность объекта одного класса в другой (объекты остаются независимыми)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Объектно-ориентированное проектирование`\n",
    "\n",
    "- Проектирование - определение наборов интерфейсов, классов, функций, их свойств и взаимных отношений<br><br>\n",
    "\n",
    "- Система для решения одной и той же задачи может спроектирована многими способами<br><br>\n",
    "\n",
    "- Задача в том, чтобы спроектировать систему, которая будет<br><br>\n",
    "    - понятной, поддерживаемой\n",
    "    - неизбыточной\n",
    "    - несложно модифицируемой и расширяемой\n",
    "    - эффективной<br><br>\n",
    "\n",
    "- Для этого нужны собственный опыт, знания, основанные на опыте предшественников и владение возможностями языка<br><br>\n",
    "\n",
    "__ВАЖНО:__\n",
    "- шаблоны, завязанные на типизацию и интерфейсы, могут работать в Python и без строгой иерархии наследования за счёт duck-typing\n",
    "- при использовании аннотирования типов и статической проверки с номинальной типизацией это станет невозможным\n",
    "- по этой причине в коде везде определяются и наследуются корректные интерфейсы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Набор правил SOLID`\n",
    "\n",
    "- __Принцип единственной ответственности__ - объект класса отвечает за одну и только одну задачу<br><br>\n",
    "\n",
    "- __Принцип открытости/закрытости__ - класс должен быть открыт для расширения функциональности и закрыт для изменения<br><br>\n",
    "\n",
    "- __Принцип подстановки Барбары Лисков__ - наследник класса должен только дополнять родительский класс, а не менять в нём что-либо<br><br>\n",
    "\n",
    "- __Принцип разделения интерфейса__ - интерфейсы не должны покрывать много задач (класс не должен реализовывать методы, которые ему не нужны из-за слишком большого базового интерфейса)<br><br>\n",
    "\n",
    "- __Принцип инверсии зависимостей__ - нижестоящее в иерархии зависит от вышестоящего, а не наоборот<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип единственной ответственности`\n",
    "\n",
    "Объект класса отвечает за одну и только одну задачу (имеет не более одной причины для изменения)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Analyzer:\n",
    "    def read_data(self, input_path):\n",
    "        pass\n",
    "    \n",
    "    def process_data(self):\n",
    "        pass\n",
    "    \n",
    "    def print_results(self, output_path):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Класс состоит из трех независимых функциональностей - есть три причины для изменения.\n",
    "- Лучше разделить его на три класса, объединяемых на уровне интерфейса"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип открытости/закрытости`\n",
    "\n",
    "- Класс должен быть открыт для расширения функциональности и закрыт для изменения\n",
    "\n",
    "- Все последующие изменения должны производиться добавлением нового кода, а не переписыванием существующего"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Croupier:\n",
    "    def create_game(self):\n",
    "        print('Deal two cards')\n",
    "        print('Open five cards one by one')\n",
    "        print('Count the winnings')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Данный крупье умеет обслуживать игру в техасский холдем\n",
    "- Если захотим использовать его для игры в преферанс, то придется меня логику `create_game`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип открытости/закрытости`\n",
    "\n",
    "Исправить ситуацию можно по-разному, например, так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Croupier:\n",
    "    def create_game(self, game):\n",
    "        game.startSteps()\n",
    "        game.middleSteps()\n",
    "        game.finishSteps()\n",
    "    \n",
    "    def startSteps(self): pass\n",
    "    def middleSteps(self): pass\n",
    "    def finishSteps(self): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TexasHoldemGame(Croupier):\n",
    "    def startSteps(self): print('Deal two cards')\n",
    "    def middleSteps(self): print('Open three cards one by one')\n",
    "    def finishSteps(self): print('Count the winnings')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PreferansGame(Croupier):\n",
    "    def startSteps(self): print('Deal ten cards')\n",
    "    def middleSteps(self): print('Deal buy-in')\n",
    "    def finishSteps(self): print('Count the winnings')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип подстановки Лисков (LSP)`\n",
    "\n",
    "- Наследник класса должен только дополнять родительский класс, а не менять в нём что-либо<br><br>\n",
    "- Должна быть возможность вместо базового типа подставить любой его подтип<br><br>\n",
    "- Принцип не означает, что не нужно использовать перегрузку виртуальных методов<br><br>\n",
    "\n",
    "- Требуется, чтобы код наследника:\n",
    "    - не изменял состояния родительского класса\n",
    "    - не расширял предусловия\n",
    "    - не сужал постусловия"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Base:\n",
    "    def method(self, value):\n",
    "        if not isinstance(value, int):\n",
    "            raise Exception\n",
    "        return abs(value)\n",
    "\n",
    "class Deriv(Base):\n",
    "    def method(self, value):\n",
    "        if not isinstance(value, int) and value < 0:\n",
    "            raise Exception  # 1st error (more pre-conditions)\n",
    "        return value  # 2st error (less post-conditions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип разделения интерфейса`\n",
    "\n",
    "- Интерфейсы не должны покрывать много задач\n",
    "- Класс не должен реализовывать методы, которые ему не нужны из-за слишком большого базового интерфейса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CookingMachine:\n",
    "    def prepare_ingredients(self): pass\n",
    "    def heat_meal(self): pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Такой подход работает для горячих блюд\n",
    "- Допустим, мы захотели приготовить салат - метод `heat_meal` на больше не нужен\n",
    "- Если же мы хотим сделать сок, то ингредиенты надо выжимать - нужен новый один метод `squeeze`, который лишний для блюд и салатов\n",
    "\n",
    "Проблему можно решить выстраиванием правильного набора интерфейсов - своего на каждый тип приготавливаемых блюд и напитков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип инверсии зависимостей`\n",
    "\n",
    "- Нижестоящее в иерархии зависит от вышестоящего, а не наоборот<br><br>\n",
    "\n",
    "- Принцип состоит из двух пунктов:<br><br>\n",
    "    - Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций\n",
    "    - Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций<br><br>\n",
    "\n",
    "- Главное, что стоит вынести отсюда:<br><br>\n",
    "    - нужно программировать на уровне интерфейсов\n",
    "    - нужно избавляться от вложенных зависимостей\n",
    "    - объекты в системе должны быть слабосвязанными"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип инверсии зависимостей`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Printer:\n",
    "    @staticmethod\n",
    "    def print_text(text):\n",
    "        print(text)\n",
    "\n",
    "class Class:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        self.printer = Printer()\n",
    "    \n",
    "    def print_value(self):\n",
    "        self.printer.print_text(self.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `Class` зависит от `Printer`\n",
    "- `Class` может использовать для печати только `Printer`, т.е. стандартный вывод\n",
    "\n",
    "Принцип нарушен - связь между классами жесткая безо всякой нужды"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принцип инверсии зависимостей`\n",
    "\n",
    "Модифицируем код так, чтобы убрать зависимости:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrinterInterface:\n",
    "    @staticmethod\n",
    "    def print_text(text):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class StdoutPrinter(PrinterInterface):\n",
    "    @staticmethod\n",
    "    def print_text(text):\n",
    "        print(text)\n",
    "\n",
    "class Class:\n",
    "    def __init__(self, value, printer):\n",
    "        self.value = value\n",
    "        self.printer = printer\n",
    "    \n",
    "    def print_value(self):\n",
    "        self.printer.print_text(self.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример: отправитель отчётов`\n",
    "\n",
    "- Все принципы связаны между собой и нарушение одного часто приводит к нарушению сразу нескольких\n",
    "- Рассмотрим ниже пример (источник: https://blog.byndyu.ru/2009/12/blog-post.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Reporter:\n",
    "    def send_reports():\n",
    "        report_builder = ReportBuilder()\n",
    "        reports = report_builder.create_reports()\n",
    "        \n",
    "        if len(reports) == 0:\n",
    "            raise Exception\n",
    "\n",
    "        report_sender = EmailReportSender()\n",
    "        for report in reports:\n",
    "            report_sender.send(report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Какие есть проблемы?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример: отправитель отчётов`\n",
    "\n",
    "Проблем в таком коде полно:\n",
    "\n",
    "- сложность тестирования: как проверить поведение `Reporter`, которое зависит от других классов?<br><br>\n",
    "- высокая связность, `Reporter`<br><br>\n",
    "    - требует, чтобы отчёты выдавал именно `ReportBuilder`\n",
    "    - требует, чтобы отправление производил именно `EmailReportSender`\n",
    "    - содаёт объекты обоих классов внутри себя<br><br>\n",
    "\n",
    "- Нарушаются сразу три принципа:<br><br>\n",
    "    - принцип единственной ответственности (класс должен просто отправлять отчёты)\n",
    "    - принцип открытости/закрытости (для отправки отчётов не по e-mail нам потребуется исправлять `Reporter`)\n",
    "    - принцип инверсии зависимостей (классы жёстко зависят друг от друга)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример: отправитель отчётов`\n",
    "\n",
    "Изменим код так, чтобы исправить эти проблемы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReportBuilderInterface:\n",
    "    def create_reports(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class ReportSenderInterface:\n",
    "    def send(self, report):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class Reporter:\n",
    "    def __init__(self, report_builder, report_sender):\n",
    "        self.report_builder = report_builder\n",
    "        self.report_sender = report_sender\n",
    "\n",
    "    def send_reports():\n",
    "        reports = report_builder.create_reports()\n",
    "        \n",
    "        if len(reports) == 0:\n",
    "            raise Exception\n",
    "\n",
    "        for report in reports:\n",
    "            report_sender.send(report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблоны ОО-проектирования`\n",
    "\n",
    "- Набор практик и рекомендаций по организации кода, полученных опытным путём<br><br>\n",
    "- Оптимизируют решения типовых задач, упрощают разработку и поддержание кода<br><br>\n",
    "- Существуют десятки шаблонов, кратко рассмотрим несколько основных:<br><br>\n",
    "    - Одиночка (Singleton)\n",
    "    - Стратегия\n",
    "    - Примесь (Mixin)\n",
    "    - Фасад\n",
    "    - Адаптер, DAO\n",
    "    - Простая фабрика\n",
    "    - Фабричный метод\n",
    "    - Абстрактная фабрика\n",
    "    - Декоратор"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Singleton`\n",
    "\n",
    "- Иногда возникает необходимость создать класс, который может иметь не более одного экземпляра (например, глобальный конфиг)\n",
    "- Есть несколько способов реализации такого поведения\n",
    "\n",
    "Один из вариантов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Singleton:\n",
    "    def __new__(cls):  # is called before init to create object\n",
    "        if not hasattr(cls, 'instance'):\n",
    "            cls.instance = super().__new__(cls)\n",
    "        return cls.instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'some_attr'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = Singleton()\n",
    "s.some_attr = 'some_attr'\n",
    "\n",
    "s_1 = Singleton()\n",
    "s_1.some_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Singleton также удобно реализовывать с помощью статического метода"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Стратегия`\n",
    "\n",
    "- В системе может быть несколько различных алгоритмов, выполняющих одну задачу разными способами\n",
    "- __Неправильный__ способ: собрать все в один класс\n",
    "- __Правильный__ - _стратегия_:\n",
    "    - все алгоритмы реализуются своими классами, реализующими общий интерфейс\n",
    "    - общий контекст занимается подменой алгоритмов и вызовом общей процедуры выполнения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StrategyInterface:\n",
    "    def execute(self, value): raise NotImplementedError\n",
    "\n",
    "class StrategyA(StrategyInterface):\n",
    "    def execute(self, value): return value\n",
    "\n",
    "class StrategyB(StrategyInterface):\n",
    "    def execute(self, value): return value * 2\n",
    "\n",
    "class Context:\n",
    "    def set_strategy(strategy):\n",
    "        self.strategy = strategy\n",
    "\n",
    "    def execute(value):\n",
    "        return self.strategy.execute(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Mixin`\n",
    "\n",
    "- Mixin - шаблон, основанный на множественном наследовании<br><br>\n",
    "- Используется в одном из двух основных случаев:<br><br>\n",
    "    - хочется иметь в одном классе много опциональных признаков\n",
    "    - хочется использовать один и тот же признак во многих классах<br><br>\n",
    "    \n",
    "- Реализуется в виде класса, содержащего необходимую функциональность<br><br>\n",
    "\n",
    "- Далее этот класс наследуется любым нужным классом, умеющим эту функциональность использовать<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример использования Mixin`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "class VersionMixin:\n",
    "    def set_version(self, version):\n",
    "        self._version = version\n",
    "    \n",
    "    @property  # One more example of decorator\n",
    "    def version(self):\n",
    "        return self._version if hasattr(self, '_version') else 'Unk. version'\n",
    "    \n",
    "class SomeBaseClass:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "class SomeClass(SomeBaseClass, VersionMixin):\n",
    "    def __init__(self, value):\n",
    "        super().__init__(value)\n",
    "        \n",
    "sc = SomeClass(10)\n",
    "print(sc.value)\n",
    "sc.set_version(1.0)\n",
    "print(sc.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Фасад`\n",
    "\n",
    "Предназначен для сокрытия сложного поведения за простым внешним интерфейсом"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ATMImpl:\n",
    "    def check_pin(self, pin): pass\n",
    "    def make_db_request(self, user): pass\n",
    "    def check_money(self, user, amount): pass\n",
    "    def send_money(self, amount): pass\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ATM:\n",
    "    def __init__(self, atm_impl):\n",
    "        self.atm_impl = atm_impl\n",
    "\n",
    "    def get_money(self, pin, user, amount):\n",
    "        pass  # use self.atm_impl methods to proceed operation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Адаптер`\n",
    "\n",
    "- Предназначен для соединения двух систем, которые могут работать вместе, но имеют несовместимые интерфейсы\n",
    "- Особенно полезен при работе с внешними API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ValueProvider:\n",
    "    def __init__(self, value):\n",
    "        if not isinstance(value, int):\n",
    "            raise ValueError\n",
    "        self._value = value\n",
    "\n",
    "    def get_value(self):\n",
    "        return self._value\n",
    "\n",
    "class ValueUser:\n",
    "    def use_value(self, value_with_name):\n",
    "        if not isinstance(value_with_name, tuple):\n",
    "            raise ValueError\n",
    "\n",
    "        print(value_with_name[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "class ValueAdapter:\n",
    "    def transform_value(self, value):\n",
    "        return (value, '')\n",
    "\n",
    "vp = ValueProvider(10)\n",
    "va = ValueAdapter()\n",
    "vu = ValueUser()\n",
    "\n",
    "vu.use_value(va.transform_value(vp.get_value()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Data Access Object`\n",
    "\n",
    "- Предоставление единого интерфейса доступа к источнику данных (как правило, к БД)\n",
    "- DAO скрывает детали уставления соединений, посылки и обработки результатов запросов и т.п.\n",
    "- По сути, это адаптер между клиентским приложением и базой данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DbDao:\n",
    "    def request(self, query): raise NotImplementedError\n",
    "\n",
    "\n",
    "class DbOneDao(DbDao):\n",
    "    def __init__(self, db_one_config):\n",
    "        self._db_one_impl = DbOne(db_one_config)\n",
    "    \n",
    "    def request(self, query):\n",
    "        return self._db_one_impl.request(query)\n",
    "\n",
    "\n",
    "class DbTwoDao(DbDao):\n",
    "    def __init__(self, db_two_config):\n",
    "        self._db_two_impl = DbTwo(db_two_config)\n",
    "    \n",
    "    def request(self, query):\n",
    "        return self._db_two_impl.proceed_request(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Фабрики`\n",
    "\n",
    "- Фабрика - это общая идея создания объекта с помощью какой-то другой сущности<br><br>\n",
    "- Создавать объекты могут<br><br>\n",
    "    - обычные функции\n",
    "    - методы этого же класса (в т.ч. и статические)\n",
    "    - методы других классов<br><br>\n",
    "- При это в зависимости от ситуации могут использоваться как примитивные решения, так и сложные фабрики<br><br>\n",
    "- Рассмотрим ниже три основных фабричных шаблона:<br><br>\n",
    "    - простая фабрика\n",
    "    - фабричный метод\n",
    "    - абстрактная фабрика"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Простая фабрика`\n",
    "\n",
    "- Есть объект класса `VendingMachine`, описывающий торговый автомат\n",
    "- Объект имеет метод `get_item`, который по имени товара возвращает объект этого товара"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VendingMachine:\n",
    "    def get_item(self, item):\n",
    "        if item == 'cola':\n",
    "            return Cola()  # skip ammount checks\n",
    "        elif item == 'chocolate':\n",
    "            return Сhocolate()\n",
    "        else:\n",
    "            raise ValueError('Unknown item')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Создаваемые продукты могут быть никак не связаны друг с другом\n",
    "- Класс `VendingMachine` является простой фабрикой"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Фабричный метод`\n",
    "\n",
    "- Есть объект класса `CottageBuilder`, который производит объекты-коттеджи `Cottage`<br><br>\n",
    "- Весь наш программный комплекс заточен под обработку производства коттеджей<br><br>\n",
    "- В некоторый момент было принято решение начать производство многоэтажных домов (`MultiStoreyBuilding`)<br><br>\n",
    "- Неправильная архитектура приведёт к необходимости переписывания кода во многих местах<br><br>\n",
    "- Фабричный метод позволяет избежать этого"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Фабричный метод: общая схема`\n",
    "\n",
    "- Имеется класс-производитель `ConcreteFactory` и класс-продукт `ConcreteProduct`\n",
    "- Вводим интерфейс производителя `FactoryInterface` и интерфейс продукта `ProductInterface`\n",
    "- Каждый конкретный производитель получает возможность создавать конкретный продукт с помощью одного и того же метода\n",
    "\n",
    "Для нашего примера код выглядит так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BuilderInterface:\n",
    "    def build(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class BuildingInterface:\n",
    "    def open_door(self, door_number): raise NotImplementedError\n",
    "    def open_window(self, window_number): raise NotImplementedError\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CottageBuilder(BuilderInterface):\n",
    "    def build(self):\n",
    "        return Cottage()\n",
    "\n",
    "class MultiStoreyBuilder(BuilderInterface):\n",
    "    def build(self):\n",
    "        return MultiStoreyBuilding()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Фабричный метод: общая схема`\n",
    "\n",
    "Осталось описать код классов продуктов (то есть зданий):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cottage(BuildingInterface):\n",
    "    def open_door(self, door_number): self._open_door(door_number)\n",
    "    def open_window(self, window_number): self._open_window(window_number)\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiStoreyBuilder(BuildingInterface):\n",
    "    def open_door(self, door_number): self._open_door(door_number)\n",
    "    def open_window(self, window_number): self._open_window(window_number)\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- теперь в коде нет разницы, с каким зданием мы работаем, интерфейс у них всех общий\n",
    "- тип здания, который нам надо построить, определяется только внутри конкретного строителя"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Абстрактная фабрика`\n",
    "\n",
    "- Шаблон предназначен для создания систем взаимосвязанных объектов без указания их конкретных классов<br><br>\n",
    "- Проще всего разобрать на примере (источник: https://refactoring.guru/ru/design-patterns/abstract-factory)<br><br>\n",
    "- Задача:<br><br>\n",
    "    - есть набор одних и тех же элементов графического интерфейса (CheckBox, Button, TextField и прочие)\n",
    "    - в каждой операционной системе должны отображаться все эти элементы\n",
    "    - при этом в каждой OS собственный стиль отображения<br><br>\n",
    "\n",
    "- Опишем использование абстрактной фабрики для такого случая"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Интерфейсы фабрик и продуктов`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbstractGui:  # more declarative than necessary, remember about duck-typing\n",
    "    def create_check_box(self): raise NotImplementedError\n",
    "    def create_button(self): raise NotImplementedError\n",
    "    def create_text_field(self): raise NotImplementedError\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbstractCheckBox:\n",
    "    def set_state(self): raise NotImplementedError\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbstractButton:\n",
    "    def on_press(self): raise NotImplementedError\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbstractTextField:\n",
    "    def is_empty(self): raise NotImplementedError\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Конкретные классы фабрики и продуктов`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WindowsGui(AbstractGui):\n",
    "    def create_check_box(self): return WindowsCheckBox()\n",
    "    def create_button(self): return WindowsButton()\n",
    "    def create_text_field(self): return WindowsTextField()\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WindowsCheckBox(CheckBox):\n",
    "    def set_state(self): self._get_state_impl()\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WindowsButton(AbstractButton):\n",
    "    def on_press(self): self._on_press_impl()\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WindowsTextField(AbstractTextField):\n",
    "    def is_empty(self): self._is_empty_impl()\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аналогично определим классы для Mac OS и Ubuntu (Unity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Использование абстрактной фабрики`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GuiApplication:\n",
    "    def __init__(self):\n",
    "        import sys\n",
    "        \n",
    "        self.gui = None\n",
    "        if sys.platform == 'win32':\n",
    "            self.gui = WindowsGui()\n",
    "        elif sys.platform == 'linux':\n",
    "            self.gui = LinuxGui()\n",
    "        elif sys.platform == 'darwin':\n",
    "            self.gui = MacOsGui()\n",
    "        else:\n",
    "            raise SystemError(f'Unsupported OS type {sys.platform}')\n",
    "\n",
    "    def draw_window(self):\n",
    "        # write cross-platform code, based on interface, not implementations\n",
    "        self.gui.create_button()\n",
    "        self.gui.create_check_box()\n",
    "        self.gui.create_text_field()\n",
    "        ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Шаблон Декоратор`\n",
    "\n",
    "- Шаблон проектирования, позволяющий динамически наделить объект дополнительными свойствами<br><br>\n",
    "- Реализация включает в себя интерфейс, реализующие его объекты-компоненты и объекты-декораторы<br><br>\n",
    "- Задача из жизни: сбор набора метрик для отправки в сервис мониторинга<br><br>\n",
    "    - собирается несколько сотен различных метрик\n",
    "    - метрики могут агрегироваться несколькими способами (mean/median/mode/max/min по интервалу)\n",
    "    - метрики могут преобразовываться несколькими способами (положительная срезка, фильтрация значений)<br><br>\n",
    "- Модификаторы могут применяться в произвольных сочетаниях, количествах и порядках<br><br>\n",
    "\n",
    "- Как можно реализовать подобную систему без необходимости расписывать кучу условий?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Декоратор идеален для такой задачи`\n",
    "\n",
    "Опишем интерфейс метрики и реализующие его классы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricInterface():  # again for Python it's unnecessary declaration\n",
    "    def calculate(self): raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricA(MetricInterface):\n",
    "    def calculate(self):\n",
    "        self.values = self._calculate_a()  # returns list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricB(MetricInterface):\n",
    "    def calculate(self):\n",
    "        self.values = self._calculate_b()  # returns list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Собственно декораторы`\n",
    "\n",
    "Теперь опишем классы операций над метриками, которые тоже реализуют интерфейс метрики:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CalculateMeanDecorator(MetricInterface):\n",
    "    def __init__(self, metric):\n",
    "        self.metric = metric\n",
    "    \n",
    "    def calculate(self):\n",
    "        self.values = [self._calculate_mean(self.metric.calculate())]  #[scalar] == list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FilterZerosDecorator(MetricInterface):\n",
    "    def __init__(self, metric):\n",
    "        self.metric = metric\n",
    "    \n",
    "    def calculate(self):\n",
    "        self.values = list(filter(lambda x: x != 0.0, self.metric.calculate()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Использование декоратора`\n",
    "\n",
    "Теперь можно легко создавать метрики и тут же снабжать их нужными свойствами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "metric_1 = MetricA()\n",
    "metric_2 = MetricB()\n",
    "metric_3 = FilterZerosDecorator(MetricA())\n",
    "metric_4 = CalculateMeanDecorator(FilterZerosDecorator(MetricB()))\n",
    "\n",
    "for metric in [metric_1, metric_2, metric_3, metric_4]:\n",
    "    metric.calculate()\n",
    "    MetricSender.send(metric.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Снова о декораторах в синтаксисе языка Python`\n",
    "\n",
    "- Шаблон \"Декоратор\" и декоратор в Python - это разные вещи!\n",
    "- Шаблон используется обычно в языках со статической типизацией для динамического добавления объектам новых свойств\n",
    "- Декораторы в Python - это инструмент языка, предназначенный для добавления новых свойств функциям, классам и методам на этапе их определения\n",
    "- В Python это особенно просто за счёт duck-typing\n",
    "- Этот тот случай, когда нужно вспомнить о замыканиях (функциях, возвращающих функции)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример декоратора функции`\n",
    "\n",
    "Опишем декоратор, замеряющий время работы функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timed(callable_obj):\n",
    "    import time\n",
    "\n",
    "    def __timed(*args, **kw):\n",
    "        time_start = time.time()\n",
    "        result = callable_obj(*args, **kw)\n",
    "        time_end = time.time()\n",
    "        \n",
    "        print('{}  {:.3f} ms'.format(callable_obj.__name__,\n",
    "                                     (time_end - time_start) * 1000))\n",
    "        return result\n",
    "\n",
    "    return __timed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "func  37.708 ms\n"
     ]
    }
   ],
   "source": [
    "@timed\n",
    "def func():\n",
    "    for i in range(1000000):\n",
    "        pass\n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример декоратора функции`\n",
    "\n",
    "Посмотрим, что это за функция на самом деле:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def __timed(*args, **kw):\n",
      "        time_start = time.time()\n",
      "        result = callable_obj(*args, **kw)\n",
      "        time_end = time.time()\n",
      "        \n",
      "        print('{}  {:.3f} ms'.format(callable_obj.__name__,\n",
      "                                     (time_end - time_start) * 1000))\n",
      "        return result\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import inspect\n",
    "lines = inspect.getsource(func)\n",
    "print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример декоратора класса`\n",
    "\n",
    "Опишем декоратор класса, который получает на вход декоратор функции и оборачивает его вокруг каждого публичного метода класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorate_class(decorator):\n",
    "    def _decorate(cls):\n",
    "        for f in cls.__dict__:\n",
    "            if callable(getattr(cls, f)) and not f.startswith(\"_\"):\n",
    "                setattr(cls, f, decorator(getattr(cls, f)))\n",
    "        return cls\n",
    "    return _decorate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "method  0.001 ms\n"
     ]
    }
   ],
   "source": [
    "@decorate_class(timed)\n",
    "class Cls:\n",
    "    a = 10\n",
    "    def method(self): pass\n",
    "    def _method_2(self): pass\n",
    "\n",
    "Cls().method()\n",
    "Cls().a  # not callable\n",
    "Cls()._method_2()  # not public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При определении класса он производится вызов `decorate_class._decorate`, которая возвращает обновлённый класс."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Мета-классы в Python`\n",
    "\n",
    "- Вспомним, что в Python всё, включая классы, является объектами <br><br>\n",
    "- Это позволяет создавать классы и менять их свойства (ещё один способ помимо декораторов)<br><br>\n",
    "- Описание класса определяет свойства объекта<br><br>\n",
    "- Описание мета-класса определяет свойства класса<br><br>\n",
    "- В Python есть один класс, не являющийся объектом - это мета-класс `type`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Мета-классы в Python`\n",
    "\n",
    "`type` можно использовать напрямую для создания классов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyClass'>\n",
      "value\n"
     ]
    }
   ],
   "source": [
    "Class = type('MyClass', (object, ), {'field': lambda self: 'value'})\n",
    "c = Class()\n",
    "\n",
    "print(type(c))\n",
    "print(c.field())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Мета-классы в Python`\n",
    "\n",
    "- А можно на основе `type` описывать мета-классы\n",
    "\n",
    "- Напишем простой мета-класс, который добавляет метод `hello` в создаваемый класс\n",
    "\n",
    "- Источник примера: https://gitjournal.tech/metaklassy-i-metaprogrammirovanie-v-python/ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "greetings from <class '__main__.TryHello'>, a HelloMeta type class\n"
     ]
    }
   ],
   "source": [
    "class HelloMeta(type):  # always inherit type or it's childs\n",
    "    def hello(cls):\n",
    "        print(\"greetings from %s, a HelloMeta type class\" % (type(cls())))\n",
    "\n",
    "    # call meta-class\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        cls = type.__call__(self, *args, **kwargs)  # create class as usual\n",
    "\n",
    "        setattr(cls, \"hello\", self.hello)  # add 'hello' attribute\n",
    "\n",
    "        return cls\n",
    "\n",
    "class TryHello(object, metaclass=HelloMeta):  \n",
    "    def greet(self):\n",
    "        self.hello()\n",
    "\n",
    "greeter = TryHello()  \n",
    "greeter.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Зачем нужно работать с мета-классами?`\n",
    "\n",
    "- На самом деле, это не нужно почти никогда, лучше использовать декораторы<br><br>\n",
    "- Бывает полезно в тех случаях, когда нужно штамповать классы с заданными свойствами или при отсутствии информации о деталях класса до момента выполнения кода<br><br>\n",
    "- **Пример**:\n",
    "    - вы определили класс данных с методами обработки, зависящими от формата\n",
    "    - класс имеет метакласс, который определяется аргументами программы\n",
    "    - в аргументах передаются различные форматы и методы обработки\n",
    "    - мета-класс в зависимости от них переопределяет методы вашего класса<br><br>\n",
    "\n",
    "- **Пример**: генерация API, в текущем контексте может требоваться, чтобы все методы ваших классов были в верхнем регистре<br><br>"
   ]
  },
  {
   "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.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}