Grammalecte  Check-in [dbf7b575b0]

Overview
Comment:[graphspell][py] spellchecker wrapper for ibdawg
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | graphspell
Files: files | file ages | folders
SHA3-256: dbf7b575b030e837130b31b122916a0ef1c2d4cb06332f0f7d156384f0e1a965
User & Date: olr on 2018-02-13 10:47:09
Original Comment: [graphspell] spellchecker wrapper for ibdawg
Other Links: manifest | tags
Context
2018-02-13
10:47
[graphspell][js] spellchecker wrapper for ibdawg check-in: c989c20101 user: olr tags: trunk, graphspell
10:47
[graphspell][py] spellchecker wrapper for ibdawg check-in: dbf7b575b0 user: olr tags: trunk, graphspell
2018-02-12
23:36
[fr] pt: à l’époque check-in: 067013544a user: olr tags: trunk, fr
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified gc_lang/fr/rules.grx from [a338fa9d13] to [29eda24584].

︙︙
5766
5767
5768
5769
5770
5771
5772

5773
5774
5775
5776
5777
5778
5779

TEST: Une tierce connaissance qui est au pire triviale, mais non nulle.
TEST: ces immeubles qui les ont le plus marqués
TEST: quel potentiel électoral réel pour les souverainistes pur sucre ?
TEST: Cette scène que décrit ici Yannick est représentative.
TEST: attentifs aux spécificités socioculturelles de chaque peuple, constituées dans la longue durée autour d’une langue et de traditions
TEST: Il était à l’époque chargé de maintenir en état ces machines.



#
# //////////////////////////////////////// RÈGLES DE CONTRÔLE ////////////////////////////////////////
#


!!!! Redondances dans la phrase                                                                     








>








5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
5777
5778
5779
5780

TEST: Une tierce connaissance qui est au pire triviale, mais non nulle.
TEST: ces immeubles qui les ont le plus marqués
TEST: quel potentiel électoral réel pour les souverainistes pur sucre ?
TEST: Cette scène que décrit ici Yannick est représentative.
TEST: attentifs aux spécificités socioculturelles de chaque peuple, constituées dans la longue durée autour d’une langue et de traditions
TEST: Il était à l’époque chargé de maintenir en état ces machines.



#
# //////////////////////////////////////// RÈGLES DE CONTRÔLE ////////////////////////////////////////
#


!!!! Redondances dans la phrase
︙︙
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
5976
5977

    -1>> un                                                                                         # Accord de genre erroné : « \2 » est masculin.
    <<- __also__ and hasFemForm(\2) -2>> =suggFemSing(@, True)                                      # Accord de genre erroné : « \1 » est un déterminant féminin.
    <<- morphex(\2, ":[NAQ].*:p", ":[siGW]") and not morph(word(-2), ":B", False) -2>> =suggFemSing(@) # Accord de nombre erroné : « \2 » devrait être au singulier.
__[i]/gn(gn_une_des_accord)__
    (une) +des +({w_2})  @@0,$
    <<- morphex(\2, ":[NAQ].*:m", ":(?:e|f|G|W|V0|3s)") -1>> un                                     # Accord de genre erroné : « \2 » est masculin.
    <<- __also__ and hasFemForm(\2) -2>> =suggFemPlur(@, True)                                      # Accord de genre erroné : « \1 » est un déterminant féminin.


TEST: un {{slashs}}                                           ->> slash
TEST: un {{fromages}}.                                        ->> fromage
TEST: Un {{ballons}}                                          ->> ballon
TEST: Une {{cinglées}}                                        ->> cinglée










<








5964
5965
5966
5967
5968
5969
5970

5971
5972
5973
5974
5975
5976
5977

    -1>> un                                                                                         # Accord de genre erroné : « \2 » est masculin.
    <<- __also__ and hasFemForm(\2) -2>> =suggFemSing(@, True)                                      # Accord de genre erroné : « \1 » est un déterminant féminin.
    <<- morphex(\2, ":[NAQ].*:p", ":[siGW]") and not morph(word(-2), ":B", False) -2>> =suggFemSing(@) # Accord de nombre erroné : « \2 » devrait être au singulier.
__[i]/gn(gn_une_des_accord)__
    (une) +des +({w_2})  @@0,$
    <<- morphex(\2, ":[NAQ].*:m", ":(?:e|f|G|W|V0|3s)") -1>> un                                     # Accord de genre erroné : « \2 » est masculin.
    <<- __also__ and hasFemForm(\2) -2>> =suggFemPlur(@, True)                                      # Accord de genre erroné : « \1 » est un déterminant féminin.


TEST: un {{slashs}}                                           ->> slash
TEST: un {{fromages}}.                                        ->> fromage
TEST: Un {{ballons}}                                          ->> ballon
TEST: Une {{cinglées}}                                        ->> cinglée
︙︙

Modified graphspell/spellchecker.py from [c6b35d80ee] to [19c7dd4df2]. 

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
        except:
            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)

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