Ch9_Pattern.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \n",
    "## 실전 속의 디자인\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 팩토리 패턴\n",
    "+ 파이썬은 클래스, 함수, 사용자 정의 객체 등의 역할이 구분되지 않으므로 필요하지 않음\n",
    "\n",
    "### 생성 패턴\n",
    "+ 객체 초기화를 위한 파라미터를 결정하거나 초기화에 필요한 관련 객체를 준비하는 등의 모든 관련 작업을 단순화하려는 것\n",
    "\n",
    "#### 싱글턴과 공유 상태\n",
    "+ 일반적인 상태에서 싱글턴은 사용하지 않은 것이 좋음\n",
    "+ 객체 지향 소프트웨어를 위한 전역 변수의 한 형태이며 나쁜 습관일 확률이 높음\n",
    "+ 파이썬에서 이를 해결하는 가장 쉬운 방법은 모듈을 사용하는 것. 여러 번 임포트하더라도 sys.modules에 로딩되는 것은 항상 하나임\n",
    "+ 클래스 변수의 게터나 세트를 활용하거나 디스크립터 사용할 수도 있음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Pull at 0.3\n",
      "INFO:__main__:Pull at 0.3\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "logging.basicConfig()\n",
    "logger = logging.getLogger(__name__)\n",
    "\n",
    "\n",
    "\"\"\" 게터/세터 구현 \"\"\"\n",
    "class GitFetcher:\n",
    "    _current_tag = None\n",
    "\n",
    "    def __init__(self, tag):\n",
    "        self.current_tag = tag # 프로퍼티를 통해 클래스 변수와 연결되어 있음\n",
    "\n",
    "    @property\n",
    "    def current_tag(self):\n",
    "        if self._current_tag is None:\n",
    "            raise AttributeError(\"Tag is not initialized yet.\")\n",
    "        return self._current_tag \n",
    "    \n",
    "    @current_tag.setter\n",
    "    def current_tag(self, new_tag):\n",
    "        self.__class__._current_tag = new_tag \n",
    "        \n",
    "    def pull(self):\n",
    "        logger.info(f\"Pull at {self.current_tag}\")\n",
    "\n",
    "        \n",
    "if __name__ == \"__main__\":\n",
    "    f1 = GitFetcher(0.1)\n",
    "    f2 = GitFetcher(0.2)\n",
    "    f1.current_tag = 0.3\n",
    "    \n",
    "    f2.pull()\n",
    "    f1.pull()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:calling __set__\n",
      "INFO:__main__:calling __set__\n",
      "INFO:__main__:calling __set__\n",
      "INFO:__main__:Pull at 0.3\n",
      "INFO:__main__:Pull at 0.3\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "logging.basicConfig()\n",
    "logger = logging.getLogger(__name__)\n",
    "\n",
    "\n",
    "\"\"\" 디스크립터 구현 \"\"\"\n",
    "class SharedArrtibute:\n",
    "    def __init__(self, initial_value=None):\n",
    "        self.value = initial_value\n",
    "        self._name = None\n",
    "        \n",
    "    def __get__(self, instance, owner):\n",
    "        if instance is None:\n",
    "            return self\n",
    "        if self.value is None:\n",
    "            raise AttributeError(f\"{self._name} was never set\")\n",
    "        return self.value\n",
    "    \n",
    "    def __set__(self, instance, new_value):\n",
    "        logger.info(\"calling __set__\")\n",
    "        self.value = new_value\n",
    "        \n",
    "    def __set_name__(self, owner, name):\n",
    "        self._name = name\n",
    "        \n",
    "        \n",
    "class GitFetcher:\n",
    "    current_tag = SharedArrtibute()\n",
    "    current_branch = SharedArrtibute()\n",
    "\n",
    "    def __init__(self, tag, branch=None):\n",
    "        self.current_tag = tag \n",
    "        self.__class__.current_branch = branch # __class__를 사용하면 디스크립터가 동작하지 않음\n",
    "\n",
    "    def pull(self):\n",
    "        logger.info(f\"Pull at {self.current_tag}\")\n",
    "        return self.current_tag\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    f1 = GitFetcher(0.1)\n",
    "    f2 = GitFetcher(0.2)\n",
    "    f1.current_tag = 0.3\n",
    "    \n",
    "    f2.pull()\n",
    "    f1.pull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### borg 패턴\n",
    "\n",
    "+ 어쩔 수 없이 꼭 싱글턴을 사용해야 하는 상태에서의 대안\n",
    "+ 같은 클래스의 모든 인스턴스가 모든 속성을 복제하는 객체를 만드는 것"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseFetcher:\n",
    "    def __init__(self, source):\n",
    "        self.source = source\n",
    "\n",
    "        \n",
    "class TagFetcher(BaseFetcher):\n",
    "    _attributes = {} # borg 패턴의 특징,\n",
    "    \n",
    "    def __init__(self, source):\n",
    "        self.__dict__ = self.__class__._attributes\n",
    "        super().__init__(source)\n",
    "        \n",
    "    def pull(self):\n",
    "        logger.info(f\"Pull at tag {self.source}\")\n",
    "        return f\"Tag = {self.source}\"\n",
    "    \n",
    "\n",
    "class BranchFetcher(BaseFetcher):\n",
    "    _attributes = {} # 사전은 레퍼런스 형태로 전달되는 변경 가능한 mutable 객체이므로\n",
    "                     # 사전을 업데이트하면 모든 객체에 동일하게 업데이트 됨\n",
    "    \n",
    "    def __init__(self, source):\n",
    "        self.__dict__ = self.__class__._attributes\n",
    "        super().__init__(source)\n",
    "        \n",
    "    def pull(self):\n",
    "        logger.info(f\"Pull at branch {self.source}\")\n",
    "        return f\"Branch = {self.source}\"    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ 실수로 사전과 관련된 로직을 추가하는 것을 방지하기 위해 믹스인 클래스를 사용해서 사전을 만드는 방법"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'source': 0.2}\n",
      "[<class '__main__.TagFetcher'>, <class '__main__.SharedAllMixin'>, <class '__main__.BaseFetcher'>, <class 'object'>]\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'TagFetcher' object has no attribute '__subclasses__'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-69-9b5fb9ac7776>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     34\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTagFetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmro\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__subclasses__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m     \u001b[0mf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'TagFetcher' object has no attribute '__subclasses__'"
     ]
    }
   ],
   "source": [
    "## 공통 부분 시작 ##\n",
    "class SharedAllMixin:\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        try:\n",
    "            self.__class__._attributes\n",
    "        except AttributeError:\n",
    "            self.__class__._attributes = {}\n",
    "\n",
    "        self.__dict__ = self.__class__._attributes\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "\n",
    "class BaseFetcher:\n",
    "    def __init__(self, source):\n",
    "        self.source = source\n",
    "## 공통 부분 끝 ##\n",
    "\n",
    "class TagFetcher(SharedAllMixin, BaseFetcher):\n",
    "    def pull(self):\n",
    "        logger.info(\"pulling from tag %s\", self.source)\n",
    "        return f\"Tag = {self.source}\"\n",
    "\n",
    "\n",
    "class BranchFetcher(SharedAllMixin, BaseFetcher):\n",
    "    def pull(self):\n",
    "        logger.info(\"pulling from branch %s\", self.source)\n",
    "        return f\"Branch = {self.source}\"\n",
    "\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    f1 = TagFetcher(0.1)\n",
    "    f2 = TagFetcher(0.2)\n",
    "    \n",
    "    print(f2.__dict__)\n",
    "    print(TagFetcher.mro())\n",
    "    print(SharedAllMixin.__subclasses__())\n",
    "    \n",
    "    f2.pull()\n",
    "    f1.pull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 빌더\n",
    "\n",
    "+ 필요로 하는 모든 객체를 직접 생성해주는 하나의 복잡한 객체를 만들어야 함\n",
    "+ 한 번에 모든 것을 처리해주는 추상화를 해야 함\n",
    "\n",
    "https://hoony-gunputer.tistory.com/entry/%EB%94%94%EC%9E%90%EC%9D%B8-%ED%8C%A8%ED%84%B4-Builder-Pattern-by-python-java\n",
    "https://medium.com/modern-nlp/10-great-ml-practices-for-python-developers-b089eefc18fc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 구조패턴\n",
    "\n",
    "+ 여러 개의 객체를 조합하여 반복을 제거"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 어댑터 패턴\n",
    "+ 두 가지 방법으로 구현 가능 \n",
    "+ 첫 번째는 사용하려는 클래스를 상속 받는 클래스를 만드는 것\n",
    "    + 상속은 얼마나 많은 외부 라이브러리를 가져올지 정확히 할기 어려우므로 is a 관계에 한정해서 적용하는 것이 바람직 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UsernameLookup:\n",
    "    def search(self, user_namespace):\n",
    "        logger.info(\"looking for %s\", user_namespace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UserSource(UsernameLookup):\n",
    "    def fetch(self, user_id, username):\n",
    "        user_namespace = self._adapt_arguments(user_id, username)\n",
    "        return self.search(user_namespace)\n",
    "\n",
    "    @staticmethod\n",
    "    def _adapt_arguments(user_id, username):\n",
    "        return f\"{user_id}:{username}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ 두 번째 방법은 컴포지션을 사용 \n",
    "    + 더 나은 방법으로 소개함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UserSource:\n",
    "    def __init__(self, username_lookup: UsernameLookup) -> None:\n",
    "        self.username_lookup = username_lookup\n",
    "\n",
    "    def fetch(self, user_id, username):\n",
    "        user_namespace = self._adapt_arguments(user_id, username)\n",
    "        return self.username_lookup.search(user_namespace)\n",
    "\n",
    "    @staticmethod\n",
    "    def _adapt_arguments(user_id, username):\n",
    "        return f\"{user_id}:{username}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 컴포지트\n",
    "\n",
    "+ 객체는 구조화된 트리 형태로 볼 수 있으며, 기본 객체는 리프 노드이고 컨테이너 객체는 중간 노드라 볼 수 있음\n",
    "+ 클라이언트는 이 중 아무거나 호출하여 결과를 얻으려고 할 것임\n",
    "+ 또한 컴포지트 객체도 클라이언트 처럼 동작함\n",
    "+ 즉 리프 노드인지 중간 노드인지 상관없이 해당 요청을 관련노드가 처리할 수 있을 때 까지 계속 전달"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:2807.5\n"
     ]
    }
   ],
   "source": [
    "from typing import Iterable, Union\n",
    "\n",
    "\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self._name = name\n",
    "        self._price = price\n",
    "\n",
    "    @property\n",
    "    def price(self):\n",
    "        return self._price\n",
    "\n",
    "\n",
    "class ProductBundle:\n",
    "    def __init__(\n",
    "        self,\n",
    "        name,\n",
    "        perc_discount,\n",
    "        *products: Iterable[Union[Product, \"ProductBundle\"]]\n",
    "    ) -> None:\n",
    "        self._name = name\n",
    "        self._perc_discount = perc_discount\n",
    "        self._products = products\n",
    "\n",
    "    @property\n",
    "    def price(self):\n",
    "        total = sum(p.price for p in self._products)\n",
    "        return total * (1 - self._perc_discount)\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "        electronics = ProductBundle(\n",
    "            \"electronics\",\n",
    "            0,\n",
    "            ProductBundle(\n",
    "                \"smartphones\",\n",
    "                0.15,\n",
    "                Product(\"smartphone1\", 200),\n",
    "                Product(\"smartphone2\", 700),\n",
    "            ),\n",
    "            ProductBundle(\n",
    "                \"laptops\",\n",
    "                0.05,\n",
    "                Product(\"laptop1\", 700),\n",
    "                Product(\"laptop2\", 950),\n",
    "            ),\n",
    "        )\n",
    "        tablets = ProductBundle(\n",
    "            \"tablets\", 0.05, Product(\"tablet1\", 200), Product(\"tablet2\", 300)\n",
    "        )\n",
    "        total = ProductBundle(\"total\", 0, electronics, tablets)\n",
    "        logger.info(total.price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 데코레이터 패턴\n",
    "\n",
    "+ 파이선 데코레이터와는 다른 개념\n",
    "+ 상속을 하지 않고도 객체의 기능을 동적으로 확장 할 수 있음\n",
    "+ 동일한 인터페이스를 가지고 여러 단계를 거쳐 결과를 장식하거나 결합도 할 수 있는 또 다른 객체를 만드는 것\n",
    "+ 이 객체들은 연결되어 있으며 각각의 객체는 본래 의도에 더해 새로운 기능이 추가될 수 있음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DictQuery:\n",
    "    def __init__(self, **kwargs):\n",
    "        self._raw_query = kwargs\n",
    "\n",
    "    def render(self) -> dict:\n",
    "        return self._raw_query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QueryEnhancer:\n",
    "    def __init__(self, query: DictQuery):\n",
    "        self.decorated = query\n",
    "\n",
    "    def render(self):\n",
    "        return self.decorated.render()\n",
    "\n",
    "\n",
    "class RemoveEmpty(QueryEnhancer):\n",
    "    def render(self):\n",
    "        original = super().render()                     # 오리지널을 받아서\n",
    "        return {k: v for k, v in original.items() if v} # 새로운 형식으로 리턴함\n",
    "\n",
    "\n",
    "class CaseInsensitive(QueryEnhancer):\n",
    "    def render(self):\n",
    "        original = super().render()\n",
    "        return {k: v.lower() for k, v in original.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "original = DictQuery(foo=\"bar\", empty=\"\", none=None, upper=\"UPPERCASE\", title=\"Title\")\n",
    "new_query = CaseInsensitive(RemoveEmpty(original))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'foo': 'bar', 'upper': 'uppercase', 'title': 'title'}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_query.render()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ 파이썬의 동적인 특성을 활용해 다른 방법으로 구현한 사례"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable, Dict, Iterable\n",
    "\n",
    "class QueryEnhancer:\n",
    "    def __init__(\n",
    "        self,\n",
    "        query: DictQuery,\n",
    "        *decorators: Iterable[Callable[[Dict[str, str]], Dict[str, str]]] # Callable[[input], return type]\n",
    "    ) -> None:\n",
    "        self._decorated = query\n",
    "        self._decorators = decorators\n",
    "\n",
    "    def render(self):\n",
    "        current_result = self._decorated.render()\n",
    "        for deco in self._decorators:\n",
    "            current_result = deco(current_result)\n",
    "        return current_result\n",
    "\n",
    "\n",
    "def remove_empty(original: dict) -> dict:\n",
    "    return {k: v for k, v in original.items() if v}\n",
    "\n",
    "\n",
    "def case_insensitive(original: dict) -> dict:\n",
    "    return {k: v.lower() for k, v in original.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'foo': 'bar', 'upper': 'uppercase', 'title': 'title'}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "QueryEnhancer(original, remove_empty, case_insensitive).render()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 파사드 패턴\n",
    "+ 여러 객체가 다대다 관계를 이루며 상화작용을 하는 경우 사용됨\n",
    "+ 각각의 객체에 대한 모든 연결을 만드는 대신 파사드 역할을 하는 중간 객체를 만들어 해결\n",
    "+ 디렉토리의 패키지 빌드할 때 \\_\\_init\\_\\_.py 파일을 나머지 파일들과 함께 두는 것은 모듈의 루트오서 파사드와 같은 역할을 함\n",
    "    + \\_\\_init\\_\\_.py 파일의 API가 유지되는 한 클라이언트에 영향을 주지 않게 됨"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 행동 패턴\n",
    "+ 어떤 패턴을 사용하든지 간에 결국에는 중복을 피하거나 행동을 캡슐화하는 추상화를 통해 모델 간 결합력을 낮추는 방법"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 책임 연쇄 패턴\n",
    "\n",
    "+ 후계자라는 개념이 추가됨, 현재 초리할 수 없을 때 대비한 다음 이벤트 객체를 의미\n",
    "+ 직접 처리가 가능한 경우 결과를 반환하지만 처리가 불가능하면 후계자에게 전달하고 이 과정을 반복함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "class Event:\n",
    "    pattern = None\n",
    "\n",
    "    def __init__(self, next_event=None):\n",
    "        self.successor = next_event\n",
    "\n",
    "    def process(self, logline: str):\n",
    "        if self.can_process(logline):\n",
    "            return self._process(logline)\n",
    "\n",
    "        if self.successor is not None:\n",
    "            return self.successor.process(logline)\n",
    "\n",
    "    def _process(self, logline: str) -> dict:\n",
    "        parsed_data = self._parse_data(logline)\n",
    "        return {\n",
    "            \"type\": self.__class__.__name__,\n",
    "            \"id\": parsed_data[\"id\"],\n",
    "            \"value\": parsed_data[\"value\"],\n",
    "        }\n",
    "\n",
    "    @classmethod\n",
    "    def can_process(cls, logline: str) -> bool:\n",
    "        return cls.pattern.match(logline) is not None\n",
    "\n",
    "    @classmethod\n",
    "    def _parse_data(cls, logline: str) -> dict:\n",
    "        return cls.pattern.match(logline).groupdict()\n",
    "\n",
    "\n",
    "class LoginEvent(Event):\n",
    "    pattern = re.compile(r\"(?P<id>\\d+):\\s+login\\s+(?P<value>\\S+)\")\n",
    "\n",
    "\n",
    "class LogoutEvent(Event):\n",
    "    pattern = re.compile(r\"(?P<id>\\d+):\\s+logout\\s+(?P<value>\\S+)\")\n",
    "\n",
    "\n",
    "class SessionEvent(Event):\n",
    "    pattern = re.compile(r\"(?P<id>\\d+):\\s+log(in|out)\\s+(?P<value>\\S+)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "chain = LogoutEvent(LoginEvent())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'type': 'LoginEvent', 'id': '567', 'value': 'User'}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain.process(\"567: login User\") # 로그 아웃이 먼저 실행됨"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 커맨트 패턴\n",
    "<순서>\n",
    "+ 실행될 명령의 파라미터들을 저장하는 객체를 만드는 것\n",
    "+ 명령에 필요한 파라미터에 필터를 더하거나 제거하는 것처럼 상호작용할 수 잇는 메서드 제공\n",
    "+ 마지막으로 실제로 작업을 수행할 객체를 만듬"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 상태 패턴\n",
    "+ 상태별로 작은 객체를 만들어 각각의 객체가 적은 책임을 갖게 하도록 구현"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "\n",
    "class InvalidTransitionError(Exception):\n",
    "    \"\"\"Raised when trying to move to a target state from an unreachable source\n",
    "    state.\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "class MergeRequestState(abc.ABC):\n",
    "    def __init__(self, merge_request):\n",
    "        self._merge_request = merge_request\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def open(self):\n",
    "        ...\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def close(self):\n",
    "        ...\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def merge(self):\n",
    "        ...\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.__class__.__name__\n",
    "\n",
    "\n",
    "class Open(MergeRequestState):\n",
    "    def open(self):\n",
    "        self._merge_request.approvals = 0\n",
    "\n",
    "    def close(self):\n",
    "        self._merge_request.approvals = 0\n",
    "        self._merge_request.state = Closed # 상태를 전환하는 코드\n",
    "\n",
    "    def merge(self):\n",
    "        logger.info(\"merging %s\", self._merge_request)\n",
    "        logger.info(\"deleting branch %s\", self._merge_request.source_branch)\n",
    "        self._merge_request.state = Merged # 상태를 전환하는 코드\n",
    "\n",
    "\n",
    "class Closed(MergeRequestState):\n",
    "    def open(self):\n",
    "        logger.info(\"reopening closed merge request %s\", self._merge_request)\n",
    "        self._merge_request.state = Open # 상태를 전환하는 코드\n",
    "\n",
    "    def close(self):\n",
    "        \"\"\"Current state.\"\"\"\n",
    "\n",
    "    def merge(self):\n",
    "        raise InvalidTransitionError(\"can't merge a closed request\")\n",
    "\n",
    "\n",
    "class Merged(MergeRequestState):\n",
    "    def open(self):\n",
    "        raise InvalidTransitionError(\"already merged request\")\n",
    "\n",
    "    def close(self):\n",
    "        raise InvalidTransitionError(\"already merged request\")\n",
    "\n",
    "    def merge(self):\n",
    "        \"\"\"Current state.\"\"\"\n",
    "\n",
    "\n",
    "class MergeRequest:\n",
    "    def __init__(self, source_branch: str, target_branch: str) -> None:\n",
    "        self.source_branch = source_branch\n",
    "        self.target_branch = target_branch\n",
    "        self._state = None\n",
    "        self.approvals = 0\n",
    "        self.state = Open # 상태를 전환하는 코드\n",
    "\n",
    "    @property\n",
    "    def state(self):\n",
    "        return self._state\n",
    "\n",
    "    @state.setter\n",
    "    def state(self, new_state_cls):\n",
    "        print(\"calling setter\", new_state_cls)\n",
    "        self._state = new_state_cls(self)\n",
    "\n",
    "    def open(self):\n",
    "        return self.state.open()\n",
    "\n",
    "    def close(self):\n",
    "        return self.state.close()\n",
    "\n",
    "    def merge(self):\n",
    "        return self.state.merge()\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.target_branch}:{self.source_branch}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling setter <class '__main__.Open'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mr = MergeRequest(\"develop\", \"master\")\n",
    "mr.open()\n",
    "mr.approvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling setter <class '__main__.Closed'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mr.approvals = 3\n",
    "mr.close()\n",
    "mr.approvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:reopening closed merge request master:develop\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling setter <class '__main__.Open'>\n"
     ]
    }
   ],
   "source": [
    "mr.open()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:merging master:develop\n",
      "INFO:__main__:deleting branch develop\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling setter <class '__main__.Merged'>\n"
     ]
    }
   ],
   "source": [
    "mr.merge()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "ename": "InvalidTransitionError",
     "evalue": "already merged request",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mInvalidTransitionError\u001b[0m                    Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-101-7333a1258b38>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-96-6e257b2773a3>\u001b[0m in \u001b[0;36mclose\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     86\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 87\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     89\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmerge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-96-6e257b2773a3>\u001b[0m in \u001b[0;36mclose\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     58\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mInvalidTransitionError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"already merged request\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmerge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mInvalidTransitionError\u001b[0m: already merged request"
     ]
    }
   ],
   "source": [
    "mr.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Null 객체 패턴\n",
    "\n",
    "+ 함수나 메서드는 일관된 타입을 잔환해야 한다는 것\n",
    "+ 검색하는 사용자가 없다고 가정했을 때\n",
    "    + 예외를 발생하거나\n",
    "    + UserUnknow 타입을 반환\n",
    "    + 어떤 경우에도 None을 반환하면 안됨\n",
    "    + None이라는 문구는 방금 일어난 일에 대한 아무것도 설명해주지 않으며 호출자는 특별한 공지가 없으면 아무 생각없이 반환 객체에 대해 메서드를 호출할 것이므로 결국 AttributeError가 발생하게 된다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.6 64-bit ('cleancode': venv)",
   "language": "python",
   "name": "python37664bitcleancodevenv75c55895aceb487e9e5693697f2a0d36"
  },
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}