def setDictionary(self): import dictLangDialog dialog = dictLangDialog.DictLangDialog() try: dialog.show() lang = dialog.selectedLang if lang == "United States" and enchant.dict_exists("en_US"): self.wordlist = enchant.request_dict("en_US") elif lang == "Chinese" and enchant.dict_exists("zh"): self.wordlist = enchant.request_dict("zh") elif lang == "Russian" and enchant.dict_exists("ru"): self.wordlist = enchant.request_dict("ru") elif lang == "German" and enchant.dict_exists("de_DE"): self.wordlist = enchant.request_dict("de_DE") elif lang == "French" and enchant.dict_exists("fr_FR"): self.wordlist = enchant.request_dict("fr_FR") elif lang == "Norwegian" and enchant.dict_exists("no"): self.wordlist = enchant.request_dict("no") elif lang == "Zulu" and enchant.dict_exists("zu"): self.wordlist = enchant.request_dict("zu") elif lang == "Arabic" and enchant.dict_exists("ar"): self.wordlist = enchant.request_dict("ar") elif lang == "Hindi" and enchant.dict_exists("hi"): self.wordlist = enchant.request_dict("hi") elif lang == "British" and enchant.dict_exists("en_GB"): self.wordlist = enchant.request_dict("en_GB") except: self.wordlist = enchant.request_dict("en_GB")
def toggleSpellcheck(self, v): self.spellcheck = v if enchant and self.spellcheck and not self._dict: if self.currentDict and enchant.dict_exists(self.currentDict): self._dict = enchant.Dict(self.currentDict) elif enchant.get_default_language() and enchant.dict_exists(enchant.get_default_language()): self._dict = enchant.Dict(enchant.get_default_language()) else: self.spellcheck = False if self.highlighter: self.highlighter.rehighlight() else: self.spellcheck = False
def _initialize(self): """ @raise ImportError: if pyenchant is not installed @raise enchant.Error: if no default dictionary exists """ # lazy import for catching import exceptions on missing Enchant import enchant import enchant.checker import enchant.tokenize # select a dictionary language = str(self._preferences.get("SpellCheckDictionary", "")) if len(language) > 0 and enchant.dict_exists(language): self._dictionary = enchant.Dict(language) else: # try to use default language (may raise enchant.Error) self._dictionary = enchant.Dict() language = self._dictionary.tag self._log.debug("Using dictionary '%s'" % language) # create a spellchecker that is aware of email addresses and URLs self._checker = enchant.checker.SpellChecker(language, filters=[enchant.tokenize.EmailFilter, enchant.tokenize.URLFilter]) self._initialized = True
def _initialize(self): """ @raise ImportError: if pyenchant is not installed @raise enchant.Error: if no default dictionary exists """ # lazy import for catching import exceptions on missing Enchant import enchant import enchant.checker import enchant.tokenize # select a dictionary language = str(self._preferences.get("SpellCheckDictionary", "")) if len(language) > 0 and enchant.dict_exists(language): self._dictionary = enchant.Dict(language) else: # try to use default language (may raise enchant.Error) self._dictionary = enchant.Dict() language = self._dictionary.tag self._log.debug("Using dictionary '%s'" % language) # create a spellchecker that is aware of email addresses and URLs self._checker = enchant.checker.SpellChecker( language, filters=[enchant.tokenize.EmailFilter, enchant.tokenize.URLFilter]) self._initialized = True
def initSpellchecker(self): # TODO: disable spellchecker icon in case of not working enchant try: import enchant spellDictDir = settings.get('spellchecker:directory') if spellDictDir: if enchant.__ver_major__ >= 1 and enchant.__ver_minor__ >= 6: enchant.set_param("enchant.myspell.dictionary.path", spellDictDir) else: print "Your pyenchant version is to old. Please " \ "upgrade to version 1.6.0 or higher, if you want " \ "to use spellchecker." return None spellLang = settings.get('spellchecker:lang') if enchant.dict_exists(spellLang): self.dict = enchant.Dict(spellLang) else: # try dictionary based on the current locale try: self.dict = enchant.Dict() settings.set('spellchecker:lang', self.dict.tag) except: # we don not have working dictionary... return None if self.dict: self.usePWL(self.dict) except: print "can not start spellchecker!!!" import traceback traceback.print_exc() return None
def __init__(self, name): self._lang = name if not (self._lang and enchant.dict_exists(self._lang)): self._lang = self.getDefaultDictionary() self._dict = enchant.DictWithPWL(self._lang, self.getCustomDictionaryPath())
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: import enchant raw = request.raw_post_data input = json.loads(raw) id = input["id"] method = input["method"] params = input["params"] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language '%s'" % lang) checker = enchant.Dict(str(lang)) if method == "checkWords": result = [word for word in arg if not checker.check(word)] elif method == "getSuggestions": result = checker.suggest(arg) else: raise RuntimeError("Unkown spellcheck method: '%s'" % method) output = {"id": id, "result": result, "error": None} except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(json.dumps(output), content_type="application/json")
def aspell(string): ''' если ok: False, [] если ошибка: True, aspell_sug ''' enchant.set_param("enchant.aspell.dictionary.path", "./aspell6-ru-0.99f7-1") if not enchant.dict_exists('ru_RU'): copyfile( './resources/aspell/ru_RU.dic', os.path.dirname(enchant.__file__).replace('\\', '/') + '/share/enchant/myspell/ru_RU.dic') copyfile( './resources/aspell/ru_RU.aff', os.path.dirname(enchant.__file__).replace('\\', '/') + '/share/enchant/myspell/ru_RU.aff') d = enchant.Dict("ru_RU") if d.check(string): # aspell says OK # print('aspell says OK') return False, [] else: # print('aspell says mistake and suggests:') aspell_sug = d.suggest(string) return True, aspell_sug
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: import enchant raw = request.raw_post_data input = simplejson.loads(raw) id = input['id'] method = input['method'] params = input['params'] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language '%s'" % lang) checker = enchant.Dict(lang) if method == 'checkWords': result = [word for word in arg if not checker.check(word)] elif method == 'getSuggestions': result = checker.suggest(arg) else: raise RuntimeError("Unkown spellcheck method: '%s'" % method) output = { 'id': id, 'result': result, 'error': None, } except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(simplejson.dumps(output), content_type='application/json')
def spellcheck(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: raw = request.raw_post_data input = json.loads(raw) id = input['id'] method = input['method'] params = input['params'] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language '%s'" % lang) checker = enchant.Dict(str(lang)) if method == 'checkWords': result = [word for word in arg if word and not checker.check(word)] elif method == 'getSuggestions': result = checker.suggest(arg) else: raise RuntimeError("Unkown spellcheck method: '%s'" % method) output = { 'id': id, 'result': result, 'error': None, } except Exception: return HttpResponse("Error running spellchecker") return HttpResponse(json.dumps(output), content_type='application/json')
def __init__(self, languages=('en_US', ), unicode_data=True, cldr_data=True, quick=True): ''' Initialize the emoji matcher :param languages: A list of languages to use for matching emoji :type languages: List or tuple of strings :param unicode_data: Whether to load the UnicodeData.txt file as well :type unicode_data: Boolean :param cldr_data: Whether to load data from CLDR as well :type cldr_data: Boolean :param quick: Whether to do a quicker but slighly less precise match. Quick matching is about 4 times faster and usually good enough. :type quick: Boolean ''' self._languages = languages self._quick = quick self._enchant_dicts = [] if IMPORT_ENCHANT_SUCCESSFUL: for language in self._languages: if enchant.dict_exists(language): self._enchant_dicts.append(enchant.Dict(language)) # From the documentation # (https://docs.python.org/3.6/library/difflib.html): # “SequenceMatcher computes and caches detailed information # about the second sequence, so if you want to compare one # sequence against many sequences, use set_seq2() to set the # commonly used sequence once and call set_seq1() repeatedly, # once for each of the other sequences.” self._matcher = SequenceMatcher(isjunk=None, a='', b='', autojunk=False) self._match_cache = {} self._string1 = '' self._seq1 = '' self._len1 = 0 self._string2 = '' self._string2_number_of_words = 0 self._string2_word_list = [] self._seq2 = '' self._len2 = 0 self._emoji_dict = {} self._candidate_cache = {} # The three data sources are loaded in this order on purpose. # The data from Unicode is loaded first to put the official # names first into the list of names to display the official # names in the candidates, if possible. The second best names # are the long names of emojione. if unicode_data: self._load_unicode_data() self._load_emojione_data() if cldr_data: for language in _expand_languages(self._languages): self._load_cldr_annotation_data(language)
def __init__(self, language="en_US"): if not enchant.dict_exists(language): logging.warning("Spelling_Corrector: Don't have {} , Please check it!!!", language) logging.warning("Recommend same language for you: {}", enchant.list_languages()) language = "en_US" self.dict = enchant.Dict(language) self.check = SpellChecker(language) self.tokenizer = get_tokenizer(language)
def addspell(self, channel, sender, line): words = line.split() if enchant.dict_exists(words[0]): d = enchant.Dict(words.pop(0)) else: d = enchant.Dict('en') for i in words: d.add(i)
def clean_ques(ques): ques = ques.lower() ques = tokenizer.tokenize(ques) for i in range(len(ques)): if not enchant.dict_exists(ques[i]): ques[i] = dictionary.suggest(ques[i])[0] #ques = [q for q in ques if q not in stop] ques = [stemmer.stem(q) for q in ques if q not in stop] return ques
def __init__(self,language): ''' Constructor ''' if enchant.dict_exists(language): self.dictionnary = enchant.Dict(language) else: availableDicos = '[%s]' % ', '.join(map(str, enchant.list_languages())) sys.exit("No dictionary installed for {}, the available dictionaries are: {}".format(language,availableDicos))
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: if not enchant: raise RuntimeError("install pyenchant for spellchecker functionality") raw = force_text(request.body) raw = force_text(request.body) try: input = json.loads(raw) id = input['id'] method = input['method'] params = input['params'] lang = params[0] arg = params[1] except ValueError: data = QueryDict(raw.encode('utf8')) method = data.get('method') text = data.get('text') lang = data.get('lang') if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language {!r}".format(lang)) checker = enchant.Dict(str(lang)) if method == 'spellcheck': res = {} for word in text.split(): tmp = word.encode('utf8').strip() if tmp == '': continue if not checker.check(tmp): res[tmp] = checker.suggest(tmp) output = dict(words=res) else: if method == 'checkWords': result = [word for word in arg if word and not checker.check(word)] elif method == 'getSuggestions': result = checker.suggest(arg) else: raise RuntimeError("Unknown spellcheck method: {!r}".format(method)) output = { 'id': id, 'result': result, 'error': None, } except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(json.dumps(output), content_type='application/json')
def set_dict(self, tag): if tag: logger.info('Setting dictionary %s', tag) if tag and enchant and enchant.dict_exists(tag): self.dict = enchant.Dict(tag) else: if tag: logger.warning('Failed to set dictionary %s', tag) self.dict = None self.config_store.set('spelling', 'language', self.current_language()) self.new_dict.emit()
def loadDicts(): global text_dic, en_dic en_dic = en.Dict("ru_RU") if en.dict_exists("ru_RU"): if os.path.exists(os.path.expanduser('~/.ExPy/dict.txt')): buf_dic = en.DictWithPWL("ru_RU",os.path.expanduser('~/.ExPy/dict.txt')) text_dic = SpellChecker(buf_dic, filters=[EmailFilter,URLFilter]) else: text_dic = SpellChecker("ru_RU", filters=[EmailFilter,URLFilter]) else: QtGui.QMessageBox.information(None, "Не обнаружен словарь", "Не обнаружен русский словарь Hunspell, проверка орфографии невозможна")
def set_dict(self, tag): if not bool(enchant): self.dict = None elif tag and enchant.dict_exists(tag): self.dict = enchant.Dict(tag) else: self.dict = None if self.dict: self.tag = self.dict.tag else: self.tag = '' self.new_dict.emit()
def init_language(self): '''Init self.language.''' c = self.c language = g.toUnicode(c.config.getString('enchant_language')) if language: try: ok = enchant.dict_exists(language) except Exception: ok = False if not ok: g.warning('Invalid language code for Enchant', repr(language)) g.es_print('Using "en_US" instead') language = 'en_US' self.language = language
def getDefaultDictionary(): if not EnchantDictionary.isInstalled(): return None default_locale = enchant.get_default_language() if default_locale and not enchant.dict_exists(default_locale): default_locale = None if default_locale is None: default_locale = QLocale.system().name() if default_locale is None: default_locale = self.availableDictionaries()[0] return default_locale
def set_language(self, code): if code: logger.debug('Setting dictionary %s', code) self.dict = None if Gspell: if code: self.dict = Gspell.Checker.new(Gspell.Language.lookup(code)) elif enchant: if code and enchant.dict_exists(code): self.dict = enchant.Dict(code) if code and not self.dict: logger.warning('Failed to set dictionary %s', code) self.config_store.set('spelling', 'language', self.current_language()) self.new_dict.emit()
def init_language(self): """Init self.language.""" c = self.c language = g.checkUnicode(c.config.getString('enchant-language')) if language: try: ok = enchant.dict_exists(language) except Exception: ok = False if not ok: g.warning('Invalid language code for Enchant', repr(language)) g.es_print('Using "en_US" instead') g.es_print('Use @string enchant_language to specify your language') language = 'en_US' self.language = language
def init_language(self): '''Init self.language.''' c = self.c language = g.toUnicode(c.config.getString('enchant_language')) if language: try: ok = enchant.dict_exists(language) except Exception: ok = False if not ok: g.warning('Invalid language code for Enchant', repr(language)) g.es_print('Using "en_US" instead') g.es_print('Use @string enchant_language to specify your language') language = 'en_US' self.language = language
def loadDicts(): global text_dic, en_dic en_dic = en.Dict("ru_RU") if en.dict_exists("ru_RU"): if os.path.exists(os.path.expanduser('~/.ExPy/dict.txt')): buf_dic = en.DictWithPWL("ru_RU", os.path.expanduser('~/.ExPy/dict.txt')) text_dic = SpellChecker(buf_dic, filters=[EmailFilter, URLFilter]) else: text_dic = SpellChecker("ru_RU", filters=[EmailFilter, URLFilter]) else: QtGui.QMessageBox.information( None, "Не обнаружен словарь", "Не обнаружен русский словарь Hunspell, проверка орфографии невозможна" )
def spell_check(self, post, lang): """ Check spellings for the given post and given language. """ if enchant.dict_exists(lang): checker = SpellChecker(lang, filters=[EmailFilter, URLFilter]) checker.set_text(post.text(lang=lang, strip_html=True)) words = [error.word for error in checker] words = [ word for word in words if self._not_in_other_dictionaries(word, lang) ] LOGGER.notice('Mis-spelt words in %s: %s' % (post.fragment_deps(lang), ', '.join(words))) else: LOGGER.notice('No dictionary found for %s' % lang)
def __init__(self, c): """Ctor for EnchantClass class.""" self.c = c language = g.toUnicode(c.config.getString("enchant_language")) # Set the base language if language and not enchant.dict_exists(language): g.warning("Invalid language code for Enchant", repr(language)) g.es_print('Using "en_US" instead') language = "en_US" # Compute fn, the full path to the local dictionary. fn = c.config.getString("enchant_local_dictionary") if not fn: fn = g.os_path_finalize_join(g.app.loadDir, "..", "plugins", "spellpyx.txt") # Fix bug https://github.com/leo-editor/leo-editor/issues/108 if not g.os_path_exists(fn): fn = g.os_path_finalize_join(g.app.homeDir, ".leo", "spellpyx.txt") self.open_dict(fn, language)
def __init__(self, c): """Ctor for EnchantClass class.""" self.c = c language = g.toUnicode(c.config.getString('enchant_language')) # Set the base language if language and not enchant.dict_exists(language): g.warning('Invalid language code for Enchant', repr(language)) g.es_print('Using "en_US" instead') language = 'en_US' # Compute fn, the full path to the local dictionary. fn = c.config.getString('enchant_local_dictionary') if not fn: fn = g.os_path_finalize_join(g.app.loadDir, "..", "plugins", 'spellpyx.txt') # Fix bug https://github.com/leo-editor/leo-editor/issues/108 if not g.os_path_exists(fn): fn = g.os_path_finalize_join(g.app.homeDir, '.leo', 'spellpyx.txt') self.open_dict(fn, language)
def __init__(self, c): """Ctor for EnchantClass class.""" # pylint: disable=super-init-not-called self.c = c language = g.toUnicode(c.config.getString('enchant_language')) # Set the base language if language and not enchant.dict_exists(language): g.warning('Invalid language code for Enchant', repr(language)) g.es_print('Using "en_US" instead') language = 'en_US' # Compute fn, the full path to the local dictionary. fn = c.config.getString('enchant_local_dictionary') if not fn: fn = g.os_path_finalize_join(g.app.loadDir, "..", "plugins", 'spellpyx.txt') # Fix bug https://github.com/leo-editor/leo-editor/issues/108 if not g.os_path_exists(fn): fn = g.os_path_finalize_join(g.app.homeDir, '.leo', 'spellpyx.txt') self.open_dict(fn, language)
def spell_check(self, post, lang): """ Check spellings for the given post and given language. """ if enchant.dict_exists(lang): checker = SpellChecker(lang, filters=[EmailFilter, URLFilter]) checker.set_text(post.text(lang=lang, strip_html=True)) words = [error.word for error in checker] words = [ word for word in words if self._not_in_other_dictionaries(word, lang) ] LOGGER.notice( 'Mis-spelt words in %s: %s' % ( post.fragment_deps(lang), ', '.join(words) ) ) else: LOGGER.notice('No dictionary found for %s' % lang)
def spell_check(request): """ Returns a response that implements the TinyMCE spellchecker protocol. """ try: if not enchant: raise RuntimeError("install pyenchant for spellchecker functionality") method = request.POST.get("method") text = request.POST.get("text") lang = request.POST.get("lang") if not enchant.dict_exists(lang): e_msg = f"Dictionary not found for language '{lang}', check pyenchant." raise RuntimeError(e_msg) checker = enchant.Dict(lang) def sanitize_words(text): """ Sanitize words in text and recommend suggestions for wrong words. """ suggested_words = {} words = text.split() for word in words: word.strip() word.strip(".,:;'\"") if not checker.check(word): suggested_words[word] = checker.suggest(word) return suggested_words if method == "spellcheck": output = {"words": sanitize_words(text)} else: e_msg = f"Got an unexpected method '{method}'" raise RuntimeError(e_msg) except Exception as err: logging.exception("Error running spellchecker") output = {"error": str(err)} return JsonResponse(output)
def spell(inp): "spell <word> -- Check spelling of <word>." if ' ' in inp: return "This command only supports one word at a time." if not enchant.dict_exists(locale): return "Could not find dictionary: " dictionary = enchant.Dict(locale) is_correct = dictionary.check(inp) suggestions = dictionary.suggest(inp) s_string = ', '.join(suggestions[:10]) if is_correct: return '"{}" appears to be \x02valid\x02! ' \ '(suggestions: {})'.format(inp, s_string) else: return '"{}" appears to be \x02invalid\x02! ' \ '(suggestions: {})'.format(inp, s_string)
def spell(self, channel, sender, line): if len(line.split()) == 2: lang, word = line.split() try: d = enchant.Dict(lang) except enchant.errors.DictNotFoundError: return 'Languages: ' + ', '.join(enchant.list_languages()) return sugg(d, word) if len(line.split()) == 1: d = enchant.Dict('en_US') return sugg(d, line) if not line: return 'Usage: [language] {<word for suggestions> | <sentence>}' words = line.split() if enchant.dict_exists(words[0]): c = enchant.checker.SpellChecker(words.pop(0)) else: c = enchant.checker.SpellChecker('en_US') c.set_text(' '.join(words)) return 'Unknown words: ' + ', '.join([i.word for i in c])
def spell(inp): "spell <word> -- Check spelling of <word>." if ' ' in inp: return "This command only supports one word at a time." if not enchant.dict_exists(locale): return "Could not find dictionary: {}".format(locale) dictionary = enchant.Dict(locale) is_correct = dictionary.check(inp) suggestions = dictionary.suggest(inp) s_string = ', '.join(suggestions[:10]) if is_correct: return '"{}" appears to be \x02valid\x02! ' \ '(suggestions: {})'.format(inp, s_string) else: return '"{}" appears to be \x02invalid\x02! ' \ '(suggestions: {})'.format(inp, s_string)
def spell_check(request): """Spellcheck view.""" import enchant raw = request.body input = json.loads(raw) id = input['id'] if ('id' in input) else None method = input['method'] if ('method' in input) else {} params = input['params'] if ('params' in input) else {} result = {} try: if params and method: lang = params['lang'] if ('lang' in params) else 'en-au' arg = params['words'] if ('words' in params) else [] if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language '%s'" % lang) checker = enchant.Dict(str(lang)) if method == 'spellcheck': for x in [ word for word in arg if word and not checker.check(word) ]: result[x] = checker.suggest(x) except Exception: pass output = { 'id': id, 'result': result, } # except Exception: # logging.exception("Error running spellchecker") # return HttpResponse("Error running spellchecker") return HttpResponse(json.dumps(output), content_type='application/json')
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: if not enchant: raise RuntimeError( "install pyenchant for spellchecker functionality") raw = force_text(request.body) input = json.loads(raw) id = input['id'] method = input['method'] params = input['params'] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError( "dictionary not found for language {!r}".format(lang)) checker = enchant.Dict(str(lang)) if method == 'checkWords': result = [word for word in arg if word and not checker.check(word)] elif method == 'getSuggestions': result = checker.suggest(arg) else: raise RuntimeError( "Unknown spellcheck method: {!r}".format(method)) output = { 'id': id, 'result': result, 'error': None, } except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(json.dumps(output), content_type='application/json')
def spell_check(request): """Spellcheck view.""" import enchant raw = request.body input = json.loads(raw) id = input['id'] if ('id' in input) else None method = input['method'] if ('method' in input) else {} params = input['params'] if ('params' in input) else {} result = {} try: if params and method: lang = params['lang'] if ('lang' in params) else 'en-au' arg = params['words'] if ('words' in params) else [] if not enchant.dict_exists(str(lang)): raise RuntimeError( "dictionary not found for language '%s'" % lang) checker = enchant.Dict(str(lang)) if method == 'spellcheck': for x in [word for word in arg if word and not checker.check(word)]: result[x] = checker.suggest(x) except Exception: pass output = { 'id': id, 'result': result, } # except Exception: # logging.exception("Error running spellchecker") # return HttpResponse("Error running spellchecker") return HttpResponse(json.dumps(output), content_type='application/json')
def spell(inp): """spell <word/sentence> -- Check spelling of a word or sentence.""" if not enchant.dict_exists(locale): return "Could not find dictionary: {}".format(locale) if len(inp.split(" ")) > 1: # input is a sentence checker = SpellChecker(locale) checker.set_text(inp) offset = 0 for err in checker: # find the location of the incorrect word start = err.wordpos + offset finish = start + len(err.word) # get some suggestions for it suggestions = err.suggest() s_string = '/'.join(suggestions[:3]) s_string = "\x02{}\x02".format(s_string) # calculate the offset for the next word offset = (offset + len(s_string)) - len(err.word) # replace the word with the suggestions inp = inp[:start] + s_string + inp[finish:] return inp else: # input is a word dictionary = enchant.Dict(locale) is_correct = dictionary.check(inp) suggestions = dictionary.suggest(inp) s_string = ', '.join(suggestions[:10]) if is_correct: return '"{}" appears to be \x02valid\x02! ' \ '(suggestions: {})'.format(inp, s_string) else: return '"{}" appears to be \x02invalid\x02! ' \ '(suggestions: {})'.format(inp, s_string)
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: if not enchant: raise RuntimeError("install pyenchant for spellchecker functionality") raw = force_text(request.body) input = json.loads(raw) id = input['id'] method = input['method'] params = input['params'] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError("dictionary not found for language {!r}".format(lang)) checker = enchant.Dict(str(lang)) if method == 'checkWords': result = [word for word in arg if word and not checker.check(word)] elif method == 'getSuggestions': result = checker.suggest(arg) else: raise RuntimeError("Unknown spellcheck method: {!r}".format(method)) output = { 'id': id, 'result': result, 'error': None, } except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(json.dumps(output), content_type='application/json')
def spell_check(request): """ Returns a HttpResponse that implements the TinyMCE spellchecker protocol. """ try: if not enchant: raise RuntimeError( "install pyenchant for spellchecker functionality") raw = force_text(request.body) input = json.loads(raw) id = input["id"] method = input["method"] params = input["params"] lang = params[0] arg = params[1] if not enchant.dict_exists(str(lang)): raise RuntimeError(f"dictionary not found for language {lang}") checker = enchant.Dict(str(lang)) if method == "checkWords": result = [word for word in arg if word and not checker.check(word)] elif method == "getSuggestions": result = checker.suggest(arg) else: raise RuntimeError(f"Unknown spellcheck method: {method}") output = { "id": id, "result": result, "error": None, } except Exception: logging.exception("Error running spellchecker") return HttpResponse(_("Error running spellchecker")) return HttpResponse(json.dumps(output), content_type="application/json")
def spell(inp): """spell <word/sentence> -- Check spelling of a word or sentence.""" if not enchant.dict_exists(locale): return "Could not find dictionary: {}".format(locale) if len(inp.split(" ")) > 1: # input is a sentence chkr = SpellChecker(locale) chkr.set_text(inp) offset = 0 for err in chkr: # find the location of the incorrect word start = err.wordpos + offset finish = start + len(err.word) # get some suggestions for it suggestions = err.suggest() s_string = '/'.join(suggestions[:3]) s_string = "\x02{}\x02".format(s_string) # calculate the offset for the next word offset = (offset + len(s_string)) - len(err.word) # replace the word with the suggestions inp = inp[:start] + s_string + inp[finish:] return inp else: # input is a word dictionary = enchant.Dict(locale) is_correct = dictionary.check(inp) suggestions = dictionary.suggest(inp) s_string = ', '.join(suggestions[:10]) if is_correct: return '"{}" appears to be \x02valid\x02! ' \ '(suggestions: {})'.format(inp, s_string) else: return '"{}" appears to be \x02invalid\x02! ' \ '(suggestions: {})'.format(inp, s_string)
import os from django.conf import settings from django.contrib.staticfiles import finders import enchant enchant.dict_exists('pl') DEFAULT_CONFIG = getattr( settings, 'TINYMCE_DEFAULT_CONFIG', { 'plugins': "spellchecker", 'theme': "advanced", 'toolbar': "undo redo | styleselect | bold italic | link image", 'relative_urls': False, 'width': '100%', 'height': 500, }) USE_SPELLCHECKER = getattr(settings, 'TINYMCE_SPELLCHECKER', True) USE_COMPRESSOR = getattr(settings, 'TINYMCE_COMPRESSOR', False) INCLUDE_JQUERY = getattr(settings, 'TINYMCE_INCLUDE_JQUERY', True) USE_EXTRA_MEDIA = getattr(settings, 'TINYMCE_EXTRA_MEDIA', None) USE_FILEBROWSER = getattr(settings, 'TINYMCE_FILEBROWSER', 'filebrowser' in settings.INSTALLED_APPS) if 'staticfiles' in settings.INSTALLED_APPS or 'django.contrib.staticfiles' in settings.INSTALLED_APPS: JS_URL = getattr(settings, 'TINYMCE_JS_URL',
""" Django settings for CompeteFashion project. Generated by 'django-admin startproject' using Django 1.9.5. For more information on this file, see https://docs.djangoproject.com/en/1.9/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.9/ref/settings/ """ import os import enchant enchant.dict_exists('en') # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATE_PATH = os.path.join(BASE_DIR, 'templates') STATIC_PATH = os.path.join(BASE_DIR, 'static') SITE_ID = 1 # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'eiyn&c$k!k@7z+clovku%o_)rp5u0en!_=tr=^!=h$_tv6*awu' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = []
def check_collection(inpath, outpath, lang, wordFiles=[]): """ Checks the orthography of the text in a collection. The expected input are plain text files. Arguments: inpath (string): path to the input files, including file name pattern outpath (string): path to the output file, including the output file's name lang (string): which dictionary to use, e.g. "es", "fr", "de" wordFiles (list): optional; list of strings; paths to files with lists of words which will not be treated as errors (e.g. named entities) """ try: enchant.dict_exists(lang) try: tknzr = get_tokenizer(lang) except enchant.errors.TokenizerNotFoundError: tknzr = get_tokenizer() chk = checker.SpellChecker(lang, tokenize=tknzr) except enchant.errors.DictNotFoundError: print("ERROR: The dictionary " + lang + "doesn't exist. Please choose another dictionary.") sys.exit(0) all_words = [] all_num = [] all_idnos = [] print("...checking...") for file in glob.glob(inpath): idno = os.path.basename(file)[-10:-4] all_idnos.append(idno) err_words = [] with open(file, "r", encoding="UTF-8") as fin: intext = fin.read().lower() chk.set_text(intext) if len(wordFiles) !=0: allCorrects = "" for file in wordFiles: with open(file, "r", encoding="UTF-8") as f: corrects = f.read().lower() allCorrects = allCorrects + corrects for err in chk: if not wordFiles or err.word not in allCorrects: err_words.append(err.word) all_words.append(err_words) err_num = collections.Counter(err_words) all_num.append(err_num) print("..." + str(len(err_num)) + " different errors found in " + idno) df = pd.DataFrame(all_num,index=all_idnos).T df = df.fillna(0) df = df.astype(int) df["sum"] = df.sum(axis=1) # df = df.sort("sum", ascending=False) df = df.sort_values(by="sum", ascending=False) df.to_csv(outpath) print("done")
def test_HasENUS(): """Test that the en_US language is available through default broker.""" assert dict_exists("en_US")
def __init__(self, lang): import enchant self.lang = str(lang) if not enchant.dict_exists(lang): raise RuntimeError("dictionary not found for language '%s'" % lang) self.backend = enchant.Dict(lang)
def setDict(self, d): self.currentDict = d if d and enchant.dict_exists(d): self._dict = enchant.Dict(d) if self.highlighter: self.highlighter.rehighlight()
def set_language(self, language): if not enchant.dict_exists(language): return self.language = language self.spellchecker = enchant.Dict(language)
print "Check a mis-spelled word: " print "\tcheck(\"Helo\"): {}".format(d.check("Helo")) print "\n" print "suggest a word:" print "* ordered from most likely replacement to least likely" print "\tsuggest(\"Helo\"): {}".format(d.suggest("Helo")) print "\n" print "attempt to determine language:" print "\ttag: {}".format(d.tag) print "\n" print "check whether dictionaries exist:" print "\tenchant.dict_exists(\"en_US\"): {}".format(enchant.dict_exists("en_US")) print "\tenchant.dict_exists(\"fake\"): {}".format(enchant.dict_exists("fake")) print "\n" print "List available dictionaries:" print "\tenchant.list_languages(): {}".format(enchant.list_languages()) print "\n" print "Providers:" print "* Different providers exist using different frameworks: (aspell, MySpell)." print "\tprovider: {}".format(d.provider) print "\tprovider.name: {}".format(d.provider.name) print "\tprovider.file: {}".format(d.provider.file) print "\n" print "Brokers:"
def check_collection(inpath, outpath, lang, wordFiles=[]): """ Checks the orthography of the text in a collection. The expected input are plain text files. Arguments: inpath (string): path to the input files, including file name pattern outpath (string): path to the output file, including the output file's name lang (string): which dictionary to use, e.g. "es", "fr", "de" wordFiles (list): optional; list of strings; paths to files with lists of words which will not be treated as errors (e.g. named entities) """ try: enchant.dict_exists(lang) try: tknzr = get_tokenizer(lang) except enchant.errors.TokenizerNotFoundError: tknzr = get_tokenizer() chk = checker.SpellChecker(lang, tokenize=tknzr) except enchant.errors.DictNotFoundError: print("ERROR: The dictionary " + lang + "doesn't exist. Please choose another dictionary.") sys.exit(0) all_words = [] all_num = [] all_idnos = [] print("...checking...") for file in glob.glob(inpath): idno, ext = os.path.basename(file).split(".") all_idnos.append(idno) err_words = [] with open(file, "r", encoding="UTF-8") as fin: intext = fin.read().lower() chk.set_text(intext) if len(wordFiles) != 0: allCorrects = "" for file in wordFiles: with open(file, "r", encoding="UTF-8") as f: corrects = f.read().lower() allCorrects = allCorrects + corrects for err in chk: if not wordFiles or err.word not in allCorrects: err_words.append(err.word) all_words.append(err_words) err_num = collections.Counter(err_words) all_num.append(err_num) print("..." + str(len(err_num)) + " different errors found in " + idno) df = pd.DataFrame(all_num, index=all_idnos).T df = df.fillna(0) df = df.astype(int) df["sum"] = df.sum(axis=1) # df = df.sort("sum", ascending=False) df = df.sort_values(by="sum", ascending=False) df.to_csv(outpath) print("done")