pyrealb-fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expérience avec `pyrealb`\n",
    "\n",
    "_[This notebook in English](https://mybinder.org/v2/gh/lapalme/pyrealb-jupyter/HEAD?labpath=pyrealb-en.ipynb)_\n",
    "\n",
    "Ce _notebook Jupyter_ notebook montre quelques exemples de réalisation de texte avec **pyrealb**.  \n",
    "\n",
    "**À l'oouverture, choisissez l'item de menu `Run/Run all cells`**\n",
    "\n",
    "Vous pouvez aussi l'utiliser dans votre browser (en passant par Binder) avec [ce lien](https://mybinder.org/v2/gh/lapalme/pyrealb-jupyter/HEAD?labpath=pyrealb-en.ipynb). \n",
    "\n",
    "**pyrealb** est un système qui permet de réaliser des phrases en anglais ou en français à partir d'une structure JavaScript créée par des appels à des fonctions. **pyrealb** gère automatiquement la conjugaison ou déclinaison ainsi que la majorité des accords entre les constituants. \n",
    "\n",
    "La syntaxe des fonctions a été conçue pour ressembler à celle qui est utilisée dans les grammaires en constituants: des terminaux sont intégrés à des syntagmes, chacun d'eux pouvant ensuite être modifié par des options qui sont spécifiées par des appels de *méthodes* ou fonctions internes aux structures ainsi créées. Une notation sous forme de dépendances syntaxiques est aussi disponible.\n",
    "\n",
    "Une des flexibilités intéressantes est le fait qu'on peut obtenir des variantes (p.ex. négatives ou passives) d'une même phrase en spécifiant des options. Nous n'expliquons pas ici toutes les options ni toutes les valeurs possibles de leurs paramètres. Pour ceci, il faut consulter la  [documentation **pyrealb** ](http://www.iro.umontreal.ca/~lapalme/pyrealb/documentation.html).\n",
    "\n",
    "Ce notebook *Jupyter* présente brièvement la syntaxe utilisée par **pyrealb** à l'aide d'exemples simples mais aussi avec quelques exemples plus complexes.  Vous pouvez modifier les exemples and voir leur nouvelle réalisation. Lorsqu'une expression est changée, on peut lancer son évaluation avec (shift-return) ou en cliquant sur un triangle orienté vers la droite à gauche de la cellule. Il faut se rappeler que, contraitement à un tableur, le changement d'une expression **n'a pas** un effet immédiat sur les expressions qui en dépendent. On peut forcer leur réévaluation en cliquand sur un triangle orienté vers la droite avec une flèche vers le bas (_Execute cell and below_). \n",
    "\n",
    "*Nota bene*: losrque **pyrealb** détecte une erreur dans une spécification la réalisation apparaît avec un mot entre double crochets `[[...]]`, un message est aussi affiché avant la réalisation.\n",
    "\n",
    "## Chargement de `pyrealb`\n",
    "Il faut tout d'abord importer les fonctions du package  `pyrealb` qui aura déjà dû être installé en utilisant `pip`. On indique ensuite que nous allons réaliser du texte en français."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.0.0'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pyrealb import *\n",
    "loadFr()        # indiquer que la réalisation se fera en français\n",
    "pyrealb_version # vérifier la version de pyrealb qui devrait être '3.0.0'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Création et réalisation d'un premier mot\n",
    "\n",
    "On appelle un constructeur pour créer une structure Python, par exemple pour créer un nom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pyrealb.TerminalFr.TerminalFr at 0x10ef7ed90>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(\"chat\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cet appel a bien construit une structure Python intéressante, mais pour en obtenir la réalisation sous forme de chaîne de caractères, il faut appeler `str(..)` (`print(..)` le fait implicitement) ou `.realize()` sur l'objet. \n",
    "\n",
    "Pour simplifier la notation dans les prochains exemples, nous définissons la fonction `realiser()` qui accepte un nombre quelconque de paramètres, qui réalise chacun d'un et qui combine leurs réalisations en une chaine avec un séparateur (une virgule, par défaut)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def realiser(*exps,sep=', '):\n",
    "    return sep.join(exp.realize() for exp in exps)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "qui peut être appelé comme suit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'chat, chien, papillon'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(N('chat'),N(\"chien\"),N(\"papillon\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Création de terminaux\n",
    "On appelle le constructeur en lui donnant en paramètre la forme de base du mot:\n",
    "* singulier pour un article, un nom ou un adjectif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'un, chat, gris'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(D(\"un\"),\n",
    "         N(\"chat\"),\n",
    "         A(\"gris\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* infinitif pour un verbe qui est par défaut conjugué au présent, 3e personne du singulier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aime'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(V(\"aimer\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* première personne du singulier pour un pronom, qui est décliné par défaut à la 3e personne du singulier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'il'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(Pro(\"je\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* adverbe, préposition, conjonction et *canned (quoted) text*, on spécifie la forme qui ne sera pas fléchié à la réalisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tellement, de, ou, Wow!!'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(Adv(\"tellement\"),\n",
    "         P(\"de\"),\n",
    "         C(\"ou\"),\n",
    "         Q(\"Wow!!\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* date: actuelle si aucun paramètre, sinon une date en format ISO. On verra plus tard comment chosir les champs à réaliser "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'le vendredi 25 décembre 2020 à 0 h 0 min 0 s; le dimanche 17 décembre 2023 à 23 h 19 min 1 s'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(DT(\"2020-12-25\"),\n",
    "         DT(),\n",
    "         sep=\"; \")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* nombre correspondant à la valeur numérique donnée en paramètre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123, 45 678'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(NO(123),\n",
    "         NO(45678))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifications à l'aide d'options: _[fonctions d'un terminal](http://www.iro.umontreal.ca/~lapalme/pyrealb/documentation.html#optionsFr)_:\n",
    "* nombre: singulier `.n(\"s\")`, pluriel `.n(\"p\")`\n",
    "* genre: masculin `.g(\"m\")`, féminin `.g(\"f\")`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'une, lapins, grises'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(D(\"un\").g(\"f\"), \n",
    "         N(\"lapin\").n(\"p\"), \n",
    "         A(\"gris\").g(\"f\").n(\"p\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* personne : première `.pe(1)`, deuxième `.pe(2)` ou troisième `.pe(3)`, à combiner avec le nombre\n",
    "* temps: passé simple `.t(\"ps\")`, passé composé `.t(\"pc\")`, futur `.t(\"f\")`, ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'vous, aimâtes, lui, finirons'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(Pro(\"je\").pe(2).n(\"p\"), \n",
    "         V(\"aimer\").t(\"ps\").pe(2).n(\"p\"),\n",
    "         Pro(\"moi\").pe(3), \n",
    "         V(\"finir\").t(\"f\").pe(1).n(\"p\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* formatage de dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'le dimanche 17 décembre 2023; vendredi 25/12/2020'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(DT().dOpt({\"hour\":False,\"minute\":False,\"second\":False,\"nat\":True}),\n",
    "         DT(\"2020-12-25\").dOpt({\"hour\":False,\"minute\":False,\"second\":False,\"nat\":False}),\n",
    "         sep=\"; \")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* formatage de nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cent vingt-trois, quinzième, 3,1416'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(NO(123).dOpt({\"nat\":True}),\n",
    "         NO(15).dOpt({\"ord\":True}),\n",
    "         NO(3.141592).dOpt({\"mprecision\":4}))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sortie HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'un, <a href=\"https://fr.wikipedia.org/wiki/Chat\" target=\"_blank\">chat</a>, <i>gris</i>'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(D('un'),\n",
    "         N(\"chat\").tag(\"a\",\n",
    "                       {\"href\":\"https://fr.wikipedia.org/wiki/Chat\",\n",
    "                        \"target\":\"_blank\"}),\n",
    "         A(\"gris\").tag(\"i\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Création de syntagmes\n",
    "Les syntagmes sont obtenus par composition d'appels à des terminaux ou à d'autres syntagmes.\n",
    "* *syntagme nominal* (`NP`) à l'intérieur duquel le genre et le nombre du premier nom sont propagés aux autres composants, la position des adjectifs par rapport au nom est donnée par le lexique\n",
    "* *syntagme verbal* (`VP`) contenant souvent un syntagme nominal comme complément direct\n",
    "* *phrase* (`S`) qui combine typiquement (mais pas seulement) un syntagme nominal et un syntagme verbal. Le premier syntagme nominal est considéré comme le sujet de la phrase avec lequel le verbe du premier syntagme verbal sera accordé. Par défaut, `S` à la racine met la première lettre en majuscule et ajoute un point à la fin de la phrase.\n",
    "\n",
    "Nous créons deux syntagmes nominaux, un syntagme verbal et une phrase qui seront utilisés dans des expressions ultérieures. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "np1 = NP(D(\"le\"),\n",
    "         N(\"souris\").n(\"p\"),\n",
    "         A(\"petit\"),\n",
    "         A(\"gris\"))\n",
    "np2 = NP(D(\"le\"), \n",
    "         N(\"orange\"))\n",
    "s = S(np1,\n",
    "      VP(V(\"manger\").t(\"f\"), \n",
    "          np2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant affichons leur réalisations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"les petites souris grises, l'orange, Les petites souris grises mangeront l'orange. \""
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(np1,np2,s)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifications de syntagme avec des options, i.e. [fonctions qui sont des propriétés des objets Phrase](http://rali.iro.umontreal.ca/JSrealB/current/documentation/user.html?lang=fr#npMod)\n",
    "\n",
    "Une caractéristique intéressante d'une phrase est le fait qu'elle peut être modifiée. Par exemple, une structure de phrase affirmative peut être réalisée comme une négative, une passive ou une question.  Plus d'un millier de structures différentes peuvent être obtenues à partir d'une seule structure affirmative.\n",
    "\n",
    "Par exemple, pour réaliser une version négative et passive de la phrase précédente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'orange ne sera pas mangée par les petites souris grises. \""
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(S(np1,\n",
    "           VP(V(\"manger\").t(\"f\"), \n",
    "              np2)).typ({\"neg\":True,\"pas\":True}))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme une option peut modifier la structure interne d'un syntagme lors de sa réalisation, c'est aussi vrai pour un terminal, il est préférable de créer une copie de l'objet avant de le réaliser, lorsqu'on prévoit le réutiliser.\n",
    "\n",
    "**Ce _problème_ est exacerbé dans ce  _notebook Jupyter_ car une cellule peut être évaluée, donc réalisée, plusieurs fois modifiant ainsi la structure à chaque fois.**\n",
    "\n",
    "Une façon simple de créer une copie d'une expression est de définir une fonction qui retournera une nouvelle expression à chaque appel. Cette façon de procéder a l'avantage de permettre de paramétrer l'expression. Pour notre variable `np1`, elle sera paramétrée par le nombre, singulier par défaut. Par convention, nous suffixons le nom par `_f` pour nous rappeler que c'est une fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def np1_f(n=\"s\"):\n",
    "  return NP(D(\"le\"),\n",
    "            N(\"chat\").n(n),\n",
    "            A(\"petit\"),\n",
    "            A(\"noir\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction peut être appelée plusieurs fois, créant une nouvelle expression à chaque appel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'les petits chats noirs, le petit chat noir'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "realiser(np1_f(\"p\"),np1_f())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme ce type de fonction se limite souvent à retourner une valeur, on peut utiliser des _lambda_. On peut définir deux fonctions pour les syntagmes précédents et réaliser deux nouvelles phrases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Les petits chats noirs mangent les oranges. || L'orange n'est pas mangée par le petit chat noir. \""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np2_f = lambda n = \"s\": NP(D(\"le\"),N(\"orange\").n(n))\n",
    "s_f = lambda n = \"s\" : S(np1_f(n),VP(V(\"manger\"),np2_f(n)))\n",
    "realiser(s_f(\"p\"),s_f().typ({\"neg\":True,\"pas\":True}),sep=\"|| \")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour simplifier la notation pour les prochains exemples de transformations, nous définissons la fonction suivante qui évalue la fonction pour créer l'expression sur laquelle est appliquée la transformation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def afficher(ph_f,mod_typ={}):\n",
    "    return ph_f().typ(mod_typ).realize()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Phrase originale:\n",
    "\n",
    "* sa réalisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Le petit chat noir mange l'orange. \""
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(s_f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sa négation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Le petit chat noir ne mange pas l'orange. \""
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(s_f,{\"neg\":True})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sa négation au passif introduisant l'auxiliaire être dont l'attribut doit s'accorder avec le sujet "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'orange n'est pas mangée par le petit chat noir. \""
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(s_f,{\"neg\":True,\"pas\":True})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* question sur le sujet du verbe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Qui mange l'orange? \""
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(s_f,{\"int\":\"wos\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* question sur l'objet du verbe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Qu'est-ce que le petit chat noir mange? \""
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(s_f,{\"int\":\"wad\"})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variante avec une subordonnée\n",
    "\n",
    "La subordonnée est créée en ajoutant un `SP` comme dernier constituant de `np2_f`. Ceci a permis d'imbriquer la subordonnée à l'intérieur du `NP`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp_f = lambda : S(np2_f().add(SP(Pro(\"que\"),\n",
    "                                 np1_f(),\n",
    "                                 VP(V(\"manger\").t(\"pc\")))),\n",
    "                 VP(V(\"être\"),\n",
    "                    A(\"mûr\")).t(\"ps\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* la structure résultante montrée en tant que code source\n",
    "``` python\n",
    "S(NP(D('le'),\n",
    "     N('orange').n(\"s\"),\n",
    "     SP(Pro('que'),\n",
    "        NP(D('le'),\n",
    "           N('chat').n(\"s\"),\n",
    "           A('petit'),\n",
    "           A('noir')),\n",
    "        VP(V('manger').t(\"pc\")))),\n",
    "  VP(V('être'),\n",
    "     A('mûr')).t(\"ps\"))\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sa réalisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'orange que le petit chat noir a mangée fut mûre. \""
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(sp_f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sa négation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'orange que le petit chat noir a mangée ne fut pas mûre. \""
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(sp_f,{\"neg\":True})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntagme coordonné\n",
    "\n",
    "`CP` permet de réaliser une liste de syntagmes où tous les éléments sont séparés par une virgule, sauf les deux derniers qui sont séparés par une conjonction qui est spécifiée à l'intérieur (souvent comme premier paramètre) du constructeur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp_f = lambda: CP(C(\"et\"),\n",
    "                  NP(D(\"le\"),N(\"éléphant\")),\n",
    "                  NP(D(\"le\"),N(\"souris\")),\n",
    "                  NP(D(\"un\"),N(\"loup\"))) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* une utilisation dans une phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'éléphant, la souris et un loup sont arrivés. \""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda: S(cp_f(), \n",
    "                   VP(V(\"arriver\").t(\"pc\"))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* on peut y ajouter des éléments, ici un nouveau `NP` contenant un nombre en toutes lettres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"L'éléphant, la souris, un loup et vingt-cinq chiens sont arrivés. \""
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda: S(cp_f().add(NP(NO(25).nat(True),\n",
    "                            N(\"chien\"))),\n",
    "                   VP(V(\"arriver\").t(\"pc\"))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pronominalisation\n",
    "\n",
    "Afin d'alléger le texte, il est souvent intéressant de remplacer un syntagme nominal par un pronom.\n",
    "Soient les deux constituants suivants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "garcon_f = lambda: NP(D(\"le\"),N(\"garçon\"),A(\"beau\"))\n",
    "femme_f = lambda: NP(D(\"un\"),N(\"femme\"),A(\"intelligent\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construisons une phrase initiale avec un verbe au passé composé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Le beau garçon a aimé une femme intelligente. '"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda: S(garcon_f(),\n",
    "                   VP(V(\"aimer\").t(\"pc\"),\n",
    "                      femme_f())))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronominalisons le sujet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Il a aimé une femme intelligente. '"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda: S(garcon_f().pro(),\n",
    "                   VP(V(\"aimer\").t(\"pc\"),\n",
    "                      femme_f())))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronominalisons aussi l'objet. On remarque que le pronom a été placé avant le verbe et que le participe passé avec *avoir* a été accordé correctement avec son complément d'objet direct qui maintenant le précède."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Qui ne l'a plus aimée? \""
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda: S(garcon_f().pro(),\n",
    "                   VP(V(\"aimer\").t(\"pc\"),\n",
    "                      femme_f().pro())))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notation en dépendances\n",
    "\n",
    "Pour réaliser des phrases, il est aussi possible d'utiliser une notation en [syntaxe de dépendances](https://en.wikipedia.org/wiki/Dependency_grammar). \n",
    "\n",
    "Une dépendance est créée avec une fonction qui indique le nom de la relation: `root`, `subj` (sujet) , `det` (determiner) `comp` (complément), `mod` (modificateur). Leur premier paramètre est un `Terminal` qui constitue la tête de cette dépendance. Les autres paramètres, s'il y en a, sont les dépendances associées à la tête. \n",
    "\n",
    "Plutôt que de combiner des syntagmes pour créer une phrase comme on l'a montré précédemment, on construit une structure par des appels correspondant des noms de relation indiquant le rôle de cette dépendance dans la phrase. Le premier paramètre étant la tête de la dépendance. **pyrealb** utilise cette information sur les rôles pour effectuer les accords. \n",
    "\n",
    "Dans l'exemple suivant, le sujet au pluriel forcera le pluriel du déterminant et du verbe. Dans le complément, le genre féminin de souris est propagé au modificateur, l'adjectif `blanc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Les chats mangeaient une souris blanche. '"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda:root(V(\"manger\").t(\"i\"),\n",
    "                     subj(N(\"chat\").n(\"p\"),\n",
    "                          det(D(\"le\"))),\n",
    "                     comp(N(\"souris\"),\n",
    "                          det(D(\"un\")),\n",
    "                          mod(A(\"blanc\")))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les phrases coordonnées sont construites à l'aide de la fonction `coord` qui a comme tête la conjonction de coordination et, comme dépendants, des relations qui doivent toutes être du même type. Par exemple;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'La soupe, des légumes ou du poulet ne sont pas mangés par le garçon et la fille. '"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "afficher(lambda:root(V(\"manger\"),\n",
    "                     coord(C(\"et\"),\n",
    "                          subj(N(\"garçon\"),det(D(\"le\"))),\n",
    "                          subj(N(\"fille\"),det(D(\"le\")))),\n",
    "                     coord(C(\"ou\"),\n",
    "                          comp(N(\"soupe\"),det(D(\"le\"))),                  \n",
    "                          comp(N(\"légume\").n(\"p\"),det(D(\"un\"))),\n",
    "                          comp(N(\"poulet\"),det(D(\"le\"),\n",
    "                                               mod(P(\"de\")).pos(\"pre\"))))),{\"pas\":True,\"neg\":True})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pyrealb** détermine l'ordre des mots dans une phrase: `det` et `subj` apparaissent avant la tête, alors que `comp` et `mod` viennent après. Cet ordre par défaut peut être changé en spécifiant `.pos()` avec paramètre `pre` ou `post` comme dans l'exemple précédent où on voulait que `de` apparaisse avant `le`. En cas d'égalité de position, on utilise la position relative dans l'expression."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Ces quelques expressions ont illustré certaines possibilités de **pyrealb** pour la réalisation de phrases en français. Plusieurs accords sont effectués automatiquement ainsi que l'élision. Une fois établie la structure de base d'une phrase, il est possible d'en obtenir de multiples variantes (négation, passivation ou interrogation) en ne spécifiant que des options au niveau de la phrase. \n",
    "\n",
    "Vous pouvez voir d'autres [démonstrations](https://github.com/lapalme/pyrealb/tree/main/demos).\n",
    "\n",
    "[Guy Lapalme](mailto:lapalme@iro.umontreal.ca)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.11.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6e67b6aeadde66d5ca52686905ccfb75449b7be33eaca437f591eb4c7acc9558"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}