Constructeur de la classe Lemme à partir de la ligne linea.

        Exemple de linea avec numéro d'éclat:
            # cădo|lego|cĕcĭd|cās|is, ere, cecidi, casum|687
            #   0 | 1  | 2   | 3 |     4                | 5

        :param linea: Ligne à parser
        :type linea: str
        :param origin: 0 for original curated lemma, 1 for automatic import from Gaffiot
        :type origin: int
        :param _deramise: Force the deramisation of the normalized graphie
        :type _deramise: bool

def parse_lemme(self, linea: str, origin: int=0, _deramise: bool=True):
        """ Constructeur de la classe Lemme à partir de la ligne linea.

        Exemple de linea avec numéro d'éclat:
            # cădo|lego|cĕcĭd|cās|is, ere, cecidi, casum|687
            #   0 | 1  | 2   | 3 |     4                | 5

        :param linea: Ligne à parser
        :type linea: str
        :param origin: 0 for original curated lemma, 1 for automatic import from Gaffiot
        :type origin: int
        :param _deramise: Force the deramisation of the normalized graphie
        :type _deramise: bool
        """
        eclats = linea.split('|')
        lg = eclats[0].split('=')

        if _deramise:
            cle = atone(deramise(lg[0]))
        else:
            cle = atone(lg[0])

        # Some lemma have homonyms, we have a number do differentiate them
        nh = 0
        if cle[-1].isnumeric():
            nh = int(cle[-1])
            grd = cle[:-1]
        else:
            grd = cle

        # We setup the accentuated graphie
        if len(lg) == 1:
            grq = grd
        else:
            grq = lg[1]
        # Pour l'affichage des dictionnaires, élimine les doubles de la forme canonique
        gr = atone(grq.split(",")[0])
        grModele = eclats[1]
        modele = self.lemmatiseur.modele(grModele)

        # contrôle de format. la liste doit avoir 6 items
        if len(eclats) < 6:
            warnings.warn("Ligne mal formée : " + gr + "\n ---Dernier champ " + eclats[-1] + "\n ---" + linea)

        radicaux = DefaultOrderedDict(list)
        # lecture des radicaux, 2 et 3
        for i in range(2, 4):
            if eclats[i]:
                lrad = eclats[i].split(',')
                for rad in lrad:
                    radicaux[i - 1].append(Radical(rad, i - 1))

        # Gros doute sur le fonctionnement ici
        indMorph = eclats[4]
        match_renvoi = Lemme.RENVOI.match(indMorph)
        if match_renvoi is not None:
            renvoi = match_renvoi.group(1)
        else:
            renvoi = ""

        pos = ""
        if "adj." in indMorph:
            pos += 'a'
        if "conj" in indMorph:
            pos += 'c'
        if "excl." in indMorph:
            pos += 'e'
        if "interj" in indMorph:
            pos += 'i'
        if "num." in indMorph:
            pos += 'm'
        if "pron." in indMorph:
            pos += 'p'
        if "prép" in indMorph:
            pos += 'r'
        if "adv" in indMorph:
            pos += 'd'
        if " nom " in indMorph:
            pos += 'n'
        if "npr." in indMorph:
            pos += 'n'
        if not pos:
            pos = modele.pos()  # Je prends le POS du modèle
            if pos == "d" and renvoi:
                pos = ""
                # S'il y a un renvoi (cf.) et que le modèle a donné le POS "d" (adverbe),
                # je prendrai le pos du renvoi (les indéclinables ont le POS par défaut "d").
                # Je ne peux pas le faire maintenant !

        # Nombre d'occurrences
        if len(eclats[5]):
            nbOcc = int(eclats[5])
        else:
            nbOcc = 1


        lemma = Lemme(
            cle=cle,
            graphie=gr, graphie_accentuee=grq,
            modele=modele, radicaux=radicaux,
            parent=self.lemmatiseur,
            nombre_homonymie=nh, nbOcc=nbOcc,
            origin=origin, pos=pos
        )
        # We register the lemma for each radical
        for radNum in lemma._radicaux:
            for rad in lemma._radicaux[radNum]:
                rad.set_lemme(lemma)
        self._register_lemme(lemma)
        return lemma