Grammalecte  Check-in [624e793673]

Overview
Comment:[core][fr] avoid and check suggestions duplicates
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | fr | core
Files: files | file ages | folders
SHA3-256: 624e79367389d2baa9379b288f1fc9d59357209be54e51c48a83cfa9783d26b7
User & Date: olr on 2021-01-26 14:44:09
Other Links: manifest | tags
Context
2021-01-29
11:51
[fr] faux positifs et ajustements check-in: 1e2de42383 user: olr tags: trunk, fr
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
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified gc_core/js/tests.js from [9717be7ff0] to [5369fe7f34].

︙
191
192
193
194
195
196
197





198
199


200
201
202
203
204
205
206
207
208
209
210
211

191
192
193
194
195
196
197
198
199
200
201
202


203
204
205
206
207
208
209
210
211
212
213
214
215
216








+
+
+
+
+
-
-
+
+













    _checkSuggestions (sAllExceptedSuggs, sAllFoundSuggs) {
        let lAllExpectedSuggs = sAllExceptedSuggs.split("|||");
        let lAllFoundSuggs = sAllFoundSuggs.split("|||");
        if (lAllExpectedSuggs.length != lAllFoundSuggs.length) {
            return false;
        }
        for (let i = 0;  i < lAllExpectedSuggs.length;  i++) {
            let lExpectedSuggs = lAllExpectedSuggs[i].split("|");
            let lFoundSuggs = lAllFoundSuggs[i].split("|");
            if (lExpectedSuggs.length != lFoundSuggs.length) {
                return false;
            }
            let aExpectedSuggs = new Set(lAllExpectedSuggs[i].split("|"));
            let aFoundSuggs = new Set(lAllFoundSuggs[i].split("|"));
            let aExpectedSuggs = new Set(lExpectedSuggs);
            let aFoundSuggs = new Set(lFoundSuggs);
            if (aExpectedSuggs.size !== aFoundSuggs.size || ![...aExpectedSuggs].every(value => aFoundSuggs.has(value))) {
                return false;
            }
        }
        return true;
    }
}


if (typeof(exports) !== 'undefined') {
    exports.TestGrammarChecking = TestGrammarChecking;
}

Modified gc_core/py/lang_core/tests_core.py from [335b223b65] to [be13fd30fe].

︙
173
174
175
176
177
178
179
180



181
182
183
184
185
186
187

173
174
175
176
177
178
179

180
181
182
183
184
185
186
187
188
189








-
+
+
+









    def _checkSuggestions (self, sAllExceptedSuggs, sAllFoundSuggs):
        lAllExpectedSuggs = sAllExceptedSuggs.split("|||")
        lAllFoundSuggs = sAllFoundSuggs.split("|||")
        if len(lAllExpectedSuggs) != len(lAllFoundSuggs):
            return False
        for sExceptedSuggs, sFoundSuggs in zip(lAllExpectedSuggs, lAllFoundSuggs):
            if set(sExceptedSuggs.split("|")) != set(sFoundSuggs.split("|")):
            lExpectedSuggs = sExceptedSuggs.split("|")
            lFoundSuggs = sFoundSuggs.split("|")
            if len(lExpectedSuggs) != len(lFoundSuggs) or set(lExpectedSuggs) != set(lFoundSuggs):
                return False
        return True


def purgeMessage (sMessage):
    for sToReplace, sReplacement in [
        ("l’ ", "l’"), ("d’ ", "d’"), ("n’ ", "n’"), ("j’ ", "j’"), ("m’ ", "m’"), ("t’ ", "t’"), ("s’ ", "s’"), ("qu’ ", "qu’"),
︙

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

︙
19
20
21
22
23
24
25
26

27
28
29
30
31
32
33

19
20
21
22
23
24
25

26
27
28
29
30
31
32
33








-
+








    return sVerb, sSuffix


def suggVerb (sFlex, sWho, funcSugg2=None, bVC=False):
    "change <sFlex> conjugation according to <sWho>"
    if bVC:
        sFlex, sSfx = splitVerb(sFlex)
    aSugg = []
    dSugg = {}
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            # we get the tense
            aTense = {} # we use dict as ordered set
            for sMorph in _oSpellChecker.getMorph(sFlex):
                for m in re.finditer(">"+sStem+"/.*?(:(?:Y|I[pqsf]|S[pq]|K|P|Q))", sMorph):
︙
41
42
43
44
45
46
47
48

49
50
51
52
53


54
55
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
150
151
152
153

41
42
43
44
45
46
47

48
49
50
51


52
53
54


55
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
150
151
152
153








-
+



-
-
+
+

-
-
+
+
















-
+




-
+

-
+

-
+

-
+

-
+


-
+

-
+


-
+

-
+


-
+

-
+

-
+

-
+


-
+

-
+

-
+

-
-
-
+
+
+
















-
+





-
+




-
-
-
+
+
+








                            aTense[":Ip"] = ""
                        else:
                            aTense[m.group(1)] = ""
            for sTense in aTense.keys():
                if sWho == ":1ś" and not conj._hasConjWithTags(tTags, sTense, ":1ś"):
                    sWho = ":1s"
                if conj._hasConjWithTags(tTags, sTense, sWho):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, sTense, sWho))
                    dSugg[conj._getConjWithTags(sStem, tTags, sTense, sWho)] = ""
    if funcSugg2:
        sSugg2 = funcSugg2(sFlex)
        if sSugg2:
            aSugg.append(sSugg2)
    if aSugg:
            dSugg[sSugg2] = ""
    if dSugg:
        if bVC:
            aSugg = [ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in aSugg ]
        return "|".join(aSugg)
            return "|".join([ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in dSugg.keys() ])
        return "|".join(dSugg.keys())
    return ""


def joinVerbAndSuffix (sFlex, sSfx):
    if sSfx.startswith(("-t-", "-T-")) and sFlex.endswith(("t", "d", "T", "D")):
        return sFlex + sSfx[2:]
    if sFlex.endswith(("e", "a", "c", "E", "A", "C")):
        if re.match("(?i)-(?:en|y)$", sSfx):
            return sFlex + "s" + sSfx
        if re.match("(?i)-(?:ie?l|elle|on)$", sSfx):
            return sFlex + "-t" + sSfx
    return sFlex + sSfx


def suggVerbPpas (sFlex, sPattern=None):
    "suggest past participles for <sFlex>"
    aSugg = []
    dSugg = {}
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            if not sPattern:
                aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
                if conj._hasConjWithTags(tTags, ":PQ", ":Q2"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2")] = ""
                if conj._hasConjWithTags(tTags, ":PQ", ":Q3"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3")] = ""
                if conj._hasConjWithTags(tTags, ":PQ", ":Q4"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4")] = ""
            elif sPattern == ":m:s":
                aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
            elif sPattern == ":m:p":
                if conj._hasConjWithTags(tTags, ":PQ", ":Q2"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2")] = ""
                else:
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
            elif sPattern == ":f:s":
                if conj._hasConjWithTags(tTags, ":PQ", ":Q3"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3")] = ""
                else:
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
            elif sPattern == ":f:p":
                if conj._hasConjWithTags(tTags, ":PQ", ":Q4"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4")] = ""
                else:
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
            elif sPattern == ":s":
                aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
                if conj._hasConjWithTags(tTags, ":PQ", ":Q3"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3")] = ""
            elif sPattern == ":p":
                if conj._hasConjWithTags(tTags, ":PQ", ":Q2"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2")] = ""
                else:
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
                if conj._hasConjWithTags(tTags, ":PQ", ":Q4"):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4"))
                    dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4")] = ""
            else:
                aSugg.append(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
    if aSugg:
        return "|".join(aSugg)
                dSugg[conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1")] = ""
    if dSugg:
        return "|".join(dSugg)
    return ""


def suggVerbTense (sFlex, sTense, sWho):
    "change <sFlex> to a verb according to <sTense> and <sWho>"
    aSugg = []
    for sStem in _oSpellChecker.getLemma(sFlex):
        if conj.hasConj(sStem, sTense, sWho):
            aSugg.append(conj.getConj(sStem, sTense, sWho))
    if aSugg:
        return "|".join(aSugg)
    return ""


def suggVerbFrom (sStem, sFlex, sWho=""):
    "conjugate <sStem> according to <sFlex> (and eventually <sWho>)"
    aSugg = []
    dSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        lTenses = [ m.group(0)  for m in re.finditer(":(?:Y|I[pqsf]|S[pq]|K|P|Q)", sMorph) ]
        if sWho:
            for sTense in lTenses:
                if conj.hasConj(sStem, sTense, sWho):
                    aSugg.append(conj.getConj(sStem, sTense, sWho))
                    dSugg[conj.getConj(sStem, sTense, sWho)] = ""
        else:
            for sTense in lTenses:
                for sWho in [ m.group(0)  for m in re.finditer(":[123][sp]", sMorph) ]:
                    if conj.hasConj(sStem, sTense, sWho):
                        aSugg.append(conj.getConj(sStem, sTense, sWho))
    if aSugg:
        return "|".join(aSugg)
                        dSugg[conj.getConj(sStem, sTense, sWho)] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


def suggVerbImpe (sFlex, bVC=False):
    "change <sFlex> to a verb at imperative form"
    if bVC:
        sFlex, sSfx = splitVerb(sFlex)
︙
183
184
185
186
187
188
189
190

191
192
193
194
195
196
197
198



199
200
201
202
203
204
205

183
184
185
186
187
188
189

190
191
192
193
194
195



196
197
198
199
200
201
202
203
204
205








-
+





-
-
-
+
+
+








    elif cMode == ":S":
        lMode = [":Sp", ":Sq"]
    elif cMode.startswith((":I", ":S")):
        lMode = [cMode]
    else:
        return ""
    sWho = _dQuiEst.get(sSuj.lower(), ":3s")
    aSugg = []
    dSugg = {}
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            for sTense in lMode:
                if conj._hasConjWithTags(tTags, sTense, sWho):
                    aSugg.append(conj._getConjWithTags(sStem, tTags, sTense, sWho))
    if aSugg:
        return "|".join(aSugg)
                    dSugg[conj._getConjWithTags(sStem, tTags, sTense, sWho)] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


## Nouns and adjectives

def suggPlur (sFlex, bSelfSugg=False):
    "returns plural forms assuming sFlex is singular"
︙
253
254
255
256
257
258
259
260

261
262
263
264
265

266
267
268
269

270
271
272
273
274
275
276

277
278
279
280
281



282
283
284
285
286
287

288
289
290
291
292

293
294
295
296

297
298
299
300
301

302
303
304
305
306

307
308
309
310
311



312
313
314
315
316
317

318
319
320
321
322

323
324
325
326

327
328
329
330
331

332
333
334
335
336



337
338
339
340
341
342

343
344
345
346
347

348
349
350
351

352
353
354
355
356

357
358
359
360
361



362
363
364
365
366
367
368

253
254
255
256
257
258
259

260
261
262
263
264

265
266
267
268

269
270
271
272
273
274
275

276
277
278



279
280
281
282
283
284
285
286

287
288
289
290
291

292
293
294
295

296
297
298
299
300

301
302
303
304
305

306
307
308



309
310
311
312
313
314
315
316

317
318
319
320
321

322
323
324
325

326
327
328
329
330

331
332
333



334
335
336
337
338
339
340
341

342
343
344
345
346

347
348
349
350

351
352
353
354
355

356
357
358



359
360
361
362
363
364
365
366
367
368








-
+




-
+



-
+






-
+


-
-
-
+
+
+





-
+




-
+



-
+




-
+




-
+


-
-
-
+
+
+





-
+




-
+



-
+




-
+


-
-
-
+
+
+





-
+




-
+



-
+




-
+


-
-
-
+
+
+








    if aSugg:
        return "|".join(aSugg)
    return ""


def suggMasSing (sFlex, bSuggSimil=False):
    "returns masculine singular forms"
    aSugg = []
    dSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":m" in sMorph or ":e" in sMorph:
                aSugg.append(suggSing(sFlex))
                dSugg[suggSing(sFlex)] = ""
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isMasForm(sStem):
                    aSugg.append(sStem)
                    dSugg[sStem] = ""
        else:
            # a verb
            sVerb = cr.getLemmaOfMorph(sMorph)
            if conj.hasConj(sVerb, ":PQ", ":Q1") and conj.hasConj(sVerb, ":PQ", ":Q3"):
                # We also check if the verb has a feminine form.
                # If not, we consider it’s better to not suggest the masculine one, as it can be considered invariable.
                aSugg.append(conj.getConj(sVerb, ":PQ", ":Q1"))
                dSugg[conj.getConj(sVerb, ":PQ", ":Q1")] = ""
    if bSuggSimil:
        for e in phonet.selectSimil(sFlex, ":m:[si]"):
            aSugg.append(e)
    if aSugg:
        return "|".join(aSugg)
            dSugg[e] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


def suggMasPlur (sFlex, bSuggSimil=False):
    "returns masculine plural forms"
    aSugg = []
    dSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":m" in sMorph or ":e" in sMorph:
                aSugg.append(suggPlur(sFlex))
                dSugg[suggPlur(sFlex)] = ""
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isMasForm(sStem):
                    aSugg.append(suggPlur(sStem, True))
                    dSugg[suggPlur(sStem, True)] = ""
        else:
            # a verb
            sVerb = cr.getLemmaOfMorph(sMorph)
            if conj.hasConj(sVerb, ":PQ", ":Q2"):
                aSugg.append(conj.getConj(sVerb, ":PQ", ":Q2"))
                dSugg[conj.getConj(sVerb, ":PQ", ":Q2")] = ""
            elif conj.hasConj(sVerb, ":PQ", ":Q1"):
                sSugg = conj.getConj(sVerb, ":PQ", ":Q1")
                # it is necessary to filter these flexions, like “succédé” or “agi” that are not masculine plural.
                if sSugg.endswith("s"):
                    aSugg.append(sSugg)
                    dSugg[sSugg] = ""
    if bSuggSimil:
        for e in phonet.selectSimil(sFlex, ":m:[pi]"):
            aSugg.append(e)
    if aSugg:
        return "|".join(aSugg)
            dSugg[e] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


def suggFemSing (sFlex, bSuggSimil=False):
    "returns feminine singular forms"
    aSugg = []
    dSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":f" in sMorph or ":e" in sMorph:
                aSugg.append(suggSing(sFlex))
                dSugg[suggSing(sFlex)] = ""
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isMasForm(sStem):
                    aSugg.extend(mfsp.getFemForm(sStem, False))
                    dSugg.update(dict.fromkeys(mfsp.getFemForm(sStem, False), ""))
        else:
            # a verb
            sVerb = cr.getLemmaOfMorph(sMorph)
            if conj.hasConj(sVerb, ":PQ", ":Q3"):
                aSugg.append(conj.getConj(sVerb, ":PQ", ":Q3"))
                dSugg[conj.getConj(sVerb, ":PQ", ":Q3")] = ""
    if bSuggSimil:
        for e in phonet.selectSimil(sFlex, ":f:[si]"):
            aSugg.append(e)
    if aSugg:
        return "|".join(aSugg)
            dSugg[e] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


def suggFemPlur (sFlex, bSuggSimil=False):
    "returns feminine plural forms"
    aSugg = []
    dSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":f" in sMorph or ":e" in sMorph:
                aSugg.append(suggPlur(sFlex))
                dSugg[suggPlur(sFlex)] = ""
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isMasForm(sStem):
                    aSugg.extend(mfsp.getFemForm(sStem, True))
                    dSugg.update(dict.fromkeys(mfsp.getFemForm(sStem, True)))
        else:
            # a verb
            sVerb = cr.getLemmaOfMorph(sMorph)
            if conj.hasConj(sVerb, ":PQ", ":Q4"):
                aSugg.append(conj.getConj(sVerb, ":PQ", ":Q4"))
                dSugg[conj.getConj(sVerb, ":PQ", ":Q4")] = ""
    if bSuggSimil:
        for e in phonet.selectSimil(sFlex, ":f:[pi]"):
            aSugg.append(e)
    if aSugg:
        return "|".join(aSugg)
            dSugg[e] = ""
    if dSugg:
        return "|".join(dSugg)
    return ""


def g_suggAgree (dTokenDst, dTokenSrc):
    "returns suggestions for <dTokenDst> that matches agreement with <dTokenSrc>"
    lMorphSrc = dTokenSrc["lMorph"]  if "lMorph" in dTokenSrc  else  _oSpellChecker.getMorph(dTokenSrc["sValue"])
    if not lMorphSrc:
︙
408
409
410
411
412
413
414
415

416
417
418
419
420

421
422

423
424
425

426
427

428
429
430


431
432
433
434

435
436

437
438
439
440

441
442
443
444



445
446
447
448
449
450

451
452
453

454
455

456
457

458
459
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
489
490
491
492

408
409
410
411
412
413
414

415
416
417
418
419

420
421

422
423
424

425
426

427
428


429
430
431
432
433

434
435

436
437
438
439

440
441



442
443
444
445
446
447
448
449

450
451
452

453
454

455
456

457
458
459
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
489
490
491
492








-
+




-
+

-
+


-
+

-
+

-
-
+
+



-
+

-
+



-
+

-
-
-
+
+
+





-
+


-
+

-
+

-
+












-
-
+
+






-
+

-
+

-
+

-
-
+
+








    if phonet.hasSimil(sFlex, ":m"):
        return True
    return False


def switchGender (sFlex, bPlur=None):
    "return feminine or masculine form(s) of <sFlex>"
    aSugg = []
    dSugg = {}
    if bPlur is None:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                if ":s" in sMorph:
                    aSugg.append(suggMasSing(sFlex))
                    dSugg[suggMasSing(sFlex)] = ""
                elif ":p" in sMorph:
                    aSugg.append(suggMasPlur(sFlex))
                    dSugg[suggMasPlur(sFlex)] = ""
            elif ":m" in sMorph:
                if ":s" in sMorph:
                    aSugg.append(suggFemSing(sFlex))
                    dSugg[suggFemSing(sFlex)] = ""
                elif ":p" in sMorph:
                    aSugg.append(suggFemPlur(sFlex))
                    dSugg[suggFemPlur(sFlex)] = ""
                else:
                    aSugg.append(suggFemSing(sFlex))
                    aSugg.append(suggFemPlur(sFlex))
                    dSugg[suggFemSing(sFlex)] = ""
                    dSugg[suggFemPlur(sFlex)] = ""
    elif bPlur:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                aSugg.append(suggMasPlur(sFlex))
                dSugg[suggMasPlur(sFlex)] = ""
            elif ":m" in sMorph:
                aSugg.append(suggFemPlur(sFlex))
                dSugg[suggFemPlur(sFlex)] = ""
    else:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                aSugg.append(suggMasSing(sFlex))
                dSugg[suggMasSing(sFlex)] = ""
            elif ":m" in sMorph:
                aSugg.append(suggFemSing(sFlex))
    if aSugg:
        return "|".join(aSugg)
                dSugg[suggFemSing(sFlex)] = ""
    if dSugg:
        return "|".join(dSugg.keys())
    return ""


def switchPlural (sFlex):
    "return plural or singular form(s) of <sFlex>"
    aSugg = []
    aSugg = {}
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if ":s" in sMorph:
            aSugg.append(suggPlur(sFlex))
            aSugg[suggPlur(sFlex)] = ""
        elif ":p" in sMorph:
            aSugg.append(suggSing(sFlex))
            aSugg[suggSing(sFlex)] = ""
    if aSugg:
        return "|".join(aSugg)
        return "|".join(aSugg.keys())
    return ""


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:
    dSugg = dict.fromkeys(phonet.selectSimil(sWord, sPattern), "")
    if not dSugg 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)
                            dSugg[sName] = ""
                else:
                    aSugg.extend(conj.getNamesFrom(sInfi))
                    dSugg.update(dict.fromkeys(conj.getNamesFrom(sInfi), ""))
                break
    if aSugg:
    if dSugg:
        if bVC:
            aSugg = [ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in aSugg ]
        return "|".join(aSugg)
            return "|".join([ joinVerbAndSuffix(sSugg, sSfx)  for sSugg in dSugg.keys() ])
        return "|".join(dSugg.keys())
    return ""


def suggCeOrCet (sWord):
    "suggest “ce” or “cet” or both according to the first letter of <sWord>"
    if re.match("(?i)[aeéèêiouyâîï]", sWord):
        return "cet"
︙

Fossil 2.20 [210e89a059] 2022-11-16 18:46:32
This page was generated in about 0.007s