def tweet(messageid=None):
if id is None:
return render_template(404)
parz = Parsing()
datum = parz.get_tweet(messageid)
return render_template("message.html", datum=datum)
def tweeter(name=None):
parz = Parsing()
if name is None:
data = parz.index_data()
return render_template('tweetindex.html', data=data)
else:
data = parz.tweeter_data(name)
return render_template('tweet.html', data=data)
def __init__(self, id, nr):
self.domain = Domain()
self.phrasebase = Phrasebase()
self.parsing = Parsing()
self.evaluation = Evaluation(self.domain.getTopics(),
self.domain.getPraise(),
self.domain.getCriticism())
super(L, self).__init__()
self.ui = UI(nr)
self.id = id
L.totalCount += 1
self.displayCount()
self.running = True
def removeRareEntities(filePath):
inFile = open(filePath, 'r')
occurenceCountDict = {}
p = Parsing()
for line in inFile:
if 'inv idx' in line:
break
elif ': ' in line and 'num preds' not in line and 'predicate' not in line and line != "":
entities = p.extractEntities(line)
if entities in occurenceCountDict:
oldCount = occurenceCountDict[entities]
newCount = oldCount + 1
occurenceCountDict[entities] = newCount
else:
occurenceCountDict[entities] = 1
rareEntitiesList = []
for key, value in occurenceCountDict.items():
if value < 3:
rareEntitiesList.append(key)
orig_stdout = sys.stdout
f = open('GermanLoc#LocNoRareEntities.txt', 'w')
sys.stdout = f
inFile2 = open(filePath, 'r')
for line in inFile2:
if 'inv idx' in line:
break
elif ': ' in line and 'num preds' not in line and 'predicate' not in line and line != "":
entities = p.extractEntities(line)
if entities in rareEntitiesList:
continue
else:
print(line.rstrip())
else:
print(line.rstrip())
sys.stdout = orig_stdout
f.close()
group1 = parser.add_mutually_exclusive_group()
group1.add_argument('-l', '--length', default='3', type=int, help='Choose the size of your puzzle between 3 and 70')
group1.add_argument('-f', '--file', type=str, help='Name of your file, if this option is selected, ignore: -s/u')
group2 = parser.add_mutually_exclusive_group()
group2.add_argument('-s', '--solvable', action='store_true', help='Generate only solvable puzzle')
group2.add_argument('-u', '--unsolvable', action='store_false', help='Generate only unsolvable puzzle')
parser.add_argument('-a', '--anim', action='store_true' , help='Launch an animation of the resolution of the puzzle')
return parser.parse_args(arg)
if __name__ == '__main__':
arg = parse_argument(sys.argv[1:])
if (arg.file):
try:
fd = open(arg.file, "r")
parsing = Parsing(fd)
except:
sys.exit("Error - Openning error")
start = parsing.puzzle
goal = printspiral(spiral(int(sqrt(len(start)))))
if (my_resolvable(parsing, start, goal) == 1):
exit
else:
if arg.length < 71 and arg.length > 2:
goal = printspiral(spiral(arg.length))
solvable = None
if (arg.solvable == True):
solvable = True
elif (arg.unsolvable == False):
solvable = False
def main():
try:
if len(argv) < 3:
print('''Options:\nparse_messages [group name]
\rparse_participants [group name]\nget_statistics [group name | date from | date until]'''
)
return 1
parse = Parsing(argv[2])
if argv[1] == "parse_messages":
if len(argv) == 3:
mod = 0
elif len(argv) == 4:
mod = int(argv[3])
elif len(argv) == 5:
mod = list()
mod.append(datetime.strptime(argv[3], '%Y-%m-%d'))
mod.append(datetime.strptime(argv[4], '%Y-%m-%d'))
else:
return 1
parse.parse_messages(mod)
elif argv[1] == "parse_participants":
parse.parse_participants()
elif argv[1] == "get_statistics":
if len(argv) < 5:
print('Invalid argument')
return 1
datum_range = parse.get_datum_range(argv[3], argv[4])
if datum_range:
print(
"There are %i messages during this period.\nDo you want to proceed?[y/n]"
% datum_range[0])
else:
print("There are no messages during this period.")
return
if 'y' in input():
parse.get_message_range(argv[3], argv[4], datum_range[1])
print('Done')
parse.finish()
return 0
except KeyboardInterrupt:
print('Terminating...', end='\r')
parse.finish()
print('Terminated...')
return 0
except:
print("Invalid argument")
return 0
from pprint import pprint
from graph import Graph
from parsing import get_file, Parsing, Table
if __name__ == '__main__':
code = get_file('cont.go')
lexemes = Parsing().parsing_lexeme(code)
table_lexemes = Table().get_table()
# pprint(table_lexemes)
graph = Graph(table_lexemes[2:])
graph.stmt()
print(graph.get_variable_table())
#graph = graph.get_abstract_syntax_trees()
# pprint(graph)
# RecursiveDescent(graph).output()
def main():
"Using argparse to get events or search meetup"
parser = argparse.ArgumentParser(description='TGmeetup')
parser.add_argument(
'-u',
'--update',
help='Update the events.json infomation.',
action="store_true")
parser.add_argument(
'-c',
'--country',
type=str,
help='This is a country code which follow ISO 3166-1 alpha-2.')
parser.add_argument('-t', '--city', type=str, help='This is a city name.')
parser.add_argument(
'-n',
'--name',
type=str,
help='This is a community short name.')
parser.add_argument(
'-k',
'--keyword',
type=str,
help='This is a keyword of community. \
This could help find the related community.')
args = parser.parse_args()
parsing = Parsing()
if args.city is not None or args.keyword is not None or args.name is not None:
if args.name is not None and args.city is None and args.keyword is None:
# Show the group info (default country = Taiwan)
result = parsing.show_organization_info(args.name, args.country)
print(
"The information of \"" +
result["title"] +
"\" in " +
result["city"] +
" (" +
result["countrycode"] +
")")
print(json.dumps(result, indent=2, sort_keys=False))
elif args.city is not None and args.name is None and args.keyword is None:
# List all the meetup in the city (default country = Taiwan)
result = parsing.get_meetup_via_city(args.city, args.country)
print_result(result)
elif args.keyword is not None and args.city is None and args.name is None:
# List all the meetup related to this keyword (default country =
# Taiwan)
result = parsing.show_meetup_via_keyword(
args.keyword, args.country)
print_result(result)
else:
print(
"Please just use one option, such as name,keyword or city, \
and country option.")
print("eg.")
print("tgmeetup -k keypord\n tgmeetup -n name\ntgmetup -t Hsinchu")
else:
if args.update:
update()
print("Update all the meetup infomation.")
else:
# List all group with event in the country(default country =
# Taiwan).
result = parsing.list_all_group_in_country(args.country)
print_result(result)
class AnalisadorSemantico:
'''
Clase principal encargada de llevar a cabo el parsing y ademas analizar la semantica de la declaraciones de
funciones, varibales, condicionales, entre otras.
'''
def __init__(self, nombre_archivo):
self._parsing = Parsing()
self._lista_tokens = []
self.lista_errores = []
self._tokenize(nombre_archivo)
def _tokenize(self, _nombre_archivo):
archivo = open(_nombre_archivo, 'r')
contador_linea = 1
for linea in archivo.readlines():
tokens = tokenize(linea)
self._lista_tokens.append({
'linea': contador_linea,
'tokens': tokens
})
contador_linea += 1
def analizar(self):
self.parse()
tabla = self._parsing.obtenerTabla()
self._analisis_semantico_declaraciones(tabla)
self._analisis_semantico_identificadores(tabla)
self._mostrar_errores()
def parse(self):
for i in self._lista_tokens:
linea = i['linea']
tokens = i['tokens']
error = self._parsing.parse(tokens, linea)
if (error != ""):
self.lista_errores.append(error)
def analisis_semantico_declaraciones(self, tabla):
self._analisis_semantico_declaraciones(tabla)
def _analisis_semantico_identificadores(self, tabla):
'''
Verifica que las variables se encuentren declaradas y su ambito sea el correspondiente
'''
interes = {'int', 'string', 'float', 'identificador'}
for tokens in self._lista_tokens:
if (tokens['tokens']):
resultado = self._analizador_elementos(tokens['tokens'])
if resultado == 'ASIGNACION':
llave = tabla.buscar_simbolo(
tokens['tokens'][0][0]
) #verifica que la variable que esta a la izquierda del
#operador de asignacion este en la tabla
if llave:
lista_asignaciones = self._extraer_asignaciones(
tokens['tokens'])
for asignacion in lista_asignaciones:
if asignacion[1] == 'identificador':
valor = tabla.buscar_simbolo(
asignacion[0]
) #se verifica que la variable que va a ser asignada este en la tabla
if valor:
if not valor['tipo'] == llave[
'tipo']: #si la variable esta en la tabla se verifica que sea del mismo tipo
salida = "Error - linea: {}. Asignacion de tipo '{}' incorrecta.".format(
tokens['linea'], valor['tipo'])
self.lista_errores.append(salida)
else: #si no es una variable es un tipo dato primitivo
tipo_valor = self._tipo_dato_checker(
llave['tipo'], asignacion[0])
if not tipo_valor:
salida = "Error - linea: {}. Asignacion de tipo '{}' incorrecta.".format(
tokens['linea'], llave['tipo'])
self.lista_errores.append(salida)
else:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], tokens['tokens'][0][0])
self.lista_errores.append(salida)
elif resultado == 'CONDICIONAL':
lista_asignaciones = self._extraer_asignaciones(
tokens['tokens'])
if len(lista_asignaciones
) > 1: #caso en que hayan dos elementos comparados
if lista_asignaciones[0][
1] == 'identificador' and lista_asignaciones[1][
1] == 'identificador': #caso de que ambos elementos sean variables
elemento1 = tabla.buscar_simbolo(
lista_asignaciones[0][0])
elemento2 = tabla.buscar_simbolo(
lista_asignaciones[1][0])
if not elemento1 or not elemento2:
if not elemento1:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'],
lista_asignaciones[0][0])
self.lista_errores.append(salida)
else:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'],
lista_asignaciones[1][0])
self.lista_errores.append(salida)
elif lista_asignaciones[0][
1] == 'identificador' or lista_asignaciones[1][
1] == 'identificador': #caso de que solo haya una variable y el otro sea algun tipo de dato primitivo
elemento1 = lista_asignaciones[0]
elemento2 = lista_asignaciones[1]
if elemento1[1] == 'identificador':
encontrado = tabla.buscar_simbolo(elemento1[0])
if encontrado:
if not elemento2[1] == encontrado['tipo']:
salida = "Error - linea: {}. Comparacion de tipo '{}' incorrecta.".format(
tokens['linea'],
encontrado['tipo'])
self.lista_errores.append(salida)
else:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], elemento1[0])
self.lista_errores.append(salida)
else:
encontrado = tabla.buscar_simbolo(elemento2[0])
if encontrado:
if not elemento1[1] == encontrado['tipo']:
salida = "Error - linea: {}. Comparacion de tipo '{}' incorrecta.".format(
tokens['linea'],
encontrado['tipo'])
self.lista_errores.append(salida)
else:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], elemento2[0])
self.lista_errores.append(salida)
else:
elemento1 = lista_asignaciones[0]
elemento2 = lista_asignaciones[1]
if not elemento1[1] == elemento2[
2]: #caso de que los datos primitivos no sean del mismo tipo
salida = "Error - linea: {}. Comparacion de tipo '{}' incorrecta.".format(
tokens['linea'], elemento1[1])
self.lista_errores.append(salida)
else: #en caso de que el condicional solo tenga un elemento dentro
if lista_asignaciones[0][
1] == 'identificador': #caso de que ambos elementos sean variables
elemento1 = tabla.buscar_simbolo(
lista_asignaciones[0][0])
if not elemento1:
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], lista_asignaciones[0][0])
self.lista_errores.append(salida)
elif resultado == 'ASIGNACION_FUNCION':
tipos = {'string', 'int', 'float', 'void'}
parametros = []
if tokens['tokens'][0][0] in tipos:
parametros = self._extraer_parametros(tokens['tokens'])
for parametro in parametros:
if not parametro in tabla.obtener_tabla().keys():
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], parametro)
self.lista_errores.append(salida)
else:
if tabla.obtener_tabla(
)[parametro]['ambito'] != 'global':
salida = "Error - linea: {}. '{}' no esta declarado.".format(
tokens['linea'], parametro)
self.lista_errores.append(salida)
def _extraer_parametros(self, linea):
'''
Utilizado para extraer los parametros que se encuentran entre parentesis en una funcion
'''
lista_parametros = [] #se guardan los parametros de la linea de tokens
parametro_auxiliar = []
contador_parentesis = 0
for i in range(0, len(linea) + 1): #recorre la linea de tokens
if linea[i][1] == 'parentesis':
if contador_parentesis < 1:
contador_parentesis += 1
else: #si el token vuelve a ser un parentesis significa que es el parentesis que cierra
lista_parametros += parametro_auxiliar #lo que este en parametro_auxiliar se agrega a la lista de parametros
break
elif contador_parentesis > 0:
if linea[i][
1] == 'coma': #si el token es una coma todo lo que este en el parametro_auxiliar se agrega a la lista de parametros
if len(parametro_auxiliar) > 0:
lista_parametros.append(parametro_auxiliar)
parametro_auxiliar = []
elif linea[i][
1] != 'coma': #si el token actual no es una coma, es parte del parametro (tipo, identificador, =, valor)
parametro_auxiliar.append(
linea[i][0]) #se agrega al parameto_auxiliar
return lista_parametros
def _extraer_asignaciones(self, linea_token):
interes = {'identificador', 'int', 'string', 'float'}
lista_asignaciones = []
for i in range(0, len(linea_token)):
if linea_token[i][1] in interes:
lista_asignaciones.append(linea_token[i])
return lista_asignaciones
def _analizador_elementos(self, tokens):
operador_asignacion = False
condicional = False
parentesis_abre = False
parentesis_cierra = False
palabra_tipo = False
for token in tokens:
if token[1] == 'tipo':
palabra_tipo = True
if token[1] == 'asignacion':
operador_asignacion = True
if token[1] == 'parentesis':
if token[0] == '(':
parentesis_abre = True
else:
parentesis_cierra = True
if token[1] == 'condicicional':
condicional = True
if condicional and parentesis_abre:
return 'CONDICIONAL'
elif operador_asignacion and parentesis_abre:
return 'ASIGNACION_FUNCION'
elif operador_asignacion and not palabra_tipo:
return 'ASIGNACION'
else:
return 'NONE'
def _analisis_semantico_declaraciones(self, tabla):
'''
Verifica que las asignaciones sean del mismo tipo en las declaraciones
'''
errores = queue.Queue()
for key, value in tabla.obtener_tabla().items():
tipo = value['tipo']
valor = value['valor']
if valor:
if self._tipo_dato_checker(tipo, valor):
continue
else:
if valor in tabla.obtener_tabla():
elemento_tabla = tabla.obtener_tabla()[valor]
if tipo == elemento_tabla['tipo']:
continue
else:
errores.put(value)
else:
errores.put(value)
if not errores.empty():
while not errores.empty():
value = errores.get()
salida = "Error - linea: {}. Asignacion de tipo '{}' incorrecta.".format(
value['linea'], value['tipo'])
self.lista_errores.append(salida)
def _obtener_tabla(self):
return self._parsing.obtenerTabla()
def _tipo_dato_checker(self, tipo, valor):
if tipo == 'int':
return self._verifica_int(valor)
elif tipo == 'float':
return self._verifica_float(valor)
elif tipo == 'string':
return self._verifica_string(valor)
def _verifica_int(self, int):
return int.isdigit()
def _verifica_float(self, entrada):
try:
float(entrada)
return True
except ValueError:
return False
def _verifica_string(self, entrada):
token = re.compile(r'"[a-zA-Z0-9_]*"')
objeto_encontrado = token.match(entrada)
if objeto_encontrado:
return True
return False
def _mostrar_errores(self):
print()
if len(self.lista_errores) > 0:
for error in self.lista_errores:
print(error)
else:
print("El programa se encuentra libre de errores!")
print()
def __init__(self, nombre_archivo):
self._parsing = Parsing()
self._lista_tokens = []
self.lista_errores = []
self._tokenize(nombre_archivo)
from parsing import Parsing
from dominant import Dominant
from darsi import Darsi
from rollershop import Rollershop
from wakepark import Wakepark
import urllib.request
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.firefox import GeckoDriverManager
import time
import keyboard
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
parsing = Parsing()
sys.setrecursionlimit(100000)
shops = {
'Dominant': Dominant(),
'FAMILY BOARDSHOP': Wakepark(),
'Rollershop': Rollershop(),
'Darsi': Darsi(),
}
# # get main_page
# for name in shops.keys():
# print(name)
# page_doc = parsing.get_page_doc(shops[name])
# print(page_doc)
nodeList = labelDict[i[1]['label']]
nodeList.append(i[0])
labelDict[i[1]['label']] = nodeList
for i, j in labelDict.items():
print(i, j)
#max_key, max_value = max(d.items(), key = lambda x: len(set(x[1])))
#print(max_key,max_value)
if __name__ == "__main__":
print("Hello Graph Aligner")
#extract the German only entity set
c = Parsing()
entitySet = EntitySet()
vectorMap = VectorMap()
discardThisVectorMap, germanEntitySet = c.parse(
"GermanLoc#LocNoRareEntities.txt", entitySet, vectorMap)
#extract the English only entity set
freshVectorMap = VectorMap()
freshEntitySet = EntitySet()
discardThisVectorMap, englishEntitySet = c.parse(
"/afs/inf.ed.ac.uk/user/s17/s1782911/location#location.txt",
freshEntitySet, freshVectorMap)
#calculate the intersection of those sets. This is the overlap of entities
intersection = list(englishEntitySet.intersection(germanEntitySet.toSet()))
print("the overlap between the tow sets is ", len(intersection))
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
from ambiguity import Ambiguity
from constraints import Constraints
from language_generation import LanguageGeneration
from parsing import Parsing
from ranges import Ranges
from resolution import Resolution
if __name__ == "__main__":
# Creating TIMEX expressions from natural language using the Recognizer package.
Ambiguity.date_ambiguity()
Ambiguity.time_ambiguity()
Ambiguity.date_time_ambiguity()
Ranges.date_range()
Ranges.time_range()
# Manipulating TIMEX expressions in code using the TIMEX Datatype package.
Parsing.examples()
LanguageGeneration.examples()
Resolution.examples()
Constraints.examples()
import os
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext
from telegram import Bot, Update
from telegram.utils.request import Request
from logging import getLogger
from bot_token import bot_token
from debug_for_bot import debug_requests, load_config
from keyboards_for_bot import available_shops_keyboard, available_categories_keyboard, back_button_logic
from some_data import shops, User
from parsing import Parsing
config = load_config(getLogger(__name__))
users = dict()
parsing = Parsing()
@debug_requests
def do_start(update: Update, context=CallbackContext):
chat_id = update.message.chat_id
if chat_id not in users.keys():
users[chat_id] = User(chat_id)
update.effective_chat.send_message(
text='Select shop', reply_markup=available_shops_keyboard())
else:
users[chat_id].selected_shop = None
users[chat_id].categories = None
users[chat_id].selected_category = None
update.effective_chat.send_message(
text='Select shop', reply_markup=available_shops_keyboard())
class L(threading.Thread):
totalCount = 0
#Initialize all the components#
def __init__(self, id, nr):
self.domain = Domain()
self.phrasebase = Phrasebase()
self.parsing = Parsing()
self.evaluation = Evaluation(self.domain.getTopics(),
self.domain.getPraise(),
self.domain.getCriticism())
super(L, self).__init__()
self.ui = UI(nr)
self.id = id
L.totalCount += 1
self.displayCount()
self.running = True
def getUI(self):
return self.ui
#main method, organize the whole structure of the dialogue#
def run(self):
#setup
self.parsing.setui(self.ui)
warnings.filterwarnings(module='sklearn*',
action='ignore',
category=DeprecationWarning)
#introductory greeting of the user, general explanations and so on
self.intro()
#getting stories to ask
total_number = 6
stories = self.organizeStories(total_number)
#main loop for asking all stories
for story in stories:
self.askStory(story)
#get the evaluation and tell it to the user
eval = self.evaluation.evaluate()
for e in eval:
self.ui.tell(e)
#say goodbye
self.goodbye()
#just for keeping track of how many lizas there are
def displayCount(self):
print(
"I am the %d. Liza started here since the last restart of the program."
% L.totalCount)
#display a final goodbye message, and then a "system message" stating the liza has disconnected.
def goodbye(self):
self.ui.tell("Goodbye!")
self.ui.info("Liza has disconnected.")
sys.exit()
#For asking if the user wants to take a break
def askbreak(self):
self.ui.tell("Do you want to continue with this?")
answer = self.ui.listen()
if (answer == ""):
self.ui.tell(
"Do you want to continue? If you don't reply, I have to assume that you are gone..."
)
answer = self.ui.listen()
if (answer == ""):
self.ui.tell("Well, okay... I guess we can't continue then.")
self.goodbye()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay, great! So let's return to the questions.")
return True
self.ui.tell("Oh. I am sorry.")
self.goodbye()
#for asking a question and continuing until we finally got an answer
def askForever(self, question):
answer = ""
time = 0
self.ui.tell(question)
self.ui.prompt()
while True:
time = time + 1
answer = self.ui.listen()
if answer == "" and time < 4:
self.ui.tell(self.phrasebase.getReply("waiting"))
self.ui.prompt()
if answer == "" and time >= 4 and time < 7:
self.ui.tell(self.phrasebase.getReply("worried_waiting"))
self.ui.prompt()
if time >= 7 and time < 10:
continue
if time >= 10:
self.ui.tell(
"It seems that you are a bit distracted right now. Or maybe dead. ... ...I hope you are not dead. But because it's been a while since your last answer..."
)
self.ui.prompt()
self.askbreak()
time = 0
self.ui.tell("So my question was: " + question)
if answer != "":
return answer
def askStory(self, story):
#if story type is already explained, go on
#otherwise, explain
if not self.domain.getExplained(story.group):
self.ui.tell(self.phrasebase.getReply("new_topic"))
self.ui.tell(self.domain.groups[story.group])
answer = self.askForever(
self.phrasebase.getReply("want_topic_explanation"))
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(self.domain.getExplanation(story.group))
self.domain.setExplained(story.group)
self.ui.tell("Now let's get to the question!")
if meaning == "no":
self.ui.tell("Ok, then let's get right to the question.")
else:
self.ui.tell("Oh, I really like to explain things.")
self.ui.tell(self.domain.getExplanation(story.group))
self.domain.setExplained(story.group)
self.ui.tell("Now let's get to the question!")
if (len(story.intro) > 0):
answer = self.askForever(story.intro)
meaning = self.parsing.parse(answer)
if "yes" in meaning:
self.ui.tell(story.introyes)
elif "no" in meaning:
self.ui.tell(story.introno)
else:
self.ui.tell(self.phrasebase.getReply("meaninglesses"))
self.ui.tell(story.text)
self.ui.tell(story.question)
answer = self.ui.listenLong()
if answer == "" or answer == None:
print("seems like they don't know the answer...")
self.ui.tell(self.phrasebase.getReply("offer_hint"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
#print(answer)
#print(meaning)
if meaning == "yes":
self.ui.tell(story.hint)
self.ui.prompt()
if meaning == "no":
self.ui.tell("ok!")
meaning = self.parsing.parse(answer)
if not meaning == "correct" or meaning == "incorrect":
answer = self.askForever(
self.phrasebase.getReply("introbla") + story.question)
#print(answer)
meaning = self.parsing.parseQuiz(answer, story)
#print(meaning)
if meaning == "whatquestion":
self.ui.tell("The question was: " + story.question)
# if meaning == "hint":
# self.ui.tell(story.hint)
# answer = askForever(self.phrasebase.getReply("introbla") + story.question)
if meaning == "explain":
self.ui.tell(self.phrasebase.getReply("offer_explanation"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(story.explain)
#explained the answer
#student model: didn't know the answer
return
if meaning == "no":
self.ui.tell("ok!")
answer = self.askForever(
self.phrasebase.getReply("introbla") + story.question)
meaning = self.parsing.parse(answer)
if meaning == "correct":
if (randint(0, 1) > 0):
self.askCalibration(True)
self.ui.tell(
story.answercorrect
) #you could also use self.phrasebase.getReply("correct")
self.evaluation.answer(story, True)
#student model: knew the answer
elif meaning == "incorrect":
if (randint(0, 1) > 0):
self.askCalibration(False)
self.evaluation.answer(story, False)
self.ui.tell(
story.answerincorrect
) #you could also use self.phrasebase.getReply("incorrect")
self.ui.tell(self.phrasebase.getReply("offer_explanation"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(story.explain)
return
def askCalibration(self, correctness):
self.ui.tell(self.phrasebase.getReply("howsure"))
answer = self.ui.listen()
percent = self.parsing.parsePercent(answer)
self.evaluation.calibrate(correctness, percent)
def organizeStories(self, total):
storylist = []
topic = 0
for i in range(0, total):
topic = topic % len(self.domain.getTopics())
story = self.domain.getStory(topic)
storylist.append(story)
topic = topic + 1
return storylist
def intro(self):
#the bot introduces itself
answer = self.askForever(self.phrasebase.getReply("greetings"))
meaning = self.parsing.parse(answer)
#print(meaning)
if "greet" in meaning or "yes" in meaning:
self.ui.tell("Nice to meet you!")
answer = self.askForever("You are a human, aren't you?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Great! This means you can help me.")
if meaning == "no":
answer = self.askForever(
"Are you sure? What is the sum of two and three?")
meaning = self.parsing.parse(answer)
if meaning == "five":
self.ui.tell(
"See, you solved the captcha. You are sufficiently human for my purposes."
)
else:
self.ui.tell("Very funny. You are definitely human.")
self.ui.tell(
"My programmers want me to teach you how to be rational, make good decisions and judge situations correctly."
)
answer = self.askForever("Do you want to be more rational?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Yeah, that's the spirit!")
if meaning == "no":
answer = self.askForever(
"Why would you think that? Rationality is just the ability to make good decisions. Do you want to be able to make good decisions?"
)
meaning = self.parsing.parse(answer)
if meaning == "no":
self.askbreak()
self.ui.tell(
"I will just try to ask you some questions, and try to explain to you what you could do better. If I do a bad job at explaning, just ask me, ok? I never taught humans before."
)
self.ui.tell(
"So, let's see... the first thing I want you to know is that you don't have to be extremely intelligent to be rational. There are very intelligent people who do things that are not at all reasonable. The key to rational decisions is to know when not to follow your gut feelings, but to stop and actually think about the problem."
)
answer = self.askForever(
"To get used to the whole situation - how about I ask you a test question? Just to make sure I am doing this teaching thing right. "
)
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay, thank you!")
if meaning == "no":
self.ui.tell("I would nevertheless like to ask the test question.")
answer = self.askForever(
"This is my first question: Do people need to follow their gut feelings to make rational decisions?"
)
meaning = self.parsing.parse(answer)
if meaning == "no":
self.ui.tell(
"Amazing! I mean, it was easy, I know, but you did it. Very reasonable of you to say this! Now we can start with the actual teaching."
)
if meaning == "yes":
self.ui.tell(
"Uhm... no. This is a bit awkward. Following you gut feelings means not to think about something, but just go with what feels right. A lot of psychologists have shown that people tend to make a lot of mistakes when they make decisions that way."
)
answer = self.askForever("Do you still want to continue?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay! Let's start with the actual teaching!")
else:
self.askbreak()