Grammalecte  Check-in [967fb3887c]

Overview
Comment:[build] new checkAgreement function, [core] remove legacy code, [fr] clarification conj 3pl
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | fr | core | build
Files: files | file ages | folders
SHA3-256: 967fb3887c59e9a1dee231e9373379f9f2a8328ffdcf2ef37e878371d2bcf8d8
User & Date: olr on 2020-05-08 19:18:58
Other Links: manifest | tags
Context
2020-05-09
07:33
[fr] ajustements pour conjugaisons [core] remove legacy code check-in: d858319927 user: olr tags: core, fr, trunk
2020-05-08
19:18
[build] new checkAgreement function, [core] remove legacy code, [fr] clarification conj 3pl check-in: 967fb3887c user: olr tags: build, core, fr, trunk
18:12
[fr] ajustements et faux positifs check-in: 74b71b524a user: olr tags: fr, trunk
Changes

Modified compile_rules_graph.py from [14532ae517] to [a158723aa9].

    53     53       sCode = re.sub(r"\b(morph|analyse|tag|value)\(<(\d+)", 'g_\\1(g_token(lToken, nTokenOffset+1-\\2)', sCode)    # previous token
    54     54       sCode = re.sub(r"\bspell *[(]", '_oSpellChecker.isValid(', sCode)
    55     55       sCode = re.sub(r"\bbefore\(\s*", 'look(sSentence[:lToken[1+nTokenOffset]["nStart"]], ', sCode)          # before(sCode)
    56     56       sCode = re.sub(r"\bafter\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', sCode)                 # after(sCode)
    57     57       sCode = re.sub(r"\bbefore0\(\s*", 'look(sSentence0[:lToken[1+nTokenOffset]["nStart"]], ', sCode)        # before0(sCode)
    58     58       sCode = re.sub(r"\bafter0\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', sCode)                # after0(sCode)
    59     59       sCode = re.sub(r"\banalyseWord[(]", 'analyse(', sCode)
           60  +    sCode = re.sub(r"\bcheckAgreement[(]\\(\d+), *\\(\d+)", 'g_checkAgreement(lToken[nTokenOffset+\\1], lToken[nTokenOffset+\\2]', sCode)
    60     61       sCode = re.sub(r"[\\](\d+)", 'lToken[nTokenOffset+\\1]["sValue"]', sCode)
    61     62       sCode = re.sub(r"[\\]-(\d+)", 'lToken[nLastToken-\\1+1]["sValue"]', sCode)
    62     63       sCode = re.sub(r">1", 'lToken[nLastToken+1]["sValue"]', sCode)
    63     64       sCode = re.sub(r"<1", 'lToken[nTokenOffset]["sValue"]', sCode)
    64     65       return sCode
    65     66   
    66     67   

Modified gc_lang/fr/modules-js/gce_analyseur.js from [d1adb20722] to [9617baecc3].

    47     47   }
    48     48   
    49     49   function apposition (sWord1, sWord2) {
    50     50       // returns true if nom + nom (no agreement required)
    51     51       return sWord2.length < 2 || (cregex.mbNomNotAdj(_oSpellChecker.getMorph(sWord2)) && cregex.mbPpasNomNotAdj(_oSpellChecker.getMorph(sWord1)));
    52     52   }
    53     53   
    54         -function isAmbiguousNAV (sWord) {
    55         -    // words which are nom|adj and verb are ambiguous (except être and avoir)
    56         -    let lMorph = _oSpellChecker.getMorph(sWord);
    57         -    if (lMorph.length === 0) {
    58         -        return false;
    59         -    }
    60         -    if (!cregex.mbNomAdj(lMorph) || sWord == "est") {
    61         -        return false;
    62         -    }
    63         -    if (cregex.mbVconj(lMorph) && !cregex.mbMG(lMorph)) {
    64         -        return true;
    65         -    }
    66         -    return false;
    67         -}
    68         -
    69         -function isAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj) {
    70         -    //// use it if sWord1 won’t be a verb; word2 is assumed to be true via isAmbiguousNAV
    71         -    let lMorph2 = _oSpellChecker.getMorph(sWord2);
    72         -    if (lMorph2.length === 0) {
    73         -        return false;
    74         -    }
    75         -    if (cregex.checkConjVerb(lMorph2, sReqMorphConj)) {
    76         -        // verb word2 is ok
    77         -        return false;
    78         -    }
    79         -    let lMorph1 = _oSpellChecker.getMorph(sWord1);
    80         -    if (lMorph1.length === 0) {
    81         -        return false;
    82         -    }
    83         -    if (cregex.checkAgreement(lMorph1, lMorph2) && (cregex.mbAdj(lMorph2) || cregex.mbAdj(lMorph1))) {
    84         -        return false;
    85         -    }
    86         -    return true;
    87         -}
    88         -
    89     54   function isVeryAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj, bLastHopeCond) {
    90     55       //// use it if sWord1 can be also a verb; word2 is assumed to be true via isAmbiguousNAV
    91     56       let lMorph2 = _oSpellChecker.getMorph(sWord2);
    92     57       if (lMorph2.length === 0) {
    93     58           return false;
    94     59       }
    95     60       if (cregex.checkConjVerb(lMorph2, sReqMorphConj)) {
................................................................................
   109     74       }
   110     75       //if cregex.isNomAdjVerb(lMorph1): # considered true
   111     76       if (bLastHopeCond) {
   112     77           return true;
   113     78       }
   114     79       return false;
   115     80   }
           81  +
           82  +function g_checkAgreement (oToken1, oToken2) {
           83  +    // check agreement between <oToken1> and <oToken2>
           84  +    let lMorph1 = oToken1.hasOwnProperty("lMorph") ? oToken1["lMorph"] : _oSpellChecker.getMorph(oToken1["sValue"]);
           85  +    if (lMorph1.length === 0) {
           86  +        return true;
           87  +    }
           88  +    let lMorph2 = oToken2.hasOwnProperty("lMorph") ? oToken2["lMorph"] : _oSpellChecker.getMorph(oToken2["sValue"]);
           89  +    if (lMorph2.length === 0) {
           90  +        return true;
           91  +    }
           92  +    return cregex.checkAgreement(lMorph1, lMorph2);
           93  +}
   116     94   
   117     95   function checkAgreement (sWord1, sWord2) {
   118     96       let lMorph2 = _oSpellChecker.getMorph(sWord2);
   119     97       if (lMorph2.length === 0) {
   120     98           return true;
   121     99       }
   122    100       let lMorph1 = _oSpellChecker.getMorph(sWord1);

Modified gc_lang/fr/modules/gce_analyseur.py from [09993a8236] to [8df2416282].

    36     36       return s1 + " et " + s2
    37     37   
    38     38   
    39     39   def apposition (sWord1, sWord2):
    40     40       "returns True if nom + nom (no agreement required)"
    41     41       return len(sWord2) < 2 or (cr.mbNomNotAdj(_oSpellChecker.getMorph(sWord2)) and cr.mbPpasNomNotAdj(_oSpellChecker.getMorph(sWord1)))
    42     42   
    43         -
    44         -def isAmbiguousNAV (sWord):
    45         -    "words which are nom|adj and verb are ambiguous (except être and avoir)"
    46         -    lMorph = _oSpellChecker.getMorph(sWord)
    47         -    if not cr.mbNomAdj(lMorph) or sWord == "est":
    48         -        return False
    49         -    if cr.mbVconj(lMorph) and not cr.mbMG(lMorph):
    50         -        return True
    51         -    return False
    52         -
    53         -
    54         -def isAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj):
    55         -    "use it if <sWord1> won’t be a verb; <sWord2> is assumed to be True via isAmbiguousNAV"
    56         -    lMorph2 = _oSpellChecker.getMorph(sWord2)
    57         -    if not lMorph2:
    58         -        return False
    59         -    if cr.checkConjVerb(lMorph2, sReqMorphConj):
    60         -        # verb word2 is ok
    61         -        return False
    62         -    lMorph1 = _oSpellChecker.getMorph(sWord1)
    63         -    if not lMorph1:
    64         -        return False
    65         -    if cr.checkAgreement(lMorph1, lMorph2) and (cr.mbAdj(lMorph2) or cr.mbAdj(lMorph1)):
    66         -        return False
    67         -    return True
    68         -
    69     43   
    70     44   def isVeryAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj, bLastHopeCond):
    71     45       "use it if <sWord1> can be also a verb; <sWord2> is assumed to be True via isAmbiguousNAV"
    72     46       lMorph2 = _oSpellChecker.getMorph(sWord2)
    73     47       if not lMorph2:
    74     48           return False
    75     49       if cr.checkConjVerb(lMorph2, sReqMorphConj):
................................................................................
    84     58       if cr.isNomAdj(lMorph1):
    85     59           return True
    86     60       #if cr.isNomAdjVerb(lMorph1): # considered True
    87     61       if bLastHopeCond:
    88     62           return True
    89     63       return False
    90     64   
           65  +
           66  +def g_checkAgreement (dToken1, dToken2):
           67  +    "check agreement between <dToken1> and <dToken2>"
           68  +    lMorph1 = dToken1["lMorph"]  if "lMorph" in dToken1  else  _oSpellChecker.getMorph(dToken1["sValue"])
           69  +    if not lMorph1:
           70  +        return True
           71  +    lMorph2 = dToken2["lMorph"]  if "lMorph" in dToken2  else  _oSpellChecker.getMorph(dToken2["sValue"])
           72  +    if not lMorph2:
           73  +        return True
           74  +    return cr.checkAgreement(lMorph1, lMorph2)
           75  +
    91     76   
    92     77   def checkAgreement (sWord1, sWord2):
    93     78       "check agreement between <sWord1> and <sWord1>"
    94     79       lMorph2 = _oSpellChecker.getMorph(sWord2)
    95     80       if not lMorph2:
    96     81           return True
    97     82       lMorph1 = _oSpellChecker.getMorph(sWord1)

Modified gc_lang/fr/rules.grx from [d7aa7b1dc0] to [43d6b2bea4].

 26941  26941   TEST: Vous pouvez tous triompher de votre adversaire avec de la ruse.
 26942  26942   TEST: tous prendre une bonne cuite, voilà ce que nous allons faire.
 26943  26943   TEST: on va tous manger au resto.
 26944  26944   TEST: elles vont toutes aller faire un tour
 26945  26945   
 26946  26946   
 26947  26947   __conj_det_plur_nom__
 26948         -    [ces|mes|tes|ses|nos|vos|leurs|quelques|maints]  @:[NA].*:[pi]¬:V0  @:V¬:(?:[13]p|P|Y|G|M|A.*:e:[pi])
        26948  +    [ces|mes|tes|ses|nos|vos|leurs|quelques|maints]  @:[NA].*:[pi]¬:V0  @:V¬:(?:3p|P|Y|G|M|A.*:[pi])
 26949  26949           <<- /conj/ morph(<1, ":Cs|<start>|>,")
 26950  26950               and not( morph(\3, ":3s") and before("(?i)\\b(?:l[ea] |l’|une? |ce(?:tte|t|) |[mts](?:on|a) |[nv]otre ).+ entre .+ et ") ) >>>
 26951         -        <<- /conj/ not checkAgreement(\2, \3) -3>> =suggVerb(\3, ":3p") && Conjugaison erronée. Accord avec “\1 \2…”. Le verbe devrait être à la 3ᵉ personne du pluriel.
 26952         -        <<- /conj/ __else__ and isAmbiguousAndWrong(\2, \3, ":p", ":3p")
 26953         -        -3>> =suggVerb(\3, ":3p", suggPlur)                             && Accord avec « \1 \2… » incorrect. Conjugaison erronée ou accord nom/adjectif incorrect.
        26951  +        <<- /conj/ morph(\3, ":A.*:s") or (morph(\3, ":N") and morph(\2, ":A")) -3>> =suggVerb(\3, ":3p", suggPlur)     && Accord avec « \1 \2… » incorrect. Conjugaison erronée ou accord nom/adjectif incorrect.
        26952  +        <<- /conj/ __else__ -3>> =suggVerb(\3, ":3p")                                                                   && Conjugaison erronée. Accord avec “\1 \2…”. Le verbe devrait être à la 3ᵉ personne du pluriel.
 26954  26953   
 26955         -    [ces|mes|tes|ses|nos|vos|leurs|quelques|maints]  @:[NA].*:[pi]¬:V0  qui  @:V¬:(?:[13]p|P|Y|G|M|A.*:e:[pi])
        26954  +    [ces|mes|tes|ses|nos|vos|leurs|quelques|maints]  @:[NA].*:[pi]¬:V0  qui  @:V¬:(?:3p|P|Y|G|M|A.*:e:[pi])
 26956  26955           <<- /conj/ morph(<1, ":Cs|<start>|>,")
 26957  26956               and not( morph(\4, ":3s") and before("(?i)\\b(?:l[ea] |l’|une? |ce(?:tte|t|) |[mts](?:on|a) |[nv]otre ).+ entre .+ et ") )
 26958         -        -4>> =suggVerb(\4, ":3p")                                       && Conjugaison erronée. Accord avec “\1 \2 \3…”. Le verbe devrait être à la 3ᵉ personne du pluriel.
        26957  +        -4>> =suggVerb(\4, ":3p")                                                                                       && Conjugaison erronée. Accord avec “\1 \2 \3…”. Le verbe devrait être à la 3ᵉ personne du pluriel.
 26959  26958   
 26960  26959   TEST: Ses « chiens » {{coure}} sur ma pelouse.
 26961  26960   TEST: mes filles {{passe}} ce matin
 26962  26961   TEST: vos filles {{passes}} ce matin
 26963  26962   TEST: ces travaux qui {{demande}} tant d’efforts.
 26964  26963   TEST: vos questions ne {{réclame}} aucune réflexion.
 26965  26964   TEST: Ces attaques à main armée {{donne}} la chair de poule.
 26966  26965   TEST: Ces marchands {{passe}} leur temps à se quereller.
 26967  26966   TEST: maints hommes {{oublie}} leurs origines pour mieux se construire un passé glorieux
        26967  +TEST: nos hommes qui {{repartirons}} demain
 26968  26968   TEST: le lien entre les agences de renseignement et ces mêmes entreprises pouvait reposer sur des activités de surveillance à proprement parler.
 26969  26969   TEST: trier les cons et les connes expose à un violent coup de boomerang
 26970  26970   TEST: Tu penses que quelqu’un qui frappe sa femme et ses enfants est un bon père ?
 26971  26971   
 26972  26972   
 26973  26973   __conj_det_plur_nom_confusion__
 26974  26974       les  @:[NA].*:[pi]¬:V0  @:V¬:(?:3p|P|Y|G|M|A.*:e:[pi])