comprendre-les-metaclasses.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qu'est-ce qu'une métaclasse ?\n",
    "\n",
    "> « Metaclasses are deeper magic that 99% of users should never worry about. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why). »  \n",
    "*Tim Peters, Python Guru*\n",
    "\n",
    "Ce qui se traduit approximativement en : \"Les métaclassent sont la magie profonde de Python dont 99% des personnes qui programment dans ce langage n'ont pas à se soucier. Si vous vous demandez ce que c'est, c'est que vous n'en avez pas besoin. Si vous en avez besoin, vous savez ce que c'est et n'avez pas besoin d'explication à leur sujet.\"\n",
    "\n",
    "Merci Tim ! Nous voilà bien avancés !\n",
    "\n",
    "Ceci dit, ce n'est pas complètement faux. Il reste assez rare de créer des métaclasses en Python. Mais elles peuvent solutionner élégamment des problèmes complexes. \n",
    "\n",
    "De nombreuses librairies comme Django les utilisent dans leur mécanique interne.\n",
    "\n",
    "Alors qu'est-ce qu'une métaclasse ? C'est une classe dont les instances sont des classes.\n",
    "\n",
    "Autrement dit, une classe est une usine qui fabrique des variables, appelées *instances de classe*. Une métaclasse est une usine qui fabrique des classes. Ou encore, une usine qui fabrique des usines.\n",
    "\n",
    "L'intérêt est de pouvoir faire bénéficier les classes basées sur une métaclasse d'un même comportement sans avoir à le copier/coller d'une classe à l'autre.\n",
    "\n",
    "L'héritage est fait pour cela, soulignerez-vous avec pertinence. Mais l'héritage ne résout pas tout..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les limites de l'héritage\n",
    "\n",
    "Imaginons que vous souhaitiez réaliser une classe Singleton.  \n",
    "Une classe singleton est une classe qui n'a qu'une seule instance d'une variable.  Si vous créez plusieurs instances, la classe retournera toujours la première créée. Et toutes vos instances auront le même **id**.\n",
    "\n",
    "A quoi sert ce genre de classes ?\n",
    "\n",
    "* La constante *None* est un exemple de singleton. Elle n'existe qu'en 1 seul exemplaire. C'est pour cela que dans les tests Python vous pouvez écrire:\n",
    "\n",
    "```python\n",
    "a == None or a is None\n",
    "```\n",
    "\n",
    "L'opérateur **is** qui compare les adresses fonctionne sur ce test d'égalité car toutes les instances de None ont la même adresse. Ce ne serait pas vrai pour des entiers:\n",
    "\n",
    "```python\n",
    "a = 10**16\n",
    "b = 10**16\n",
    "print(a == b) # True\n",
    "print(a is b) # Très certainement False\n",
    "```\n",
    "\n",
    "* Les drivers qui pilotent des périphériques comme une imprimante sont souvent des objets singleton: pas besoin d'avoir 50 exemplaires du pilote en mémoire, un seul peut discuter à la fois avec l'imprimante.\n",
    "* Certains logiciels comme *Word* sont des singletons, si vous le lancez plusieurs fois, c'est l'application active qui est ré-affichée.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comment implémenter une classe Singleton en Python\n",
    "\n",
    "Chaque langage a ses techniques. En Java/C++ on peut faire une classe avec un constructeur privé pour empêcher qu'il soit appelé par les développeurs et les forcer à passer une méthode **get_instance** qui gère l'unique appel de constructeur de la classe.\n",
    "\n",
    "En Python, tout est publique, cette solution n'est pas applicable.  Le site [Wikipédia présente quelques solutions](https://fr.wikipedia.org/wiki/Singleton_(patron_de_conception)) pour différents langages dont Python. \n",
    "\n",
    "Pour implémenter une classe Singleton nous devons l'empêcher de créer plus d'une instance.\n",
    "\n",
    "En Python, la création d'une variable se fait dans le constructeur. \n",
    "\n",
    "Le constructeur n'est pas la fonction `__init__`.  \n",
    "Le constructeur c'est la fonction qui crée la variable en mémoire.  \n",
    "`__init__` est appelée pour initialiser les attributs de l'instance, une fois cette dernière créée. C'est la fonction [`__new__`](https://docs.python.org/3/reference/datamodel.html#object.__new__) qui alloue l'objet en mémoire.\n",
    "\n",
    "Généralement on ne la définit jamais car Python gère la mémoire lui-même. Et c'est bien plus simple ainsi.\n",
    "\n",
    "Mais ici nous pourrions la redéfinir pour qu'elle:\n",
    "\n",
    "* crée une variable lors du tout premier appel et mémorise cette dernière\n",
    "* retourne la variable déjà créée lors des appels suivants\n",
    "\n",
    "L'unique instance singleton pouvant être mémorisée dans un attribut de classe.  \n",
    "Ce qui donne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Singleton(object):\n",
    "    \n",
    "    instance_unique = None  # Attribut de classe mémorisant l'unique instance\n",
    "    \n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        \"\"\"Remarquez ici, le premier paramètre n'est pas self mais la classe, car la variable \n",
    "        n'est pas encore créée - nous allons justement la créer.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Si l'instance n'est pas encore créée...\n",
    "        if cls.instance_unique is None:\n",
    "            # On la crée en appelant la méthode __new__ du parent qui saura comment faire...\n",
    "            cls.instance_unique = super().__new__(cls, *args, **kwargs)\n",
    "            \n",
    "        return cls.instance_unique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il ne reste plus qu'à tester:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bien joué !\n"
     ]
    }
   ],
   "source": [
    "s1 = Singleton()\n",
    "s2 = Singleton()\n",
    "\n",
    "assert s1 == s2\n",
    "assert s1 is s2\n",
    "assert id(s1) == id(s2)\n",
    "assert type(s1) == Singleton\n",
    "print(\"Bien joué !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mission accomplie brillament, avec l'usage de la méthode `__new__` ce qui est assez rare en Python. Cela commence à être du haut niveau.\n",
    "\n",
    "Maintenant, imaginons que nous ayons besoin d'une seconde classe Singleton. Nous n'allons pas dupliquer la première. Héritons de cette dernière, la mécanique est déjà en place !\n",
    "\n",
    "Pour cela je duplique (en mode notebook) la classe précédente, comme vous pourriez le faire dans un script afin de ré-initialiser `Singleton.instance_unique` à None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Héhé... trop facile... Quel est le besoin d'une métaclase ?\n"
     ]
    }
   ],
   "source": [
    "class Singleton(object):\n",
    "    \n",
    "    instance_unique = None  # Attribut de classe mémorisant l'unique instance\n",
    "    \n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        \"\"\"Remarquez ici, le premier paramètre n'est pas self mais la classe, car la variable \n",
    "        n'est pas encore créée - nous allons justement la créer.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Si l'instance n'est pas encore créée...\n",
    "        if cls.instance_unique is None:\n",
    "            # On la crée en appelant la méthode __new__ du parent qui saura comment faire...\n",
    "            cls.instance_unique = super().__new__(cls, *args, **kwargs)\n",
    "            \n",
    "        return cls.instance_unique\n",
    "    \n",
    "class SingletonChild(Singleton):\n",
    "    pass\n",
    "\n",
    "\n",
    "sc1 = SingletonChild()\n",
    "sc2 = SingletonChild()\n",
    "\n",
    "assert sc1 == sc2\n",
    "assert sc2 is sc1\n",
    "assert id(sc1) == id(sc2)\n",
    "\n",
    "assert type(sc1) == SingletonChild, \"Je ne suis pas du type attendu\"\n",
    "\n",
    "print(\"Héhé... trop facile... Quel est le besoin d'une métaclase ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trop facile, ou presque..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imaginons, que vous ayez besoin de 2 instances singleton, une pour la classe *Singleton* et une pour *SingletonChild*. Vous écririez alors ceci..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bien joué !\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "Je ne suis pas du type attendu",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-a6c537ef7b85>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     39\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msc1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msc2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msc1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mSingletonChild\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Je ne suis pas du type attendu\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"OUILLE...\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: Je ne suis pas du type attendu"
     ]
    }
   ],
   "source": [
    "class Singleton(object):\n",
    "    \n",
    "    instance_unique = None  # Attribut de classe mémorisant l'unique instance\n",
    "    \n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        \"\"\"Remarquez ici, le premier paramètre n'est pas self mais la classe, car la variable \n",
    "        n'est pas encore créée - nous allons justement la créer.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Si l'instance n'est pas encore créée...\n",
    "        if cls.instance_unique is None:\n",
    "            # On la crée en appelant la méthode __new__ du parent qui saura comment faire...\n",
    "            cls.instance_unique = super().__new__(cls, *args, **kwargs)\n",
    "            \n",
    "        return cls.instance_unique\n",
    "    \n",
    "class SingletonChild(Singleton):\n",
    "    pass\n",
    "\n",
    "\n",
    "# Création de l'instance singleton pour la classe Singleton\n",
    "s1 = Singleton()\n",
    "s2 = Singleton()\n",
    "\n",
    "assert s1 == s2\n",
    "assert s1 is s2\n",
    "assert id(s1) == id(s2)\n",
    "assert type(s1) == Singleton\n",
    "print(\"Bien joué !\")\n",
    "\n",
    "# Création de l'instance singleton pour la classe SingletonChild\n",
    "# ICI ça se gâte...\n",
    "\n",
    "sc1 = SingletonChild()\n",
    "sc2 = SingletonChild()\n",
    "\n",
    "assert sc1 == sc2\n",
    "assert sc2 is sc1\n",
    "assert id(sc1) == id(sc2)\n",
    "\n",
    "assert type(sc1) == SingletonChild, \"Je ne suis pas du type attendu\"\n",
    "\n",
    "print(\"OUILLE...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Même ainsi...",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-d4e116bc2208>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msc1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSingletonChild\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Même ainsi...\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: Même ainsi..."
     ]
    }
   ],
   "source": [
    "assert isinstance(sc1, SingletonChild), \"Même ainsi...\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Singleton'>\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(type(sc1))\n",
    "print(isinstance(sc1, Singleton))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(sc1 == s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et faisant hériter SingletonChild de Singleton, la classe fille bénéficie de la même fonction `__new__` mais celle-ci a déjà alloué l'instance unique pour la variable *s1* laquelle est du type Singleton. \n",
    "\n",
    "Du coup SingletonChild ne possède pas sa propre instance.\n",
    "\n",
    "Il faudrait dupliquer l'attribut `instance_unique` dans SingletonChild:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ok, mais on a dupliqué un attribut de classe\n"
     ]
    }
   ],
   "source": [
    "class SingletonChild(Singleton):\n",
    "    instance_unique = None\n",
    "    \n",
    "    \n",
    "sc1 = SingletonChild()\n",
    "sc2 = SingletonChild()\n",
    "\n",
    "assert sc1 == sc2\n",
    "assert sc2 is sc1\n",
    "assert id(sc1) == id(sc2)\n",
    "assert isinstance(sc1, SingletonChild)\n",
    "print(\"Ok, mais on a dupliqué un attribut de classe\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La solution est viable et presque jolie, en dehors de cette création d'instance quasiment incontournable pour chaque sous classe de Singleton.\n",
    "\n",
    "On peut très bien vivre avec. Mais on peut aussi faire mieux en automatisant ce code avec les métaclasses.\n",
    "ce qui nous permettra aussi de ne pas avoir besoin de faire hériter SingletonChild de Singleton pour qu'elle soit une classe Singleton..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comment sont créées les classes en Python\n",
    "Avant de nous lancer dans la création de métaclasses et de classes basées sur ce modèle, rentrons plus en détails dans la compréhension du langage et de la création d'une classe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python *tout est objet*.  \n",
    "Une fonction est un objet, une classe est un objet..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n"
     ]
    }
   ],
   "source": [
    "def  hello():\n",
    "    \"\"\"Affiche bonjour\"\"\"\n",
    "    print(\"Bonjour !\")\n",
    "    \n",
    "print(type(hello))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour !\n"
     ]
    }
   ],
   "source": [
    "salut = hello\n",
    "salut()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que peut-on faire avec hello ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']\n"
     ]
    }
   ],
   "source": [
    "print(dir(hello))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Affiche bonjour\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(hello.__doc__)   # la docstring est stockée ici\n",
    "print(hello.__name__)  # le nom de la fonction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ET vous pourriez aussi ajouter des attributs sur la fonction, comme un compteur d'appels... Mais ce n'est pas l'objet de cet article."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les types Python comme *int*, *str*, *list* sont aussi des objets. Ce sont des classes qui sont des instances de métaclasses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quel est donc le type de **int**, autrement dit, la métaclasse qui a créé la classe *int* ?   \n",
    "Est-ce **object** ?   \n",
    "Non, *object* est la classe parent de *int*, ce n'est pas la classe qui a créé la classe *int*. C'est la classe dont hérite *int*, tout comme *SingletonChild* hérite de *Singleton*. Mais *Singleton* n'a pas créé *SingletonChild*. *Singleton* a créé les variables **s1** et **s2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Type** est le type de *int*. **type** n'est pas juste une fonction qui affiche le type d'une variable, c'est une classe qui crée des classes, c'est une **métaclasse** !\n",
    "\n",
    "Mais qui a créé **type** ?\n",
    "\n",
    "Python peut-il répondre à la question du pourquoi du comment de l'univers et de tout ce qui est vivant ?\n",
    "\n",
    "La réponse est-elle *Guido Van Rossum* ou *42* ?   \n",
    "N'attendons plus pour savoir, la réponse au Saint-Graal de l'existence des objets est là, tout prêt !  \n",
    "Posons la question !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(type))  # Alors ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est *type* ! *type* s'est créée elle-même ! C'est la classe toute puissante !\n",
    "\n",
    "La classe *type* peut donc servir à fabriquer des variables, qui sont des classes !\n",
    "\n",
    "Si on lui passe un seul paramètre, elle retourne le type de cette variable, sinon elle construit une classe.\n",
    "\n",
    "Voici les paramètres acceptés dans sa seconde utilisation:\n",
    "\n",
    "* Le nom de la classe créée\n",
    "* Un tuple qui contient la liste des parents\n",
    "* Un dictionnaire qui contient les attributs et méthodes de la classe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous écrivez ce code:\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MaClasse'>\n",
      "blue\n",
      "Hello man!\n",
      "(<class '__main__.MaClasse'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "class A(object):\n",
    "    pass\n",
    "\n",
    "class B(object):\n",
    "    pass\n",
    "\n",
    "MaClasse = type(\"MaClasse\",\n",
    "                (A, B),\n",
    "                {\"color\" : 'blue', \n",
    "                 'hello' : lambda self: 'Hello man!'}\n",
    "                )\n",
    "mc = MaClasse()\n",
    "print(type(mc))\n",
    "print(MaClasse.color)\n",
    "print(mc.hello())\n",
    "print(MaClasse.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est équivalent à celui-ci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MaClasse'>\n",
      "blue\n",
      "Hello man!\n",
      "(<class '__main__.MaClasse'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "class A(object):\n",
    "    pass\n",
    "\n",
    "class B(object):\n",
    "    pass\n",
    "\n",
    "class MaClasse(A, B):\n",
    "    color = \"blue\"\n",
    "    \n",
    "    def hello(self):\n",
    "        return \"Hello man!\"\n",
    "\n",
    "mc = MaClasse()\n",
    "print(type(mc))\n",
    "print(MaClasse.color)\n",
    "print(mc.hello())\n",
    "print(MaClasse.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est assez bluffant au début. Mais pas très pratique à mettre en oeuvre: définir des méthodes au travers d'un dictionnaire ce n'est pas très heureux."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour résumer, quand vous écrivez:\n",
    "\n",
    "```python\n",
    "class MaClasse(object):\n",
    "    pass\n",
    "```\n",
    "\n",
    "Python exécute:\n",
    "\n",
    "```python\n",
    "MaClasse = type(\"MaClasse\", (object, ), {} )\n",
    "```\n",
    "\n",
    "Ce qui reste valide, mais il est plus confortable d'utiliser le mot clef **class**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comment crée-t-on une métaclasse ?\n",
    "\n",
    "Pour cela il suffit de créer une classe qui hérite de **type**.\n",
    "\n",
    "\n",
    "```python\n",
    "class MaMetaClasse(type):\n",
    "    pass\n",
    "```\n",
    "\n",
    "Une métaclasse est une classe qui crée des classes, comme type, nous pourrions donc écrire:\n",
    "\n",
    "```python\n",
    "MaClasse = MaMetaClasse()\n",
    "mon_object = MaClasse()\n",
    "```\n",
    "\n",
    "Ne confondez pas :\n",
    "\n",
    "* Le type d'une variable: C'est le nom de la classe qui a créé la variable\n",
    "* Le parent d'une classe : C'est la classe dont hérite votre classe, que vous pouvez consulter avec : `MyClass .__base__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MaMetaClasse'>\n",
      "<class '__main__.MaClasse'>\n",
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "class MaMetaClasse(type):\n",
    "    pass\n",
    "\n",
    "MaClasse = MaMetaClasse(\"MaClasse\", (object,), {})\n",
    "mon_object = MaClasse()\n",
    "\n",
    "print(type(MaClasse))\n",
    "print(type(mon_object))\n",
    "print(MaClasse.__base__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais cette syntaxe n'est pas très heureuse.  \n",
    "La [PEP3115](https://www.python.org/dev/peps/pep-3115/) présente la syntaxe officielle pour définir une classe basée sur une métaclasse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MaMetaClasse'>\n",
      "<class '__main__.MaClasse'>\n",
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "class MaMetaClasse(type):\n",
    "    pass\n",
    "\n",
    "class MaClasse(object, metaclass=MaMetaClasse):\n",
    "    pass\n",
    "\n",
    "print(type(MaClasse))\n",
    "print(type(mon_object))\n",
    "print(MaClasse.__base__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comment implémenter la classe Singleton avec une MetaClasse ?\n",
    "\n",
    "\n",
    "L'idée est la suivante, si la classe doit posséder un attribut `instance_unique`, il suffit de l'initialiser dans la métaclasse. Ainsi chaque classe basée sur la métaclasse possèdera cet attribut sans qu'il y ait besoin de copier/coller ce code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Précisions sur la mécanique de création des objets en Python\n",
    "\n",
    "Quand on écrit:\n",
    "\n",
    "```python\n",
    "ma_variable = MaClasse()\n",
    "```\n",
    "\n",
    "* Python alloue l'objet en mémoire avec la fonction `MaClasse.__new__`\n",
    "* Puis il initialise l'objet avec la fonction `MaClasse.__init__`  \n",
    "  La fonction `__init__` permet d'affecter des attributs à l'objet créé. \n",
    "\n",
    "Mais vous savez aussi que l'on peut appeler un objet comme une fonction si la classe de l'objet définit la méthode spéciale `__call__`.\n",
    "\n",
    "Exemple:\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "En voiture Paul Pierre Jacqueline\n"
     ]
    }
   ],
   "source": [
    "class Vehicule:\n",
    "    \n",
    "    def __call__(self, *args, **kwargs):\n",
    "        print(\"En voiture\", *args)\n",
    "        \n",
    "v = Vehicule()\n",
    "v(\"Paul\", \"Pierre\", \"Jacqueline\")\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour créer une variable, vous appelez la classe comme une fonction:  \n",
    "\n",
    "`variable = MaClasse()` \n",
    "\n",
    "Ceci appelle donc la méthode `__call__` de la métaclasse en lui passant la classe en premier paramètre:\n",
    "\n",
    "* qui crée la variable avec `MaClasse.__new__()`\n",
    "* puis initialise la variable avec `MaClasse.__init__()`\n",
    "* puis retourne la variable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Illustrons ceci avec un exemple concret...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Création de la métaclasse\n",
      "Création de la classe\n",
      "Dans MetaClasse.__new__\n",
      "Dans MetaClasse.__init__ MaClasse\n",
      "Création de la variable\n",
      "Dans MetaClasse.__call__ MaClasse\n",
      "MaClasse.__new__\n",
      "MaClasse.__init__\n",
      "Appel de la variable comme une fonction\n",
      "MaClasse.__call__\n",
      "Mais quelle belle mécanique...\n"
     ]
    }
   ],
   "source": [
    "print('Création de la métaclasse')\n",
    "class MetaClasse(type):\n",
    "    \n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        print(\"Dans MetaClasse.__new__\")\n",
    "        return super().__new__(cls, *args, **kwargs)\n",
    "    \n",
    "    def __init__(cls, *args, **kwargs):\n",
    "        print(\"Dans MetaClasse.__init__\", cls.__name__)\n",
    "        super().__init__(*args, **kwargs)\n",
    "    \n",
    "    def __call__(cls, *args, **kwargs):\n",
    "        print(\"Dans MetaClasse.__call__\", cls.__name__)\n",
    "        return super().__call__(*args, **kwargs)\n",
    "        \n",
    "    \n",
    "print(\"Création de la classe\")\n",
    "class MaClasse(object, metaclass=MetaClasse):\n",
    "\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        print(\"MaClasse.__new__\")\n",
    "        return super().__new__(cls, *args, **kwargs)\n",
    "\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        print(\"MaClasse.__init__\")\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        print(\"MaClasse.__call__\")\n",
    "        print(*args, **kwargs)\n",
    "\n",
    "print(\"Création de la variable\")\n",
    "i = MaClasse()\n",
    "print(\"Appel de la variable comme une fonction\")\n",
    "i(\"Mais quelle belle mécanique...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notez** l'usage de *cls* dans l'appel à *super()* pour la méthode `__new__` et sans *cls* pour les autres comme `__init__`.  \n",
    "En effet, la variable n'est pas encore créée quand on appelle `__new__` il faut donc passer l'attribut cls qui ne représente pas l'instance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons maintenant écrire une métaclasse **MetaSingleton** :\n",
    "\n",
    "* Lorsque nous créerons une classe basée sur cette métaclasse cela appellera ses méthodes `__new__` et `__init__`\n",
    "* Lorsque nous créerons une instance de classe basée sur la métaclasse MetaSingleton, cela appellera ̀`MetaSingleton.__call__(Classe)`  \n",
    "C'est là que vous devrez tester l'existence de l'instance unique\n",
    "* Dans la méthode `__init__` de la métaclasse, initialisez l'attribut statique de la classe, ce sera plus simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extra génial\n"
     ]
    }
   ],
   "source": [
    "class MetaSingleton(type):\n",
    "    \n",
    "    def __init__(cls, *args, **kwargs):\n",
    "        \"\"\"cls est la classe créée par la métaclasse\"\"\"\n",
    "        # ajout de l'attribut de classe instance unique\n",
    "        cls.instance_unique = None\n",
    "        \n",
    "        \n",
    "    def __call__(cls, *args, **kwargs):\n",
    "        \n",
    "        # On crée l'instance unique existe si elle n'existe pas déjà\n",
    "        if cls.instance_unique is None:\n",
    "            cls.instance_unique = super().__call__(*args, **kwargs)\n",
    "            \n",
    "        return cls.instance_unique\n",
    "    \n",
    "    \n",
    "class Singleton(object, metaclass=MetaSingleton):\n",
    "    pass\n",
    "\n",
    "\n",
    "class SingletonChild(Singleton):\n",
    "    pass\n",
    "\n",
    "\n",
    "# Création de l'instance singleton pour la classe Singleton\n",
    "s1 = Singleton()\n",
    "s2 = Singleton()\n",
    "\n",
    "assert s1 == s2\n",
    "assert s1 is s2\n",
    "assert id(s1) == id(s2)\n",
    "assert type(s1) == Singleton\n",
    "\n",
    "# cette fois tout ira bien !\n",
    "\n",
    "sc1 = SingletonChild()\n",
    "sc2 = SingletonChild()\n",
    "\n",
    "assert sc1 == sc2\n",
    "assert sc2 is sc1\n",
    "assert id(sc1) == id(sc2)\n",
    "\n",
    "assert type(sc1) == SingletonChild, \"Je ne suis pas du type attendu\"\n",
    "\n",
    "print(\"Extra génial\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voilà prêt(e) pour bâtir de grandes fondations...  \n",
    "Mais très sincèrement, on ne crée que rarement des métaclasses, sauf si l'on développe des frameworks sophistiqués comme l'ORM de Django. \n",
    "\n",
    "A défaut d'être appliqué professionnellement, ce tutoriel aura essayé de vous apporter la compréhension de la mécanique interne de Python.\n",
    "\n",
    "Et comme le dit *Tim Peters* : **It's deep magic !**\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour vous faire la main:\n",
    "\n",
    "* essayez d'implémenter une métaclasse qui gère un compteur d'objets créés par la classe.\n",
    "* puis qui le décrémente quand ils sont détruits...\n",
    "\n",
    "Hum, est-ce possible ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pour aller plus loin\n",
    "\n",
    "* Un très bon fil de [discussion Stackoverflow sur les métaclasses](http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python)\n",
    "* Un autre [tutoriel intéressant sur les métaclasses](https://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}