Chaque item de la liste list_of_lines est constitué de champs séparé par le caractère ':'. Le premier champ est un mot clé. Le parent est le lemmatiseur.
        Pour le format du fichier data/modeles.la, la documentation utilisateur.

        :param list_of_lines: Liste de champs séparés par le caractère ":". Le premier champ est un mot-clef
        :return: model
        :rtype: Modele

def parse_modele(self, list_of_lines: list):
        """ Chaque item de la liste list_of_lines est constitué de champs séparé par le caractère ':'. Le premier champ est un mot clé. Le parent est le lemmatiseur.
        Pour le format du fichier data/modeles.la, la documentation utilisateur.

        :param list_of_lines: Liste de champs séparés par le caractère ":". Le premier champ est un mot-clef
        :return: model
        :rtype: Modele
        """
        grq = list_of_lines[0].split(":")[1]
        gr = atone(grq)
        modele = Modele(graphie=gr, graphie_accentuee=grq, parent=self.lemmatiseur)
        pere = None

        for original_l in list_of_lines[1:]:
            # remplacement des variables par leur valeur
            l = "" + original_l

            # TODO : Ajouté * pour la premiere capture pour rendre le prefix optionnel...
            for pre, v in Modele.RE.findall(l):
                var = self.lemmatiseur.variable(v)
                if pre:
                    var = var.replace(";", ";" + pre)
                l = l.replace(v, var)

            eclats = simplified(l).split(":")
            # type_of_line -> pere des  des+  R   abs
            #                  0    1    2    3    4
            type_of_line = MODELE_CLEFS.index(eclats[0])
            if type_of_line == 0:  # père
                modele._pere = pere = self.lemmatiseur.modele(eclats[1])
            elif type_of_line == 1 or type_of_line == 2:
                # des+: désinences s'ajoutant à celles du père
                # des: désinences écrasant celles du père
                index_morphologies = listeI(eclats[1])  # Anciennement li
                radical = int(eclats[2])  # Anciennement "r"
                liste_desinences = eclats[3].split(';')  # Anciennement "ld"
                for i in range(len(index_morphologies)):
                    if i < len(liste_desinences):
                        liste_desinences_definitives = liste_desinences[i].split(',')  # Anciennement "ldd"
                    else:
                        liste_desinences_definitives = liste_desinences[-1].split(',')

                    for graphie in liste_desinences_definitives:
                        nd = Desinence(graphie, index_morphologies[i], nr=radical, parent=modele)
                        modele._desinences[nd.morphoNum()].append(nd)
                        self.ajDesinence(nd)

                # si des+, chercher les autres désinences chez le père :
                if type_of_line == 2:
                    for i in index_morphologies:
                        for dp in pere.desinences(i):
                            dh = modele.clone(dp)  # cloner la désinence
                            modele._desinences[i].append(dh)
                            self.ajDesinence(dh)

            elif type_of_line == 3:  # R:n: radical n
                modele._genRadicaux[int(eclats[1])] = eclats[2]
            elif type_of_line == 4:  # abs
                modele._absents = listeI(eclats[1])
            elif type_of_line == 7:  # abs+
                modele._absents += listeI(eclats[1])
            elif type_of_line == 5:  # suffixes suf:<intervalle>:valeur
                lsuf = listeI(eclats[1])
                gr = eclats[2]  # TODO verif : bien formée ?
                for m in lsuf:
                    modele.msuff[gr].append(m)
            elif type_of_line == 6:  # sufd: les désinences du père, suffixées
                if pere:
                    suf = eclats[1]
                    ld = pere.desinences()
                    for d in ld:
                        if d.morphoNum() in modele._absents:
                            continue
                        nd = allonge(d.grq())
                        dsuf = Desinence(nd+suf, d.morphoNum(), d.numRad(), modele)
                        modele._desinences[dsuf.morphoNum()].append(dsuf)
                        self.ajDesinence(dsuf)
            elif type_of_line == 8:  # POS
                modele.set_pos(eclats[1])
            else:
                warnings.warn("Modele : Erreur pour " + l, UnknownModeleConfigurationKey)

        # père
        if pere:
            if not modele.pos():  # Small difference with original codebase : we inherit the pos if the parent has it
                modele.set_pos(pere.pos())
            for m in pere.morphos():
                # héritage des désinence
                if modele.deja(m):
                    continue
                ld = pere.desinences(m)
                for d in ld:
                    if d.morphoNum() in modele._absents:  # morpho absente chez le descendant
                        continue
                    dh = modele.clone(d)
                    modele._desinences[dh.morphoNum()].append(dh)
                    self.ajDesinence(dh)

            # héritage des radicaux
            for numRad in set([d.numRad() for d in flatten(modele._desinences.values())]):
                if numRad not in modele._genRadicaux:
                    if pere.hasRadical(numRad):
                        modele._genRadicaux[numRad] = pere.genRadical(numRad)
                    else:
                        if self._debug:
                            warnings.warn(gr + " has no radical {}".format(numRad), MissingRadical)

            # héritage des absents
            modele._absents = pere.absents()

        # génération des désinences suffixées
        ldsuf = []
        clefsSuff = set(list(modele.msuff.keys()))
        for suff in clefsSuff:
            for d in flatten(modele._desinences.values()):
                if d.morphoNum() in modele.msuff[suff]:
                    gq = d.grq()
                    if gq == "-":
                        gq = ""
                    gq += suff
                    dsuf = Desinence(gq, d.morphoNum(), d.numRad(), modele)
                    ldsuf.append(dsuf)

        for dsuf in ldsuf:
            modele._desinences[dsuf.morphoNum()].append(dsuf)
            self.ajDesinence(dsuf)

        return modele