Grammalecte  Check-in [2281684b2d]

Overview
Comment:[core][fr] improve suggSimil: filter names derivating from verbs, code clarification [fr] update suggestions tests
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | fr | core
Files: files | file ages | folders
SHA3-256: 2281684b2deb9309b1f4b8dcc796d72339f252cda9b384c5c53ee0b6231b1415
User & Date: olr on 2021-01-25 18:27:03
Other Links: manifest | tags
Context
2021-01-26
14:44
[core][fr] avoid and check suggestions duplicates check-in: 624e793673 user: olr tags: trunk, fr, core
2021-01-25
18:27
[core][fr] improve suggSimil: filter names derivating from verbs, code clarification [fr] update suggestions tests check-in: 2281684b2d user: olr tags: trunk, fr, core
15:12
[fr] suggestions: verbe-nous -> interrogatif + impératif check-in: 623e5fc83d user: olr tags: trunk, fr
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified gc_lang/fr/modules-js/conj.js from [9439cc3700] to [03aa2c6aa7].

︙︙
85
86
87
88
89
90
91
92

93

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139


140


141

142
143
144
145
146
147
148
149
150

        // returns raw informations about sVerb
        if (!this._dVerb.hasOwnProperty(sVerb)) {
            return null;
        }
        return this._lVtyp[this._dVerb[sVerb][0]];
    },

    getSimil: function (sWord, sMorph, bSubst=false) {

        if (!sMorph.includes(":V")) {

            return new Set();
        }
        let sInfi = sMorph.slice(1, sMorph.indexOf("/"));
        let aSugg = new Set();
        let tTags = this._getTags(sInfi);
        if (tTags) {
            if (!bSubst) {
                // we suggest conjugated forms
                if (sMorph.includes(":V1")) {
                    aSugg.add(sInfi);
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":3s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":2p"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Iq", ":1s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Iq", ":3s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Iq", ":3p"));
                } else if (sMorph.includes(":V2")) {
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":1s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":3s"));
                } else if (sMorph.includes(":V3")) {
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":1s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Ip", ":3s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Is", ":1s"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":Is", ":3s"));
                } else if (sMorph.includes(":V0a")) {
                    aSugg.add("eus");
                    aSugg.add("eut");
                } else {
                    aSugg.add("étais");
                    aSugg.add("était");
                }
                aSugg.delete("");
            } else {
                if (this._dVerbNames.hasOwnProperty(sInfi)) {
                    // there are names derivated from the verb
                    aSugg.gl_update(this._dVerbNames[sInfi]);
                } else {
                    // we suggest past participles
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":PQ", ":Q1"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":PQ", ":Q2"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":PQ", ":Q3"));
                    aSugg.add(this._getConjWithTags(sInfi, tTags, ":PQ", ":Q4"));
                    aSugg.delete("");
                    // if there is only one past participle (epi inv), unreliable.
                    if (aSugg.size === 1) {
                        aSugg.clear();
                    }


                }


            }

        }
        return aSugg;
    },

    _getTags: function (sVerb) {
        // returns tuple of tags (usable with functions _getConjWithTags and _hasConjWithTags)
        if (!this._dVerb.hasOwnProperty(sVerb)) {
            return null;
        }








|
>
|
>
|
|
<
|
|
|
<
<
<
<
|
|
<
<
<
<
<
<
<
<
<
<
<
<
|
<
<
<
<

<
<
<
<
<
<
<
<
<
|
|
<
<
<
<
|
>
>

>
>

>

<








85
86
87
88
89
90
91
92
93
94
95
96
97

98
99
100




101
102












103




104









105
106




107
108
109
110
111
112
113
114
115

116
117
118
119
120
121
122

        // returns raw informations about sVerb
        if (!this._dVerb.hasOwnProperty(sVerb)) {
            return null;
        }
        return this._lVtyp[this._dVerb[sVerb][0]];
    },

    getNamesFrom: function (sVerb) {
        // returns a list of names derivating from <sVerb>
        if (this._dVerbNames.hasOwnProperty(sVerb)) {
            // there are names derivated from the verb
            return this._dVerbNames[sVerb];
        } else {

            // we suggest past participles
            let tTags = this._getTags(sVerb);
            if (tTags) {




                let aSugg = [ this._getConjWithTags(sVerb, tTags, ":PQ", ":Q1") ];
                if (this._hasConjWithTags(tTags, ":PQ", ":Q2")) {












                    aSugg.push(this._getConjWithTags(sVerb, tTags, ":PQ", ":Q2"));




                }









                if (this._hasConjWithTags(tTags, ":PQ", ":Q3")) {
                    aSugg.push(this._getConjWithTags(sVerb, tTags, ":PQ", ":Q3"));




                }
                if (this._hasConjWithTags(tTags, ":PQ", ":Q4")) {
                    aSugg.push(this._getConjWithTags(sVerb, tTags, ":PQ", ":Q4"));
                }
                // if there is only one past participle (epi inv), unreliable.
                return (aSugg.length > 1) ? aSugg : [];
            }
            return [];
        }

    },

    _getTags: function (sVerb) {
        // returns tuple of tags (usable with functions _getConjWithTags and _hasConjWithTags)
        if (!this._dVerb.hasOwnProperty(sVerb)) {
            return null;
        }
︙︙
634
635
636
637
638
639
640
641
642
643
644
645
646
647

    exports._dImpeProNegEn = conj._dImpeProNegEn;
    exports._dGroup = conj._dGroup;
    exports._dTenseIdx = conj._dTenseIdx;
    exports.isVerb = conj.isVerb;
    exports.getConj = conj.getConj;
    exports.hasConj = conj.hasConj;
    exports.getVtyp = conj.getVtyp;
    exports.getSimil = conj.getSimil;
    exports._getTags = conj._getTags;
    exports._getConjWithTags = conj._getConjWithTags;
    exports._hasConjWithTags = conj._hasConjWithTags;
    exports._modifyStringWithSuffixCode = conj._modifyStringWithSuffixCode;
    exports.Verb = Verb;
}








|







606
607
608
609
610
611
612
613
614
615
616
617
618
619

    exports._dImpeProNegEn = conj._dImpeProNegEn;
    exports._dGroup = conj._dGroup;
    exports._dTenseIdx = conj._dTenseIdx;
    exports.isVerb = conj.isVerb;
    exports.getConj = conj.getConj;
    exports.hasConj = conj.hasConj;
    exports.getVtyp = conj.getVtyp;
    exports.getNamesFrom = conj.getNamesFrom;
    exports._getTags = conj._getTags;
    exports._getConjWithTags = conj._getConjWithTags;
    exports._hasConjWithTags = conj._hasConjWithTags;
    exports._modifyStringWithSuffixCode = conj._modifyStringWithSuffixCode;
    exports.Verb = Verb;
}

Modified gc_lang/fr/modules-js/gce_suggestions.js from [e69e781426] to [c7763dfdd8].

︙︙
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617



618

619







620
621
622
623
624
625
626

}

function hasSimil (sWord, sPattern=null) {
    return phonet.hasSimil(sWord, sPattern);
}

function suggSimil (sWord, sPattern=null, bSubst=false, bVC=false) {
    // return list of words phonetically similar to sWord and whom POS is matching sPattern
    let sSfx;
    if (bVC) {
        [sWord, sSfx] = splitVerb(sWord);
    }
    let aSugg = phonet.selectSimil(sWord, sPattern);
    if (aSugg.size === 0 || !bSubst) {
        for (let sMorph of gc_engine.oSpellChecker.getMorph(sWord)) {



            for (let e of conj.getSimil(sWord, sMorph, bSubst)) {

                aSugg.add(e);







            }
        }
    }
    if (aSugg.size > 0) {
        if (bVC) {
            return Array.from(aSugg).map((sSugg) => joinVerbAndSuffix(sSugg, sSfx)).join("|");
        }








|





|

>
>
>
|
>
|
>
>
>
>
>
>
>








603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637

}

function hasSimil (sWord, sPattern=null) {
    return phonet.hasSimil(sWord, sPattern);
}

function suggSimil (sWord, sPattern=null, bSubst=false, bVC=false) {
    // return list of words phonetically similar to <sWord> and whom POS is matching <sPattern>
    let sSfx;
    if (bVC) {
        [sWord, sSfx] = splitVerb(sWord);
    }
    let aSugg = phonet.selectSimil(sWord, sPattern);
    if (aSugg.size === 0 && bSubst) {
        for (let sMorph of gc_engine.oSpellChecker.getMorph(sWord)) {
            if (sMorph.includes(":V")) {
                let sInfi = sMorph.slice(1, sMorph.indexOf("/"));
                if (sPattern) {
                    for (let sName of conj.getNamesFrom(sInfi)) {
                        if (_oSpellChecker.getMorph(sName).some(sMorph => (sMorph.search(sPattern) !== -1))) {
                            aSugg.add(sName);
                        }
                    }
                }
                else {
                    conj.getNamesFrom(sInfi).forEach(sName => aSugg.add(sName));
                }
                break;
            }
        }
    }
    if (aSugg.size > 0) {
        if (bVC) {
            return Array.from(aSugg).map((sSugg) => joinVerbAndSuffix(sSugg, sSfx)).join("|");
        }
︙︙

Modified gc_lang/fr/modules/conj.py from [9d698bfb2e] to [542bdbf844].

︙︙
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

def getVtyp (sVerb):
    "returns raw informations about sVerb"
    if sVerb not in _dVerb:
        return None
    return _lVtyp[_dVerb[sVerb][0]]


def getSimil (sWord, sMorph, bSubst=False):
    "returns a list of verbal forms similar to <sWord>, according to <sMorph>"
    if ":V" not in sMorph:
        return []
    sInfi = sMorph[1:sMorph.find("/")]
    aSugg = []
    tTags = _getTags(sInfi)
    if tTags:
        if not bSubst:
            # we suggest conjugated forms
            if ":V1" in sMorph:
                aSugg.append(sInfi)
                if _hasConjWithTags(tTags, ":Ip", ":3s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":3s"))
                if _hasConjWithTags(tTags, ":Ip", ":2p"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":2p"))
                if _hasConjWithTags(tTags, ":Iq", ":1s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":1s"))
                if _hasConjWithTags(tTags, ":Iq", ":3s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":3s"))
                if _hasConjWithTags(tTags, ":Iq", ":3p"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":3p"))
            elif ":V2" in sMorph:
                if _hasConjWithTags(tTags, ":Ip", ":1s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":1s"))
                if _hasConjWithTags(tTags, ":Ip", ":3s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":3s"))
            elif ":V3" in sMorph:
                if _hasConjWithTags(tTags, ":Ip", ":1s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":1s"))
                if _hasConjWithTags(tTags, ":Ip", ":3s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":3s"))
                if _hasConjWithTags(tTags, ":Is", ":1s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Is", ":1s"))
                if _hasConjWithTags(tTags, ":Is", ":3s"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":Is", ":3s"))
            elif ":V0a" in sMorph:
                aSugg.append("eus")
                aSugg.append("eut")
            else:
                aSugg.append("étais")
                aSugg.append("était")
        else:
            if sInfi in _dVerbNames:
                # there are names derivated from the verb
                aSugg.extend(_dVerbNames[sInfi])
            else:
                # we suggest past participles


                aSugg.append(_getConjWithTags(sInfi, tTags, ":PQ", ":Q1"))
                if _hasConjWithTags(tTags, ":PQ", ":Q2"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":PQ", ":Q2"))
                if _hasConjWithTags(tTags, ":PQ", ":Q3"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":PQ", ":Q3"))
                if _hasConjWithTags(tTags, ":PQ", ":Q4"):
                    aSugg.append(_getConjWithTags(sInfi, tTags, ":PQ", ":Q4"))
                # if there is only one past participle (epi inv), unreliable.
                if len(aSugg) == 1:
                    return []
    return aSugg


def getConjSimilInfiV1 (sInfi):
    "returns verbal forms phonetically similar to infinitive form (for verb in group 1)"
    if sInfi not in _dVerb:
        return []
    aSugg = []
    tTags = _getTags(sInfi)
    if tTags:

        if _hasConjWithTags(tTags, ":Iq", ":2s"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Iq", ":2s"))
        if _hasConjWithTags(tTags, ":Iq", ":3s"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Iq", ":3s"))
        if _hasConjWithTags(tTags, ":Iq", ":3p"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Iq", ":3p"))
        if _hasConjWithTags(tTags, ":Is", ":1s"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Is", ":1s"))
        if _hasConjWithTags(tTags, ":Ip", ":2p"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Ip", ":2p"))
        if _hasConjWithTags(tTags, ":Iq", ":2p"):
            aSugg.add(_getConjWithTags(sInfi, tTags, ":Iq", ":2p"))
    return aSugg


def _getTags (sVerb):
    "returns tuple of tags (usable with functions _getConjWithTags and _hasConjWithTags)"
    if sVerb not in _dVerb:
        return None








|
|
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
|
|
|
|
|
>
>
|
|
|
|
|
|
|
|
|
|
<









>

|

|

|

|

|

|








56
57
58
59
60
61
62
63
64









































65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

def getVtyp (sVerb):
    "returns raw informations about sVerb"
    if sVerb not in _dVerb:
        return None
    return _lVtyp[_dVerb[sVerb][0]]


def getNamesFrom (sVerb):
    "returns a list of names derivating from <sVerb>"









































    if sVerb in _dVerbNames:
        # there are names derivated from the verb
        return list(_dVerbNames[sVerb])
    else:
        # we suggest past participles
        tTags = _getTags(sVerb)
        if tTags:
            aSugg = [ _getConjWithTags(sVerb, tTags, ":PQ", ":Q1") ]
            if _hasConjWithTags(tTags, ":PQ", ":Q2"):
                aSugg.append(_getConjWithTags(sVerb, tTags, ":PQ", ":Q2"))
            if _hasConjWithTags(tTags, ":PQ", ":Q3"):
                aSugg.append(_getConjWithTags(sVerb, tTags, ":PQ", ":Q3"))
            if _hasConjWithTags(tTags, ":PQ", ":Q4"):
                aSugg.append(_getConjWithTags(sVerb, tTags, ":PQ", ":Q4"))
            # if there is only one past participle (epi inv), unreliable.
            return aSugg  if len(aSugg) > 1  else []
        return []



def getConjSimilInfiV1 (sInfi):
    "returns verbal forms phonetically similar to infinitive form (for verb in group 1)"
    if sInfi not in _dVerb:
        return []
    aSugg = []
    tTags = _getTags(sInfi)
    if tTags:
        # example: arriver, arrivais, arrivait, arrivai, arrivez, arriviez
        if _hasConjWithTags(tTags, ":Iq", ":2s"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":2s"))
        if _hasConjWithTags(tTags, ":Iq", ":3s"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":3s"))
        if _hasConjWithTags(tTags, ":Iq", ":3p"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":3p"))
        if _hasConjWithTags(tTags, ":Is", ":1s"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Is", ":1s"))
        if _hasConjWithTags(tTags, ":Ip", ":2p"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Ip", ":2p"))
        if _hasConjWithTags(tTags, ":Iq", ":2p"):
            aSugg.append(_getConjWithTags(sInfi, tTags, ":Iq", ":2p"))
    return aSugg


def _getTags (sVerb):
    "returns tuple of tags (usable with functions _getConjWithTags and _hasConjWithTags)"
    if sVerb not in _dVerb:
        return None
︙︙

Modified gc_lang/fr/modules/gce_suggestions.py from [9319456bd1] to [4f758a8cb1].

︙︙
460
461
462
463
464
465
466
467
468
469
470
471
472







473
474
475
476
477
478
479
480
481


def hasSimil (sWord, sPattern=None):
    "return True if there is words phonetically similar to <sWord> (according to <sPattern> if required)"
    return phonet.hasSimil(sWord, sPattern)


def suggSimil (sWord, sPattern=None, bSubst=False, bVC=False):
    "return list of words phonetically similar to sWord and whom POS is matching sPattern"
    if bVC:
        sWord, sSfx = splitVerb(sWord)
    aSugg = phonet.selectSimil(sWord, sPattern)
    if not aSugg or not bSubst:
        for sMorph in _oSpellChecker.getMorph(sWord):







            aSugg.extend(conj.getSimil(sWord, sMorph, bSubst))
            break
    if aSugg:
        if bVC:
            aSugg = [ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in aSugg ]
        return "|".join(aSugg)
    return ""










|



|

>
>
>
>
>
>
>
|
|








460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488


def hasSimil (sWord, sPattern=None):
    "return True if there is words phonetically similar to <sWord> (according to <sPattern> if required)"
    return phonet.hasSimil(sWord, sPattern)


def suggSimil (sWord, sPattern=None, bSubst=False, bVC=False):
    "return list of words phonetically similar to <sWord> and whom POS is matching <sPattern>"
    if bVC:
        sWord, sSfx = splitVerb(sWord)
    aSugg = phonet.selectSimil(sWord, sPattern)
    if not aSugg and bSubst:
        for sMorph in _oSpellChecker.getMorph(sWord):
            if ":V" in sMorph:
                sInfi = sMorph[1:sMorph.find("/")]
                if sPattern:
                    for sName in conj.getNamesFrom(sInfi):
                        if any(re.search(sPattern, sMorph2)  for sMorph2 in _oSpellChecker.getMorph(sName)):
                            aSugg.append(sName)
                else:
                    aSugg.extend(conj.getNamesFrom(sInfi))
                break
    if aSugg:
        if bVC:
            aSugg = [ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in aSugg ]
        return "|".join(aSugg)
    return ""
︙︙

Modified gc_lang/fr/rules.grx from [008b0113f0] to [01736fd21b].

︙︙
7350
7351
7352
7353
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364
7365

TEST: {{Ont}} ne sait jamais quoi faire                                                                             ->> On
TEST: si {{ont}} donne à ces gens, ça n’en finit plus.                                                              ->> on
TEST: {{Ont}} viens !                                                                                               ->> On
TEST: {{Ont}} ne sait pas comment faire.                                                                            ->> On
TEST: ce livre qu’{{ont}} t’apporte                                                                                 ->> on
TEST: ouais, c’est ça, {{ont}} t’assure que c’est vrai                                                              ->> on
TEST: {{Ont}} lui avait donné du temps                                                                              ->> On
TEST: {{Ont}} leur {{prendra}} tout                                                                                 ->> On|||prise|prises
TEST: Qu’importe, {{ont}} leur {{prend}} tout                                                                       ->> on|||prise|prises
TEST: {{peut-ont}} y arriver avec si peu de moyens ?                                                                ->> peut-on
TEST: {{peut ont}} y arriver ?                                                                                      ->> peut-on
TEST: comme ce que l’{{ont}} {{voit}} dans le lien entre polygynie et guerre.                                       ->> on|||vu
TEST: Tout à fait, {{ont}} peut même dire qu’à l’adolescence, ce sont les problèmes de l’enfance qui ressortent.    ->> on
TEST: pour le verbe avoir, écrivez “ont”.
TEST: les politiques de l’offre ont échoué.
TEST: qui n’ont somme toute que le désir de vivre paisiblement








|
|








7350
7351
7352
7353
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364
7365

TEST: {{Ont}} ne sait jamais quoi faire                                                                             ->> On
TEST: si {{ont}} donne à ces gens, ça n’en finit plus.                                                              ->> on
TEST: {{Ont}} viens !                                                                                               ->> On
TEST: {{Ont}} ne sait pas comment faire.                                                                            ->> On
TEST: ce livre qu’{{ont}} t’apporte                                                                                 ->> on
TEST: ouais, c’est ça, {{ont}} t’assure que c’est vrai                                                              ->> on
TEST: {{Ont}} lui avait donné du temps                                                                              ->> On
TEST: {{Ont}} leur {{prendra}} tout                                                                                 ->> On|||prise
TEST: Qu’importe, {{ont}} leur {{prend}} tout                                                                       ->> on|||prise
TEST: {{peut-ont}} y arriver avec si peu de moyens ?                                                                ->> peut-on
TEST: {{peut ont}} y arriver ?                                                                                      ->> peut-on
TEST: comme ce que l’{{ont}} {{voit}} dans le lien entre polygynie et guerre.                                       ->> on|||vu
TEST: Tout à fait, {{ont}} peut même dire qu’à l’adolescence, ce sont les problèmes de l’enfance qui ressortent.    ->> on
TEST: pour le verbe avoir, écrivez “ont”.
TEST: les politiques de l’offre ont échoué.
TEST: qui n’ont somme toute que le désir de vivre paisiblement
︙︙
8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061
8062
8063
8064
8065

TEST: un {{maintient}} difficile.                                                   ->> maintien
TEST: cette {{plaît}} est infectée.                                                 ->> plaie
TEST: ledit {{soutient}} ne vaut rien                                               ->> soutien
TEST: {{ce}} {{rappelle}} n’en finit pas.                                           ->> se|||rappel
TEST: mon {{rackette}} n’a pas porté les fruits espérés.                            ->> racket
TEST: mon {{impacte}}                                                               ->> impact
TEST: ton {{recèle}} avait été dévoilé                                              ->> recel
TEST: un verbe au {{passait}} simple                                                ->> passé|passés|passée|passées|passe|passes|passant|passions
TEST: quel {{impacte}} cela aura-t-il ?                                             ->> impact
TEST: chaque {{désire}} importe.                                                    ->> désir
TEST: l’attuque du {{briguant}}                                                     ->> brigand
TEST: quelqu’un arrive.
TEST: Belle qui tient mon vit captif entre tes doigts.
TEST: Quel serait l’homme capable d’une telle horreur ?
TEST: Une était plus courte que l’autre.








|








8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061
8062
8063
8064
8065

TEST: un {{maintient}} difficile.                                                   ->> maintien
TEST: cette {{plaît}} est infectée.                                                 ->> plaie
TEST: ledit {{soutient}} ne vaut rien                                               ->> soutien
TEST: {{ce}} {{rappelle}} n’en finit pas.                                           ->> se|||rappel
TEST: mon {{rackette}} n’a pas porté les fruits espérés.                            ->> racket
TEST: mon {{impacte}}                                                               ->> impact
TEST: ton {{recèle}} avait été dévoilé                                              ->> recel
TEST: un verbe au {{passait}} simple                                                ->> passé|passe|passant
TEST: quel {{impacte}} cela aura-t-il ?                                             ->> impact
TEST: chaque {{désire}} importe.                                                    ->> désir
TEST: l’attuque du {{briguant}}                                                     ->> brigand
TEST: quelqu’un arrive.
TEST: Belle qui tient mon vit captif entre tes doigts.
TEST: Quel serait l’homme capable d’une telle horreur ?
TEST: Une était plus courte que l’autre.
︙︙
8139
8140
8141
8142
8143
8144
8145
8146
8147
8148
8149
8150
8151
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
8175
8176
8177
8178

    à  un  @:V¬:[GNAWMB]
        <<- /conf/ not value(<1, "|un|") -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)             && Incohérence : après “\1 \2”, on devrait trouver un substantif masculin.

    à  une  @:V¬:[GNAWMB]
        <<- /conf/ not value(<1, "|une|") -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)            && Incohérence : après “\1 \2”, on devrait trouver un substantif féminin.

TEST: à le {{poussait}}                                                                             ->> pousser
TEST: à la {{finit}}                                                                                ->> finie|finir|finis|fini|finies
TEST: à l’{{imaginions}}                                                                            ->>
TEST: à son {{impacte}}                                                                             ->> impact
TEST: à leur {{profile}}                                                                            ->> profil|profiler
TEST: à un {{employer}}                                                                             ->> employé|employée|employés|employées
TEST: à une {{employer}}                                                                            ->> employée|employé|employés|employées
TEST: à leurs {{finissions}}                                                                        ->> fini|finie|finis|finies
TEST: on les voit un par un devenir prendre un chemin de predition
TEST: une référence à l’astuce de base qui permet d’outrepasser ses droits.
TEST: Le mari répète à l’envi qu’il a découvert la France à travers les mots de sa femme.
TEST: Il reste de nombreux militants sincères à la FI.


__conf_de_vconj__
    [de|d’]  @:[123][sp]¬:[GNA]
        <<- /conf/ not \2.istitle() and not \2.isupper() and not value(\2, "|jure|") and not tag(\2, "eg1mot")
        -2>> =suggSimil(\2, ":[NA]", True)+"|"+suggVerbInfi(\2)                                     && Incohérence avec « \1 » : “\2” est une forme verbale conjuguée.

TEST: il s’agit de {{mette}} en évidence.
TEST: sa façon de {{nettoyez}} était inefficace.                                            ->> nettoyer|nettoyant


    [de|d’]  [l’|leur]  @:[123][sp]¬:[GNAQ]
        <<- /conf/ not \3.istitle() and not \3.isupper() -3>> =suggSimil(\3, ":[NA].*:[si]", True)  && Incohérence avec « \1 \2 » : “\3” est une forme verbale conjuguée.

TEST: de l’{{arrivait}}                                                                     ->> arrivée|arrivées|arrivant
TEST: la production d’électricité par des énergies renouvelables aurait encore augmenté de 7 %, selon les calculs de l’AIE


    [de|d’]  le  *WORD
        <<- /conf/ space(\1, 0, 1) and morph(\3, ":[NAQ].*:[me]", ":[YG]") and not \3.istitle()
            and not (value(\3, "|mal|") and morph(>1, ":Y")) -1:2>> du                              && Incohérence avec « \1 \2 » : “\3” est un nom ou un adjectif.
        <<- /conf/ morph(\3, ":[123][sp]") -3>> =suggVerbInfi(\3)                                   && Incohérence avec « \1 \2 » : “\3” est une forme verbale conjuguée.








|



|
|
|


















|








8139
8140
8141
8142
8143
8144
8145
8146
8147
8148
8149
8150
8151
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
8175
8176
8177
8178

    à  un  @:V¬:[GNAWMB]
        <<- /conf/ not value(<1, "|un|") -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)             && Incohérence : après “\1 \2”, on devrait trouver un substantif masculin.

    à  une  @:V¬:[GNAWMB]
        <<- /conf/ not value(<1, "|une|") -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)            && Incohérence : après “\1 \2”, on devrait trouver un substantif féminin.

TEST: à le {{poussait}}                                                                             ->> pousser
TEST: à la {{finit}}                                                                                ->> finie|finir
TEST: à l’{{imaginions}}                                                                            ->>
TEST: à son {{impacte}}                                                                             ->> impact
TEST: à leur {{profile}}                                                                            ->> profil|profiler
TEST: à un {{employer}}                                                                             ->> employé
TEST: à une {{employer}}                                                                            ->> employée
TEST: à leurs {{finissions}}                                                                        ->> finis|finies
TEST: on les voit un par un devenir prendre un chemin de predition
TEST: une référence à l’astuce de base qui permet d’outrepasser ses droits.
TEST: Le mari répète à l’envi qu’il a découvert la France à travers les mots de sa femme.
TEST: Il reste de nombreux militants sincères à la FI.


__conf_de_vconj__
    [de|d’]  @:[123][sp]¬:[GNA]
        <<- /conf/ not \2.istitle() and not \2.isupper() and not value(\2, "|jure|") and not tag(\2, "eg1mot")
        -2>> =suggSimil(\2, ":[NA]", True)+"|"+suggVerbInfi(\2)                                     && Incohérence avec « \1 » : “\2” est une forme verbale conjuguée.

TEST: il s’agit de {{mette}} en évidence.
TEST: sa façon de {{nettoyez}} était inefficace.                                            ->> nettoyer|nettoyant


    [de|d’]  [l’|leur]  @:[123][sp]¬:[GNAQ]
        <<- /conf/ not \3.istitle() and not \3.isupper() -3>> =suggSimil(\3, ":[NA].*:[si]", True)  && Incohérence avec « \1 \2 » : “\3” est une forme verbale conjuguée.

TEST: de l’{{arrivait}}                                                                     ->> arrivée|arrivant
TEST: la production d’électricité par des énergies renouvelables aurait encore augmenté de 7 %, selon les calculs de l’AIE


    [de|d’]  le  *WORD
        <<- /conf/ space(\1, 0, 1) and morph(\3, ":[NAQ].*:[me]", ":[YG]") and not \3.istitle()
            and not (value(\3, "|mal|") and morph(>1, ":Y")) -1:2>> du                              && Incohérence avec « \1 \2 » : “\3” est un nom ou un adjectif.
        <<- /conf/ morph(\3, ":[123][sp]") -3>> =suggVerbInfi(\3)                                   && Incohérence avec « \1 \2 » : “\3” est une forme verbale conjuguée.
︙︙
8204
8205
8206
8207
8208
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
8220
8221
8222
8223
8224
8225
8226
8227
8228
8229
8230
8231
8232
8233
8234
8235
8236
8237
8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256

        -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)                                              && Incohérence avec “\1\2” : “\3” est une forme verbale.

    d’  une  @:[123][sp]¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|plus|moins|")
        -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)                                              && Incohérence avec “\1\2” : “\3” est une forme verbale.

TEST: d’un {{œillait}}                                                  ->> œillet
TEST: d’une {{habille}} de femme                                        ->> habillé|habillée|habillés|habillées
TEST: plus d’un ont été traumatisés
TEST: Plus d’une sont parties aussi vite qu’elles étaient venues


__conf_par_vconj__
    par  ?[le|la|l’|les|leur|leurs]¿  @:[123][sp]¬:[GNA]
        <<- /conf/ not \-1.istitle() --1>> =suggSimil(\-1, ":[NA]", True)                           && Incohérence avec “\1” : “\-1” est une forme verbale.

    par  un  @:V¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|un|")
        -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)                                              && Incohérence avec “\1 \2” : “\3” est une forme verbale.

    par  une  @:V¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|une|")
        -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)                                              && Incohérence avec “\1 \2” : “\3” est une forme verbale.

TEST: par {{bloque}} de données                                         ->> bloc|blocs
TEST: par une {{donnait}} sans importance                               ->> donne|donnes|donnée|données
TEST: par un {{bloque}} de donnée                                       ->> bloc
TEST: conçu par un {{employer}} très compétent                          ->> employé|employés|employée|employées
TEST: pour les insulter au sortir du seul troquet dispensateur d’oubli liquide du coin
TEST: ce peut être un matériau à part entière pour alimenter discussions et délibérations.


__conf_préposition_det_verbe__
    [malgré|dès] [un|le]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)         && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [une|la]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)         && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [l’|leur|son|ton]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[si]", True)              && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [les|leurs]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[pi]", True)              && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

TEST: malgré un {{employer}} peu dévoué                                         ->> employé|employés|employée|employées
TEST: dès le {{commencent}}, j’ai vu le problème.                               ->> commençant
TEST: dès la {{posent}}                                                         ->> pause|pose
TEST: malgré l’{{arrête}} qui interdisait le port                               ->> arête
TEST: malgré les {{arrêtes}}                                                    ->> arêtes
TEST: malgré les deux précédentes erreurs










|

















|

|

















|








8204
8205
8206
8207
8208
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
8220
8221
8222
8223
8224
8225
8226
8227
8228
8229
8230
8231
8232
8233
8234
8235
8236
8237
8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256

        -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)                                              && Incohérence avec “\1\2” : “\3” est une forme verbale.

    d’  une  @:[123][sp]¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|plus|moins|")
        -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)                                              && Incohérence avec “\1\2” : “\3” est une forme verbale.

TEST: d’un {{œillait}}                                                  ->> œillet
TEST: d’une {{habille}} de femme                                        ->> habillée
TEST: plus d’un ont été traumatisés
TEST: Plus d’une sont parties aussi vite qu’elles étaient venues


__conf_par_vconj__
    par  ?[le|la|l’|les|leur|leurs]¿  @:[123][sp]¬:[GNA]
        <<- /conf/ not \-1.istitle() --1>> =suggSimil(\-1, ":[NA]", True)                           && Incohérence avec “\1” : “\-1” est une forme verbale.

    par  un  @:V¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|un|")
        -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)                                              && Incohérence avec “\1 \2” : “\3” est une forme verbale.

    par  une  @:V¬:[GNA]
        <<- /conf/ not \3.istitle() and not value(<1, "|une|")
        -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)                                              && Incohérence avec “\1 \2” : “\3” est une forme verbale.

TEST: par {{bloque}} de données                                         ->> bloc|blocs
TEST: par une {{donnait}} sans importance                               ->> donne|donnée
TEST: par un {{bloque}} de donnée                                       ->> bloc
TEST: conçu par un {{employer}} très compétent                          ->> employé
TEST: pour les insulter au sortir du seul troquet dispensateur d’oubli liquide du coin
TEST: ce peut être un matériau à part entière pour alimenter discussions et délibérations.


__conf_préposition_det_verbe__
    [malgré|dès] [un|le]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[me]:[si]", True)         && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [une|la]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[fe]:[si]", True)         && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [l’|leur|son|ton]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[si]", True)              && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

    [malgré|dès] [les|leurs]  @:V¬:[GNAWMB]
        <<- /conf/ not \-1.istitle() -3>> =suggSimil(\3, ":[NA].*:[pi]", True)              && Incohérence : après « \1 \2 », on devrait trouver un groupe nominal.

TEST: malgré un {{employer}} peu dévoué                                         ->> employé
TEST: dès le {{commencent}}, j’ai vu le problème.                               ->> commençant
TEST: dès la {{posent}}                                                         ->> pause|pose
TEST: malgré l’{{arrête}} qui interdisait le port                               ->> arête
TEST: malgré les {{arrêtes}}                                                    ->> arêtes
TEST: malgré les deux précédentes erreurs
︙︙
8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400


TEST: et avec ça elle aussi {{avancés}}.                                    ->> avancée|avançait
TEST: et avec ça seulement elle aussi {{mangées}}.                          ->> mangée|mangeait


__conf_en_tant_que_subst__
    en  tant  [que|qu’]  @:V¬:[NAG]
        <<- /conf/ --1>> =suggSimil(\-1, ":[NA]")
        && Confusion probable. Après « en tant que », il faut un substantif, pas un verbe. Exemples : en tant que femme, en tant que patron, en tant que trentenaire…

TEST: en tant qu’{{abaisse}}                                                ->>
TEST: en tant que tel


__conf_presque_vconj__








|








8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400


TEST: et avec ça elle aussi {{avancés}}.                                    ->> avancée|avançait
TEST: et avec ça seulement elle aussi {{mangées}}.                          ->> mangée|mangeait


__conf_en_tant_que_subst__
    en  tant  [que|qu’]  @:V¬:[NAG]
        <<- /conf/ --1>> =suggSimil(\-1, ":[NA]", True)
        && Confusion probable. Après « en tant que », il faut un substantif, pas un verbe. Exemples : en tant que femme, en tant que patron, en tant que trentenaire…

TEST: en tant qu’{{abaisse}}                                                ->>
TEST: en tant que tel


__conf_presque_vconj__
︙︙
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641


TEST: tu {{ma}} prise par surprise                          ->> m’as
TEST: il {{ma}} tuée                                        ->> m’a
TEST: cette femme ne {{ma}} prise que deux fois             ->> m’a
TEST: {{on}} {{ma}} dézinguée                               ->> ont|||m’a
TEST: ça {{ma}} {{foutu}} en l’air                          ->> m’a|||foutue
TEST: cet homme {{ma}} succédé à ce poste                   ->> m’a
TEST: {{ma}} {{donner}} la nausée, ce con                   ->> m’a|||donnée|données|donne|donnes
TEST: c’est ça qui {{ma}} forcée à poursuivre               ->> m’a
TEST: ça ma grande, c’est mon secret


# m’ont / mon
__conf_m_ont!6__
    il  mon








|








11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641


TEST: tu {{ma}} prise par surprise                          ->> m’as
TEST: il {{ma}} tuée                                        ->> m’a
TEST: cette femme ne {{ma}} prise que deux fois             ->> m’a
TEST: {{on}} {{ma}} dézinguée                               ->> ont|||m’a
TEST: ça {{ma}} {{foutu}} en l’air                          ->> m’a|||foutue
TEST: cet homme {{ma}} succédé à ce poste                   ->> m’a
TEST: {{ma}} {{donner}} la nausée, ce con                   ->> m’a|||donnée|donne
TEST: c’est ça qui {{ma}} forcée à poursuivre               ->> m’a
TEST: ça ma grande, c’est mon secret


# m’ont / mon
__conf_m_ont!6__
    il  mon
︙︙

Fossil 2.24 [8be0372c10] 2024-04-23 13:25:26
This page was generated in about 0.045s