def save_evaluation_practice_words(self, practiceMode, saveEnabled): _FUNC_NAME_ = "save_evaluation_practice_words" if saveEnabled: if len(self.activePracticeWords) > 0: if practiceMode.lower() == "test": practiceFileName = SB_DATA_DIR + SB_PRACTICE_WORD_FILE practiceFileName = practiceFileName.format(LISTID=self.contestList) elif practiceMode.lower() == "revise": practiceFileName = SB_DATA_DIR + SB_REVISION_WORD_FILE currentPracticeWordList = [] # Get previously saved practice words if os.path.isfile(practiceFileName) and os.path.getsize(practiceFileName) > 0: currentPracticeWordList = cfile.read(practiceFileName).splitlines() # Use of splitlines() avoids the newline character from being stored in the word list # Save practice words to practice file, if not already saved for word in self.activePracticeWords: DEBUG_VAR="word" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(word))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) practiceFileText = SB_EMPTY_STRING if word not in currentPracticeWordList: practiceFileText = practiceFileText + word + SB_NEWLINE if practiceFileText != SB_EMPTY_STRING: cfile.append(practiceFileName, practiceFileText)
elif entryRowName == "Lang. of Origin": wordEtymology = entryRowValue elif entryRowName == "Definition": wordDefinition = entryRowValue elif entryRowName == "Examples": wordExamples = entryRowValue wordExamples = re.sub('[ ]*,[ ]*', APP_WORD_DELIMITER, wordExamples, flags=re.IGNORECASE) elif entryRowName == "Addl. Info": wordNote = entryRowValue elif entryRowName == "Sentence": wordSentence = entryRowValue elif entryRowName == "Related Words": wordRelated = entryRowValue wordRelated = re.sub('[ ]*,[ ]*', APP_WORD_DELIMITER, wordRelated, flags=re.IGNORECASE) elif entryRowName != APP_EMPTY_STRING: cfile.append(APP_LIST_ERROR_FILE, "{};{}".format(displayWord, entryRowName)) audioElement = browser.find_element_by_xpath("//audio[@id='audio1']") if audioElement is not None: wordAudioURL = audioElement.get_property("src") wordEntry = "#!Source: " + APP_SOURCE_DESC wordEntry = wordEntry + APP_NEWLINE + "#!Word: " + listWord wordEntry = wordEntry + APP_NEWLINE + "#!Respelling: " + wordRespelling wordEntry = wordEntry + APP_NEWLINE + "#!AudioURL: " + wordAudioURL wordEntry = wordEntry + APP_NEWLINE + "#!Etymology: " + wordEtymology wordEntry = wordEntry + APP_NEWLINE + "#!Sentence: " + wordSentence wordEntry = wordEntry + APP_NEWLINE + "#!Note: " + wordNote wordEntry = wordEntry + APP_NEWLINE + "#!Meta: " + wordMeta wordEntry = wordEntry + APP_NEWLINE + "#!Examples: " + wordExamples
def display_evaluation_result(self, practiceMode, saveResultEnabled, savePracticeEnabled): if practiceMode.lower() == "test": testHeader = unicode("=============== Start of Test Log ===============", 'utf-8') testTrailer = unicode("================ End of Test Log ================", 'utf-8') testFileName = SB_DATA_DIR + SB_TEST_LOG elif practiceMode.lower() == "revise": testHeader = unicode("=============== Start of Revision Log ===============", 'utf-8') testTrailer = unicode("================ End of Revision Log ================", 'utf-8') testFileName = SB_DATA_DIR + SB_REVISION_LOG # Test header testStats = SB_NEWLINE + unicode("Spelling Bee {0}".format(self.contestList), 'utf-8') testStats += SB_NEWLINE + unicode("Word Count [{0}] Chapter [{1}/{2}] Words [{3}-{4}]".format(self.word_count(), self.activeChapter, self.chapter_count(), self.activeRangeStart + 1, self.activeRangeEnd + 1), 'utf-8') testStats += SB_NEWLINE + SB_NEWLINE + unicode("Test Date [{0}] Score [{1}]".format(self.activeTestDate, self.activeTestScore), 'utf-8') displayText = testStats print displayText, logText = testHeader + testStats # Test valuations # Print colorized test valuations coloredTestValuations = [] for valuation in self.activeTestValuations: if re.match('^' + SB_RIGHT_SYMBOL + '.*', valuation): textColor = coutput.get_term_color('green', 'normal', 'normal') else: textColor = coutput.get_term_color('red', 'normal', 'normal') coloredTestValuations.append(textColor + valuation + coutput.get_term_color('normal', 'normal', 'normal')) print SB_NEWLINE, coutput.print_columnized_list(coloredTestValuations, SB_COLUMN_COUNT) columnizedTestValuations = coutput.columnize(self.activeTestValuations, SB_COLUMN_COUNT) for row in columnizedTestValuations: logText += SB_NEWLINE for col in row: logText += col # Test practice words if len(self.activePracticeWords) > 0: practiceWordsText = SB_NEWLINE + unicode("Practice Words:", 'utf-8') for row in coutput.columnize(self.activePracticeWords, SB_COLUMN_COUNT): practiceWordsText += SB_NEWLINE for col in row: practiceWordsText += col print practiceWordsText, logText += SB_NEWLINE + practiceWordsText # Test trailer logText += SB_NEWLINE + testTrailer + SB_NEWLINE if saveResultEnabled: # Save practice words self.save_evaluation_practice_words(practiceMode, savePracticeEnabled) # Save test log cfile.append(testFileName, logText)
def lookup_dictionary_by_word(self, word): _FUNC_NAME_ = "lookup_dictionary_by_word" DEBUG_VAR="self.wordList[0]" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(self.wordList[0]))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) DEBUG_VAR="word" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(word))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) self.activeWord = word.strip() DEBUG_VAR="self.activeWord" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(self.activeWord))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) # Setup connection and error logging connectionPool = urllib3.PoolManager(10, headers=SB_USER_AGENT) errorFileName = SB_DATA_DIR + SB_ERR_LOG # Check offline for dictionary entry self.activeEntry = SB_EMPTY_STRING self.activeDefinition = [] overrideDefnFileName = SB_DICT_OVERRIDE_DIR + SB_DICT_OVERRIDE_DEFN.format(WORD=word).replace(" ", "_") offlineEntryFileName = SB_DICT_OFFLINE_DIR + SB_DICT_OFFLINE_ENTR.format(WORD=word).replace(" ", "_") # Check for dictionary definition override if os.path.isfile(overrideDefnFileName) and os.path.getsize(overrideDefnFileName) > 0: self.activeEntry = unicode("[Dictionary Definition Override]", 'utf-8') self.activeDefinition = cfile.read(overrideDefnFileName).splitlines() DEBUG_VAR="self.activeEntry" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(self.activeEntry))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) # Check primary source for dictionary entry elif os.path.isfile(offlineEntryFileName) and os.path.getsize(offlineEntryFileName) > 100: coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "offlineEntryFile size :: {0}".format(os.path.getsize(offlineEntryFileName))) self.activeEntry = cfile.read(offlineEntryFileName) self.activeDefinition = cdict.parse_word_definition(self.activeWord, self.activeEntry) DEBUG_VAR="self.activeEntry" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(self.activeEntry))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) else: # Download dictionary entry self.activeEntry = cdict.get_dictionary_entry(connectionPool, self.activeWord) DEBUG_VAR="self.activeEntry" coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "{0} :: {1}".format(DEBUG_VAR, type(self.activeEntry))) coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, eval(DEBUG_VAR)) # Save dictionary entry offline cfile.write(offlineEntryFileName, self.activeEntry) # Retrieve word definition self.activeDefinition = cdict.parse_word_definition(self.activeWord, self.activeEntry) if len(self.activeDefinition) == 0: # Log missing definition error errorText = unicode("ERROR:Missing Definition:{0}\n", 'utf-8') errorText = errorText.format(self.activeWord) cfile.append(errorFileName, errorText) # Check offline for word pronunciation self.activePronunciation = SB_EMPTY_STRING self.activePronunciationWord = SB_EMPTY_STRING overrideProncnFileName = SB_DICT_OVERRIDE_DIR + SB_DICT_OVERRIDE_CLIP.format(WORD=self.activeWord).replace(" ", "_") offlineProncnFileName = SB_DICT_OFFLINE_DIR + SB_DICT_OFFLINE_CLIP.format(WORD=self.activeWord).replace(" ", "_") # Check for dictionary pronunciation override if os.path.isfile(overrideProncnFileName) and os.path.getsize(overrideProncnFileName) > 0: self.activePronunciation = overrideProncnFileName self.activePronunciationWord = self.activeWord # Check primary source for dictionary entry and pronunciation elif os.path.isfile(offlineEntryFileName) and os.path.getsize(offlineEntryFileName) > 100 and os.path.isfile(offlineProncnFileName) and os.path.getsize(offlineProncnFileName) > 1000: coutput.print_debug(SB_ERR_DEBUG, _FUNC_NAME_, "offlineProncnFile size :: {0}".format(os.path.getsize(offlineProncnFileName))) self.activePronunciation = offlineProncnFileName # Retrieve pronunciation audio clip word form and filename [wordClipForm, wordClipURL] = cdict.parse_word_clip(self.activeWord, self.activeEntry) self.activePronunciationWord = wordClipForm else: # Retrieve pronunciation audio clip word form and filename [wordClipForm, wordClipURL] = cdict.parse_word_clip(self.activeWord, self.activeEntry) # Save pronunciation offline if wordClipURL == SB_EMPTY_STRING: # Log missing audio error errorText = unicode("ERROR:Missing Audio:{0}\n", 'utf-8') errorText = errorText.format(self.activeWord) cfile.append(errorFileName, errorText) else: # Download audio clip cfile.download(connectionPool, wordClipURL, offlineProncnFileName) self.activePronunciation = offlineProncnFileName self.activePronunciationWord = wordClipForm # Log audio mismatch error wordToken = re.sub('[^a-zA-Z]', SB_EMPTY_STRING, self.activeWord.lower()) pronunciationToken = re.sub('[^a-zA-Z]', SB_EMPTY_STRING, self.activePronunciationWord.lower()) if self.activePronunciation != SB_EMPTY_STRING and wordToken != pronunciationToken: errorText = unicode("ERROR:Audio Mismatch:{0}\n", 'utf-8') errorText = errorText.format(self.activeWord) cfile.append(errorFileName, errorText) # Close connection connectionPool.clear()
if SDO_ERR_AUDIO_REGEX_PATTERN.match(logValues[2]): coutput.print_watcher(SB_ERR_DEBUG, _FUNC_NAME_, 'wordEntry[4]') if wordEntry[4] != "": print ">> Downloaded pronunciation override" cfile.download(connectionPool, wordEntry[4], SDO_OVERRIDE_PRON_FILE.format(WORD=word)) else: SDO_ERR_CLIP_MISSING = True coutput.print_color('yellow', "WARNING: Pronunciation override not available") # Log errors errorText = unicode("ERROR:{0}:", 'utf-8').format(word) if SDO_ERR_DEFN_MISSING: errorText += unicode(">Definition Missing", 'utf-8') if SDO_ERR_CLIP_MISSING: errorText += unicode(">Audio Missing", 'utf-8') if errorText != unicode("ERROR:{0}:", 'utf-8').format(word): errorText += unicode("\n", 'utf-8') cfile.append(SDO_LOG_FILE, errorText) connectionPool.clear() ######################################################################## # Debugging Commands ######################################################################## ''' cd $PROJ sudo python spellit_download_log_overrides.py '''
print("\n>>>>>>>>>> {} Fetching entry rows ...".format(wordIndex)) entryRows = browser.find_elements_by_xpath( "//div[@class='table-responsive']/table/tbody/tr") setWord = APP_COLLECTION_CATEGORY for row in entryRows: entryCols = row.find_elements_by_tag_name("td") if len(entryCols) == 0: continue elif len(entryCols) != 7: cfile.append( APP_LIST_ERROR_FILE, "Unexpected Columns:{}:{}".format( len(entryCols), row.text.strip())) continue displayWord = '' listWord = '' keyWord = '' wordMeta = '' wordRespelling = '' wordAudioURL = '' wordFuncLabel = '' wordEtymology = '' wordDefinition = '' wordExamples = '' wordNote = ''