def _dispatcher(self): """ Receive messages and route them to functionality. """ while 1: try: response = self._incoming_messages.get(block=True) self._format_incoming(response) now = time.time() # match the event to the best command for command in self.commands[:]: if command.deadline is not False and command.deadline < now: self.unregister_command(command) # silently remove him continue match = command.matches(self, response) if match: command(_SlackBotWrapper(self, response), response, *match.groups()) if command.activations is not False and command.activations <= 0: self.unregister_command(command) except Exception: with util.hilite('red'): traceback.print_exc() print(response) else: try: if u'_logged' not in response: with util.hilite('gray'): print(response) except: print("Wow something went REAL wrong.")
def anon(bot, command): if len(command) >= 2: setting = command[1] bot.config[config_id] = setting != '0' with util.hilite('gray'): print(name, end=": ") config_item = bot.config.get(config_id, default) with util.hilite('green' if config_item else 'red'): print(config_item)
def log_presence_change(bot, msg): """ Print to the terminal that a user has changed presence. """ msg[u'_logged'] = True with autoflush(bot), util.hilite('gray'): print('{} is now '.format(msg[u'user_name']), end='') color = { u'active': 'green', u'away': 'yellow', }[msg[u'presence']] with util.hilite(color): print(msg[u'presence'], end='') print(".")
def log_new_user(bot, msg): msg[u'_logged'] = True user = msg[u'user'] with autoflush(bot): with util.hilite('cyan'): print(user[u'name'], end=" ") print("({}) has joined the team!".format(user[u'real_name']))
def log_user_change(bot, msg): if msg[u'user'][u'deleted'] is True: msg[u'_logged'] = True with autoflush(bot): with util.hilite('cyan'): print(msg[u'name'], end=" ") print("has left the team.")
def cli_input(bot, msg): bot.set_debug_fn(_get_debug_fn(bot)) current_thread = threading.current_thread() _setup_autocompletion(bot) command_list = { 'bot': _bot, 'channel': _channel, 'show_typing': _config_boolean('show_typing', "Show typing", False), 'terminal_ping': _config_boolean('terminal_ping', "Terminal ping", True), } while 1: try: message = raw_input(get_cli_prefix(bot)) print("\033[A\033[K", end='\r') # Clear the raw_input line. if current_thread.stopped(): return if message[:1] == "/": command = message.split() command_list.get(command[0][1:], _unknown_command)(bot, command) else: bot.say(message, channel=bot.config['send_channel']) except: with util.hilite('red'): print("Error on output:") traceback.print_exc()
def log_starred(bot, msg): item = msg[u'item'] if item[u'type'] in ['message', 'channel', 'file', 'im']: with autoflush(bot): msg[u'_logged'] = True with util.hilite('yellow'): print(msg[u'user_name'], end=" starred ") _print_star_info(bot, msg)
def _channel(bot, command): if len(command) == 1: print("Currently sending to", end=' ') else: bot.config['send_channel'] = command[1] print("Set channel to", end=' ') with util.hilite('cyan'): print(bot.config['send_channel'], end='') print(".")
def log_starred(bot, msg): item = msg[u'item'] if item[u'type'] == 'message': msg[u'_logged'] = True message = item[u'message'] with util.hilite('yellow'): print(msg[u'user_name'], end=" starred ") _log_message( bot, bot.get_channel_name(item[u'channel']), bot.get_nick(message[u'user']), message[u'text'], ) elif item[u'type'] == 'channel': msg[u'_logged'] = True channel = item[u'channel'] with util.hilite('yellow'): print(msg[u'user_name'], end=" starred ") with util.hilite('purple'): print(bot.get_channel_name(channel))
def log_message_delete(bot, msg): msg[u'_logged'] = True with autoflush(bot): with util.hilite('cyan'): _log_message( bot, msg[u'channel_name'], "", util.hilite_string( 'gray', "Deleted message from {}.".format(msg[u'deleted_ts'])), )
def _print_star_info(bot, msg): item = msg[u'item'] if item[u'type'] == 'message': message = item[u'message'] _log_message( bot, bot.get_channel_name(item[u'channel']), bot.get_nick(message[u'user']), message[u'text'], ) elif item[u'type'] in ('channel', 'im'): channel = item[u'channel'] with util.hilite('purple'): print(bot.get_channel_name(channel)) elif item[u'type'] == 'file': sent_file = item[u'file'] message = sent_file[u'permalink_public'] with util.hilite('purple'): print(bot.get_nick(sent_file[u'user']), end=" ") with util.hilite('blue'): print(message)
def log_typing(bot, msg): """ Print to the terminal that a user is typing. Note that if the bot config `show_typing` is False nothing will be logged. """ msg[u'_logged'] = True if bot.config.get('show_typing'): with util.hilite('gray'): if msg[u'channel_name']: print('{} is typing in {}.'.format(msg[u'user_name'], msg[u'channel_name'])) else: print('{} is typing to you.'.format(msg[u'user_name']))
def log_message_changed(bot, msg): """ Print to the terminal that a user's message has been edited. Note that this does not necessarily mean the user has edited their message. Automatic unfurling in particular is handled via message_changed. """ msg[u'_logged'] = True with util.hilite('gray'): print("edited", end=" ") message = msg[u'message'] _log_message( bot, msg[u'channel_name'], bot.get_nick(message[u'user']), message[u'text'], )
def cli_input(bot, msg): while 1: try: message = raw_input() if message[:1] == "/": command = message.split() if command[0] == "/channel": _channel(bot, command) elif command[0] == "/show_typing": _show_typing(bot, command) elif command[0] == "/bot": _bot(bot, command) else: bot.say(message, channel=bot.config['send_channel']) except: with util.hilite('red'): print("Error on output:") traceback.print_exc()
def load_module(self, name, filename=None): """ Load a module, overwriting the previous module if possible Return an Exception, or None if no exception. """ if filename is None: filename = self.get_module_path(name) cmds = self.commands[:] # backup the commands (in case of failure) module_cmds = None if name in modules.register.modules: # unload the old module to make room for the new one, but remember it # in case something goes wrong when loading the new module. module_cmds = self.unload_module(name) try: # commands are registered automatically module = imp.load_source(name, filename) # # If you decide to use a setup method uncomment this, # # although actually it would probably be better as an # # explicit decorator. Ones for 'onload', 'onunload', # # stuff like that. # if hasattr(module, "setup"): # module.setup() except Exception as e: with util.hilite('red'): traceback.print_exc() print("Error loading {}: {} (in bot.py)".format(name, e), file=sys.stderr) self.commands = cmds # replace commands' previous state if module_cmds is not None: modules.register.load_module( name, module_cmds) # reload module's previous state elif name in modules.register.modules: # loaded a couple commands modules.register.unload_module(name) return e else: commands = modules.register.module(name) if commands is not None: self.register_commands(commands) return None
def compute_observability(self, meteo, cwvalidity=30, cloudscheck=True, verbose=True, displayall=True, future=False): """ Update the status using :meth:`~obs.Observable.update`. Compute the observability param, a value between 0 and 1 that tells if the target can be observed at a given time. Also define flags for each parameter (moon, wind, etc...) The closer to 1 the better 0 is impossible to observe :param meteo: a Meteo object, whose time attribute has been actualized beforehand :param cwvalidity: float, current weather validity: time (in minutes) after/before which the allsky cloud coverage and wind are not taken into account in the observability, effectively setting the future variable to True :param verbose: boolean, displaying the status of the observable according to the present function :param displayall: boolean, if verbose is True, then print also the targets that are not observable. :param future: boolean, if set to True then cloud coverage and wind are note taken into account in the observability. """ if SETTINGS["misc"]["singletargetlogs"] == "True": logger.debug("Computing observability for {}...".format(self.name)) logger.info("Current time is %s" % meteo.time) self.update(meteo=meteo) observability = 1 # by default, we can observe if np.abs(meteo.time - Time.now()).to(u.s).value / 60. > cwvalidity: future=True # Let's start with a simple yes/no version # We add a small message to display if it's impossible to observe: msg = '' warnings = '' ### General conditions: # Each condition has an associated bool flag to tell if it is respected or not # Not respected conditions decrease the overall observability by a given amount # todo: configure the observability amount decrease in the obsprogram files. # check the moondistance: self.obs_moondist = True if self.angletomoon.degree < self.minangletomoon: observability *= 0.8 self.obs_moondist = False msg += '\nMoonDist:%0.1f' % self.angletomoon.degree # high airmass self.obs_highairmass = True if self.airmass > 1.5: self.obs_highairmass = False observability *= 0.7 msg += '\nAirmass:%0.2f' % self.airmass # check the airmass: self.obs_airmass = True if self.airmass > self.maxairmass: self.obs_airmass = False observability = 0 msg += '\nAirmass:%0.2f' % self.airmass # check the wind: self.obs_wind, self.obs_wind_info = True, True if not future: if meteo.windspeed > 0. and meteo.windspeed < 100. and self.angletowind is not None: if self.angletowind.degree < 90 and meteo.windspeed >= float(meteo.location.get("weather", "windWarnLevel")): self.obs_wind = False observability = 0 msg += '\nWA:%0.1f/WS:%0.1f' % (self.angletowind.degree, meteo.windspeed) if meteo.windspeed >= float(meteo.location.get("weather", "windLimitLevel")): self.obs_wind = False observability = 0 msg += '\nWS:%s' % meteo.windspeed else: self.obs_wind_info = False warnings += '\nNo wind info' else: self.obs_wind_info = False # check the clouds self.obs_clouds, self.obs_clouds_info = cloudscheck, True if not future: if cloudscheck: self.is_cloudfree(meteo) if self.cloudfree <= 0.5 : self.obs_clouds = False warnings += '\nWarning ! It might be cloudy' observability = 0 elif self.cloudfree <= 0.9: self.obs_clouds = False msg += '\nCould be cloud-free' observability *= self.cloudfree elif self.cloudfree <= 1.: msg += '\nShould be cloud-free' else: self.obs_clouds_info = False warnings += '\nNo cloud info' #print("no cloud info") else: self.obs_clouds_info = False warnings += '\nNo cloud info' else: self.obs_clouds_info = False # check the internal observability flag self.obs_internal = True if hasattr(self, 'internalobs'): if self.internalobs == 0: self.obs_internal = False observability = self.internalobs msg += '\nSpreadsheet NO' ### Program specific conditions: pobs, pmsg, pwarn = self.program.observability(self.attributes, meteo.time) if pobs == 0: observability = 0 msg += pmsg warnings += pwarn # Finally, add the eventuel comment: if hasattr(self, 'comment'): msg += '\n %s' % self.comment to_print = "%s | %s\nalpha=%s, delta=%s\naz=%0.2f, alt=%0.2f%s" % (self.name, meteo.time.iso, self.alpha, self.delta, rad2deg(self.azimuth.value), rad2deg(self.altitude.value), msg) if verbose: if observability == 1: print((util.hilite(to_print, True, True))) if not warnings == '': print((util.hilite(warnings, False, False))) print(("="*20)) else: if displayall: print((util.hilite(to_print, False, False))) if not warnings == '': print((util.hilite(warnings, False, False))) print(("="*20)) else: pass else: # then we send the print message to the logger if SETTINGS["misc"]["singletargetlogs"] == "True": logger.info(to_print) self.observability = observability
def log_image(bot, msg): permalink = msg[u'file'].get(u'permalink_public') if permalink: msg[u'_logged'] = True with autoflush(bot), util.hilite('blue'): print(permalink)
def _log_message(bot, channel, user, text): with util.hilite('cyan'): print(channel, end=' ') with util.hilite('purple'): print(user, end=' ') print(_format_text(bot, text))
def _unknown_command(bot, command): with util.hilite('gray'): print("Unknown command '{}'".format(command[0]))