Grammalecte  Check-in [456aa2a2aa]

Overview
Comment:[lo][fr][py] générateur de conjugaisons: nouvelles fonctions
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | fr | lo | multid
Files: files | file ages | folders
SHA3-256: 456aa2a2aa3f0dc66e0693b16c7f8439c579e06db35b00ddce026d8086078dc4
User & Date: olr on 2018-03-06 16:44:41
Original Comment: [lo][fr] générateur de conjugaisons: nouvelles fonctions
Other Links: branch diff | manifest | tags
Context
2018-03-06
18:16
[fx][fr][js] générateur de conjugaisons: nouvelles fonctions check-in: 0230771aa5 user: olr tags: fr, fx, multid
16:44
[lo][fr][py] générateur de conjugaisons: nouvelles fonctions check-in: 456aa2a2aa user: olr tags: fr, lo, multid
15:38
[core][fr] générateur de conjugaisons comme module (déplacement de fichiers) check-in: fb9f2914eb user: olr tags: core, fr, multid
Changes

Modified gc_lang/fr/modules/conj_generator.py from [2b6010474b] to [908448219c].

     1         -# Conjugation data
            1  +# Conjugation generator
            2  +# beta stage, unfinished, the root for a new way to generate flexions…
     2      3   
     3         -# beta stage, unfinished, may be useless or the root for a new way to generate flexions…
            4  +import re
     4      5   
     5         -# Règles de conjugaison
            6  +
            7  +def conjugate (sVerb, sVerbTag="i_____a", bVarPpas=True):
            8  +    lConj = []
            9  +    cGroup = getVerbGroupChar(sVerb)
           10  +    for nCut, sAdd, sFlexTags, sPattern in getConjRules(sVerb):
           11  +        if not sPattern or re.search(sPattern, sVerb):
           12  +            lConj.append((sVerb[0:-nCut]+sAdd, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
           13  +    return lConj
           14  +
           15  +
           16  +def getVerbGroupChar (sVerb, ):
           17  +    sVerb = sVerb.lower()
           18  +    if sVerb.endswith("er"):
           19  +        return "1"
           20  +    if sVerb.endswith("ir"):
           21  +        return "2"
           22  +    if sVerb == "être" or sVerb == "avoir":
           23  +        return "0"
           24  +    if sVerb.endswith("re"):
           25  +        return "3"
           26  +    return "4"
           27  +
           28  +
           29  +def getConjRules (sVerb, bVarPpas=True, nGroup=2):
           30  +    if sVerb.endswith("er"):
           31  +        # premier groupe, conjugaison en fonction de la terminaison du lemme
           32  +        # 5 lettres
           33  +        if sVerb[-5:] in oConj["V1"]:
           34  +            lConj = oConj["V1"][sVerb[-5:]]
           35  +        # 4 lettres
           36  +        elif sVerb[-4:] in oConj["V1"]:
           37  +            if sVerb.endswith(("eler", "eter")):
           38  +                lConj = oConj["V1"][sVerb[-4:]]["1"]
           39  +            lConj = oConj["V1"][sVerb[-4:]]
           40  +        # 3 lettres
           41  +        elif sVerb[-3:] in oConj["V1"]:
           42  +            lConj = oConj["V1"][sVerb[-3:]]
           43  +        else:
           44  +            lConj = oConj["V1"]["er"]
           45  +        lConj.extend(oConj["V1_ppas"][bVarPpas])
           46  +    elif sVerb.endswith("ir") and nGroup <= 2:
           47  +        # deuxième groupe
           48  +        lConj = oConj["V2"]
           49  +        lConj.extend(oConj["V2_ppas"][bVarPpas])
           50  +    else:
           51  +        # TODO: troisième groupe
           52  +        lConj = [ [0, "", ":Y/*", false] ]
           53  +    return lConj
           54  +
     6     55   
     7     56   oConj = {
     8     57       "V1_ppas": {
     9         -        "var": [
           58  +        True: [
    10     59               [2,     "é",           ":Q:A:1ŝ:m:s/*",     False],
    11     60               [2,     "és",          ":Q:A:m:p/*",        False],
    12     61               [2,     "ée",          ":Q:A:f:s/*",        False],
    13     62               [2,     "ées",         ":Q:A:f:p/*",        False],
    14     63           ],
    15         -        "invar": [
           64  +        False: [
    16     65               [2,     "é",           ":Q:e:i/*",          False],
    17     66           ]
    18     67       },
    19     68   
    20     69       "V2_ppas": {
    21         -        "var": [
           70  +        True: [
    22     71               [2,     "i",           ":Q:A:m:s/*",        False],
    23     72               [2,     "is",          ":Q:A:m:p/*",        False],
    24     73               [2,     "ie",          ":Q:A:f:s/*",        False],
    25     74               [2,     "ies",         ":Q:A:f:p/*",        False],
    26     75           ],
    27         -        "invar": [
           76  +        False: [
    28     77               [2,     "i",           ":Q:e:i/*",          False],
    29     78           ]
    30     79       },
    31     80   
    32     81       # deuxième groupe (le seul groupe régulier)
    33     82       "V2": [
    34     83           [2,     "ir",           ":Y/*",             False],

Modified gc_lang/fr/oxt/DictOptions/LexiconEditor.py from [afd65cf50b] to [2c842dcb12].

   397    397                       c_m = "m"  if self.xV_m.State  else "_"
   398    398                       c_ae = "e"  if self.xV_ae.State  else "_"
   399    399                       c_aa = "a"  if self.xV_aa.State  else "_"
   400    400                       sVerbTag = c_i + c_t + c_n + c_p + c_m + c_ae + c_aa
   401    401                       if not sVerbTag.endswith("__") and not sVerbTag.startswith("____"):
   402    402                           sVerbPattern = self.xVpattern.Text.strip()
   403    403                           if not sVerbPattern:
   404         -                            if sLemma.endswith("er") or sLemma.endswith("ir"):
   405         -                                # tables de conjugaison du 1er et du 2e groupe
   406         -                                cGroup = "1"  if sLemma.endswith("er")  else "2"
   407         -                                for nCut, sAdd, sFlexTags, sPattern in self._getConjRules(sLemma):
   408         -                                    if not sPattern or re.search(sPattern, sLemma):
   409         -                                        self.lGeneratedFlex.append((sLemma[0:-nCut]+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
   410         -                                # participes passés
   411         -                                bPpasVar = "var"  if self.xV_pp.State  else "invar"
   412         -                                lPpasRules = conjgen.oConj["V1_ppas"][bPpasVar]  if sLemma.endswith("er")  else conjgen.oConj["V2_ppas"][bPpasVar]
   413         -                                for nCut, sAdd, sFlexTags, sPattern in lPpasRules:
   414         -                                    if not sPattern or re.search(sPattern, sLemma):
   415         -                                        self.lGeneratedFlex.append((sLemma[0:-nCut]+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
          404  +                            # Utilisation du générateur de conjugaison
          405  +                            for sFlexion, sFlexTags in conjgen.conjugate(sLemma, sVerbTag, bool(self.xV_pp.State)):
          406  +                                self.lGeneratedFlex.append((sFlexion, sLemma, sFlexTags))
   416    407                           else:
   417    408                               # copie du motif d’un autre verbe : utilisation du conjugueur
   418    409                               if conj.isVerb(sVerbPattern):
   419    410                                   oVerb = conj.Verb(sLemma, sVerbPattern)
   420    411                                   for sTag1, dFlex in oVerb.dConj.items():
   421    412                                       if sTag1 != ":Q":
   422    413                                           for sTag2, sConj in dFlex.items():
................................................................................
   442    433                   # Autre
   443    434                   sFlexion = self.xFlexion.Text.strip()
   444    435                   sTags = self.xTags.Text.strip()
   445    436                   if sFlexion and sTags.startswith(":"):
   446    437                       self.lGeneratedFlex.append((sFlexion, sLemma, sTags))
   447    438           self._showGenWords()
   448    439   
   449         -    def _getConjRules (self, sVerb):
   450         -        if sVerb.endswith("ir"):
   451         -            # deuxième groupe
   452         -            return conjgen.oConj["V2"]
   453         -        elif sVerb.endswith("er"):
   454         -            # premier groupe, conjugaison en fonction de la terminaison du lemme
   455         -            # 5 lettres
   456         -            if sVerb[-5:] in conjgen.oConj["V1"]:
   457         -                return conjgen.oConj["V1"][sVerb[-5:]]
   458         -            # 4 lettres
   459         -            if sVerb[-4:] in conjgen.oConj["V1"]:
   460         -                if sVerb.endswith(("eler", "eter")):
   461         -                    return conjgen.oConj["V1"][sVerb[-4:]]["1"]
   462         -                return conjgen.oConj["V1"][sVerb[-4:]]
   463         -            # 3 lettres
   464         -            if sVerb[-3:] in conjgen.oConj["V1"]:
   465         -                return conjgen.oConj["V1"][sVerb[-3:]]
   466         -            return conjgen.oConj["V1"]["er"]
   467         -        else:
   468         -            # troisième groupe
   469         -            return [ [0, "", ":Y/*", false] ]
   470         -
   471    440       def _showGenWords (self):
   472    441           xGridDataModel = self.xGridModelNew.GridDataModel
   473    442           xGridDataModel.removeAllRows()
   474    443           if not self.lGeneratedFlex:
   475    444               self.xAdd.Enabled = False
   476    445               return
   477    446           for i, (sFlexion, sLemma, sTag) in enumerate(self.lGeneratedFlex):