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,