def find_antonyms(self): """ Purpose ---------- This function queries multiple online repositories to discover antonyms associated with the specific word provided to the Class Antonyms. The antonyms are deduplicated and sorted alphabetically. Returns ---------- :returns: antonyms: list of antonyms :rtype: list """ valid_word = self._validate_word() if valid_word: check_cache = self._check_cache() if check_cache[0] is True: antonyms = cleansing.flatten_multidimensional_list(check_cache[1]) if self._output_format == 'list': return sorted(set(antonyms)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(antonyms))} return output_dict elif self._output_format == 'json': json_object = json.dumps({'antonyms': {self._word: sorted(set(antonyms))}}, indent=4, ensure_ascii=False) return json_object elif check_cache[0] is False: antonyms_01 = self._query_thesaurus_com() antonyms_02 = self._query_wordhippo() antonyms = ([x for x in [antonyms_01, antonyms_02] if x is not None]) antonyms_results = cleansing.flatten_multidimensional_list(antonyms) if len(antonyms_results) != 0: if self._output_format == 'list': return sorted(set(antonyms_results)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(antonyms_results))} return output_dict elif self._output_format == 'json': json_object = json.dumps({'antonyms': {self._word: sorted(set(antonyms_results))}}, indent=4, ensure_ascii=False) return json_object else: return _colorized_text(255, 0, 255, f'antonyms were found for the word: {self._word} \n' f'Please verify that the word is spelled correctly.') else: return _colorized_text(255, 0, 255, f'Please verify that the word {self._word} is spelled correctly.')
def query_thesaurus_com(single_word): """ This function queries thesaurus.com for antonyms related to the 'single_word' parameter. :param single_word: string variable to search for :return: list of antonyms """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_antonyms(single_word, 'thesaurus_com') if not check_cache: try: req = requests.get( f'https://tuna.thesaurus.com/pageData/{single_word}', headers=basic_soup.http_headers, allow_redirects=True, verify=True, timeout=30) if '{"data":null}' not in req.text: dict_antonyms = req.json( )['data']['definitionData']['definitions'][0]['antonyms'] if dict_antonyms: antonyms = sorted([r["term"] for r in dict_antonyms]) caching.insert_word_cache_antonyms( single_word, 'thesaurus_com', antonyms) return antonyms else: logger.error( f'The word {single_word} has no antonyms on thesaurus.com.' ) else: logger.error( f'The word {single_word} was not found on thesaurus.com.' ) except requests.HTTPError as e: logger.error('A HTTP error has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.ConnectionError as e: if requests.codes: 'Failed to establish a new connection' logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.Timeout as e: logger.error('A connection timeout has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.RequestException as e: logger.error('An ambiguous exception occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: antonyms = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return antonyms else: logger.error(f'The word {single_word} was not in a valid format.') logger.error( f'Please verify that the word {single_word} is spelled correctly.')
def find_definitions(self): """ Purpose ---------- This function queries multiple online repositories to discover definitions related with the specific word provided to the Class Definitions. Returns ---------- :return: list of definitions :rtype: list """ valid_word = self._validate_word() if valid_word: check_cache = caching.cache_antonyms(self._word) if check_cache is False: definition_01 = self._query_collins_dictionary() definition_02 = self._query_merriam_webster() definition_03 = self._query_synonym_com() definitions = ([ x for x in [definition_01, definition_02, definition_03] if x is not None ]) definitions = cleansing.flatten_multidimensional_list( definitions) if not definitions: return f'No definitions were found for the word: {self._word}' else: return sorted(set(definitions)) else: definitions = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return sorted(set(definitions)) else: return f'Please verify that the word {self._word} is spelled correctly.'
def find_synonyms(self): """ Purpose ---------- This function queries multiple online repositories to discover synonyms associated with the specific word provided to the Class Synonyms. The synonyms are deduplicated and sorted alphabetically. Returns ---------- :returns: synonyms: list of synonyms :rtype: list """ valid_word = self._validate_word() if valid_word: check_cache = self._check_cache() if check_cache is False: synonyms_01 = self._query_collins_dictionary() synonyms_02 = self._query_merriam_webster() synonyms_03 = self._query_synonym_com() synonyms_04 = self._query_thesaurus_com() synonyms_05 = self._query_wordnet() synonyms = ([x for x in [synonyms_01, synonyms_02, synonyms_03, synonyms_04, synonyms_05] if x is not None]) synonyms_results = cleansing.flatten_multidimensional_list(synonyms) if not synonyms_results: return f'No synonyms were found for the word: {self._word}' else: return sorted(set([word.lower() for word in synonyms_results])) else: synonyms = cleansing.flatten_multidimensional_list([val for val in check_cache.values()]) return sorted(set(synonyms)) else: return f'Please verify that the word {self._word} is spelled correctly.'
def query_synonym_com(single_word): """ This function queries synonym.com for a definition related to the 'single_word' parameter. :param single_word: string variable to search for :return: definition for the word """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_definition(single_word, 'synonym_com') if not check_cache: try: results_definition = basic_soup.get_single_page_html(f'https://www.synonym.com/synonyms/{single_word}') soup = BeautifulSoup(results_definition, "lxml") description_tag = soup.find("meta", property="og:description") if 'find any words based on your search' not in description_tag['content']: find_definition = regex.split(r'\|', description_tag['content']) definition_list = find_definition[1].lstrip().replace('definition:', '').split(',') definition = [cleansing.normalize_space(i) for i in definition_list] definition_list_to_string = ' '.join([str(elem) for elem in definition]) caching.insert_word_cache_definition(single_word, 'synonym_com', definition_list_to_string) return definition_list_to_string else: logger.error(f'synonym.com had no reference for the word {single_word}') except bs4.FeatureNotFound as e: logger.error('An error occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except AttributeError as e: logger.error('An AttributeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except KeyError as e: logger.error('A KeyError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except TypeError as e: logger.error('A TypeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: definition = cleansing.flatten_multidimensional_list([val for val in check_cache.values()]) return definition else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error(f'Please verify that the word {single_word} is spelled correctly.')
def query_collins_dictionary_synonym(single_word): """ This function queries collinsdictionary.com for a definition related to the 'single_word' parameter. :param single_word: string variable to search for :return: definition for the word """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_definition(single_word, 'collins_dictionary') if not check_cache: try: results_definition = basic_soup.get_single_page_html( f'https://www.collinsdictionary.com/dictionary/english-thesaurus/{single_word}') query_results = basic_soup.query_html(results_definition, 'div', 'class', 'form type-def titleTypeSubContainer') if query_results is not None: definition = query_results.findNext('div', {'class': 'def'}) caching.insert_word_cache_definition(single_word, 'collins_dictionary', definition.text) return definition.text else: logger.error(f'Collins Dictionary had no reference for the word {single_word}') except bs4.FeatureNotFound as e: logger.error('An error occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except AttributeError as e: logger.error('An AttributeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except KeyError as e: logger.error('A KeyError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except TypeError as e: logger.error('A TypeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: definition = cleansing.flatten_multidimensional_list([val for val in check_cache.values()]) return definition else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error(f'Please verify that the word {single_word} is spelled correctly.')
def query_thesaurus_com(single_word): """ This function queries thesaurus.com for a definition related to the 'single_word' parameter. :param single_word: string variable to search for :return: definition for the word """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_definition(single_word, 'thesaurus_com') if not check_cache: try: req = requests.get(f'https://tuna.thesaurus.com/pageData/{single_word}', headers=basic_soup.http_headers, allow_redirects=True, verify=True, timeout=30) if req.json()['data'] is not None: definition = req.json()['data']['definitionData']['definitions'][0]['definition'] caching.insert_word_cache_definition(single_word, 'thesaurus_com', definition) return definition else: logger.error(f'thesaurus.com had no reference for the word {single_word}') except requests.HTTPError as e: logger.error('A HTTP error has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.ConnectionError as e: if requests.codes: 'Failed to establish a new connection' logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.Timeout as e: logger.error('A connection timeout has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.RequestException as e: logger.error('An ambiguous exception occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: definition = cleansing.flatten_multidimensional_list([val for val in check_cache.values()]) return definition else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error(f'Please verify that the word {single_word} is spelled correctly.')
def find_hyponyms(self): """ Purpose ---------- This function queries classicthesaurus_com for hyponyms associated with the specific word provided to the Class Hyponyms. Returns ---------- :returns: hyponyms: list of hyponyms :rtype: list Raises ---------- :raises AttributeError: Raised when an attribute reference or assignment fails. IndexError: Raised when a sequence subscript is out of range KeyError: Raised when a mapping (dictionary) key is not found in the set of existing keys. TypeError: Raised when an operation or function is applied to an object of inappropriate type. bs4.FeatureNotFound: raised by the BeautifulSoup constructor if no parser with the requested features is found """ valid_word = self._validate_word() if valid_word: check_cache = self._check_cache() if check_cache is False: try: if self._proxies is None: response = Query( f'https://www.classicthesaurus.com/{self._word}/narrower' ).get_single_page_html() if response.status_code == 404: logger.info( f'Classic Thesaurus had no hyponyms reference for the word {self._word}' ) else: soup = BeautifulSoup(response.text, "lxml") hyponym = _get_hyponyms(soup) if 'no hyponyms found' in hyponym: return f'No hyponyms were found for the word: {self._word}' else: number_of_pages = _get_number_of_pages(soup) if number_of_pages >= 2: for page in range(2, number_of_pages): sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/narrower/' f'{page}').get_single_page_html() sub_soup = BeautifulSoup( sub_html.text, 'lxml') additional_hyponym = _get_hyponyms( sub_soup) hyponym.union(additional_hyponym) self._update_cache(sorted(hyponym)) return sorted(set(hyponym)) elif self._proxies is not None: response = Query( f'https://www.classicthesaurus.com/{self._word}/narrower', self._proxies).get_single_page_html() if response.status_code == 404: logger.info( f'Classic Thesaurus had no hyponyms reference for the word {self._word}' ) else: soup = BeautifulSoup(response.text, "lxml") hyponym = _get_hyponyms(soup) if 'no hyponyms found' in hyponym: return f'No hyponyms were found for the word: {self._word}' else: number_of_pages = _get_number_of_pages(soup) if number_of_pages >= 2: for page in range(2, number_of_pages): sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/narrower/' f'{page}', self._proxies ).get_single_page_html() sub_soup = BeautifulSoup( sub_html.text, 'lxml') additional_hyponym = _get_hyponyms( sub_soup) hyponym.union(additional_hyponym) self._update_cache(sorted(hyponym)) return sorted(set(hyponym)) except bs4.FeatureNotFound as error: logger.error( 'An error occurred in the following code segment:') logger.error(''.join( traceback.format_tb(error.__traceback__))) except AttributeError as error: logger.error( 'An AttributeError occurred in the following code segment:' ) logger.error(''.join( traceback.format_tb(error.__traceback__))) except IndexError as error: logger.error( 'An IndexError occurred in the following code segment:' ) logger.error(''.join( traceback.format_tb(error.__traceback__))) except KeyError as error: logger.error( 'A KeyError occurred in the following code segment:') logger.error(''.join( traceback.format_tb(error.__traceback__))) except TypeError as error: logger.error( 'A TypeError occurred in the following code segment:') logger.error(''.join( traceback.format_tb(error.__traceback__))) else: hyponym = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return hyponym
def find_hypernyms(self): """ Purpose ---------- This function queries classicthesaurus_com for hypernyms associated with the specific word provided to the Class Hypernyms. Returns ---------- :returns: hypernym: list of hypernyms :rtype: list Raises ---------- :raises AttributeError: Raised when an attribute reference or assignment fails IndexError: Raised when a sequence subscript is out of range KeyError: Raised when a mapping (dictionary) key is not found in the set of existing keys TypeError: Raised when an operation or function is applied to an object of inappropriate type bs4.FeatureNotFound: raised by the BeautifulSoup constructor if no parser with the requested features is found """ valid_word = self._validate_word() if valid_word: check_cache = self._check_cache() if check_cache[0] is True: hypernym = cleansing.flatten_multidimensional_list(list(check_cache[1])) if self._output_format == 'list': return sorted(hypernym) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(hypernym))} return output_dict elif self._output_format == 'json': json_object = json.dumps({'hypernyms': {self._word: sorted(set(hypernym))}}, indent=4, ensure_ascii=False) return json_object elif check_cache[0] is False: try: response = '' if self._proxies is None: if self._user_agent is None: response = Query( f'https://www.classicthesaurus.com/{self._word}/broader').get_single_page_html() elif self._user_agent is not None: response = Query(f'https://www.classicthesaurus.com/{self._word}/broader', user_agent=self._user_agent).get_single_page_html() elif self._proxies is not None: if self._user_agent is None: response = Query(f'https://www.classicthesaurus.com/{self._word}/broader', proxies=self._proxies).get_single_page_html() elif self._user_agent is not None: response = Query(f'https://www.classicthesaurus.com/{self._word}/broader', user_agent=self._user_agent, proxies=self._proxies).get_single_page_html() if response.status_code == 404: logger.info(f'Classic Thesaurus had no hypernyms reference for the word {self._word}') else: soup = BeautifulSoup(response.text, "lxml") cloudflare_protection = CloudflareVerification('https://www.classicthesaurus.com', soup).cloudflare_protected_url() if cloudflare_protection is False: hypernym = _get_hypernyms(soup) if 'no hypernyms found' in hypernym: return _colorized_text(255, 0, 255, f'No hypernyms were found for the word: {self._word} \n' f'Please verify that the word is spelled correctly.') else: number_of_pages = _get_number_of_pages(soup) if number_of_pages >= 2: for page in range(2, number_of_pages): sub_html = '' if self._proxies is None: if self._user_agent is None: sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/broader/{page}').get_single_page_html() elif self._user_agent is not None: sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/broader/{page}', user_agent=self._user_agent).get_single_page_html() elif self._proxies is not None: if self._user_agent is None: sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/broader/{page}', proxies=self._proxies).get_single_page_html() elif self._user_agent is not None: sub_html = Query( f'https://www.classicthesaurus.com/{self._word}/broader/{page}', user_agent=self._user_agent, proxies=self._proxies).get_single_page_html() sub_soup = BeautifulSoup(sub_html.text, 'lxml') additional_hypernym = _get_hypernyms(sub_soup) if additional_hypernym: hypernym.union(additional_hypernym) self._update_cache(hypernym) if self._output_format == 'list': return sorted(set(hypernym)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(hypernym))} return output_dict elif self._output_format == 'json': json_object = json.dumps({'hypernyms': {self._word: sorted(set(hypernym))}}, indent=4, ensure_ascii=False) return json_object elif cloudflare_protection is True: logger.info('-' * 80) logger.info(f'The following URL has Cloudflare DDoS mitigation service protection.') logger.info('https://www.classicthesaurus.com') logger.info('-' * 80) return None except bs4.FeatureNotFound as error: logger.error('An error occurred in the following code segment:') logger.error(''.join(traceback.format_tb(error.__traceback__))) except AttributeError as error: logger.error('An AttributeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(error.__traceback__))) except IndexError as error: logger.error('An IndexError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(error.__traceback__))) except KeyError as error: logger.error('A KeyError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(error.__traceback__))) except TypeError as error: logger.error('A TypeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(error.__traceback__)))
def find_definitions(self): """ Purpose ---------- This function queries multiple online repositories to discover definitions related with the specific word provided to the Class Definitions. Returns ---------- :return: list of definitions :rtype: list """ valid_word = self._validate_word() if valid_word: check_cache = caching.cache_antonyms(self._word) if check_cache[0] is True: definitions = cleansing.flatten_multidimensional_list( check_cache[1]) if self._output_format == 'list': return sorted(set(definitions)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(definitions))} return output_dict elif self._output_format == 'json': json_object = json.dumps( { 'definitions': { self._word: sorted(set(definitions)) } }, indent=4, ensure_ascii=False) return json_object elif check_cache[0] is False: # _query_collins_dictionary() disabled due to Cloudflare protection # definition_01 = self._query_collins_dictionary() definition_02 = self._query_merriam_webster() definition_03 = self._query_synonym_com() definitions = ([ x for x in [definition_02, definition_03] if x is not None ]) definitions = cleansing.flatten_multidimensional_list( definitions) if not definitions: return _colorized_text( 255, 0, 255, f'No definitions were found for the word: {self._word} \n' f'Please verify that the word is spelled correctly.') else: if self._output_format == 'list': return sorted(set(definitions)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(definitions))} return output_dict elif self._output_format == 'json': json_object = json.dumps( { 'definitions': { self._word: sorted(set(definitions)) } }, indent=4, ensure_ascii=False) return json_object else: return _colorized_text( 255, 0, 255, f'Please verify that the word {self._word} is spelled correctly.' )
def query_collins_dictionary_synonym(single_word): """ This function queries collinsdictionary.com for synonyms related to the 'single_word' parameter. :param single_word: string variable to search for :return: list of synonyms """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_synonyms(single_word, 'collins_dictionary') if not check_cache: try: synonyms = [] results_synonym = basic_soup.get_single_page_html( f'https://www.collinsdictionary.com/dictionary/english-thesaurus/{single_word}' ) soup = BeautifulSoup(results_synonym, 'lxml') word_found = soup.find( 'h1', text= f'Sorry, no results for “{single_word}” in the English Thesaurus.' ) if word_found: logger.error( f'Collins Dictionary had no reference for the word {single_word}' ) logger.error( f'Please verify that the word {single_word} is spelled correctly.' ) else: query_results = basic_soup.query_html( results_synonym, 'div', 'class', 'blockSyn') content_descendants = query_results.descendants for item in content_descendants: if item.name == 'div' and item.get( 'class', 'form type-syn orth'): children = item.findChild('span', {'class': 'orth'}) if children is not None: synonyms.append(children.text) caching.insert_word_cache_synonyms(single_word, 'collins_dictionary', synonyms) return sorted(synonyms) except bs4.FeatureNotFound as e: logger.error( 'A BeautifulSoup error occurred in the following code segment:' ) logger.error(''.join(traceback.format_tb(e.__traceback__))) except AttributeError as e: logger.error( 'An AttributeError occurred in the following code segment:' ) logger.error(''.join(traceback.format_tb(e.__traceback__))) except KeyError as e: logger.error( 'A KeyError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except TypeError as e: logger.error( 'A TypeError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: synonyms = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return synonyms else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error( f'Please verify that the word {single_word} is spelled correctly.')
def query_wordnet(single_word): """ This function queries wordnet for synonyms related to the 'single_word' parameter. :param single_word: string variable to search for :return: list of synonyms """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_synonyms(single_word, 'wordnet') if not check_cache: try: synonyms = [] results = requests.get( f'http://wordnetweb.princeton.edu/perl/webwn?s={single_word}', headers=basic_soup.http_headers, allow_redirects=True, verify=True, timeout=30) soup = BeautifulSoup(results.text, "lxml") if soup.findAll('h3', text='Noun'): parent_node = soup.findAll("ul")[0].findAll('li') for children in parent_node: for child in children.find_all(href=True): if 'S:' not in child.contents[0]: synonyms.append(child.contents[0]) synonyms = sorted([x.lower() for x in synonyms]) caching.insert_word_cache_synonyms(single_word, 'wordnet', synonyms) return synonyms else: logger.error( f'Wordnet had no reference for the word {single_word}') logger.error( f'Please verify that the word {single_word} is spelled correctly.' ) except IndexError as e: logger.error( 'A IndexError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.HTTPError as e: logger.error('A HTTP error has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.ConnectionError as e: if requests.codes: 'Failed to establish a new connection' logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.Timeout as e: logger.error('A connection timeout has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.RequestException as e: logger.error('An ambiguous exception occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: synonyms = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return synonyms else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error( f'Please verify that the word {single_word} is spelled correctly.')
def query_thesaurus_plus(single_word): """ This function queries thesaurus.plus for synonyms related to the 'single_word' parameter. :param single_word: string variable to search for :return: list of synonyms """ valid_word = word_verification.validate_word_syntax(single_word) if valid_word: check_cache = caching.cache_synonyms(single_word, 'thesaurus_plus') if not check_cache: try: synonyms_list = [] results_synonym = basic_soup.get_single_page_html( f'https://thesaurus.plus/synonyms/{single_word}/category/noun' ) soup = BeautifulSoup(results_synonym, "lxml") no_word = soup.find('title', text='404. Page not found') if no_word: logger.error( f'thesaurus.plus has no reference for the word {single_word}' ) logger.error( f'Please verify that the word {single_word} is spelled correctly.' ) else: synonyms = [] parent_node = soup.find('ul', { 'class': 'list paper' }).findAll('li')[1:] for children in parent_node: for child in children.findAll( 'div', {'class': 'action_pronounce'}): split_dictionary = str(child.attrs).split(',') synonyms_list.append(split_dictionary[1].replace( "'data-term':", "").replace("'", "")) synonyms = sorted([ cleansing.normalize_space(i) for i in synonyms_list ]) caching.insert_word_cache_synonyms(single_word, 'thesaurus_plus', synonyms) return synonyms except IndexError as e: logger.error( 'A IndexError occurred in the following code segment:') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.HTTPError as e: logger.error('A HTTP error has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.ConnectionError as e: if requests.codes: 'Failed to establish a new connection' logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.Timeout as e: logger.error('A connection timeout has occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) except requests.RequestException as e: logger.error('An ambiguous exception occurred.') logger.error(''.join(traceback.format_tb(e.__traceback__))) else: synonyms = cleansing.flatten_multidimensional_list( [val for val in check_cache.values()]) return synonyms else: logger.error(f'The word "{single_word}" was not in a valid format.') logger.error( f'Please verify that the word {single_word} is spelled correctly.')
def find_synonyms(self): """ Purpose ---------- This function queries multiple online repositories to discover synonyms associated with the specific word provided to the Class Synonyms. The synonyms are deduplicated and sorted alphabetically. Returns ---------- :returns: synonyms: list of synonyms :rtype: list """ valid_word = self._validate_word() if valid_word: check_cache = self._check_cache() if check_cache[0] is True: synonyms = cleansing.flatten_multidimensional_list( check_cache[1]) if self._output_format == 'list': return sorted(set(synonyms)) elif self._output_format == 'dictionary': output_dict = {self._word: sorted(set(synonyms))} return output_dict elif self._output_format == 'json': json_object = json.dumps( {'synonyms': { self._word: sorted(set(synonyms)) }}, indent=4, ensure_ascii=False) return json_object elif check_cache[0] is False: # _query_collins_dictionary() disabled due to Cloudflare protection # synonyms_01 = self._query_collins_dictionary() synonyms_02 = self._query_merriam_webster() synonyms_03 = self._query_synonym_com() synonyms_04 = self._query_thesaurus_com() synonyms_05 = self._query_wordnet() synonyms = ([ x for x in [synonyms_02, synonyms_03, synonyms_04, synonyms_05] if x is not None ]) synonyms_results = cleansing.flatten_multidimensional_list( synonyms) if not synonyms_results: return _colorized_text( 255, 0, 255, f'No synonyms were found for the word: {self._word} \n' f'Please verify that the word is spelled correctly.') else: if self._output_format == 'list': return sorted( set([word.lower() for word in synonyms_results])) elif self._output_format == 'dictionary': output_dict = { self._word: sorted( set([ word.lower() for word in synonyms_results ])) } return output_dict elif self._output_format == 'json': json_object = json.dumps( { 'synonyms': { self._word: sorted( set([ word.lower() for word in synonyms_results ])) } }, indent=4, ensure_ascii=False) return json_object else: return _colorized_text( 255, 0, 255, f'Please verify that the word {self._word} is spelled correctly.' )