Grammalecte  Check-in [09254c7f4b]

Overview
Comment:[graphspell] spellchecker: activate/deactivate dictionaries
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | graphspell | multid
Files: files | file ages | folders
SHA3-256: 09254c7f4b314489e70f195fadcd9ffab4497a7b0c159003bf53d0708747bc12
User & Date: olr on 2018-03-20 18:06:39
Other Links: branch diff | manifest | tags
Context
2018-03-20
19:55
[graphspell] code clarification check-in: 3cb01f1bc2 user: olr tags: graphspell, multid
18:06
[graphspell] spellchecker: activate/deactivate dictionaries check-in: 09254c7f4b user: olr tags: graphspell, multid
13:57
[graphspell][js] dawg: use <Set> to prevent duplicate entries check-in: 52593d2f38 user: olr tags: graphspell, multid
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified graphspell-js/spellchecker.js from [c98943d8b7] to [758b22b0da].

︙
35
36
37
38
39
40
41



42
43
44
45
46
47
48

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51








+
+
+








        if (!mainDic) {
            mainDic = dDefaultDictionaries.gl_get(sLangCode, "");
        }
        this.oMainDic = this._loadDictionary(mainDic, sPath, true);
        this.oExtendedDic = this._loadDictionary(extentedDic, sPath);
        this.oCommunityDic = this._loadDictionary(communityDic, sPath);
        this.oPersonalDic = this._loadDictionary(personalDic, sPath);
        this.bExtendedDic = Boolean(this.oExtendedDic);
        this.bCommunityDic = Boolean(this.oCommunityDic);
        this.bPersonalDic = Boolean(this.oPersonalDic);
        this.oTokenizer = null;
    }

    _loadDictionary (dictionary, sPath, bNecessary=false) {
        // returns an IBDAWG object
        if (!dictionary) {
            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

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








-
+
+





-
+
+





-
+
+

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








        this.oMainDic = this._loadDictionary(dictionary);
        return Boolean(this.oMainDic);
    }

    setExtendedDictionary (dictionary) {
        // returns true if the dictionary is loaded
        this.oExtendedDic = this._loadDictionary(dictionary);
        return Boolean(this.oExtendedDic);
        this.bExtendedDic = Boolean(this.oExtendedDic);
        return this.bExtendedDic;
    }

    setCommunityDictionary (dictionary) {
        // returns true if the dictionary is loaded
        this.oCommunityDic = this._loadDictionary(dictionary);
        return Boolean(this.oCommunityDic);
        this.bCommunityDic = Boolean(this.oCommunityDic);
        return this.bCommunityDic;
    }

    setPersonalDictionary (dictionary) {
        // returns true if the dictionary is loaded
        this.oPersonalDic = this._loadDictionary(dictionary);
        return Boolean(this.oPersonalDic);
        this.bPersonalDic = Boolean(this.oPersonalDic);
        return this.bPersonalDic;
    }

    activateExtendedDictionary () {
        if (this.oExtendedDic) {
            this.bExtendedDic = true;
        }
    }

    activateCommunityDictionary () {
        if (this.oCommunityDic) {
            this.bCommunityDic = true;
        }
    }

    activatePersonalDictionary () {
        if (this.oPersonalDic) {
            this.bPersonalDic = true;
        }
    }

    deactivateExtendedDictionary () {
        this.bExtendedDic = false;
    }

    deactivateCommunityDictionary () {
        this.bCommunityDic = false;
    }

    deactivatePersonalDictionary () {
        this.bPersonalDic = false;
    }


    // parse text functions

    parseParagraph (sText) {
        if (!this.oTokenizer) {
            this.loadTokenizer();
        }
︙
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
154
155
156
157
158
159
160
161
162
163

164
165
166

167
168
169

170
171
172
173
174
175
176
177
178

179
180
181

182
183
184

185
186
187
188
189
190
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
217
218
219
220
221

159
160
161
162
163
164
165

166
167
168

169
170
171

172
173
174
175
176
177
178
179
180
181
182

183
184
185

186
187
188

189
190
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
217

218
219
220

221
222
223
224
225
226
227
228
229

230
231
232

233
234
235

236
237
238
239
240
241
242
243

244
245
246

247
248
249

250
251
252
253
254
255
256
257
258








-
+


-
+


-
+










-
+


-
+


-
+










-
+


-
+


-
+








-
+


-
+


-
+








-
+


-
+


-
+







-
+


-
+


-
+









    // IBDAWG functions

    isValidToken (sToken) {
        // checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)
        if (this.oMainDic.isValidToken(sToken)) {
            return true;
        }
        if (this.oExtendedDic && this.oExtendedDic.isValidToken(sToken)) {
        if (this.bExtendedDic && this.oExtendedDic.isValidToken(sToken)) {
            return true;
        }
        if (this.oCommunityDic && this.oCommunityDic.isValidToken(sToken)) {
        if (this.bCommunityDic && this.oCommunityDic.isValidToken(sToken)) {
            return true;
        }
        if (this.oPersonalDic && this.oPersonalDic.isValidToken(sToken)) {
        if (this.bPersonalDic && this.oPersonalDic.isValidToken(sToken)) {
            return true;
        }
        return false;
    }

    isValid (sWord) {
        // checks if sWord is valid (different casing tested if the first letter is a capital)
        if (this.oMainDic.isValid(sWord)) {
            return true;
        }
        if (this.oExtendedDic && this.oExtendedDic.isValid(sWord)) {
        if (this.bExtendedDic && this.oExtendedDic.isValid(sWord)) {
            return true;
        }
        if (this.oCommunityDic && this.oCommunityDic.isValid(sToken)) {
        if (this.bCommunityDic && this.oCommunityDic.isValid(sToken)) {
            return true;
        }
        if (this.oPersonalDic && this.oPersonalDic.isValid(sWord)) {
        if (this.bPersonalDic && this.oPersonalDic.isValid(sWord)) {
            return true;
        }
        return false;
    }

    lookup (sWord) {
        // checks if sWord is in dictionary as is (strict verification)
        if (this.oMainDic.lookup(sWord)) {
            return true;
        }
        if (this.oExtendedDic && this.oExtendedDic.lookup(sWord)) {
        if (this.bExtendedDic && this.oExtendedDic.lookup(sWord)) {
            return true;
        }
        if (this.oCommunityDic && this.oCommunityDic.lookup(sToken)) {
        if (this.bCommunityDic && this.oCommunityDic.lookup(sToken)) {
            return true;
        }
        if (this.oPersonalDic && this.oPersonalDic.lookup(sWord)) {
        if (this.bPersonalDic && this.oPersonalDic.lookup(sWord)) {
            return true;
        }
        return false;
    }

    getMorph (sWord) {
        // retrieves morphologies list, different casing allowed
        let lResult = this.oMainDic.getMorph(sWord);
        if (this.oExtendedDic) {
        if (this.bExtendedDic) {
            lResult.push(...this.oExtendedDic.getMorph(sWord));
        }
        if (this.oCommunityDic) {
        if (this.bCommunityDic) {
            lResult.push(...this.oCommunityDic.getMorph(sWord));
        }
        if (this.oPersonalDic) {
        if (this.bPersonalDic) {
            lResult.push(...this.oPersonalDic.getMorph(sWord));
        }
        return lResult;
    }

    * suggest (sWord, nSuggLimit=10) {
        // generator: returns 1, 2 or 3 lists of suggestions
        yield this.oMainDic.suggest(sWord, nSuggLimit);
        if (this.oExtendedDic) {
        if (this.bExtendedDic) {
            yield this.oExtendedDic.suggest(sWord, nSuggLimit);
        }
        if (this.oCommunityDic) {
        if (this.bCommunityDic) {
            yield this.oCommunityDic.suggest(sWord, nSuggLimit);
        }
        if (this.oPersonalDic) {
        if (this.bPersonalDic) {
            yield this.oPersonalDic.suggest(sWord, nSuggLimit);
        }
    }

    * select (sPattern="") {
        // generator: returns all entries which morphology fits <sPattern>
        yield* this.oMainDic.select(sPattern)
        if (this.oExtendedDic) {
        if (this.bExtendedDic) {
            yield* this.oExtendedDic.select(sPattern);
        }
        if (this.oCommunityDic) {
        if (this.bCommunityDic) {
            yield* this.oCommunityDic.select(sPattern);
        }
        if (this.oPersonalDic) {
        if (this.bPersonalDic) {
            yield* this.oPersonalDic.select(sPattern);
        }
    }
}

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

Modified graphspell/spellchecker.py from [b7bf43a731] to [374c5d134a].

︙
28
29
30
31
32
33
34



35
36
37
38
39
40
41

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44








+
+
+








        self.sLangCode = sLangCode
        if not sfMainDic:
            sfMainDic = dDefaultDictionaries.get(sLangCode, "")
        self.oMainDic = self._loadDictionary(sfMainDic, True)
        self.oExtendedDic = self._loadDictionary(sfExtendedDic)
        self.oCommunityDic = self._loadDictionary(sfCommunityDic)
        self.oPersonalDic = self._loadDictionary(sfPersonalDic)
        self.bExtendedDic = bool(self.oExtendedDic)
        self.bCommunityDic = bool(self.oCommunityDic)
        self.bPersonalDic = bool(self.oPersonalDic)
        self.oTokenizer = None

    def _loadDictionary (self, source, bNecessary=False):
        "returns an IBDAWG object"
        if not source:
            return None
        try:
︙
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

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








-
+
+




-
+
+




+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+








        "returns True if the dictionary is loaded"
        self.oMainDic = self._loadDictionary(source)
        return bool(self.oMainDic)
            
    def setExtendedDictionary (self, source):
        "returns True if the dictionary is loaded"
        self.oExtendedDic = self._loadDictionary(source)
        return bool(self.oExtendedDic)
        self.bExtendedDic = bool(self.oExtendedDic)
        return self.bExtendedDic

    def setCommunityDictionary (self, source):
        "returns True if the dictionary is loaded"
        self.oCommunityDic = self._loadDictionary(source)
        return bool(self.oPersonalDic)
        self.bCommunityDic = bool(self.oCommunityDic)
        return self.bCommunityDic

    def setPersonalDictionary (self, source):
        "returns True if the dictionary is loaded"
        self.oPersonalDic = self._loadDictionary(source)
        self.bPersonalDic = bool(self.oPersonalDic)
        return self.bPersonalDic

    def activateExtendedDictionary (self):
        if self.oExtendedDic:
            self.bExtendedDic = True

    def activateCommunityDictionary (self):
        if self.oCommunityDic:
            self.bCommunityDic = True

    def activatePersonalDictionary (self):
        return bool(self.oPersonalDic)
        if self.oPersonalDic:
            self.bPersonalDic = True

    def deactivateExtendedDictionary (self):
        self.bExtendedDic = False

    def deactivateCommunityDictionary (self):
        self.bCommunityDic = False

    def deactivatePersonalDictionary (self):
        self.bPersonalDic = False


    # parse text functions

    def parseParagraph (self, sText, bSpellSugg=False):
        if not self.oTokenizer:
            self.loadTokenizer()
        aSpellErrs = []
︙
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
154

155
156
157
158
159
160
161
162
163
164

165
166

167
168

169
170
171
172
173
174

175
176

177
178

179
180
181
182
183

184
185
186

187
188
189

190
191

136
137
138
139
140
141
142

143
144

145
146

147
148
149
150
151
152
153
154

155
156

157
158

159
160
161
162
163
164
165
166

167
168

169
170

171
172
173
174
175
176
177

178
179

180
181

182
183
184
185
186
187
188
189
190
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

217
218
219








-
+

-
+

-
+







-
+

-
+

-
+







-
+

-
+

-
+






-
+

-
+

-
+









-
+

-
+

-
+





-
+

-
+

-
+




-
+


-
+


-
+




    # IBDAWG functions

    def isValidToken (self, sToken):
        "checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)"
        if self.oMainDic.isValidToken(sToken):
            return True
        if self.oExtendedDic and self.oExtendedDic.isValidToken(sToken):
        if self.bExtendedDic and self.oExtendedDic.isValidToken(sToken):
            return True
        if self.oCommunityDic and self.oCommunityDic.isValidToken(sToken):
        if self.bCommunityDic and self.oCommunityDic.isValidToken(sToken):
            return True
        if self.oPersonalDic and self.oPersonalDic.isValidToken(sToken):
        if self.bPersonalDic and self.oPersonalDic.isValidToken(sToken):
            return True
        return False

    def isValid (self, sWord):
        "checks if sWord is valid (different casing tested if the first letter is a capital)"
        if self.oMainDic.isValid(sWord):
            return True
        if self.oExtendedDic and self.oExtendedDic.isValid(sWord):
        if self.bExtendedDic and self.oExtendedDic.isValid(sWord):
            return True
        if self.oCommunityDic and self.oCommunityDic.isValid(sToken):
        if self.bCommunityDic and self.oCommunityDic.isValid(sToken):
            return True
        if self.oPersonalDic and self.oPersonalDic.isValid(sWord):
        if self.bPersonalDic and self.oPersonalDic.isValid(sWord):
            return True
        return False

    def lookup (self, sWord):
        "checks if sWord is in dictionary as is (strict verification)"
        if self.oMainDic.lookup(sWord):
            return True
        if self.oExtendedDic and self.oExtendedDic.lookup(sWord):
        if self.bExtendedDic and self.oExtendedDic.lookup(sWord):
            return True
        if self.oCommunityDic and self.oCommunityDic.lookup(sToken):
        if self.bCommunityDic and self.oCommunityDic.lookup(sToken):
            return True
        if self.oPersonalDic and self.oPersonalDic.lookup(sWord):
        if self.bPersonalDic and self.oPersonalDic.lookup(sWord):
            return True
        return False

    def getMorph (self, sWord):
        "retrieves morphologies list, different casing allowed"
        lResult = self.oMainDic.getMorph(sWord)
        if self.oExtendedDic:
        if self.bExtendedDic:
            lResult.extend(self.oExtendedDic.getMorph(sWord))
        if self.oCommunityDic:
        if self.bCommunityDic:
            lResult.extend(self.oCommunityDic.getMorph(sWord))
        if self.oPersonalDic:
        if self.bPersonalDic:
            lResult.extend(self.oPersonalDic.getMorph(sWord))
        return lResult

    def getLemma (self, sWord):
        return set([ s[1:s.find(" ")]  for s in self.getMorph(sWord) ])

    def suggest (self, sWord, nSuggLimit=10):
        "generator: returns 1, 2 or 3 lists of suggestions"
        yield self.oMainDic.suggest(sWord, nSuggLimit)
        if self.oExtendedDic:
        if self.bExtendedDic:
            yield self.oExtendedDic.suggest(sWord, nSuggLimit)
        if self.oCommunityDic:
        if self.bCommunityDic:
            yield self.oCommunityDic.suggest(sWord, nSuggLimit)
        if self.oPersonalDic:
        if self.bPersonalDic:
            yield self.oPersonalDic.suggest(sWord, nSuggLimit)

    def select (self, sPattern=""):
        "generator: returns all entries which morphology fits <sPattern>"
        yield from self.oMainDic.select(sPattern)
        if self.oExtendedDic:
        if self.bExtendedDic:
            yield from self.oExtendedDic.select(sPattern)
        if self.oCommunityDic:
        if self.bCommunityDic:
            yield from self.oCommunityDic.select(sPattern)
        if self.oPersonalDic:
        if self.bPersonalDic:
            yield from self.oPersonalDic.select(sPattern)

    def drawPath (self, sWord):
        self.oMainDic.drawPath(sWord)
        if self.oExtendedDic:
        if self.bExtendedDic:
            print("-----")
            self.oExtendedDic.drawPath(sWord)
        if self.oCommunityDic:
        if self.bCommunityDic:
            print("-----")
            self.oCommunityDic.drawPath(sWord)
        if self.oPersonalDic:
        if self.bPersonalDic:
            print("-----")
            self.oPersonalDic.drawPath(sWord)

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