regles_v2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#%save Mot.py _ih[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#!/usr/bin/env python\n",
    "# coding: utf-8\n",
    "from nltk.stem.snowball import FrenchStemmer\n",
    "\n",
    "class Mot:\n",
    "\n",
    "    def __init__(self, label = \"\", role = \"\", ner = \"\"):\n",
    "        self.label = label\n",
    "        self.role = role\n",
    "        self.ner = ner\n",
    "        ##print(repr(label))\n",
    "        stemmer = FrenchStemmer()\n",
    "        self.lemma = stemmer.stem(label)\n",
    "        \n",
    "        \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"label = \" + self.label + \" role = \" + self.role + \" ner \" + self.ner +\"\\n\"\n",
    "\n",
    "    def show_label(self):\n",
    "        print(self.label)\n",
    "    def show_role(self):\n",
    "        print(self.role)\n",
    "    def show_ner(self):\n",
    "        print(self.ner)\n",
    "\n",
    "if __name__ == \"__main__\" :\n",
    "    #chaque personne est un homme ou une femme\n",
    "    m1 = Mot (u\"parents\", \"det\", \"0\")\n",
    "    #print(m1.lemma)\n",
    "    m2 = Mot (u\"parent\", \"nc\", \"0\")\n",
    "    #print(m2.lemma)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#%save parametres.py _ih[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LISTE_ETRE = [u'été', u'étée', u'étées', u'étés', u'étant', 'suis', 'es', 'est', 'sommes', u'êtes', 'sont', 'serai', 'seras', \n",
    "              'sera', 'serons', 'serez', 'seront', 'serais', 'serait', 'serions', 'seriez', 'seraient', u'étais', u'était', \n",
    "              u'étions', u'étiez', u'étaient','fus', 'fut', u'fûmes', u'fûtes', 'furent', 'sois', 'soit', 'soyons', 'soyez',\n",
    "              'soient', 'fusse', 'fusses', u'fût', 'fussions', 'fussiez', 'fussent']\n",
    "\n",
    "LISTE_AVOIR = ['a','ayant', 'eu', 'eue', 'eues', 'eus', 'ai', 'as', 'avons', 'avez', 'ont', 'aurai', 'auras', 'aura', 'aurons',\n",
    "               'aurez', 'auront', 'aurais', 'aurait', 'aurions', 'auriez', 'auraient', 'avais', 'avait', 'avions', 'aviez',\n",
    "               'avaient', 'eut', u'eûmes', u'eûtes', 'eurent', 'aie', 'aies', 'ait', 'ayons', 'ayez', 'aient', 'eusse','eusses',\n",
    "               u'eût', 'eussions', 'eussiez', 'eussent']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#%save objets_relation.py _ih[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('False', 'son concept', 'personne')\n"
     ]
    }
   ],
   "source": [
    "from Mot import Mot\n",
    "\n",
    "class Concepts:\n",
    "    \n",
    "    def __init__(self, mot):\n",
    "            ##print(\"mot not null\")\n",
    "            self.clabel = mot.label\n",
    "            self.lemma = mot.lemma\n",
    "            ##print(\"lemme \", self.lemma)\n",
    "            self.mot = mot\n",
    "            self.relations_g = [] #liste des relations dans lesquelles nous avons le concept en objet_g\n",
    "            self.relations_d = [] #liste des relations dans lesquelles nous avons le concept en objet_d\n",
    "            self.decompositions = []\n",
    "    \n",
    "    \n",
    "    \n",
    "        \n",
    "class Objets(Concepts) :\n",
    "    \n",
    "    def __init__(self, label, mots , is_conc, conc):\n",
    "        Concepts.__init__(self, conc)\n",
    "        ##print(\"ahhhhhhhhhhhhhhh\", self.clabel)\n",
    "        self.is_conc = is_conc\n",
    "        self.label = label\n",
    "        self.mots = mots\n",
    "        return\n",
    "        \n",
    "    \n",
    "    \n",
    "        \n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    methode qui retourne l'indice du 'cc' lorsqu'il existe\n",
    "    \"\"\"    \n",
    "    def is_relation(self):\n",
    "        indice = -1\n",
    "        i = 0\n",
    "        for mot in self.mots:\n",
    "            if \"cc\" in mot.role:\n",
    "                indice = i\n",
    "                break;\n",
    "            elif \"CC\" in mot.role:\n",
    "                indice = i\n",
    "                break;\n",
    "            i += 1\n",
    "        return indice\n",
    "                \n",
    "    \"\"\"\n",
    "    methode qui convertie un objet compose en Relation\n",
    "    \"\"\"    \n",
    "        \n",
    "    def get_relation(self, indice, les_objets):\n",
    "        \n",
    "        new1, obj1 = self.getObjet (0, indice, les_objets)\n",
    "        new2, obj2 = self.getObjet (indice + 1, len (self.mots), les_objets)\n",
    "        lien = self.mots[indice]\n",
    "        return obj1, obj2, lien, new1, new2  \n",
    "    \n",
    "    def contains_adj(self,):\n",
    "        for mot in self.mots:\n",
    "            if(mot.role == \"ADJ\"):\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    def is_adj(self,):\n",
    "        if len(self.mots) == 1:\n",
    "            return self.mots[0].role == \"ADJ\"\n",
    "        return False\n",
    "    def appartient(self, o_label, les_objets):\n",
    "        for obj in les_objets:\n",
    "            label = obj.label\n",
    "            if o_label.replace(\" \", \"\") == label.replace(\" \",\"\"):\n",
    "                return True, obj\n",
    "        return False, None\n",
    "            \n",
    "    def union_objets(self, objet2):\n",
    "        newlabel= self.label + \" et \" + objet2.label\n",
    "        newMot = self.mots\n",
    "        newMot.append(Mot(\"et\", \"DET\", \"O\"))\n",
    "        newMot.extend(objet2.mots)\n",
    "        is_conc,conc = isconcept(newMot)\n",
    "        return Objets(newlabel, newMot, is_conc, conc)\n",
    "    \n",
    "    #les_objets represente la liste des objets deja traités\n",
    "    def getObjet(self, indice_ini, indice_fin, les_objets): \n",
    "        #print(\"dkhal get objet\")\n",
    "        o_mot = self.mots[indice_ini : indice_fin]\n",
    "        o_label = \"\"\n",
    "        for mot in o_mot:\n",
    "            if mot.label != \".\":\n",
    "                o_label += mot.label + \" \"\n",
    "            else:\n",
    "                o_label += mot.label\n",
    "        #print(\"olabel\", o_label)\n",
    "        app, obj = self.appartient(o_label, les_objets)\n",
    "        #print(\"aaaaaaaaaaaa\",app, \"obj \", str(obj))\n",
    "        if app :  \n",
    "            return not app, obj\n",
    "        else:\n",
    "            #print(\"getobjettttttttttttttttt \", o_mot[0])\n",
    "            is_conc, conc = isconcept(o_mot)\n",
    "            #print (\"is_conc\", conc)\n",
    "             \n",
    "            ##print(\"getobjettttttttttttttttt \",is_conc)\n",
    "            return not app, Objets(o_label, o_mot, is_conc, conc)\n",
    "    \n",
    "    \"\"\"\n",
    "    cette methode permet de mettre un objet qui était à droite de la relation en objet gauche\n",
    "    en mettant la première lettre en majuscule.\n",
    "    \"\"\"\n",
    "    \n",
    "    def objet_dTo_g(self):\n",
    "        premier_mot = self.mots[0].label\n",
    "        premier_mot = premier_mot[0].upper() + premier_mot[1:]\n",
    "        self.mots[0].label = premier_mot\n",
    "        self.label = self.label[0].upper() + self.label[1:]\n",
    "        return self\n",
    "    \n",
    "    def objet_gTo_d(self):\n",
    "        premier_mot = self.mots[0].label\n",
    "        premier_mot = premier_mot[0].lower() + premier_mot[1:]\n",
    "        self.mots[0].label = premier_mot\n",
    "        self.label = self.label[0].lower() + self.label[1:]\n",
    "        return self\n",
    "        \n",
    "    \n",
    "    def __str__(self):\n",
    "        \n",
    "        res = \"label \" + self.label +\" \\nmots[\"\n",
    "        for mot in self.mots:\n",
    "            res += str(mot) + \" , \"\n",
    "        res += \"]\"\n",
    "        return res;\n",
    "    \n",
    "    def affichage(self): \n",
    "        \n",
    "        self.show_label()\n",
    "        self.show_mots()\n",
    "\n",
    "        \n",
    "    def show_label(self):\n",
    "        print(self.label)\n",
    "        \n",
    "    def show_mots(self):\n",
    "        for mot in self.mots:\n",
    "            print(str(mot)) \n",
    "   \n",
    "\n",
    "\"\"\"\n",
    "Cette classe represente une relation est sous la forme objet_g ----> lien -----> objet_d\n",
    "elle est definie par deux objets de la classe Objets objet_g et objet_d\n",
    "et d'un lien qui est un Mot\n",
    "\"\"\"\n",
    "class Relation:\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self, objet_g, objet_d, lien, ponctuation, label, sous_relation):\n",
    "        self.objet_g = objet_g\n",
    "        self.objet_d = objet_d\n",
    "        self.lien = lien\n",
    "        self.label = label\n",
    "        self.sous_relation = sous_relation\n",
    "        self.ponctuation = ponctuation\n",
    "        #self.les_objets = []\n",
    "        self.origine = []\n",
    "        \n",
    "    def __str__(self):\n",
    "        res = self.label + \"\\n\" + str(self.objet_g) + \"\\n--->\\n\" + str(self.lien) + \"\\n--->\\n\" + str(self.objet_d)\n",
    "        res += \"\\nsous-relation\\n\\t\" + str(self.sous_relation) + \"\\norigine\\n\\t\"\n",
    "        for o in self.origine:\n",
    "            res += str(o.relationToligne()) + \"\\t\"\n",
    "        return res\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    methode qui retourne True si la relation est simple c-a-d contient un seul un mot verbe un mot \n",
    "    sinon elle retourne False\n",
    "    \n",
    "    \"\"\"\n",
    "    def relationToligne(self):\n",
    "        return self.objet_g.label + self.lien.label +\" \"+ self.objet_d.label + self.ponctuation.label\n",
    "    \n",
    "    def isSimple(self):\n",
    "        #print(\"hhhhhhh\")\n",
    "        return (self.objet_g.is_relation() == -1) and (self.objet_d.is_relation() == -1)\n",
    "            \n",
    "    \"\"\"\n",
    "    cette fonction sert à convertir une phrase quelconque en une relation\n",
    "    \"\"\"\n",
    "def getRelation_verbe(label, mots, roles, ners, les_objets):\n",
    "    #lesmots represente la liste des mots sous format d'objets de la classe Mot\n",
    "    lesmots = []\n",
    "    for i in range(len(mots)):\n",
    "        lesmots.append(Mot(mots[i], roles[i], ners[i]))\n",
    "    is_conc, conc = isconcept(lesmots)\n",
    "    #print(\"premier isconcept\")\n",
    "    objet = Objets(label, lesmots, is_conc, conc)\n",
    "    try:\n",
    "        indice = roles.index(\"V\")\n",
    "        new, objet_g = objet.getObjet(0, indice, les_objets)\n",
    "        #print(\"OBJET G\")\n",
    "        try:\n",
    "            indice_ponc = roles.index(\"PUNC\")\n",
    "        except:\n",
    "            indice_ponc = len(roles)-1\n",
    "        if new:\n",
    "            les_objets.append(objet_g)\n",
    "        new, objet_d = objet.getObjet(indice+1, indice_ponc,  les_objets)\n",
    "        if new:\n",
    "            les_objets.append(objet_g)\n",
    "        lien = lesmots[indice]\n",
    "        ponctuation = lesmots [indice_ponc]\n",
    "        ind = objet_d.is_relation()\n",
    "        if ind != -1 :\n",
    "            objg, objd, lien1, new1, new2 = objet_d.get_relation(ind, les_objets)\n",
    "            if new1:\n",
    "                les_objets.append(objg)\n",
    "            if new2:\n",
    "                les_objets.append(objd)\n",
    "            sous_relation = Relation(objg, objd, lien1, None , \"conj de coordination\", None)\n",
    "        else:\n",
    "            sous_relation = None\n",
    "        return les_objets, Relation(objet_g, objet_d, lien, ponctuation, \"verbe\", sous_relation)\n",
    "    except Exception as e:\n",
    "        message = str(e)\n",
    "        ##print(message)\n",
    "        raise ValueError(\"il n'y a pas de verbe!!! \" + message) \n",
    "def isconcept(mots):\n",
    "    i = 0\n",
    "    le_conc = None\n",
    "    if len(mots) == 1:\n",
    "        #print(\"len 1\")\n",
    "        if mots[0].role == \"NPP\":\n",
    "            if mots[0].ner == \"PERSON\":\n",
    "                #print(\"dans person\")\n",
    "                le_conc = Mot(\"personne\", \"NC\", \"O\")\n",
    "                #print (\"leconc \", le_conc.clabel)\n",
    "            elif mots[0].ner == \"LOCATION\":\n",
    "                le_conc = Mot(\"lieu\", \"NC\", \"O\")\n",
    "            else:\n",
    "                le_conc = Mot(\"inconnu\", \"null\", \"O\")\n",
    "            return False, le_conc\n",
    "        elif mots[0].role == \"DET\":\n",
    "            return False, None\n",
    "        else:\n",
    "            return True, mots[0]\n",
    "    else:\n",
    "        for mot in mots: # traitement du cas où nous avons un  nom commun dans la liste des mots\n",
    "            if mot.role == \"NC\" or mot.role == \"N\":\n",
    "                le_conc = mot\n",
    "                label = \"\"\n",
    "                for lab in range(0, i):\n",
    "                    label += mots[lab].label + \" \"\n",
    "                if label in ['tout ', 'chaque ', 'toute ', 'tous les ', \"toutes les \", \"tous \", \"toutes \"]:\n",
    "                    return True, le_conc\n",
    "                return False, le_conc\n",
    "            i +=1\n",
    "        for mot in mots: #traitement du cas où nous n'avons pas de nom commun mais un adjectif\n",
    "            if mot.role == \"ADJ\":\n",
    "                le_conc = mot\n",
    "                return False , le_conc  \n",
    "    return False, le_conc\n",
    "\n",
    "if __name__ == \"__main__\" :\n",
    "        #chaque personne est un homme ou une femme\n",
    "\n",
    "    ners = ['PERSON', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['NPP', 'V', 'DET', 'NC', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Patrick', 'est', 'un', 'homme', 'ou', 'une', 'femme', '.']\n",
    "    label = \"Patrick est un homme ou une femme.\"\n",
    "    les_objets = []\n",
    "    liste_objet, r = getRelation_verbe(label, words, roles, ners, les_objets)\n",
    "    print(str(r.objet_g.is_conc), \"son concept\", r.objet_g.clabel)\n",
    "    #print(str(r.relationToligne()))\n",
    "    \n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    cette classe \n",
    "    \n",
    "    \"\"\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#%save gestion.py _ih[14]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('new ', True)\n",
      "('the_coonc', u'societ')\n",
      "('new ', True)\n",
      "('the_coonc', u'de')\n",
      "chaque societe a des hommes et des femmes .\n",
      "('new ', True)\n",
      "('the_coonc', u'societ')\n",
      "('new ', True)\n",
      "('the_coonc', u'de')\n",
      "False\n",
      "(1, '\\n elem 0', 'chaque societe a des enfants et des parents .')\n"
     ]
    }
   ],
   "source": [
    "from Mot import Mot\n",
    "from objets_relation import Relation, Objets, Concepts, isconcept\n",
    "from parametres import *\n",
    "\n",
    "\n",
    "class Gestionnaire_Relation:\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self, ):\n",
    "        self.liste_relations = []\n",
    "        self.liste_objets = []\n",
    "        self.conclusions = []\n",
    "        self.hypotheses = []\n",
    "        self.liste_concepts = []\n",
    "        self.decomposition = {}\n",
    "        self.objets_d_relations = {}\n",
    "        self.objets_g_relations = {}\n",
    "        \n",
    "    \"\"\" \n",
    "    cette fonction permet de mettre toutes les tettres d'une phrase en miniscule sauf si c'est un nom propore\n",
    "    \"\"\"\n",
    "    def pre_traitement(self,label, mots, roles):\n",
    "\n",
    "        for i in range(len(mots)):\n",
    "            if roles[i] != \"NPP\":\n",
    "                m = mots[i].lower()\n",
    "                mots[i] = m\n",
    "        label=\"\"\n",
    "        for mot in mots:\n",
    "            label+= mot + \" \"\n",
    "        label = label[0: len(label)-1]\n",
    "        return label\n",
    "        \n",
    "    def ajouter_relation(self, label, words, roles, ners) :\n",
    "        \n",
    "        relation = self.getRelation_verbe(label, words, roles, ners)\n",
    "        self.liste_relations.append(relation)\n",
    "        return relation\n",
    "\n",
    "    \n",
    "    def concept_existant(self, conc_lemma):\n",
    "        for c in self.liste_concepts:\n",
    "            #print(c)\n",
    "            if c.lemma == conc_lemma:\n",
    "                return True, c\n",
    "        return False, None\n",
    "    \n",
    "    def ajout_objet(self, indice_ini, indice_fin, objets):\n",
    "        new, objet = objets.getObjet(indice_ini, indice_fin, self.liste_objets)\n",
    "        print(\"new \", new)\n",
    "        exist, conc = self.concept_existant(objet.lemma)\n",
    "        #print(\"exist\", exist)\n",
    "        if exist == False:\n",
    "            print (\"the_coonc\", objet.lemma)\n",
    "            self.liste_concepts.append(Concepts(objet.mot))\n",
    "        \"\"\"\n",
    "        else:\n",
    "            #self, label, mots , is_conc, conc\n",
    "            new_obj = Objets(objet.label, objet.mots, objet.is_conc, objet.mot)\n",
    "            objet = new_obj\n",
    "        \"\"\"\n",
    "        if new:\n",
    "            self.liste_objets.append(objet)\n",
    "            \n",
    "        return objet\n",
    "        \n",
    "    def ajout_obj_sousrelation(self, objet, new):\n",
    "        exist, conc = self.concept_existant(objet.lemma)\n",
    "        if exist == False:\n",
    "            self.liste_concepts.append(Concepts(objet.mot))\n",
    "        \"\"\"\n",
    "        else:\n",
    "            #self, label, mots , is_conc, conc\n",
    "            new_obj = Objets(objet.label, objet.mots, objet.is_conc, objet.mot)\n",
    "            objet = new_obj     \n",
    "        \"\"\"\n",
    "        if new:\n",
    "            self.liste_objets.append(objet)\n",
    "            \n",
    "        return objet\n",
    "        \n",
    "        \n",
    "    \"\"\"\n",
    "    cette fonction sert à convertir une phrase quelconque en une relation\n",
    "    \"\"\"\n",
    "    def getRelation_verbe(self, label, mots, roles, ners):\n",
    "        \n",
    "        #lesmots represente la liste des mots sous format d'objets de la classe Mot\n",
    "        lesmots = []\n",
    "        for i in range(len(mots)):\n",
    "            lesmots.append(Mot(mots[i], roles[i], ners[i]))\n",
    "        #print(\"iiiiiiiiiiiiiiii\",len(lesmots))\n",
    "        is_conc, conc = isconcept(lesmots)   \n",
    "        objet = Objets(label, lesmots, False, conc)\n",
    "        try:\n",
    "            indice = roles.index(\"V\")\n",
    "            #print(\"indice\", indice)\n",
    "            objet_g = self.ajout_objet(0, indice, objet)\n",
    "            #print(\"ajout g ok\")\n",
    "            try:\n",
    "                indice_ponc = roles.index(\"PUNC\")\n",
    "            except:\n",
    "                indice_ponc = len(roles)-1\n",
    "            #print(\"indice_ponc\", indice_ponc)\n",
    "            objet_d = self.ajout_objet(indice+1, indice_ponc, objet)\n",
    "            \n",
    "            #print(\"ajout d ok\")\n",
    "            lien = lesmots[indice]\n",
    "            ##print(\"oooooooooooooooooooooooooooo\", indice_ponc, \"len len\", len(lesmots))\n",
    "            ponctuation = lesmots [indice_ponc]\n",
    "            ind = objet_d.is_relation()\n",
    "            if ind != -1 :\n",
    "                objg, objd, lien1, new1, new2 = objet_d.get_relation(ind, self.liste_objets)\n",
    "                obj_g = self.ajout_obj_sousrelation(objg, new1)\n",
    "                obj_d = self.ajout_obj_sousrelation(objd, new2)\n",
    "                sous_relation = Relation(obj_g, obj_d, lien1, None , \"conj de coordination\", None) \n",
    "            else:\n",
    "                sous_relation = None\n",
    "            r = Relation(objet_g, objet_d, lien, ponctuation, \"verbe\", sous_relation)\n",
    "            if ind != -1 :    \n",
    "                if(lien1.lemma == \"ou\"):\n",
    "                    self.decomposition[objet_g] = [sous_relation, r]\n",
    "            if objet_g.is_conc :\n",
    "                self.traitement_relation_concept(objet_g, r,\"relation_g\")\n",
    "            if objet_d.is_conc :\n",
    "                self.traitement_relation_concept(objet_d, r, \"relation_d\")\n",
    "            \n",
    "            return r\n",
    "        except Exception as e:\n",
    "            raise ValueError(\"il n'y a pas de verbe!!! \", str(e))\n",
    "        return\n",
    "    \n",
    "    def traitement_relation_concept(self, objet, relation, position):\n",
    "        if objet.is_conc:\n",
    "            if position == \"relation_g\":\n",
    "                objet.relations_g.append(relation)\n",
    "            elif position == \"relation_d\":\n",
    "                objet.relations_d.append(relation)            \n",
    "            \n",
    "    def traitement_avoir(self, relation):\n",
    "        ##print (\"rrrr\", relation)\n",
    "        if(relation == None):\n",
    "            lien = Mot(\"est partie de\", \"V\", \"O\")\n",
    "            return lien\n",
    "        elif relation.lien.label == \"et\":\n",
    "            lien = Mot(\"sont partie de\", \"V\", \"O\")\n",
    "            return lien\n",
    "        else:\n",
    "            return None\n",
    "    \n",
    "    \n",
    "    \n",
    "    def traitement_NPropore(self, relation):\n",
    "        \n",
    "        return None\n",
    "    \n",
    "        \n",
    "    def concatene_objets (self, objs):\n",
    "        newMot = objs[0].mots\n",
    "        vergule = Mot(\",\", \"PUNC\", \"O\")\n",
    "        newlabel = objs[0].label\n",
    "        for i in range(1, len(objs)-1):\n",
    "            newMot.append(vergule)\n",
    "            newMot.extend(objs[i].mots)\n",
    "            newlabel += \", \" + objs[i].label\n",
    "        newMot.append(Mot(\"ou\", \"CC\", \"O\"))\n",
    "        newMot.extend(objs[len(objs)-1].mots)\n",
    "        newlabel += \"ou \" + objs[len(objs)-1].label\n",
    "        is_conc, conc = isconcept(newMot)\n",
    "        \n",
    "        return Objets(newlabel, newMot, is_conc, conc)\n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction sert à traiter la règle:\n",
    "    Si obj1 est obj2 ou obj3 ET obj2 est obj21 ou obj22 ET obj3 est obj31 ou obj32 Alors\n",
    "    obj1 est obj21 , obj22, obj31 ou obj32\n",
    "    \"\"\"\n",
    "    def decomposer(self, new_relation):\n",
    "        if new_relation.sous_relation != None:\n",
    "            if(new_relation.objet_g in self.decomposition.keys()):\n",
    "                #print(\"il est dans les keys\")\n",
    "                relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)\n",
    "                #print(\"pere \"+str(pere)+\"\\n\"+str(relation_pere))\n",
    "                #print(\"frere \"+str(objet_frere)+\"\\n\")\n",
    "                if  pere != None:\n",
    "                    if(objet_frere in self.decomposition.keys()):\n",
    "                        sous1 = new_relation.sous_relation\n",
    "                        sous2, relation_frere = self.decomposition[objet_frere]\n",
    "\n",
    "                        print (sous2.lien)\n",
    "                        print(sous1.lien)\n",
    "                        newobjet = self.concatene_objets([sous1.objet_g, sous1.objet_d, sous2.objet_g, sous2.objet_d])\n",
    "                        self.liste_objets.append(newobjet)\n",
    "                        ind = newobjet.is_relation()\n",
    "                        objg, objd, lien1, new1, new2 = newobjet.get_relation(ind, self.liste_objets)\n",
    "                        if new1:\n",
    "                            self.liste_objets.append(objg)\n",
    "                        if new2:\n",
    "                            self.liste_objets.append(objd)\n",
    "                        sous_relation = Relation(objg, objd, lien1, None , \"conj de coordination\", None)\n",
    "                        r = Relation(pere, newobjet, new_relation.lien, new_relation.ponctuation, \"verbe\", \n",
    "                                    sous_relation)\n",
    "                        #print(\"ooooooooooooooooooo \"+str(relation_pere)+\"\\n aaaaaaaaaaaaa \"+ str(relation_frere) + \n",
    "                        #\"\\n bbbbbbbbbbbbb \"+str(new_relation))\n",
    "                        r.origine.extend([relation_pere, relation_frere, new_relation])\n",
    "                        return r \n",
    "        return None\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction permet de detecter si un objet fait partie de la décomposition d'un autre objet et\n",
    "    de retourner cet objet père  \n",
    "    \"\"\"\n",
    "    def pere_de(self, objet):\n",
    "        ##print(\"dkhal pere_de\")\n",
    "        for key, relation in self.decomposition.items():\n",
    "            ##print(\"key \"+ str(key) + \"relation 0\" +str(relation[0]) + \"relation 1\" +str(relation[1]))\n",
    "            if(objet == relation[0].objet_g):\n",
    "                return relation[1], key,  relation[0].objet_d\n",
    "            if (objet == relation[0].objet_d):\n",
    "                return relation[1], key,  relation[0].objet_g\n",
    "        return None, None, None\n",
    "    \n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction sert à traiter la règle:\n",
    "    Si obj1 est obj2 ET obj2 est obj3 Alors\n",
    "    obj1 est obj3\n",
    "    \"\"\"\n",
    "    def chercher_ascendant(self, new_relation):\n",
    "        #print(\"dkhal lahna\"+ new_relation.relationToligne())\n",
    "        for relation in self.liste_relations:\n",
    "            if relation.lien.label in LISTE_ETRE:\n",
    "                #print(\"rd\", relation.objet_d, \"nrd\", new_relation.objet_d, \"rg\", relation.objet_g,\"nrg\", new_relation.objet_g)\n",
    "                if relation.objet_d == new_relation.objet_g:\n",
    "                    r = Relation(relation.objet_g, new_relation.objet_d, relation.lien, relation.ponctuation, \"verbe\", \n",
    "                                new_relation.sous_relation)\n",
    "                    r.origine.extend([relation,new_relation])\n",
    "                    return r\n",
    "                if relation.objet_g == new_relation.objet_d:\n",
    "                    #print(\"dkhal lahna\")\n",
    "                    r = Relation(new_relation.objet_g, relation.objet_d, relation.lien, relation.ponctuation, \"verbe\", \n",
    "                                None)\n",
    "                    r.origine.extend([relation,new_relation])\n",
    "                    return r\n",
    "        return None\n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction  sert à traiter la règle:\n",
    "    Si obj1 est obj2 ou obj3   Et   obj2 est obj4    et  obj3 est obj5 Alors\n",
    "    \n",
    "    obj1 est obj4 ou obj5\n",
    "    \"\"\"\n",
    "    def nouvelle_decomposition (self, new_relation):\n",
    "        relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)\n",
    "        if pere!= None:\n",
    "            for relation in self.liste_relations:\n",
    "                if (relation.lien.label in LISTE_ETRE) and (relation.objet_g == objet_frere) and (relation.sous_relation == None):\n",
    "                    new_obj = self.concatene_objets([relation.objet_d, new_relation.objet_d])\n",
    "                    self.liste_objets.append(new_obj)\n",
    "                    lien1 = Mot(\"ou\", \"CC\", \"O\")\n",
    "                    sous_relation = Relation(relation.objet_d, new_relation.objet_d, lien1, None , \"conj de coordination\", None)\n",
    "                    r = Relation(pere, new_obj, relation.lien, relation.ponctuation, \"verbe\", sous_relation)\n",
    "                    r.origine.extend([relation_pere, relation, new_relation])\n",
    "                    return r\n",
    "        return None\n",
    "                    \n",
    "            \n",
    "            \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    \"\"\"\n",
    "    cette fonction sert à traiter la règle:\n",
    "    Si obj1 est obj2 Et obj3 est obj2 Alors\n",
    "    obj1 et Obj3 sont obj2\n",
    "    \"\"\"\n",
    "    def union(self, new_relation):\n",
    "        for relation in self.liste_relations:\n",
    "            if relation.lien.label in ['est']:\n",
    "                if(relation != new_relation):\n",
    "                    if relation.objet_d == new_relation.objet_d:\n",
    "                        newobj = relation.objet_g.union_objets(new_relation.objet_g)\n",
    "                        newlien = Mot(\"sont\", \"V\", \"O\")\n",
    "                        r = Relation(newobj, new_relation.objet_d, newlien, relation.ponctuation, \"verbe\", \n",
    "                                    new_relation.sous_relation)\n",
    "                        r.origine.extend([relation,new_relation])\n",
    "                        return r\n",
    "                else:\n",
    "                    return None\n",
    "        return None\n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction sert à traiter la règle:\n",
    "    Si obj1 est obj2 ou obj3  ET  obj3 est obj2 Alors\n",
    "    obj3 est probablement Obj1 \n",
    "    \"\"\"\n",
    "    def simple_hypothese(self, relation):\n",
    "        relation_pere, pere, objet_frere = self.pere_de(relation.objet_d)\n",
    "        ##print(\"ooooooooooooooooooooooo\",str(pere))\n",
    "        if pere != None:\n",
    "            lien = Mot(\"est probablement\", \"V\", \"O\")\n",
    "            r = Relation(relation.objet_g, pere, lien, relation.ponctuation, \"verbe\", None)\n",
    "            r.origine.extend([relation_pere, relation])\n",
    "            return r\n",
    "        else:\n",
    "            return None\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    cette fonction sert à traiter la règle:\n",
    "    Si obj1 est obj2 ou obj3  ET  obj4 est obj5 ou obj2 Alors\n",
    "    obj4 est probablement Obj1 \n",
    "    \"\"\"\n",
    "    def complex_hypothese(self, relation):\n",
    "        sous_relation, r = self.decomposition[relation.objet_g]\n",
    "        relation_pere_d, pere_d, objet_frere_d = self.pere_de(sous_relation.objet_d)\n",
    "        if (pere_d != None) and not(pere_d == relation.objet_g):\n",
    "            lien = Mot(\"est probablement\", \"V\", \"O\")\n",
    "            res = Relation(relation.objet_g, pere_d, lien, relation.ponctuation, \"verbe\", None)\n",
    "            res.origine.extend([relation_pere_d, relation])\n",
    "            return res\n",
    "        relation_pere_g, pere_g, objet_frere_g = self.pere_de(sous_relation.objet_g)\n",
    "        if (pere_g != None) and not(pere_g == relation.objet_g):\n",
    "            lien = Mot(\"est probablement\", \"V\", \"O\")\n",
    "            res = Relation(relation.objet_g, pere_g, lien, relation.ponctuation, \"verbe\", None)\n",
    "            res.origine.extend([relation_pere_g, relation])\n",
    "            return res\n",
    "        return None\n",
    "        \n",
    "        \n",
    "        \n",
    "    def getHypothese(self, relation):\n",
    "        nouvelles_hypotheses = []\n",
    "        new = False\n",
    "        if(not relation.objet_d.is_adj()):\n",
    "            if relation.lien.label in LISTE_ETRE:   #il faut que ça soit la liste du verbe etre\n",
    "                if(relation.sous_relation == None):\n",
    "                    r = self.simple_hypothese(relation)\n",
    "                    ##print(r.relationToligne())\n",
    "                    if r!=None:\n",
    "                        self.hypotheses.append(r)\n",
    "                        nouvelles_hypotheses.append(r)\n",
    "                        new = True\n",
    "                else:\n",
    "                    r = self.complex_hypothese(relation)\n",
    "                    if r!=None :\n",
    "                        ##print(str(r.relationToligne()))\n",
    "                        self.hypotheses.append(r)\n",
    "                        nouvelles_hypotheses.append(r)\n",
    "                        new = True\n",
    "        while new:\n",
    "            r_new = self.sous_hypotheses(r)\n",
    "            if r_new == None:\n",
    "                new = False\n",
    "            else:\n",
    "                r = r_new\n",
    "                self.hypotheses.append(r)\n",
    "                nouvelles_hypotheses.append(r)   \n",
    "        return nouvelles_hypotheses\n",
    "    \n",
    "    \n",
    "    \n",
    "    def contient (self, obj_g, obj_d, lien):\n",
    "        for relation in self.hypotheses:\n",
    "            if(relation.objet_g == obj_g) and (relation.objet_d == obj_d) and (relation.lien.label == lien.label):\n",
    "                return True\n",
    "        return False\n",
    "    \"\"\"\n",
    "    cette fonction genere les hypotheses respectant la regle\n",
    "    Si obj1 est obj2 Ou obj3 ET obj2 est problablement obj4 Alors\n",
    "    obj1 est probablement obj4.\n",
    "    \"\"\"\n",
    "    \n",
    "    def sous_hypotheses(self, new_relation):\n",
    "        relation_pere, pere, objet_frere = self.pere_de(new_relation.objet_g)\n",
    "        if pere != None:\n",
    "            lien = Mot(\"est probablement\", \"V\", \"O\")\n",
    "            if not self.contient(pere, new_relation.objet_d, lien):\n",
    "                r = Relation(pere, new_relation.objet_d, lien, new_relation.ponctuation, \"verbe\", None)\n",
    "                r.origine.extend([relation_pere, new_relation])\n",
    "                ##print(str(r.relationToligne()))\n",
    "                self.hypotheses.append(r)\n",
    "                return r\n",
    "            else:\n",
    "                return None\n",
    "        else:\n",
    "            return None\n",
    "        #return self.hypotheses\n",
    "                    \n",
    "    \n",
    "    def getConclusions(self, relation):\n",
    "        nouvelles_conclusion = []\n",
    "        new = False\n",
    "        if(not relation.objet_d.is_adj()):\n",
    "            if relation.lien.label in LISTE_AVOIR:   \n",
    "                ##print (\"traitement avoir\")\n",
    "                conc = self.traitement_avoir(relation.sous_relation)\n",
    "                if conc != None:\n",
    "                    ##print(\"coooooooonnnnnnn\", str(conc))\n",
    "                    ##print(str(relation.objet_d.objet_dTo_g()))\n",
    "                    ponct = Mot(\".\", \"PUNC\", \"O\")\n",
    "                    r = Relation(relation.objet_d.objet_dTo_g(), relation.objet_g.objet_gTo_d(), conc, ponct, conc.label, None)\n",
    "                    nouvelles_conclusion.append(r)\n",
    "                    self.conclusions.append(r)\n",
    "                    self.liste_relations.append(r)\n",
    "                    new = True\n",
    "\n",
    "            elif relation.lien.label in LISTE_ETRE:   \n",
    "                # recherche ascendants\n",
    "                r = self.chercher_ascendant (relation)\n",
    "                print(\"rrrrrrrrrrr\",r)\n",
    "                if r != None:\n",
    "                    ##print (r.relationToligne())\n",
    "                    self.conclusions.append(r)\n",
    "                    self.liste_relations.append(r)\n",
    "                    nouvelles_conclusion.append(r)\n",
    "                    new = True\n",
    "                #else:\n",
    "                    ##print (\"pas d'ascendants\")\n",
    "                r = self.union(relation)\n",
    "                if r!=None:\n",
    "                    ##print (r.relationToligne())\n",
    "                    ##print (str(r))\n",
    "                    self.conclusions.append(r)\n",
    "                    self.liste_relations.append(r)\n",
    "                    nouvelles_conclusion.append(r)\n",
    "                    new = True\n",
    "                #else:\n",
    "                    ##print (\"pas d'unions\")\n",
    "                r = self.nouvelle_decomposition(relation)\n",
    "                if r!=None:\n",
    "                    ##print (r.relationToligne())\n",
    "                    ##print (str(r))\n",
    "                    self.conclusions.append(r)\n",
    "                    self.liste_relations.append(r)\n",
    "                    nouvelles_conclusion.append(r)\n",
    "                    new = True\n",
    "                #else:\n",
    "                    ##print (\"pas de nouvelle decomposition\")\n",
    "                r = self.decomposer(relation)\n",
    "                if r!=None:\n",
    "                    ##print (r.relationToligne())\n",
    "                    ##print (str(r))\n",
    "                    self.conclusions.append(r)\n",
    "                    self.liste_relations.append(r)\n",
    "                    nouvelles_conclusion.append(r)\n",
    "                    new = True\n",
    "                #else:\n",
    "                    ##print (\"pas de doomposition multiple\")\n",
    "            else:\n",
    "                print (\"je ne connais pas ce verbe !!!\")\n",
    "        else:\n",
    "            print(\"contient un adjectif\")\n",
    "        return nouvelles_conclusion\n",
    "                    \n",
    "             \n",
    "if __name__ == \"__main__\" :\n",
    "    \n",
    "    #chaque personne est un homme ou une femme\n",
    "    \n",
    "\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O','O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'NC', 'DET','CC', 'DET','NC', 'PUNC']\n",
    "    words = ['Chaque', 'societe', 'a', 'des', 'hommes', 'et', 'des','femmes', '.']\n",
    "    label = \"Chaque societe a des hommes et des femmes.\"\n",
    "    gestion = Gestionnaire_Relation()\n",
    "    label = gestion.pre_traitement(label, words, roles)\n",
    "    #print(\"ph1\")\n",
    "    r1 = gestion.ajouter_relation(label, words, roles, ners)   \n",
    "    print(r1.objet_g.relations_g[0].relationToligne())\n",
    "    \n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O','O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'NC', 'DET','CC', 'DET','NC', 'PUNC']\n",
    "    words = ['Chaque', 'societe', 'a', 'des', 'enfants', 'et', 'des','parents', '.']\n",
    "    label = \"Chaque societe a des enfants et des parents.\"\n",
    "    gestion = Gestionnaire_Relation()\n",
    "    label = gestion.pre_traitement(label, words, roles)\n",
    "    #print(\"ph1\")\n",
    "    r2 = gestion.ajouter_relation(label, words, roles, ners)   \n",
    "    print(r1.objet_g == r2.objet_g)\n",
    "    print(len(r2.objet_g.relations_g), \"\\n elem 0\",r2.objet_g.relations_g[0].relationToligne())\n",
    "    #print(len(gestion.decomposition))\n",
    "    #print(\"conc1\")\n",
    "    \"\"\"\n",
    "    gestion.getConclusions(r)\n",
    "\n",
    "\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Chaque', 'personne', 'est', 'un', 'homme', 'ou', 'une', 'femme', '.']\n",
    "    label = \"Chaque personne est un homme ou une femme.\"\n",
    "    gestion = Gestionnaire_Relation()\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    r = gestion.ajouter_relation(label, words, roles, ners)   \n",
    "    #print(\"okokokokokokok\", len(gestion.decomposition))\n",
    "   \n",
    "    #gestion.getConclusions()\n",
    "    #print(\"hyp1\")\n",
    "    gestion.getHypothese(r)\n",
    "    \n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'PUNC']\n",
    "    words = [u'Chaque', u'père', u'est', u'un', u'homme', '.']\n",
    "    label = u\"Chaque père est un homme.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    r = gestion.ajouter_relation(label, words, roles, ners)   \n",
    "    #print(len(gestion.decomposition))\n",
    "    ##print(\"conc1\")\n",
    "    #gestion.getConclusions()\n",
    "    #print(\"hyp2\")\n",
    "    #print(\"okokokokokokok\", len(gestion.decomposition))\n",
    "    gestion.getHypothese(r)\n",
    "    \n",
    " \n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Un', 'homme', 'est', 'une', 'personne', '.']\n",
    "    label = \"Un homme est une personne.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc3\")\n",
    "    gestion.getConclusions()\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Chaque', 'frère', 'est', 'un', 'homme', '.']\n",
    "    label = \"Chaque père est un homme.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc4\")\n",
    "    gestion.getConclusions()\n",
    "    ners = ['O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'ADJ', 'PUNC']\n",
    "    words = ['Chaque', 'femme', 'est', 'féminine', '.']\n",
    "    label = \"Chaque femme est féminine.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc5\")\n",
    "    gestion.getConclusions()\n",
    "    #print(len(gestion.decomposition))\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Chaque', 'personne', 'est', 'un', 'homme', 'ou', 'une', 'femme', '.']\n",
    "    label = \"Chaque personne est un homme ou une femme.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc6\")\n",
    "    gestion.getConclusions()\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Chaque', 'enfant', 'est', 'un', 'fils', 'ou', 'une', 'fille', '.']\n",
    "    label = \"Chaque enfant est un fils ou une fille.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc7\")\n",
    "    gestion.getConclusions()\n",
    "    #print(len(gestion.decomposition))\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'N', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Un', 'fils', 'est', 'un', 'garçon', 'ou', 'un', 'homme', '.']\n",
    "    label = \"Un fils est un garçon ou un homme.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc8\")\n",
    "    gestion.getConclusions()\n",
    "    #print(len(gestion.decomposition))\n",
    "    ners = ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n",
    "    roles = ['DET', 'NC', 'V', 'DET', 'NC', 'CC', 'DET', 'NC', 'PUNC']\n",
    "    words = ['Une', 'fille', 'est', 'une', 'jeune-fille', 'ou', 'une', 'femme', '.']\n",
    "    label = \"Une fille est une jeune-fille ou une femme.\"\n",
    "    label = gestion.pre_traitement(label, words)\n",
    "    gestion.ajouter_relation(label, words, roles, ners)\n",
    "    #print(\"conc8\")\n",
    "    gestion.getConclusions()\n",
    "    #print(len(gestion.decomposition))\n",
    " \n",
    "    \"\"\"\n",
    "                    \n",
    "                    \n",
    "                \n",
    "                \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "###############Une personne est un homme ou une femme.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'CC', u'DET', u'NC', u'PUNC']\n",
      "('new ', True)\n",
      "('the_coonc', u'person')\n",
      "('new ', True)\n",
      "('the_coonc', u'homm')\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', None)\n",
      "hypotheses \n",
      "\n",
      "###############Une femme est féminine.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'ADJ', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', True)\n",
      "('the_coonc', u'f\\xe9minin')\n",
      "conlusions \n",
      "\n",
      "contient un adjectif\n",
      "hypotheses \n",
      "\n",
      "###############Un homme est masculin.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'ADJ', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', True)\n",
      "('the_coonc', u'masculin')\n",
      "conlusions \n",
      "\n",
      "contient un adjectif\n",
      "hypotheses \n",
      "\n",
      "###############Une famille a parents et enfants.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'NC', u'CC', u'NC', u'PUNC']\n",
      "('new ', True)\n",
      "('the_coonc', u'famill')\n",
      "('new ', True)\n",
      "('the_coonc', u'parent')\n",
      "conlusions \n",
      "\n",
      "Parents et enfants sont partie de une famille .\n",
      "hypotheses \n",
      "\n",
      "###############Un parent est un père ou une mère.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'CC', u'DET', u'NC', u'PUNC']\n",
      "('new ', True)\n",
      "('new ', True)\n",
      "('the_coonc', u'per')\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', None)\n",
      "hypotheses \n",
      "\n",
      "###############Un enfant est un fils ou une fille.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'CC', u'DET', u'NC', u'PUNC']\n",
      "('new ', True)\n",
      "('new ', True)\n",
      "('the_coonc', u'fil')\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', None)\n",
      "hypotheses \n",
      "\n",
      "###############Un père est un homme.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', False)\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', <objets_relation.Relation instance at 0x000000000A8D82C8>)\n",
      "un père est masculin .\n",
      "hypotheses \n",
      "\n",
      "un père est probablement une personne .\n",
      "un parent est probablement une personne .\n",
      "###############Une mère est une femme.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', False)\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', <objets_relation.Relation instance at 0x000000000AC6BB88>)\n",
      "une mère est féminine .\n",
      "un parent est un homme ou une femme .\n",
      "hypotheses \n",
      "\n",
      "une mère est probablement une personne .\n",
      "###############Une jeune-fille est féminine.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'ADJ', u'PUNC']\n",
      "('new ', True)\n",
      "('the_coonc', u'jeune-fill')\n",
      "('new ', False)\n",
      "conlusions \n",
      "\n",
      "contient un adjectif\n",
      "hypotheses \n",
      "\n",
      "###############Un garçon est masculin.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'N', u'V', u'ADJ', u'PUNC']\n",
      "('new ', True)\n",
      "('the_coonc', u'gar\\xe7on')\n",
      "('new ', False)\n",
      "conlusions \n",
      "\n",
      "contient un adjectif\n",
      "hypotheses \n",
      "\n",
      "###############Un fils est un garçon ou un homme.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'N', u'CC', u'DET', u'NC', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', True)\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', None)\n",
      "hypotheses \n",
      "\n",
      "###############Une fille est une jeune-fille ou une femme.###############\n",
      "&&&&&&&&&&&&&&&&&&&&&&&&& roles \n",
      "[u'DET', u'NC', u'V', u'DET', u'NC', u'CC', u'DET', u'NC', u'PUNC']\n",
      "('new ', False)\n",
      "('new ', True)\n",
      "conlusions \n",
      "\n",
      "('rrrrrrrrrrr', None)\n",
      "label = ou role = CC ner O\n",
      "\n",
      "label = ou role = CC ner O\n",
      "\n",
      "un enfant est une jeune-fille , une femme , un garçon ou un homme .\n",
      "hypotheses \n",
      "\n",
      "une fille est probablement une personne .\n",
      "un enfant est probablement une personne .\n"
     ]
    }
   ],
   "source": [
    "import time, codecs\n",
    "from MonCoreNLP import lecture_fichier \n",
    "from MonCoreNLP import get_enhancedPlusPlusDependencies \n",
    "#from gestion import Gestionnaire_Relation\n",
    "\n",
    "\n",
    "def generer_tous_arbres (path):\n",
    "    enhanced = {}\n",
    "    enhanceds = []\n",
    "    arbre = {}\n",
    "    arbres = []\n",
    "    ner = []\n",
    "    roles = []\n",
    "    words = []\n",
    "    relations = []\n",
    "\n",
    "    datum = \"\"\n",
    "    donnees = lecture_fichier(path)\n",
    "    gestion = Gestionnaire_Relation()\n",
    "\n",
    "    for datum in donnees:\n",
    "        premierMoty = \"ROOT\"\n",
    "        print(\"###############\" + datum + \"###############\")\n",
    "        enhanced, ner, roles, words = get_enhancedPlusPlusDependencies(datum)\n",
    "        #print (\"&&&&&&&&&&&&&&&&&&&&&&&&& enhenced \\n\" + str(enhanced))\n",
    "        #print (\"&&&&&&&&&&&&&&&&&&&&&&&&& ner \\n\" + str(ner))\n",
    "        print (\"&&&&&&&&&&&&&&&&&&&&&&&&& roles \\n\" + str(roles))\n",
    "        #print (\"&&&&&&&&&&&&&&&&&&&&&&&&& words \\n\" + str(words))\n",
    "        label = gestion.pre_traitement(datum, words, roles)\n",
    "        r = gestion.ajouter_relation(label, words, roles, ner)\n",
    "        print(\"conlusions \\n\")\n",
    "        conc = gestion.getConclusions(r)\n",
    "        for c in conc:\n",
    "            print(c.relationToligne())\n",
    "        print(\"hypotheses \\n\")\n",
    "        hyp = gestion.getHypothese(r)\n",
    "        for h in hyp:\n",
    "            print(h.relationToligne())\n",
    "       \n",
    "\n",
    "        #relation = Relation.getRelation_verbe(datum, words, roles, ner)\n",
    "        ##print(str(relation))\n",
    "        #relations.append(relation)\n",
    "        #afaire!!!!!\n",
    "        #relations.hypotheses retourne les hypothèses\n",
    "        #relations.conclusions retourne les conclusions\n",
    "        \"\"\"\n",
    "\n",
    "        ********   pour le moment pas besoin des arbres   ***************\n",
    "\n",
    "\n",
    "        arbre = creationArbreDependanceNom (enhanced)\n",
    "        m={}\n",
    "        affichageArbre (premierMoty, arbre, m)\n",
    "        enhanceds.append(enhanced)\n",
    "        arbres.append(arbre)\n",
    "        enhanced = {}\n",
    "        arbre = {}\n",
    "        \"\"\"\n",
    "        datum = \"\"\n",
    "\n",
    "        #print(\"###############################################################\")\n",
    "    \"\"\"vider l'esprit\n",
    "    \"\"\"\n",
    "\n",
    "    #gestion = Gestionnaire_Relation()\n",
    "    \"\"\"\n",
    "     self.liste_relations = []\n",
    "        self.liste_objets = []\n",
    "        self.conclusions = []\n",
    "        self.hypotheses = []\n",
    "        self.liste_concepts = []\n",
    "        self.decomposition = {}\n",
    "    \"\"\"\n",
    "    #print(len(gestion.liste_objets ))\n",
    "#generer_tous_arbres(\"./definition de famille.txt\")\n",
    "generer_tous_arbres(\"./definition de famille (simple).txt\")\n",
    "#generer_tous_arbres(\"./Connaissance des organismes.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}