def user_left_chat(self, event): log.debug("user_left_chat %s" % event) idd = self.build_identifier(event['from'].full) p = Presence(chatroom=idd, nick=idd.resource, status=OFFLINE) self.callback_presence(p)
def user_left_chat(self, event): log.debug("user_left_chat %s", event) self.callback_presence( Presence(identifier=self._idd_from_event(event), status=OFFLINE))
def contact_offline(self, event): log.debug("contact_offline %s" % event) p = Presence(identifier=self.build_identifier(event['from'].full), status=OFFLINE) self.callback_presence(p)
def _hello_event_handler(self, event): """Event handler for the 'hello' event""" self.connect_callback() self.callback_presence( Presence(identifier=self.bot_identifier, status=ONLINE))
def contact_offline(self, event): log.debug("contact_offline %s.", event) self.callback_presence( Presence(identifier=self._idd_from_event(event), status=OFFLINE))
def serve_once(self): """ Run the bot until the connection is disconnected. :return: None. """ # Log message self._log_debug('# ----- serve_once -----') # Log message self._log_debug(('# ----- Create meteor client -----\n' 'SERVER_URI: {}').format(self._server_uri)) # Create meteor client self._meteor_client = MeteorClient( self._server_uri, # Disable the meteor client's auto reconnect. # Let `serve_forever` handle reconnect. auto_reconnect=False, ) # Log message self._log_debug('# ----- Hook meteor client callbacks -----') # 5DI82 # Hook meteor client `connected` callback self._meteor_client.on('connected', self._meteor_connected_callback) # 2RAYF # Hook meteor client `changed` callback self._meteor_client.on('changed', self._meteor_changed_callback) # 4XIZB # Hook meteor client `added` callback self._meteor_client.on('added', self._meteor_added_callback) # 2JEIK # Hook meteor client `removed` callback self._meteor_client.on('removed', self._meteor_removed_callback) # 32TF2 # Hook meteor client `failed` callback self._meteor_client.on('failed', self._meteor_failed_callback) # 5W6RX # Hook meteor client `reconnected` callback self._meteor_client.on('reconnected', self._meteor_reconnected_callback) # 7MOJX # Hook meteor client `closed` callback self._meteor_client.on('closed', self._meteor_closed_callback) # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ----- Connect to meteor server -----') try: # Connect to meteor server. # # If the connecting succeeds, the meteor client's thread will call # `self._meteor_connected_callback` hooked at 5DI82. The login, # topic subscribing, and message handling are run in that thread. # # The main thread merely waits until the meteor client is closed, # meanwhile it calls heartbeat function at interval if specified. # self._meteor_client.connect() # If have error except: # Log message self._log_debug('# ----- Connecting failed -----') # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference self._meteor_client = None # The two events below should not have been set if the connecting # failed. Just in case. # # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Raise the error raise # Get whether heartbeat is enabled heartbeat_enabled = self._get_bool_config( CONFIG_KEYS.HEARTBEAT_ENABLED) try: # Wait until the topic subscribing is done in another thread at # 5MS7A self._subscribing_done_event.wait() # If heartbeat is enabled if heartbeat_enabled: # Get heartbeat function heartbeat_func = self._get_config(CONFIG_KEYS.HEARTBEAT_FUNC) # Assert the function is callable assert callable(heartbeat_func), repr(heartbeat_func) # Get heartbeat interval heartbeat_interval = self._get_config( CONFIG_KEYS.HEARTBEAT_INTERVAL, default=10, ) # Convert heartbeat interval to float heartbeat_interval = float(heartbeat_interval) # 65ZNO # Loop until the meteor client is disconnected while self._meteor_client.connected: # Send heartbeat heartbeat_func(self) # Sleep before sending next heartbeat time.sleep(heartbeat_interval) # 5W6XQ # Wait until the meteor client is closed and the `closed` callback # is called at 3DMYH self._meteor_closed_event.wait() # If have error except: # Close meteor client. # # This will cause `self._meteor_closed_callback` to be called, # which will set the `self._meteor_closed_event` below. # self._meteor_client.close() # See 5W6XQ self._meteor_closed_event.wait() # Raise the error raise # Always do finally: # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference. # # Do this before calling `callback_presence` below so that the # plugins will not be able to access the already closed client. # self._meteor_client = None # Log message self._log_debug('# ----- Call `callback_presence` -----') # Call `callback_presence` self.callback_presence( Presence(identifier=self.bot_identifier, status=OFFLINE)) # Log message self._log_debug('# ----- Call `disconnect_callback` -----') # Call `disconnect_callback` to unload plugins self.disconnect_callback() # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ===== serve_once =====')
def user_joined_chat(self, event): log.debug("user_join_chat %s" % event) idd = self.build_identifier(event['from'].full) p = Presence(identifier=idd, status=ONLINE) self.callback_presence(p)
def user_joined_chat(self, event): log.debug('user_join_chat %s', event) self.callback_presence( Presence(identifier=self._idd_from_event(event), status=ONLINE))
def serve_forever(self): self.readline_support() if not self._rooms: # artificially join a room if None were specified. self.query_room('#testroom').join() if self.demo_mode: # disable the console logging once it is serving in demo mode. root = logging.getLogger() root.removeHandler(console_hdlr) root.addHandler(logging.NullHandler()) self.connect_callback() # notify that the connection occured self.callback_presence(Presence(identifier=self.user, status=ONLINE)) self.send_message(Message(INTRO)) try: while True: if self._inroom: frm = TextOccupant(self.user, self.rooms[0]) to = self.rooms[0] else: frm = self.user to = self.bot_identifier print() full_msg = '' while True: prompt = '[␍] ' if full_msg else '>>> ' if ANSI or self.demo_mode: color = fg.red if self.user.person in self.bot_config.BOT_ADMINS[ 0] else fg.green prompt = f'{color}[{frm} ➡ {to}] {fg.cyan}{prompt}{fx.reset}' entry = input(prompt) else: entry = input(f'[{frm} ➡ {to}] {prompt}') if not self._multiline: full_msg = entry break if not entry: break full_msg += entry + '\n' msg = Message(full_msg) msg.frm = frm msg.to = to self.callback_message(msg) mentioned = [ self.build_identifier(word) for word in re.findall(r'(?<=\s)@[\w]+', entry) ] if mentioned: self.callback_mention(msg, mentioned) sleep(.5) except EOFError: pass except KeyboardInterrupt: pass finally: # simulate some real presence self.callback_presence( Presence(identifier=self.user, status=OFFLINE)) log.debug("Trigger disconnect callback") self.disconnect_callback() log.debug("Trigger shutdown") self.shutdown()
def on_connection_status(self, friend_number, status): logging.debug("TOX: user %s changed connection status", friend_number) pres = Presence(identifier=self.friend_to_idd(friend_number), status=ONLINE if status else OFFLINE) self.backend.callback_presence(pres)
def contact_online(self, event): log.debug('contact_online %s.', event) self.callback_presence( Presence(identifier=self._idd_from_event(event), status=ONLINE))
def on_status_message(self, friend_number, message): pres = Presence(identifier=self.friend_to_idd(friend_number), message=message) self.backend.callback_presence(pres)
def on_user_status(self, friend_number, kind): logging.debug("TOX: user %s changed state", friend_number) pres = Presence(identifier=self.friend_to_idd(friend_number), status=TOX_TO_ERR_STATUS[kind]) self.backend.callback_presence(pres)
def contact_offline(self, event): logging.debug("contact_offline %s" % event) p = Presence(identifier=Identifier(str(event['from'])), status=OFFLINE) self.callback_presence(p)
def user_left_chat(self, event): logging.debug("user_left_chat %s" % event) idd = Identifier(str(event['from'])) p = Presence(chatroom=idd, nick=idd.resource, status=OFFLINE) self.callback_presence(p)
def serve_forever(self): self.readline_support() # Add custom commands just for this backend. self.inject_commands_from(TextPlugin(self, 'TextPlugin')) if not self._rooms: # artificially join a room if None were specified. self.query_room('#testroom').join() if self.demo_mode: # disable the console logging once it is serving in demo mode. root = logging.getLogger() root.removeHandler(console_hdlr) root.addHandler(logging.NullHandler()) self.connect_callback() # notify that the connection occured self.callback_presence(Presence(identifier=self.user, status=ONLINE)) self.send_message(Message(INTRO)) try: while True: if self._inroom: frm = TextOccupant(self.user, self.rooms[0]) to = self.rooms[0] else: frm = self.user to = self.bot_identifier print() multiline = '' while True: prompt = '[␍] ' if multiline else '>>> ' if ANSI or self.demo_mode: color = fg.red if self.user.person in self.bot_config.BOT_ADMINS[0] else fg.green entry = input(str(color) + '[%s ➡ %s] ' % (frm, to) + str(fg.cyan) + prompt + str(fx.reset)) else: entry = input('[%s ➡ %s] ' % (frm, to) + prompt) if not entry: break multiline += entry + '\n' msg = Message(multiline) msg.frm = frm msg.to = to self.callback_message(msg) mentioned = [self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", entry) if word.startswith('@')] if mentioned: self.callback_mention(msg, mentioned) sleep(.5) except EOFError: pass except KeyboardInterrupt: pass finally: # simulate some real presence self.callback_presence(Presence(identifier=self.user, status=OFFLINE)) log.debug("Trigger disconnect callback") self.disconnect_callback() log.debug("Trigger shutdown") self.shutdown()