def _debugInfo(self):
"""
Prints a debug message about the number of acceptable events at this stage.
"""
message.logDebug(
"There are " + str(len(self._events_list)) +
" acceptable events at this stage.", "CEventEngine::_debugInfo")
async def onConnection(sid, socket):
message.logDebug("New user '" + sid + "' connected.",
"botui_frontend::onConnection")
#send initial message
initial_message = CBotUIFrontend.get_most_recent_message()
for msg in initial_message:
await sendClientMessage(sid, msg)
def check_games_for_league(league_website):
if not INCLUDE_INPLAY:
# Disregard any games that are in play
if len(league_website.getClasses("no-arrow in-play")) > 0:
message.logDebug("Game is in play, skipping.")
return
try:
game_tags = league_website.getClasses("meeting head-to-head draw")
except:
message.logWarning(
"Unable to load market tags, skipping to next match")
return
game_tags = [m for m in game_tags if m.getName() not in DISALLOWED_MARKETS]
game_tags.reverse()
for game_tag in game_tags:
message.logDebug("Considering market: " + game_tag.getName() + ".")
try:
game_webpage = CWebsite(sport_home_webpage.getHomeURL() +
game_tag.getAttr(DEFAULT_LINK_ATTR_NAME),
ODDSCHECKER_HOME,
name=game_name + ": " + game_tag.getName())
except:
message.logWarning(
"Unable to load webpage, skipping to next market")
continue
self._check_website(game_webpage)
def validate(model, test_loader):
results = {}
model.eval()
# No need to track gradients for validation, we're not optimizing.
with torch.no_grad():
for batch, labels, filenames in test_loader:
batch = batch.to(DEVICE)
labels = labels.to(DEVICE)
logits = model(batch)
preds = logits.cpu().numpy()
for (pred, label, filename) in zip(list(preds), list(labels.cpu().numpy()), filenames):
file_res = results.setdefault(filename, {"preds": [], "labels": []})
file_res["preds"].append(pred)
file_res["labels"].append(label)
results = _combine_file_results(results)
accuracy = compute_accuracy(
np.array(results["labels"]), np.array(results["preds"])
)
per_class_acc = compute_per_class_accuracy(
np.array(results["labels"]), np.array(results["preds"])
)
message.logDebug(f"validation accuracy: {accuracy * 100:2.2f}",
"data_proc::validate")
for label, acc in per_class_acc.items():
message.logDebug(f"Accuracy for class '{label}': {acc * 100:2.2f}",
"data_proc::validate")
def showTiming():
'''
Show a chart of any timing info stored in the message class, and write it to the log file.
'''
if TIMING_INFO is True:
message.logDebug("Showing average timing info for method instances:",
"utilities::showTiming")
for k, v in message.timing.items():
message.logDebug(
"{0:.2f} (sigma={1:.2f}, total={2:.2f}): {3}".format(
mean(v), stdEstimate(v), sum(v), k))
def main():
'''
This will initialize the chatbot.
'''
# initialise nlp module
agent = CEventEngine()
message.logDebug("Agent loaded.", "main::main")
# initialize frontend
frontend = CBotUIFrontend(agent)
frontend.start()
async def messageReceived(sid, msg):
if msg == None:
message.logDebug("Message from user is blank.",
"botui_frontend::messageReceived")
return
message.logDebug("User '" + sid + "' sent '" + msg + "'.",
"botui_frontend::messageReceived")
#run handler with received msg as input.
CBotUIFrontend._agent.process_input(msg)
ret = CBotUIFrontend._agent.get_update()
if ret:
for r in ret:
await sendClientMessage(sid, r)
def exit(code):
'''
Exit the program, 0 is failure, 1 is success.
'''
if not isinstance(code, int):
message.logError('Exit code must be an interger.')
exit(0)
if code == 0:
message.logError('Exiting program with failure status.')
elif code == 1:
message.logDebug('Exiting program with success status.')
else:
message.logError('Exiting program with unknown error status (' +
str(code) + ')')
def start(self):
'''
Start the message loop.
'''
initial_message = self.get_initial_message()
message.logDebug("Starting terminal frontend message loop.",
"CTerminalFrontend::start")
message.logDebug("Sending message '" + initial_message + "'",
"CTerminalFrontend::start")
self.sendMessage(initial_message)
self._running = True
while self._running:
ui = input("> ")
if not isinstance(ui, str):
message.logError("User input must be a string.",
"CTerminalFrontend::start")
ut.exit(0)
message.logDebug("Received message: '" + ui + "'",
"CTerminalFrontend::start")
if STOP_COMMAND == ui.lower():
self.stop()
else:
msg = self._agent.process_input(ui)
message.logDebug("Sending message: '" + msg + "'",
"CTerminalFrontend::start")
self.sendMessage(msg)
def exit(code):
"""
Exit the program, 0 is failure, 1 is success.
"""
if not isinstance(code, int):
message.logError("Exit code must be an interger.")
exit(0)
if code == 0:
message.logError("Exiting program with failure status.")
elif code == 1:
message.logDebug("Exiting program with success status.")
else:
message.logError("Exiting program with unknown error status (" +
str(code) + ")")
sys.exit()
def run(self):
"""
Finds the odds, runs forever.
"""
sport_specific_home_tags = self.m_homepage.getClasses(["nav-link beta-footnote"])
sport_specific_home_tags
for sports_home_tag in sport_specific_home_tags:
if sports_home_tag.hasAttr(DEFAULT_LINK_ATTR_NAME):
message.logDebug("Examining " + sports_home_tag.getName() + " arbitrage opportunities.")
try:
sport_home = CWebsite(sports_home_tag.getAttr(DEFAULT_LINK_ATTR_NAME),
ODDSCHECKER_HOME, name=sports_home_tag.getName())
except:
message.logWarning("Unable to load webpage, skipping to next sport")
continue
game_tags = sport_home.getClasses(["beta-callout full-height-link whole-row-link"])
for game_tag in game_tags:
if game_tag.hasAttr(DEFAULT_LINK_ATTR_NAME):
game_name = game_tag.getAttr("data-event-name")
if game_name is None:
message.logError("game name not found!")
message.logDebug("Examining arbitrage opportunities in game: " + game_name + ".")
try:
game_webpage = CWebsite(sport_home.getHomeURL() + game_tag.getAttr(DEFAULT_LINK_ATTR_NAME),
ODDSCHECKER_HOME, name=game_name)
except:
message.logWarning("Unable to load webpage, skipping to next match")
continue
if INCLUDE_INPLAY == False:
if len(game_webpage.getClasses("no-arrow in-play")) > 0:
message.logDebug("Game is in play, skipping.")
continue
try:
market_tags = game_webpage.getClasses("market-dd select-wrap")[0].getClasses(
"select-item beta-callout")
except:
message.logWarning("Unable to load market tags, skipping to next match")
continue
market_tags = [m for m in market_tags if m.getName() not in DISALLOWED_MARKETS]
market_tags.reverse()
for market_tag in market_tags:
message.logDebug("Considering market: " + market_tag.getName() + ".")
try:
market_webpage = CWebsite(
sport_home.getHomeURL() + market_tag.getAttr(DEFAULT_LINK_ATTR_NAME),
ODDSCHECKER_HOME, name=game_name + ": " + market_tag.getName())
except:
message.logWarning("Unable to load webpage, skipping to next market")
continue
self._check_website(market_webpage)
def main():
'''
This will initialize the chatbot.
'''
# initialise knowledge base
knowledge = CKnowledgeBase(PATH_TO_DATA)
message.logDebug("Knowledge base loaded.", "main::main")
# initialise nlp module
agent = CQueryEngine(knowledge)
message.logDebug("Agent loaded.", "main::main")
# initialize frontend
frontend = CWebFrontend(agent)
frontend.start()
def check_leagues_for_sport(sport_website):
# Grab all leagues for current sport
league_tags = sport_website.getClasses(["league-component"])
for league_tag in league_tags:
if not league_tag.hasAttr(DEFAULT_LINK_ATTR_NAME):
continue
league_name = league_tag.getName()
message.logDebug("Examining league" + league_name)
try:
# Form the link for the league
league_link = ODDSCHECKER_HOME + league_tag.getAttr(
DEFAULT_LINK_ATTR_NAME).strip("/")
# Create the website object
league_website = CWebsite(league_link,
ODDSCHECKER_HOME,
name=league_name)
# Check all the games for current league
check_games_for_league(league_website)
except:
message.logWarning(
"Unable to load league, skipping to next league")
continue
def run(self):
# Grab all sports
sport_specific_home_tags = self.m_homepage.getClasses(
["sport-menu__link"])
for sport_tag in sport_specific_home_tags:
if not sport_tag.hasAttr(DEFAULT_LINK_ATTR_NAME):
continue
message.logDebug("Examining " + sport_tag.getName().strip() +
" arbitrage opportunities.")
try:
# Form the link
full_sport_link = ODDSCHECKER_HOME + sport_tag.getAttr(
DEFAULT_LINK_ATTR_NAME)
# Create the website object
sport_website = CWebsite(full_sport_link,
ODDSCHECKER_HOME,
name=sport_tag.getName())
# Website object successfully created. Check the sport's leagues
check_leagues_for_sport(sport_website)
except:
message.logWarning(
"Unable to load web page, skipping to next sport")
pass
def _process_desired_event_info(self, input):
"""
Processes desired event info, changes state, and returns response.
:return: tuple response to input.
"""
#remove dupes
aux = []
for e in self._events_list:
if e[HEADLINE_KEY] not in [A[HEADLINE_KEY] for A in aux]:
aux.append(e)
self._events_list = aux
# Embed the input
input_embedding = nlp.embed(input)
# Scrape descriptions for all events and find embeddings for them.
new_ents = []
for event in self._events_list:
if "descriptions_embeddings" in event.keys():
event["descriptions_embeddings_scores"] = [(t[0], t[1], nlp.compare_embeddings(t[1], input_embedding)) \
for t in event["descriptions_embeddings"]]
if len(event["descriptions_embeddings_scores"]) > 0:
new_ents.append(event)
else:
if WEBLINK_KEY in event.keys():
weblink = event[WEBLINK_KEY].replace("\\/", "/")
n_h = self._getNewHeadline(event)
if n_h is not None:
try:
description = ents.scrapeDescription(weblink, n_h)
except:
description = [event[HEADLINE_KEY]]
event["descriptions_embeddings_scores"] = [
(d, nlp.embed(d)) for d in description
]
event["descriptions_embeddings_scores"] = [(t[0], t[1], nlp.compare_embeddings(t[1], input_embedding))\
for t in event["descriptions_embeddings_scores"]]
if len(event["descriptions_embeddings_scores"]) > 0:
new_ents.append(event)
self._events_list = new_ents
# Compare all embeddings to input embedding, keep top in self._event_list
for event in self._events_list:
all_scores = [
e[2] for e in event["descriptions_embeddings_scores"]
]
for d, _, s in event["descriptions_embeddings_scores"]:
if s == min(all_scores):
event["best_scoring_description"] = (d, s)
self._events_list = sorted(
self._events_list,
key=lambda x: min(
[e[2] for e in x["descriptions_embeddings_scores"]]))
self._events_list = self._events_list[0:self._max_events]
for i, event in enumerate(self._events_list):
message.logDebug(
"Best description " + str(i) + ": " +
event["best_scoring_description"][0],
"CEventsEngine::_process_desired_event_info")
self._update.append(
self._make_standard_message(DESIRED_EVENT_FOUND_MESSAGE))
self._transition_states()
if title != text:
text += ": " + title
return text
# Generate the next month's events from the handcoded timetable
new_ents = []
recurring_events = hardcoded.get_all_recurrers(days=90)
events_from_ents = ents.getEventsList()
if PREPROCESS_TYPE == "FULL":
_events_list = ut.merge_events(events_from_ents, recurring_events)
elif PREPROCESS_TYPE == "KNOWLE":
_events_list = ut.merge_events([], recurring_events)
for i, event in enumerate(_events_list):
message.logDebug(
"Parsing event " + str(i) + "/" + str(len(_events_list)) + ".",
"preprocess_events::main")
if WEBLINK_KEY in event.keys():
n_h = _getNewHeadline(event)
if n_h is not None:
try:
weblink = event[WEBLINK_KEY].replace("\\/", "/")
description = ents.scrapeDescription(weblink, n_h)
except:
description = [event[HEADLINE_KEY]]
event["descriptions_embeddings"] = [(d, nlp.embed(d))
for d in description]
if len(event["descriptions_embeddings"]) > 0:
new_ents.append(event)
ut.save(new_ents, FILE_PATH)
def stop(self):
'''Webserver cannot be stopped so this function does nothing.'''
message.logDebug(
"The webserver message loop has no stop function. It will end when the program ends.",
"Cbotuifrontend::stop")
def onDisconnection(sid):
message.logDebug("User '" + sid + "' disconnected.",
"botui_frontend::onDisconnection")
def run_events_bot():
agent = CEventEngine()
message.logDebug("Agent loaded.", "main::main")
# initialize frontend
return CBotUIFrontend(agent)
DEVICE = torch.device("cuda")
else:
DEVICE = torch.device("cpu")
models = {}
for mode in MODES:
file_path = FILE_PATH_PREF + mode + FILE_PATH_END
infile = open(file_path, 'rb')
models[mode] = pickle.load(infile)
infile.close()
# --------------------------------------------------------------
for mode in MODES:
message.logDebug("Testing model trained for mode " + mode + ".",
"main_test::__main__")
model = models[mode]
test_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
TEST_DATA_LOCATION, mode),
batch_size=32,
shuffle=False,
num_workers=0,
pin_memory=True)
validate(model, test_loader)
message.logDebug("Testing model trained for mode TSCNN.",
"main_test::__main__")
def run_event_form():
message.logDebug("Form launched", "main::main")
return
if torch.cuda.is_available():
DEVICE = torch.device("cuda")
else:
DEVICE = torch.device("cpu")
# Set this to 0 for debugging, 8 otherwise.
NUM_WORKERS = 0
LEARNING_RATE = 0.001
# --------------------------------------------------------------
for mode in ['MC', 'LMC', 'MLMC']:
message.logDebug("Begining training on " + mode + " data.",
"main_train::__main__")
LOG_DIR = "logs/" + mode + "/"
train_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
TRAIN_DATA_LOCATION, mode),
batch_size=32,
shuffle=True,
num_workers=NUM_WORKERS,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(UrbanSound8KDataset(
TEST_DATA_LOCATION, mode),
batch_size=32,
shuffle=False,
num_workers=NUM_WORKERS,