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 _validate_word(self): """ This function is designed to validate that the syntax for a string variable is in an acceptable format. :return: True or False :rtype: bool """ valid_word = word_verification.validate_word_syntax(self._word) if valid_word: return valid_word else: logger.error(f'The word {self._word} was not in a valid format.') logger.error(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 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.')