Beispiel #1
0
 def meaning(self, word):
     definition = 'DEFINITION: '
     word_meaning = vb.meaning(word, format="list")
     if not word_meaning:
         return False
     definition += vb.meaning(word, format="list")[0]
     definition = self.statement(definition)
     definition += self.addLine()
     return definition
Beispiel #2
0
    def labels(self, query):
        """ return parsed result """
        res = []
        meanings = vb.meaning(query, format="list")
        if meanings:
            meanings = [
                e.replace("<i>",
                          "").replace("</i>",
                                      "").replace("[i]",
                                                  "").replace("[/i]", "")
                for e in meanings
            ]
            for e in meanings:
                res.append((query, "meaning", e))
        synonyms = vb.synonym(query, format="list")
        if synonyms:
            for e in synonyms:
                res.append((query, "synonym", e))
        antonyms = vb.antonym(query, format="list")
        if antonyms:
            for e in antonyms:
                res.append((query, "antonym", e))

        #ps = vb.part_of_speech(query, format="list")
        #if ps:
        #    for e in ps:
        #        res.append((query, "part_of_speech", e))
        examples = vb.usage_example(query, format="list")
        if examples:
            for e in examples:
                res.append((query, "usage_example", e))
        return res
Beispiel #3
0
 def query(self, query):
     """ return raw result (dict) """
     cons = {
         "meaning": [],
         "synonym": [],
         "antonym": [],
         "usage_example": [],
         "part of speech": []
     }
     meanings = vb.meaning(query, format="list")
     if meanings:
         cons["meaning"] = [
             e.replace("<i>",
                       "").replace("</i>",
                                   "").replace("[i]",
                                               "").replace("[/i]", "")
             for e in meanings
         ]
     synonyms = vb.synonym(query, format="list")
     if synonyms:
         cons["synonym"] = synonyms
     antonyms = vb.antonym(query, format="list")
     if antonyms:
         cons["antonym"] = antonyms
     ps = vb.part_of_speech(query, format="list")
     if ps:
         cons["part of speech"] = ps
     examples = vb.usage_example(query, format="list")
     if examples:
         cons["usage_example"] = [
             e.replace("[", "").replace("]", "") for e in examples
         ]
     return cons
Beispiel #4
0
def run_bot(reddit):
	print ("Running...")
	word = (pick_word()).lower()
	deff = vb.meaning(word, format = "list")
	if deff is False or len(word) < config.minimum or len(word) > config.maximum:
		use_word(word, unused_words, used_words)
		deff = []
		print ("Could not find deffinition/didnt meet length requirements of '" + word.title() + "'. Finding another...")
		run_bot(reddit)
	else:
		print ("Found deffinition for '" + word.title() + "'. Posting...")
		string = "# Word of the day: " + word.title()
		for i in range(len(deff)):
			if i < config.ammount:
				string += "\n\n"
				string += str(i + 1)
				string += ": "
				reFormattedString = re.sub(r"\<.\>", "", deff[i])
				reFormattedString1 = re.sub(r"\[.\]", "", reFormattedString)
				reFormattedString2 = re.sub(r"\</.\>", "", reFormattedString1)
				reFormattedString3 = re.sub(r"\[/.\]", "", reFormattedString2)
				string += reFormattedString3
				i += 1

		string += config.message
		submitted = reddit.subreddit(config.subreddit).submit("Word Of The Day - " + now.strftime("%B %d, %Y") + " - " + word.title(), string)
		if config.distinguish is True and config.sticky is False and config.moderator is True:
			submitted.mod.distinguish()
		elif config.sticky is True and config.moderator is True:
			submitted.mod.sticky()
		print ("Posted Successfully!")
		use_word(word, unused_words, used_words)
		print ("Next: " + str(unused_words[0]).title())
		print ("Waiting till " + config.time + "...")
Beispiel #5
0
    def getDef(word):
        dictionary = PyDictionary()
        definition = dictionary.meaning(word)
        if isinstance(definition, dict) and 'Noun' in definition:
            defs = definition['Noun']
            if isinstance(defs, list) and len(defs) > 0:
                return defs

        # wordnik dictionary
        wordApi = WordApi.WordApi(client)
        definitions = (wordApi.getDefinitions(word,
                                              partOfSpeech='noun',
                                              limit=3))
        if definitions is not None and len(definitions) > 0:
            return [(definition.text).lower() for definition in definitions]
        meaningsList = vocabulary.meaning(word)
        if meaningsList != False:
            defs = json.loads(meaningsList)
            if (len(defs) > 0):
                definitions = []
                for definition in defs:
                    if definition['text']:
                        d = re.sub('<[^<]+?>', '', definition['text'])
                        definitions.append(d.lower())
                if len(definitions) > 0:
                    return definitions
        # owlbot api
        url = 'https://owlbot.info/api/v2/dictionary/' + word
        r = requests.get(url)
        if r is not None:
            try:
                result = r.json()
                if len(result) > 0:
                    definitions = []
                    for item in result:
                        if (item['type'] == 'noun' and item['definition']):
                            definitions.append(item['definition'].lower())
                    if len(definitions) > 0:
                        return definitions
            except:
                pass
        # wiktionary
        try:
            parser = WiktionaryParser()
            result = parser.fetch(word)
            if result is not None:
                definition = result[0]['definitions']
                if definition and len(definition) > 0:
                    definition = definition[0]
                    if 'partOfSpeech' in definition:
                        if definition['partOfSpeech'] == 'noun':
                            defs = definition['text'].lower().split('\n')
                            if len(defs) > 1:
                                return defs[0:2]
                            elif len(defs) == 1:
                                return defs
        except:
            return ' '
        return ' '
Beispiel #6
0
 def definition(text, lang='en-en'):
     src, dest = lang.split('-')
     response = voc.meaning(text, src, dest)
     if not response or response == '[]':
         return ''
     response = json.loads(response)
     output = ""
     for i, a in enumerate(response, start=1):
         output += str(i) + '. ' + a['text'] + '\n'
     return output
Beispiel #7
0
    def test_meaning_key_error(self, mock_api_call):
        res = {"result": "ok", "phrase": "humming"}

        mock_api_call.return_value = mock.Mock()
        mock_api_call.return_value.status_code = 200
        mock_api_call.return_value.json.return_value = res

        expected_result = '[{"seq": 0, "text": "the act of singing with closed lips"}]'
        expected_result = json.dumps(json.loads(expected_result))

        self.assertFalse(vb.meaning("humming"))
def define_word(word):
    definitions = vb.meaning(word)
    if (definitions is None):
        return "Word not found"
    else:
        worddefs = json.loads(definitions)
        ret = word + ": "
        i = 0
        while (i < 4 and i < len(worddefs)):
            ret += str(i + 1) + ". " + worddefs[i]['text'] + "; "
            i += 1
        ret = ret[:-2]
        return ret
Beispiel #9
0
def get_dictionary(subject):
    cons = {"meaning": [], "synonym": [], "antonym": [], "example": [], "part of speech": []}
    meanings = vb.meaning(subject, format="list")
    if meanings:
        cons["meaning"] = [e.replace("<i>", "").replace("</i>", "").replace("[i]", "") .replace("[/i]", "") for e in meanings]
    synonyms = vb.synonym(subject, format="list")
    if synonyms:
        cons["synonym"] = synonyms
    antonyms = vb.antonym(subject, format="list")
    if antonyms:
        cons["antonym"] = antonyms
    ps = vb.part_of_speech(subject, format="list")
    if ps:
        cons["part of speech"] = ps
    examples = vb.usage_example(subject, format="list")
    if examples:
        cons["example"] = [e.replace("[", "").replace("]", "") for e in examples]
    return cons
Beispiel #10
0
def details(word):
    meaning = vb.meaning(word)
    antonym = vb.antonym(word)
    synonym = vb.synonym(word)
    usage = vb.usage_example(word)

    if meaning == False:
        meaning = 'Not Found'
    else:
        meaning = json.loads(meaning)
        # meaning = str(meaning[0]['text'])
        meaning = [unescape(meaning[i]['text']) for i in range(len(meaning))]

    if antonym == False:
        antonym = 'Not Found'
    else:
        antonym = json.loads(antonym)
        antonym = str(antonym[0]['text'])

    if synonym == False:
        synonym = 'Not Found'
    else:
        synonym = json.loads(synonym)
        synonym = str(synonym[0]['text'])

    if usage == False:
        usage = 'Not Found'
    else:
        usage = json.loads(usage)
        usage = str(usage[-1]['text'])

    values = {
        'meaning': meaning,
        'antonym': antonym,
        'synonym': synonym,
        'usage': usage
    }

    return values
Beispiel #11
0
    def test_meaning_found(self, mock_api_call):
        res = {
            "tuc": [{
                "meanings": [{
                    "language": "en",
                    "text": "the act of singing with closed lips"
                }]
            }]
        }

        mock_api_call.return_value = mock.Mock()
        mock_api_call.return_value.status_code = 200
        mock_api_call.return_value.json.return_value = res

        expected_result = '[{"seq": 0, "text": "the act of singing with closed lips"}]'
        expected_result = json.dumps(json.loads(expected_result))
        result = vb.meaning("humming")

        if sys.version_info[:2] <= (2, 7):
            self.assertItemsEqual(expected_result, result)
        else:
            self.assertCountEqual(expected_result, result)
Beispiel #12
0
    def test_meaning_not_found(self, mock_api_call):
        mock_api_call.return_value = mock.Mock()
        mock_api_call.return_value.status_code = 404

        self.assertFalse(vb.meaning("humming"))
Beispiel #13
0
def get_glosbe_definitions(word):
    """
    returns list of form
    '[{"text": "Someone who is from the hills; especially from a rural area, with a connotation of a lack of refinement or sophistication.", "seq": 0}, {"text": "someone who is from the hills", "seq": 1}, {"text": "A white person from the rural southern part of the United States.", "seq": 2}]'
    """
    return vb.meaning(word, format="list")
def spell_check(key):
    global log_file_handler
    log_file_handler.write(
        str(datetime.datetime.now()) + " spell_check function reach." + "\n")

    newKeywords = []
    spell = SpellChecker()
    check = '[-@_!#$%^&*()<>?/\|+}{~:]+'

    # Splits each word in key and check for special characters and removes it
    for thisWord in key:
        # inputWord is a list consisting of spilted words
        inputWord = re.split(check, thisWord, flags=re.IGNORECASE)

        # loop checks each word for spellings and grammatical errors
        for word in inputWord:
            try:
                # raises error if word has no meaning meaning - word entered is invalid
                if vb.meaning(word) == False:
                    raise (InvalidKeywordError("\nImproper Input!"))

                # no error if word meaning exists
                elif spell.correction(
                        word) == word or vb.meaning(word) != False:
                    continue

            # handles error
            except InvalidKeywordError as error:
                log_file_handler.write(
                    str(datetime.datetime.now()) +
                    " error occured in spell_check." + "\n")
                print(error)
                print(thisWord, '\t:', word)

                # asks user to enter choice for the word that caused error
                print("\nError Type:")
                print("1.Input Word has Spelling Error.")
                print("2.No Errors")
                print("3.Remove word")
                get_numb = int(input("Enter Error no. :"))

                if get_numb == 1:
                    # suggests near correct word
                    print("\nSuggestions:", spell.candidates(word))
                    pos = inputWord.index(word)

                    # pops error word,replace and insert correct word in the same position
                    inputWord.pop(pos)
                    inputWord.insert(
                        pos, word.replace(word, input("Enter correct word:")))
                    #print(inputWord)
                    continue

                elif get_numb == 2:
                    print("Okay!!")
                    continue

                elif get_numb == 3:
                    # deletes irrelevant words
                    pos = inputWord.index(word)
                    inputWord.pop(pos)
                    continue

        if len(inputWord) >= 2:
            # joins the group of words that were spilt(if word more than 1 in list)
            #and appends in new list
            inputWord = "-".join(inputWord)
            newKeywords.append(inputWord)

        elif len(inputWord) <= 2:
            # add words to the list having length of the word in list less than or equal to 2
            newKeywords.extend(inputWord)

    print("\n Final Check:")
    log_file_handler.write(
        str(datetime.datetime.now()) + " checking final keywords." + "\n")
    print(newKeywords)
    # asks user to either 'remove/replace' or 'procceed' further
    option = int(
        input("Remove or Replace[with '-'] Keyword-[1]/procceed-[2] :"))
    if option == 1:
        log_file_handler.write(
            str(datetime.datetime.now()) +
            " modifications require for keywords." + "\n")
        # clears the 'key' list and adds words from 'newKeywords'
        key.clear()
        key.extend(newKeywords)

        # shows position of each word in list
        print("Position of Words:-")
        for num in key:
            print(num, '\t :', key.index(num))

        # takes position number from user to edit word
        # in case word is wrongly entered or replaced in the list
        # takePos is a list of positions of wrong entered words
        takePos = [int(num) for num in input("Position to remove:").split(',')]
        for tp in takePos:
            for new_thisWord in key:
                keyPos = key.index(new_thisWord)

                # loops until word in 'key' list matches with position in 'takePos' list
                if tp != keyPos:
                    continue
                else:
                    # if found, pops the word
                    key.pop(keyPos)
                    print("\n", new_thisWord, '-> popped')

                    # asks either to replace or continue further
                    option = int(input("Replace - [Yes-(1)/No-(2)]:"))
                    if option == 1:
                        log_file_handler.write(
                            str(datetime.datetime.now()) +
                            " keyword is replaced." + "\n")
                        # inserts new word in place of popped word
                        key.insert(
                            keyPos,
                            new_thisWord.replace(new_thisWord,
                                                 input("Enter correct word:")))
                    elif option == 2:
                        log_file_handler.write(
                            str(datetime.datetime.now()) +
                            " no replacement, continue." + "\n")
                        print("okay!")
                        break
        print(key)
        log_file_handler.write(
            str(datetime.datetime.now()) + " spell_check function terminate." +
            "\n")
        #function call
        collect_urls(key)

    elif option == 2:
        log_file_handler.write(
            str(datetime.datetime.now()) + " proceed further." + "\n")

        print("Yes!")
        log_file_handler.write(
            str(datetime.datetime.now()) + " spell_check function terminate." +
            "\n")

        # clears the 'key' list and adds words from 'newKeywords'
        key.clear()
        key.extend(newKeywords)
        #function call
        collect_urls(key)
class HQTrivia():
    #initialization
    def __init__(self):
        # QuickTime - MacOS has record feature for phone (best)
        self.use_quicktime = False
        self.use_input = False

        # the filename of the image (no extension = capturing image)
        self.picture = 'source'
        # location of where to work on self.picture
        self.location = os.getcwd()

        # Replace with your own auth file name
        self.google_auth_json = 'HQproject-a1a4e25e4b45.json'

        # wikipedia setting (english)
        self.wiki = wikipediaapi.Wikipedia('en')
        self.vb = Vocabulary()

        # The OCR text (directly converted from image)
        self.raw = ''
        # processed texts
        self.question = ''
        self.question_nouns = ''
        self.answers = {}
        self.lookup_info = {}

        # For debugging
        self.times = {}
        self.verbose = False

    def debug(self, msg):
        # in multiprocessing environments, following line helps
        sys.stdout.flush()
        print("hqtrivia-automation.py: " + str(msg))

    def capture(self, ftype='tiff'):
        # function to selection function to capture picture
        if self.verbose:
            pre = "[DEBUG] in capture() | "
            self.debug(pre + "choosing how to capture...")

        if self.use_input:
            if self.verbose:
                self.debug(pre + "using user input")
            return

        # add extension name as 'tiff'
        self.picture += '.' + ftype

        if self.use_quicktime:
            if self.verbose:
                self.debug(pre + "quicktime")
            #call scan_quicktime function (take screenshot)
            self.scan_quicktime(ftype)

    def scan_quicktime(self, ftype='tiff'):
        # function to take screenshot via AppleScript (wire connection to computer)
        # To do: 1. open QuickTime player and do a movie recording
        #        2. Select drop down arrow next to record button, select device
        # Steps: 1. Get Window ID of QuickTime Player
        #        2. Run shell script to screen-capture the window ID

        if self.verbose:
            self.debug("[DEBUG] Starting QuickTime")
            start = time.time()

        full_path = os.path.join(self.location, self.picture)
        script = """tell application "QuickTime Player"
set winID to id of window 1
end tell
do shell script "screencapture -x -t tiff -l " & winID &"""
        script += ' " ' + full_path + '"'
        # replace 'tiff' with ftype
        script = script.replace('tiff', ftype)

        # Take screenshot
        s = NSAppleScript.alloc().initWithSource_(script)
        s.executeAndReturnError_(None)

        if self.verbose:
            diff = time.time() - start
            self.debug("[DEBUG] Quicktime - elapsed {!s}".format(diff))
            self.times['scan_quicktime'] = diff

    def ocr_vision(self, queue):
        # Use Google Cloud Vision API to process OCR
        if self.verbose:
            pre = "[DEBUG] In ocr_vision() | "
            start = time.time()
            self.debug(pre + "starting")

        # Authenticate
        try:
            file_path = os.path.join(self.location, self.google_auth_json)
            if not os.path.isfile(file_path):
                if self.verbose:
                    self.debug(pre + "no auth file")
                queue.put("END")
                return
        except:
            if self.verbose:
                self.debug(pre + "no auth file")
            queue.put("END")
            return

        # Google Vision API credential
        os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = file_path

        # Instantiates a client
        client = vision.ImageAnnotatorClient()

        # get the image file (full path)
        if not os.path.isfile(self.picture):
            full_path = os.path.join(self.location, self.picture)
        else:
            full_path = self.picture

        # loads the image into memory
        with io.open(full_path, 'rb') as image_file:
            content = image_file.read()

        image = types.Image(content=content)

        # text detection on the image
        response = client.text_detection(image=image)
        text = response.text_annotations

        for t in text:
            self.raw = t.description
            break

        # cleaning up the text
        self.raw = self.raw.split('\n')
        # print out raw message
        self.debug(pre + "raw - " + str(self.raw))
        i = 0
        while i < len(self.raw):
            value = self.raw[i].lower()
            if i < 2:
                self.raw.pop(i)
                self.debug("method - ocr | delete [" + value + "]")
                i += 1
            else:
                i += 1
        # swipe left comment
        self.raw.pop(-1)
        # Return data to parent process
        queue.put(self.raw)

        if self.verbose:
            self.debug(pre + "raw - cleaned" + str(self.raw))
            diff = time.time() - start
            self.debug(pre + "elapsed {!s}".format(diff))

        queue.put("END")

    def parse(self):
        # Parse the raw OCR text to find Q&A
        if self.verbose:
            pre = "[DEBUG] parsing texts | "
            self.debug(pre + "starting")
            start = time.time()

        # Save it to question and answer variable
        check_q = True
        count_answer = 1
        for line in self.raw:
            #print(len(line), end=' ['+line+']\n')
            # check for question mark in the question
            if check_q:
                if len(line) > 2:
                    if '?' not in line:
                        self.question += line + ' '
                    else:
                        self.question += line
                        check_q = False
            else:
                if 'Swipe left' not in line:
                    if len(line) > 0 and line != '-':
                        ans = line
                        self.answers[ans] = {
                            "answer": ans,
                            "keywords": [],
                            "score": 0,
                            "index": str(count_answer)
                        }
                        self.lookup_info[ans] = []
                        count_answer += 1
                else:
                    break

        # checking parsed results
        if '?' not in self.question:
            self.debug(pre + "Could not find question!")
            raise
        if len(self.answers) < 1:
            self.debug(pre + "Could not find answers!")
            raise
        elif len(self.answers) > 3:
            self.debug(pre + "Found more than three answers!")
            raise

        # Use local dictionary (nltk) to find nouns
        for q in nltk.pos_tag(nltk.word_tokenize(self.question)):
            if q[1] == 'NN' or q[1] == 'NNP':
                self.question_nouns += " " + q[0]
        self.question_nouns = self.question_nouns.strip().split(' ')

        if self.verbose:
            self.debug(pre + "question = " + str(self.question))
            self.debug(pre +
                       "nouns in question - {!s}".format(self.question_nouns))
            self.debug(pre + "answer = " + str(self.answers))
            diff = time.time() - start
            self.debug(pre + "elapsed {!s}".format(diff))
            self.times["parse"] = diff

    def keywords(self, words):
        # Function to find words in a string that are also in question
        # and return keywords found
        keywords = []
        for w in words:
            if len(w) > 2:
                if w in self.question_nouns:
                    if w not in keywords:
                        keywords.append(w)

        return keywords

    def lookup_wiki(self, queue):
        # Get wiki info about answer
        # Needs to return results to parent (for multi-processing)

        if self.verbose:
            pre = "[DEBUG] lookup_wiki() | "
            self.debug(pre + "starting")
            start = time.time()

        # search in wikipedia for each answer
        for index, ans in self.answers.items():
            l_info = self.lookup_info[ans['answer']]

            try:
                page = self.wiki.page(ans['answer'])
                if page.exists():
                    try:
                        words = []
                        for i in page.sections:
                            words += i.text.split(' ')
                    except:
                        self.debug(pre +
                                   "issue with wikipedia for {!s}".format(
                                       ans['answer']))
                    else:
                        l_info.append("[Wikipedia]: " + page.summary)
                        queue.put(
                            [ans['answer'],
                             self.keywords(words), l_info])

                else:
                    a = ans['answer'].split(' ')
                    if len(a) < 2:

                        # Could not find page, so throw exception and move on
                        self.debug(pre +
                                   "no results for {!s} in wikipedia... ".
                                   format(ans['asnwer']))
                        raise

                    else:
                        # Try searching each word in answer as last resort
                        for w in a:
                            if len(w) > 3:
                                page = self.wiki.page(w)
                                if page.exists():
                                    try:
                                        words = []
                                        for i in page.sections:
                                            words += i.text.split(' ')
                                    except:
                                        self.debug(
                                            pre +
                                            "issue with wikipedia for {!s}".
                                            format(ans['answer']))
                                    else:
                                        l_info.append(
                                            "[Wikipedia {!s}]: ".format(w) +
                                            page.summary)
                                        queue.put([
                                            ans['answer'],
                                            self.keywords(words), l_info
                                        ])

            except:
                self.debug(
                    pre +
                    "issue with wikipedia for {!s}... ".format(ans['answer']))
                self.debug(sys.exc_info())

        queue.put("END")
        if self.verbose:
            self.debug(pre + "elapsed " + str(time.time() - start))

    def lookup_dict_and_syn(self, queue):
        # Use nltk to look up word info(synonym). Use online dictionary if fails.
        if self.verbose:
            pre = "[DEBUG] lookup_dict_and_syn() | "
            self.debug(pre + "starting")
            start = time.time()

        # Get dictionary/synonyms
        for index, ans in self.answers.items():
            l_info = self.lookup_info[ans['answer']]
            a = ans['answer'].split(' ')  # incase of multi word answers

            for w in a:
                # don't waste time on looking for smaller words
                if len(w) > 3:
                    # definition
                    define = nltk.corpus.wordnet.synsets(w)
                    synset_found = False
                    if len(define) < 1:
                        # local dictionary didn't find anything so search online
                        if self.verbose:
                            self.debug(pre +
                                       "nltk none for {!s}, using vocabulary".
                                       format(w))
                        try:
                            define = self.vb.meaning(w, format='list')
                            if define != False:
                                # Multiple definitions possible
                                for d in define:
                                    l_info.append(
                                        "[Meaning {!s}]: ".format(w) + d)
                                    queue.put([
                                        ans['answer'],
                                        self.keywords(d), l_info
                                    ])
                        except:
                            self.debug(
                                pre +
                                "issue with vocabulary for {!s}... ".format(w))
                            self.debug(sys.exc_info())
                    else:
                        synset_found = True
                        l_info.append("[Meaning {!s}]: ".format(w) +
                                      define[0].definition())
                        queue.put([
                            ans['answer'],
                            self.keywords(define[0].definition()), l_info
                        ])

                    # Synonyms
                    if synset_found:
                        synonyms = [
                            l.name() for s in define for l in s.lemmas()
                        ]

                        # Remove duplicates nltk adds
                        s = []
                        i = 0
                        while i < len(synonyms):
                            if synonyms[i] in s:
                                synonyms.pop(i)
                            else:
                                s.append(synonyms[i])
                                i += 1
                        syn = ', '.join(s)
                        l_info.append("[Synonyms {!s}]: ".format(w) + syn)
                        queue.put([ans['answer'], self.keywords(syn), l_info])
                    else:
                        # Local dictionary didn't find anything so search online
                        self.debug(
                            pre +
                            "nltk has nothing for {!s}, using vocabulary".
                            format(w))
                        try:
                            synonyms = self.vb.synonym(w, format='list')
                            if synonyms != False:
                                l_info.append("[Synonyms {!s}]: ".format(w) +
                                              str(synonyms))
                                queue.put([
                                    ans['answer'],
                                    self.keywords(str(synonyms)), l_info
                                ])
                        except:
                            self.debug(
                                pre +
                                "issue with vocabulary for {!s}... ".format(w))
                            self.debug(sys.exc_info())

        queue.put("END")
        if self.verbose:
            self.debug(pre + "elapsed " + str(time.time() - start))

    def lookup_google_search(self, queue):
        # Do google search for each answer
        # Find if words in results are found in the question
        if self.verbose:
            pre = "[DEBUG] lookup_google_search() | "
            self.debug(pre + "starting")
            start = time.time()

        # Google Search
        for index, ans in self.answers.items():
            l_info = self.lookup_info[ans['answer']]
            try:
                #parse replace space by plus sgin
                text = urllib.parse.quote_plus(ans['answer'])
                url = 'https://google.com/search?q=' + text
                #request google search
                response = requests.get(url, timeout=2)
                #pulling data out of html. lxml is a python paraser
                soup = BeautifulSoup(response.text, 'lxml')
                results = ''
                #find_all() - mnethod to look through a tag's descendent (class in CSS)
                for g in soup.find_all(class_='st'):
                    results += " " + g.text
                #remove new line
                cleaned_results = results.strip().replace('\n', '')
                l_info.append("[Google]: " + cleaned_results)
                queue.put(
                    [ans['answer'],
                     self.keywords(cleaned_results), l_info])
            except:
                self.debug(pre +
                           "issue with google search for {!s}... ".format(
                               ans['answer']))
                self.debug(sys.exc_info())

        if self.verbose:
            self.debug(pre + "google search elapsed " +
                       str(time.time() - start))

    def display(self):
        # Clear the screen
        os.system('cls' if os.name == 'nt' else 'clear')

        # Text to output to screen
        output = []

        # Question
        output.append('\n\nQuestion - ' + self.question + '\n')

        # Answers & Lookup Info
        # choice to track answer with the highest score
        choice = {'index': [], 'score': 0, 'l_info': []}
        # a is the key and ans is the value; items() is for dict datastructure
        for a, ans in self.answers.items():
            if ans['score'] == choice['score']:
                choice['index'].append(a)
            if 'NOT' in self.question:
                if ans['score'] < choice['score']:
                    choice['index'] = [a]
                    choice['score'] = ans['score']
            else:
                if ans['score'] > choice['score']:
                    choice['index'] = [a]
                    choice['score'] = ans['score']
            output.append("Choice - " + ans['answer'] + ' - Score ' +
                          str(ans['score']))

            for l_info in self.lookup_info[ans['answer']]:
                for l in l_info:
                    l_index = l.split(':')[0]
                    if l_index not in choice['l_info']:
                        choice['l_info'].append(l_index)
                        if len(l) > 140:
                            output.append(l[0:140])
                        else:
                            output.append(l)
            output.append("[Keywords]: " + str(ans['keywords']))
            output.append("")

        # Highest scoring answer
        if len(choice['index']) > 0:
            choose = []
            for i in choice['index']:
                choose.append(self.answers[i]['answer'])
            msg = "Answer - " + ', '.join(choose)

            # If negative word, choose the lowest score
            if 'NOT' in self.question:
                msg += (" - NOT keyword so lowest score is " +
                        str(choice['score']))
            else:
                msg += (" - highest score is " + str(choice['score']))
            output.append(msg)
        else:
            output.append("Answer - Unknown")
        output.append("")
        output.insert(1, msg + '\n')

        # print it all
        for line in output:
            print(line)
Beispiel #16
0
def getdefine(word):
    return vb.meaning(word, format="list")
Beispiel #17
0
async def on_message(message):
    # we do not want the bot to reply to itself
    if message.author == client.user:
        return

    #check if bot is working
    if message.content.startswith('!heck'):
        msg = 'Heck Off {0.author.mention}'.format(message)
        await client.send_message(message.channel, msg)

    #text response
    if message.content.startswith('!venom'):
        msg = 'is cute uwu'.format(message)
        await client.send_message(message.channel, msg)

    #text response
    if message.content[0:4] == "ayy":
        await client.send_message(message.channel, "lmao".format(message))

    #text response
    if message.content[0:5] == "lmao":
        await client.send_message(message.channel, "ayy".format(message))

    #using giphy api post a random happy birthday gif
    if message.content.startswith("!hbd"):
        msg = "HAPPPY BARTHDAYYYYY "
        if len(message.mentions) > 0:
            msg += message.mentions[0].mention
        hbds = [x for x in g.search("happy birthday")]
        hbd = hbds[random.randint(0, len(hbds))]
        msg += " " + hbd.media_url
        await client.send_message(message.channel, msg)

    #tag spam a user(not recommended)
    if message.content.startswith("!tagspam"):
        msg = ""
        if len(message.mentions) > 0:
            for i in message.mentions:
                if i.mention == "<@199515135142920192>":  #hardcoded to not work against me xd
                    await client.send_message(message.channel, "Nope")
                    return
                msg += i.mention + "\t"
        else:
            msg = "Mention someone."
            await client.send_message(message.channel, msg)
            return
        if len(message.content.split(" ")) > 2:
            try:
                r = int(message.content.split(" ")[2])
                if r > 50:
                    r = 50
            except:
                r = 5
        else:
            r = 5
        for x in range(r):
            await client.send_message(message.channel, msg)

    #synonym using vocabulary api
    if message.content[0:3] == "!s ":  #match first 3 charachters
        query = message.content.split(" ")[
            1]  #seperate the content from the identifier
        result = vb.synonym(query)
        msg = ""
        if result == False:  #if no reply from api
            msg = "Not found"
        else:
            result = json.loads(result)  #parse json string
            for i in result:
                msg += i["text"] + "\n"  #add all results
        await client.send_message(message.channel, msg)

    #antonym using vocabulary api
    if message.content[0:3] == "!a ":
        query = message.content.split(" ")[1]
        result = vb.antonym(query)
        msg = ""
        if result == False:
            msg = "Not found"
        else:
            result = json.loads(result)
            for i in result:
                msg += i["text"] + "\n"
        await client.send_message(message.channel, msg)

    #usage
    if message.content[0:3] == "!u ":
        query = message.content.split(" ")[1:]
        query = ' '.join(query)
        result = vb.usage_example(query)
        msg = ""
        if result == False:
            msg = "Not found"
        else:
            result = json.loads(result)
            for i in result:
                msg += i["text"] + "\n"
        await client.send_message(message.channel, msg)

    #meaning
    if message.content[0:3] == "!m ":
        query = message.content.split(" ")[1]
        result = vb.meaning(query)
        msg = ""
        if result == False:
            msg = "Not found"
        else:
            result = json.loads(result)
            for i in result:
                msg += i["text"] + "\n"
        await client.send_message(message.channel, msg)

    #despacito
    if message.content.startswith("!despacito"):
        with open("despacito.txt") as file:
            content = file.readlines()
        j = 0
        while j < len(content):
            msg = ""
            i = 0
            while i < 10 and j < len(
                    content
            ):  #10 lines at a time to prevent getting rate limited by discord
                msg += content[j]
                i += 1
                j += 1
            await client.send_message(message.channel, msg)
Beispiel #18
0
class HQTrivia():
    """
    A simple test to see if one can automate determining the best answer
    """

    def __init__(self):

        # This determines source location on where to caputer picture
        # QuickTime - MacOS has record feature for phone (best)
        # WebCam - Use OpenCV to capture photo (untested)
        self.use_quicktime = False
        self.use_webcam = False
        self.use_input = False

        # The filename of picture (no extension means we're capturing image)
        self.picture = 'source'

        # Default location of where to work on self.picture
        self.location = os.getcwd()

        # Replace with your own auth file name
        self.google_auth_json = 'blissend.json'

        # Default the language for wikipedia searches
        self.wiki = wikipediaapi.Wikipedia('en')
        self.vb = Vocabulary()

        # The OCR text
        self.raw = ''

        # The information we ultimately wanted to be analyzed
        self.question = ''
        self.answers = {}
        self.definitions = {}

        # For debugging
        self.verbose = False

    def debug(self, msg):
        # In multiprocessing environments, the below statement helps
        sys.stdout.flush()

        print("hqtrivia-automation.py: " + str(msg))

    def capture(self, ftype='tiff'):
        """
        Simple function to select function to capture picture
        """

        if self.verbose:
            pre = "method - capture | "
            self.debug(pre + "choosing how to capture...")

        if self.use_input:
            if self.verbose:
                self.debug(pre + "input provided, don't capture")
            return

        # Set file type
        self.picture += '.' + ftype

        if self.use_quicktime:
            if self.verbose:
                self.debug(pre + "quicktime")
            self.quicktime(ftype)
        elif self.use_webcam:
            if self.verbose:
                self.debug(pre + "webcam")
            self.webcam()

    def quicktime(self, ftype='tiff'):
        """
        Takes screenshot of phone screen via AppleScript

        To use this open QuickTime player and do a movie recording. Select the
        drop down arrow next to record button and select your iPhone. This
        requires a wire connection to your computer using QuickTime. Remember,
        don't record anything. Having it show on screen is enough for a
        screencapture!

        1. Get window ID of QuickTime Player
        2. Tell script to run shell script command screencapture the window ID
        """

        if self.verbose:
            self.debug("method - quicktime | starting")
            start = time.time()

        full_path = os.path.join(self.location, self.picture)
        script = """tell application "QuickTime Player"
set winID to id of window 1
end tell
do shell script "screencapture -x -t tiff -l " & winID &"""
        script += ' " ' + full_path + '"'
        script = script.replace('tiff', ftype)

        s = NSAppleScript.alloc().initWithSource_(script)
        s.executeAndReturnError_(None)

        if self.verbose:
            diff = time.time() - start
            self.debug("method - quicktime | elapsed {!s}".format(diff))

    def webcam(self):
        """
        Takes screenshot using webcam.

        This is untested but here just in case it's needed. You need to figure
        out which camera to capture which unfortnately appears to be a discovery
        process of entering in numbers from 0 to higher until found. Also note,
        not all cameras have good controls and autofocus sucks for this.
        """

        if self.verbose:
            self.debug("method - webcam | starting")

        video = cv2.VideoCapture(1) # cam id (try from 0 and higher til found)
        video.set(cv2.CAP_PROP_AUTOFOCUS, 0) # turn the autofocus off
        video.set(3, 1920)
        video.set(4, 1080)
        cv2.namedWindow("HQ OCR Camera")
        #img_counter = 0
        while True:
            ret, frame = video.read()
            cv2.imshow("HQ OCR Camera", frame)
            if not ret:
                break
            k = cv2.waitKey(1)
            if k%256 == 27: # ESC pressed
                print("Escape hit, closing...")
                break
            elif k%256 == 32: # SPACE pressed
                img_name = self.picture # format with counter for multiple pics
                cv2.imwrite(img_name, frame)
                print("{} written!".format(img_name))
                #img_counter += 1
                break
        video.release()
        cv2.destroyAllWindows()

    def enhance(self):
        """
        Edit image readability for Google OCR that is suuuuuuuuuuuuuper...

        picky

        1. Eliminate background on buttons (answers)
        2. Turn to grayscale
        3. Make image BIG because Google OCR likes it big ;)
        4. Reduce the grayscale (eliminates button borders in good pictures)
        5. Make anything not white, black because google can't see color -_-
        """

        if self.verbose:
            self.debug("method - enhance | starting")
            start = time.time()

        # Replace buttons (answers) background color, incease size scale/DPI
        im = Image.open(self.picture)
        im = im.convert("RGBA")
        data = np.array(im)
        red, green, blue, alpha = data.T # Unpack the bands for readability
        gray_buttons = (red > 225) & (green > 225) & (blue > 225)
        data[..., :-1][gray_buttons.T] = (255, 255, 255)
        im = Image.fromarray(data)
        width, height = im.size
        # New file since we're going to edit it
        file = self.picture.split('.')
        self.picture = "source_edited." + file[len(file)-1]
        im.crop((0, 300, width, height-400)).save(self.picture)
        #im.resize((round(width*3), round(height*3))).save(
            #self.picture, dpi=(600,600))

        # Make grayscale
        im = Image.open(self.picture)
        im = im.convert('RGBA')
        im = im.convert('L').save(self.picture)
        #exit()

        # Reduce the grayscale
        #im = Image.open(self.picture)
        #im = im.convert('RGBA')
        #data = np.array(im)
        #red, green, blue, alpha = data.T # Unpack the bands for readability
        #gray_triming = (red > 158) & (green > 158) & (blue > 158)
        #data[..., :-1][gray_triming.T] = (255, 255, 255)
        #Image.fromarray(data).save(self.picture)
        #exit()

        # Replace non white with black
        im = Image.open(self.picture)
        im = im.convert('RGBA')
        data = np.array(im)
        red, green, blue, alpha = data.T # Unpack the bands for readability
        non_white = (red < 255) & (green < 255) & (blue < 255)
        data[..., :-1][non_white.T] = (0, 0, 0)
        im = Image.fromarray(data)
        width, height = im.size
        im.resize((round(width*3), round(height*3))).save(self.picture)
        #exit()

        if self.verbose:
            diff = time.time() - start
            self.debug("method - enhance | elapsed {!s}".format(diff))

    def vision_ocr(self, queue):
        """
        Google Cloud Vision

        The better OCR tool out there but requires additional setup. It is
        free under limitations.
        """

        if self.verbose:
            pre = "method - vision_ocr | "
            start = time.time()
            self.debug(pre + "starting")

        # See if we have an auth file, if not return
        try:
            file_path = os.path.join(self.location, self.google_auth_json)
            if not os.path.isfile(file_path):
                if self.verbose:
                    self.debug(pre + "no auth file")
                queue.put("END")
                return
        except:
            if self.verbose:
                self.debug(pre + "no auth file")
            queue.put("END")
            return

        # Credentials
        os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = file_path

        # Instantiates a client
        client = vision.ImageAnnotatorClient() # spits out shit, don't know why

        # The image file
        if not os.path.isfile(self.picture):
            full_path = os.path.join(self.location, self.picture)
        else:
            full_path = self.picture

        # Loads the image into memory
        with io.open(full_path, 'rb') as image_file:
            content = image_file.read()

        image = types.Image(content=content)

        # Performs text detection on the image file
        response = client.text_detection(image=image)
        text = response.text_annotations

        for t in text:
            self.raw = t.description
            break

        # Clean up text
        self.raw = self.raw.split('\n')
        self.debug("method - vision_ocr | raw - " + str(self.raw))
        index = 0
        while index < len(self.raw):
            value = self.raw[index].lower()
            if len(value) < 10:
                self.raw.pop(index)
                #self.debug("method - ocr | delete [" + value + "]")
            else:
                index += 1
        self.raw.pop(-1) # swipe left comment

        if self.verbose:
            self.debug("method - vision_ocr | raw - cleaned" + str(self.raw))
            diff = time.time() - start
            self.debug(pre + "elapsed {!s}".format(diff))

        # Return data to parent process
        queue.put(self.raw)

    def tesseract_ocr(self, queue):
        """
        Google Tesseract OCR

        Finally read the image text if possible
        """

        # Include the below line, if you don't have tesseract in your PATH
        # Example tesseract_cmd: '/usr/local/bin/tesseract'
        #pytesseract.pytesseract.tesseract_cmd = '<fullpath_to_tesseract>'

        if self.verbose:
            pre = "method - tesseract_ocr | "
            self.debug(pre + "starting")
            start = time.time()

        # Enhance image first since tesseract doesn't do it
        self.enhance()

        # Get text from image (OCR)
        self.raw = pytesseract.image_to_string(
            Image.open(self.picture), config="-psm 11")

        # Clean it up
        self.raw = self.raw.split('\n')

        if self.verbose:
            self.debug(pre + "raw = " + str(self.raw))

        index = 0
        while index < len(self.raw):
            value = self.raw[index].lower()
            if len(value) < 1:
                self.raw.pop(index)
                #self.debug("method - ocr | delete [" + value + "]")
            else:
                index += 1

        if self.verbose:
            self.debug(pre + "raw - cleaned = " + str(self.raw))
            diff = time.time() - start
            self.debug(pre + "elapsed {!s}".format(diff))

        # Return the data to main parent process
        queue.put([self.picture, self.raw])

    def parse(self):
        """
        Parser for the OCR text

        This is tricky because the OCR text won't always be the same. So
        adjustments may have to be tweaked here.
        """

        if self.verbose:
            self.debug("method - parse | starting")
            start = time.time()

        # Parse text into question and answer variables
        check_q = True
        counter = 1 # for counting answers
        for line in self.raw:
            #print(len(line), end=' ['+line+']\n')
            if check_q:
                if len(line) > 2:
                    if '?' not in line:
                        self.question += line + ' '
                    else:
                        self.question += line
                        check_q = False
            else:
                if 'Swipe left' not in line:
                    if len(line) > 0 and line != '-':
                        ans = line
                        self.answers[str(counter)] = {
                            "answer": ans,
                            "keywords": [],
                            "score": 0,
                            "index": str(counter)
                        }
                        self.definitions[ans] = []
                        counter += 1
                else:
                    break

        if self.verbose:
            self.debug("method - parse | question = " + str(self.question))
            self.debug("method - parse | answer = " + str(self.answers))
            diff = time.time() - start
            self.debug("method - parse | elapsed {!s}".format(diff))

    def lookup(self, index):
        """
        Gets information about answer to determine relevance to question

        This is a multiprocess function and therefore updated values have to be
        returned to parent process.
        """

        if self.verbose:
            pre = "method - lookup | "
            self.debug(pre + "starting")
            start = time.time()

        # Reference/copy of self values
        answers = self.answers[index]
        definitions = self.definitions[answers['answer']]
        value = answers['answer']
        question_nouns = ''
        for q in nltk.pos_tag(nltk.word_tokenize(self.question)):
            if q[1] == 'NN' or q[1] == 'NNP':
                question_nouns += " " + q[0]
        question_nouns = question_nouns.strip().split(' ')
        if self.verbose:
            self.debug(pre + "nouns in question - {!s}".format(question_nouns))

        # First get wikipedia information (the most helpful)
        time_wiki = time.time()
        try:
            page = self.wiki.page(value)
            if page.exists():
                definitions.append(page)
                definitions.append("[Wikipedia]: " + page.summary)
        except:
            self.debug(pre + "issue with wikipedia... ")
            self.debug(sys.exc_info()[0])
        if self.verbose:
            self.debug(pre + "wiki elapsed " + str(time.time() - time_wiki))

        # Google search
        time_gsearch = time.time()
        try:
            text = urllib.parse.quote_plus(value)
            url = 'https://google.com/search?q=' + text
            response = requests.get(url, timeout=2)
            soup = BeautifulSoup(response.text, 'lxml')
            results = ''
            for g in soup.find_all(class_='st'):
                results += " " + g.text
            definitions.append("[Google]: " + results.strip().replace('\n',''))
        except:
            self.debug(pre + "issue with google search... ")
            self.debug(sys.exc_info()[0])
        if self.verbose:
            self.debug(
                pre +
                "google search elapsed " +
                str(time.time() - time_gsearch))

        # Get dictionary definitions
        time_define = time.time()
        define = nltk.corpus.wordnet.synsets(value)
        synset_found = False
        if len(define) < 1:
            # Means local dictionary didn't find anything so search online
            if self.verbose:
                self.debug(
                    pre +
                    "nltk nothing for {!s}, using vocabulary".format(value))
            try:
                define = self.vb.meaning(value, format='list')
                if define != False:
                    # There may be multiple difinitions so count them up
                    counter = 1
                    for d in define:
                        definitions.append(
                            "[Meaning " + str(counter) + "]: " + d)
                        counter += 1
            except:
                self.debug(pre + "issue with vocabulary... ")
                self.debug(sys.exc_info()[0])
        else:
            synset_found = True
            definitions.append("[Meaning]: " + define[0].definition())
        if self.verbose:
            self.debug(
                pre +
                "dictionary elapsed " +
                str(time.time() - time_define))

        # Get synonyms
        time_synonyms = time.time()
        if synset_found:
            synonyms = [l.name() for s in define for l in s.lemmas()]
            # Remove duplicates
            s = []
            i = 0
            while i < len(synonyms):
                if synonyms[i] in s:
                    synonyms.pop(i)
                else:
                    s.append(synonyms[i])
                    i += 1
            definitions.append("[Synonyms]: " + ', '.join(s))
        else:
            # Means local dictionary didn't find anything so search online
            try:
                synonyms = self.vb.synonym(value, format='list')
                if synonyms != False:
                    definitions.append("[Synonyms]: " + str(synonyms))
            except:
                self.debug(pre + "issue with vocabulary... ")
                self.debug(sys.exc_info()[0])
        if self.verbose:
            self.debug(
                pre +
                "synonyms elapsed " +
                str(time.time() - time_synonyms))

        # Score the answer
        if len(definitions) > 0:
            for define in definitions:
                if type(define) == str:
                    if "[Wikipedia]" not in define:
                        d = define.split(':') # remove pretag [Google]: bla blah
                        words = d[1].split(' ')
                else:
                    # This is for WIKIPEDIA sections which isn't a string
                    try:
                        words = []
                        for i in page.sections:
                            words += i.text.split(' ')
                    except:
                        self.debug(pre + "issue with wikipedia")
                for w in words:
                    if len(w) > 2:
                        if w in question_nouns:
                            if w not in answers['keywords']:
                                answers['keywords'].append(w)
                                answers['score'] += 1

        if self.verbose:
            diff = time.time() - start
            self.debug("method - lookup | elapsed {!s} for {!s}".format(diff, index))

        # Send data back to parent process
        return answers, definitions, index

    def display(self):
        # Question
        print('\n\nQuestion - ' + self.question, end='\n\n')

        # Answers
        choice = {'index': [], 'score': 0}
        for a, ans in self.answers.items():
            if ans['score'] == choice['score']:
                choice['index'].append(a)
            if 'NOT' in self.question:
                if ans['score'] < choice['score']:
                    choice['index'] = [a]
                    choice['score'] = ans['score']
            else:
                if ans['score'] > choice['score']:
                    choice['index'] = [a]
                    choice['score'] = ans['score']
            print("Choice - " + ans['answer'] + ' - Score ' + str(ans['score']))
            for d in self.definitions[ans['answer']]:
                if type(d) == str:
                    if len(d) > 140:
                        print(d[0:140])
                    else:
                        print(d)
            print("[Keywords]: " + str(ans['keywords']))
            print("")

        # Choose answer
        if len(choice['index']) > 0:
            choose = []
            for i in choice['index']:
                choose.append(self.answers[i]['answer'])
            print("Answer - " + ', '.join(choose), end='')
            if 'NOT' in self.question:
                print(" - NOT keyword so lowest score is " +
                      str(choice['score']))
            else:
                print(" - highest score is " + str(choice['score']))
        else:
            print("Answer - Unknown")
        print("")
Beispiel #19
0
def definition_request(word):

    response = vb.meaning(word)
    print(response)