1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
|
# Spellchecker
# Wrapper for the IBDAWG class.
# Useful to check several dictionaries at once.
from . import ibdawg
dDictionaries = {
"fr": "French.bdic",
"en": "English.bdic"
}
class Spellchecker ():
def __init__ (self, sLangCode):
self.sLangCode = sLangCode
self.oMainDic = None
if sLangCode in dDictionaries:
self.oMainDic = ibdawg.IBDAWG(dDictionaries[sLangCode])
self.lOtherDic = []
return bool(self.oMainDic)
def setMainDictionary (self, sDicName):
try:
self.oMainDic = ibdawg.IBDAWG(sDicName)
return True
print("Error: <" + sDicName + "> not set as main dictionary.")
return False
def addDictionary (self, sDicName):
try:
self.lOtherDic.append(ibdawg.IBDAWG(sDicName))
return True
except:
print("Error: <" + sDicName + "> not added to the list.")
return False
# Return codes:
# 0: invalid
# 1: correct in main dictionary
# 2+: correct in foreign dictionaries
# check in the main dictionary only
def isValidToken (self, sToken):
"(in main dictionary) checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)"
if self.oMainDic.isValidToken(sToken):
return 1
return 0
def isValid (self, sWord):
"(in main dictionary) checks if sWord is valid (different casing tested if the first letter is a capital)"
if self.oMainDic.isValid(sWord):
return 1
return 0
def lookup (self, sWord):
"(in main dictionary) checks if sWord is in dictionary as is (strict verification)"
if self.oMainDic.lookup(sWord):
return 1
return 0
# check in all dictionaries
def isValidTokenAll (self, sToken):
"(in all dictionaries) checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)"
if self.oMainDic.isValidToken(sToken):
return 1
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.isValidToken(sToken):
return i
return 0
def isValidAll (self, sWord):
"(in all dictionaries) checks if sWord is valid (different casing tested if the first letter is a capital)"
if self.oMainDic.isValid(sToken):
return 1
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.isValid(sToken):
return i
return 0
def lookupAll (self, sWord):
"(in all dictionaries) checks if sWord is in dictionary as is (strict verification)"
if self.oMainDic.lookup(sToken):
return 1
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.lookup(sToken):
return i
return 0
# check in dictionaries up to level n
def isValidTokenLevel (self, sToken, nLevel):
"(in dictionaries up to level n) checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)"
if self.oMainDic.isValidToken(sToken):
return 1
if nLevel >= 2:
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.isValidToken(sToken):
return i
if i == nLevel:
break
return 0
def isValidLevel (self, sWord, nLevel):
"(in dictionaries up to level n) checks if sWord is valid (different casing tested if the first letter is a capital)"
if self.oMainDic.isValid(sToken):
return 1
if nLevel >= 2:
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.isValid(sToken):
return i
if i == nLevel:
break
return 0
def lookupLevel (self, sWord, nLevel):
"(in dictionaries up to level n) checks if sWord is in dictionary as is (strict verification)"
if self.oMainDic.lookup(sToken):
return 1
if nLevel >= 2:
for i, oDic in enumerate(self.lOtherDic, 2):
if oDic.lookup(sToken):
return i
if i == nLevel:
break
return 0
|
>
>
>
>
>
>
>
>
|
|
|
|
>
>
>
|
|
|
<
|
>
|
>
<
|
|
>
|
|
<
>
|
|
|
<
>
>
>
|
<
<
|
|
>
>
|
|
|
>
>
>
>
|
|
|
|
>
>
>
>
|
|
|
|
<
|
<
<
<
<
<
<
|
<
|
|
|
|
|
|
<
|
<
<
<
|
<
<
|
<
<
|
|
<
<
<
<
|
<
>
|
<
|
<
<
<
<
<
<
|
<
<
|
<
<
|
<
<
<
<
<
|
<
>
|
<
|
<
|
<
|
<
<
>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
|
# Spellchecker
# Wrapper for the IBDAWG class.
# Useful to check several dictionaries at once.
# To avoid iterating over a pile of dictionaries, it is assumed that 3 are enough:
# - the main dictionary, bundled with the package
# - the extended dictionary, added by an organization
# - the personal dictionary, created by the user for its own convenience
import traceback
from . import ibdawg
dDefaultDictionaries = {
"fr": "fr.bdic",
"en": "en.bdic"
}
class Spellchecker ():
def __init__ (self, sLangCode, sfMainDic="", sfExtendedDic="", sfPersonalDic=""):
"returns True if the main dictionary is loaded"
self.sLangCode = sLangCode
if not sfMainDic:
sfMainDic = dDefaultDictionaries.get(sLangCode, "")
self.oMainDic = self._loadDictionary(sfMainDic)
self.oExtendedDic = self._loadDictionary(sfExtendedDic)
self.oPersonalDic = self._loadDictionary(sfPersonalDic)
return bool(self.oMainDic)
def _loadDictionary (self, sfDictionary):
"returns an IBDAWG object"
if not sfDictionary:
return None
try:
return ibdawg.IBDAWG(sfDictionary)
except:
print("Error: <" + sDicName + "> not loaded.")
traceback.print_exc()
return None
def setMainDictionary (self, sfDictionary):
"returns True if the dictionary is loaded"
self.oMainDic = self._loadDictionary(sfDictionary)
return bool(self.oMainDic)
def setExtendedDictionary (self, sfDictionary):
"returns True if the dictionary is loaded"
self.oExtendedDic = self._loadDictionary(sfDictionary)
return bool(self.oExtendedDic)
def setPersonalDictionary (self, sfDictionary):
"returns True if the dictionary is loaded"
self.oPersonalDic = self._loadDictionary(sfDictionary)
return bool(self.oPersonalDic)
# 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):
return True
if self.oPersonalDic 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(sToken):
return True
if self.oExtendedDic and self.oExtendedDic.isValid(sToken):
return True
if self.oPersonalDic and self.oPersonalDic.isValid(sToken):
return True
return False
def lookup (self, sWord):
"checks if sWord is in dictionary as is (strict verification)"
if self.oMainDic.lookup(sToken):
return True
if self.oExtendedDic and self.oExtendedDic.lookup(sToken):
return True
if self.oPersonalDic and self.oPersonalDic.lookup(sToken):
return True
return False
def getMorph (self, sWord):
"retrieves morphologies list, different casing allowed"
lResult = self.oMainDic.getMorph(sToken)
if self.oExtendedDic:
lResult.extends(self.oExtendedDic.getMorph(sToken))
if self.oPersonalDic:
lResult.extends(self.oPersonalDic.getMorph(sToken))
return lResult
def suggest (self, sWord, nSuggLimit=10):
"generator: returns 1,2 or 3 lists of suggestions"
yield self.oMainDic.suggest(sWord, nSuggLimit)
if self.oExtendedDic:
yield self.oExtendedDic.suggest(sWord, nSuggLimit)
if self.oPersonalDic:
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:
yield from self.oExtendedDic.select(sPattern)
if self.oPersonalDic:
yield from self.oPersonalDic.select(sPattern)
|