def __init__(self, user_database): self.user_database = user_database self._clients = set() self.last_message_sender = '' self.user_list = [] self.fernet = Fernet(FERNET_KEY) self.command_handler = CommandHandler(user_database, self.fernet)
def register_selected_shortcut(name, old_clipboard): """Retrieve the text/filename from the clipboard and register it as a new command.""" clipboard = QtGui.QApplication.clipboard() clipboard.dataChanged.disconnect() clipboard_timer.stop() urls = clipboard.mimeData().urls() text = clipboard.text() if list(old_clipboard.formats()): # Check if the old clipboard MIME object contains any data CommandHandler.main_gui.call(clipboard.setMimeData, [old_clipboard]) # Restore the old clipboard contents if text: # The clipboard contains text shortcut = unicode(text) elif urls: # The clipboard contains a file shortcut = unicode(urls[0].toString())[8:].replace("/", "\\") else: message("Unable to register the selection as a shortcut", "Error") return shortcuts_dict = load_shortcuts() # Load shortcuts from the config file if name.decode("utf-8") not in shortcuts_dict: keyword = "registered" else: keyword = "updated" CommandHandler.remove(name) # Delete the existing command register_shortcut(name, shortcut) # Register the new command shortcuts_dict.update({name.decode("utf-8"): shortcut}) # Update with new shortcut save_shortcuts(shortcuts_dict) # Write back to the file message("Shortcut %s: [i]%s[/i]\nTarget: [i]%s[/i]" % (keyword, name.decode("utf-8"), shortcut), "Success")
def test_help(self): handler = CommandHandler() room = Chatroom("../config/test_config/chat.yaml") socket = Mwsc() user = User(socket, "Test") test_helper.sync(handler.handle_command("!help", user, room)) self.assertTrue("!help" in user.websocket.incoming[-1])
def __init__(self, plugin, window): self.window = window self.plugin = plugin self.command_handler = CommandHandler() self.set_status() for view in window.get_views(): self.connect_handlers(view) window.connect('tab_added', self.on_tab_added)
def test_is_command(self): handler = CommandHandler() valid = ["!valid", "!help", "!valid with args"] invalid = ["message", "message 2", "message!", "!", "message !three"] for s in valid: self.assertTrue(handler.is_command(s)) for s in invalid: self.assertFalse(handler.is_command(s))
def __init__(self, chat_config_path): """ Create a new Chatroom Args: chat_config_path (str): path to chat config yaml """ # Dict[Websocket, User] self.connected = dict() self.command_handler = CommandHandler() self.config = ConfigManager(chat_config_path) self.name_generator = AdjAnimalNameGenerator( self.config["name_generator"]["adjective_path"], self.config["name_generator"]["animal_path"]) self.env = self.config["meta"]["enviornment"]
def __response(self, line, client): """ Manages incoming lines """ parser = Parser() response = "" if not parser.parse(line): response = f"Command corrupted: {line}" else: handler = CommandHandler(self.__root_directory) instruction = parser.instruction(line) if instruction == "up": response = self.__receive_file(client, handler) elif instruction == "down": response = self.__send_file(line, client, handler) else: response = handler.execute(line) return response
def __init__(self, servers, channels, name, password = ""): self.s = {}#IRC socket self.commandHandler = CommandHandler(self) self.user = name[0]#user self.nick = name[1]#nick self.readBuffer = ""#leftover from last block for partial IRC messages self.sendBuffer = b"" self.serverList = servers self.channels = channels self.users = {} self.password = password
def remove_shortcut(name=None): if name is None: # Register subcommands shortcuts_dict = load_shortcuts() return [key.encode("utf-8") for key in shortcuts_dict] elif name == "": message("Press tab to select a shortcut to remove", "Error") else: if CommandHandler.remove(name): shortcuts_dict = load_shortcuts() # Load shortcuts from the config file shortcuts_dict.pop(name.decode("utf-8")) # Remove shortcut save_shortcuts(shortcuts_dict) # Write back to the file message("Shortcut removed: [i]%s[/i]" % name.decode("utf-8"), "Success") else: message("Unable to remove shortcut: [i]%s[/i]" % name.decode("utf-8"), "Error")
def __init__( self, config: Config, store: Storage, github: Github, repo: Repository, ): self.config = config self.github = github self.repo = repo self.command_handler = CommandHandler(config, store, repo) # Start a flash webserver self.app = Flask(__name__) webhook = Webhook( self.app, endpoint=self.config.webhook_path, secret=self.config.webhook_secret, ) @self.app.route("/") def hello_world(): return "Hello, world!" @webhook.hook("issue_comment") def on_issue_comment(data): log.debug( f"Got comment: {json.dumps(data, indent=4, sort_keys=True)}") self._process_comment(data) @webhook.hook("pull_request_review_comment") def on_pull_request_review_comment(data): log.debug( f"Got PR review comment: {json.dumps(data, indent=4, sort_keys=True)}" ) self._process_comment(data)
def run(self): self.log = logger_config.instance cache.log = self.log try: with open(config.DB_FILENAME, 'rb') as fp: self.db = pickle.load(fp) except: self.log.error("error loading db, defaulting to empty db") self.db = {} self.api = TgApi(self.log) self.repository = MarketRepository(self.log) self.command_handler = CommandHandler(self.api, self.repository, self.db, self.log) self.log.debug("db at start: {}".format(self.db)) self.last_update = self.db[ 'last_update'] if 'last_update' in self.db else 0 # main loop loop = True while loop: try: updates = self.api.getUpdates(self.last_update) if updates is None: self.log.error('get update request failed') else: self.processUpdates(updates) try: self.processAlerts() except: self.log.exception("exception at processing alerts") time.sleep(1) except KeyboardInterrupt: self.log.info("interrupt received, stopping…") loop = False except: self.log.exception("exception at processing updates") loop = False self.persist_db() cache.persist()
import logging from aiogram import Bot, Dispatcher, executor, types import config from command_handler import CommandHandler from constants import CAPTCHA_SUCCESS from new_members_handler import NewMembersHandler from text_handler import TextHandler logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger(__name__) bot = Bot(token=config.ACCESS_TOKEN, ) dp = Dispatcher(bot=bot, ) textHandler = TextHandler() commandHandler = CommandHandler() newMembersHandler = NewMembersHandler(bot) @dp.message_handler(content_types=types.ContentType.NEW_CHAT_MEMBERS) async def process_new_member(message: types.Message): await newMembersHandler.handle(message) @dp.callback_query_handler(lambda callback: True) async def process_callback(callback: types.CallbackQuery): if callback.message: if callback.data == CAPTCHA_SUCCESS: await newMembersHandler.handleCaptchaCallback(callback)
class Chatroom: """ Chatroom manager for websocket based connections """ def __init__(self, chat_config_path): """ Create a new Chatroom Args: chat_config_path (str): path to chat config yaml """ # Dict[Websocket, User] self.connected = dict() self.command_handler = CommandHandler() self.config = ConfigManager(chat_config_path) self.name_generator = AdjAnimalNameGenerator( self.config["name_generator"]["adjective_path"], self.config["name_generator"]["animal_path"]) self.env = self.config["meta"]["enviornment"] @log(logger, logging.INFO) async def handle_connection(self, websocket, name=None): """ Registers a new websocket connection and notifies users Args: websocket (Websocket): new connection websocket """ name = name if name is not None else self.generate_name() user = User(websocket, name) self.connected[websocket] = user await self.send(Response(self.get_greeting(name), Origin.SERVER), websocket) await self.send_to_all( Response(self.get_connection_notification(name), Origin.SERVER), websocket) @log(logger, logging.INFO) async def handle_message(self, websocket, message): """ Handles incoming message: If it is a message, send to all users. If it is a command, process it Args: websocket (Websocket): websocket that sent message message (str): message sent """ user = self.connected[websocket] if self.command_handler.is_command(message): await self.command_handler.handle_command(message, user, self) return body = f"{user.name}: {message}" all_response = Response(body, Origin.USER) sender_response = Response(body, Origin.SELF) await self.send_to_all(all_response, websocket) await self.send(sender_response, websocket) @log(logger, logging.INFO) async def handle_disconnect(self, websocket): """ handles disconnect of websocket and notifies all connections Args: websocket (Websocket): Connection that was closed """ user = self.connected.pop(websocket) await self.send_to_all( Response(self.get_disconnect_notification(user.name), Origin.SERVER)) @log(logger, logging.INFO) async def send(self, response, websocket): """Send a response to a websocket Args: response (Response): The Response to send websocket (Websocket): The websocket to send the Response to """ if not isinstance(response, Response): log_message( f"Outgoing: {response} is not of type Response, preventing send", logging.CRITICAL) return if response.data["origin"] == Origin.DEFAULT: log_message(f"Outgoing response has DEFAULT origin", logging.WARNING) await websocket.send(response.json()) @log(logger, logging.INFO) async def send_to_all(self, response, skip={}): """ Send a message to all connected clients, except those in skip Args: response (Response): Response to send to all connections skip (set, optional): Union[Websocket, Iterable[Websocket]] to skip. Defaults to {}. """ if not isinstance(skip, Iterable): skip = {skip} for websocket in self.connected: if websocket not in skip: await self.send(response, websocket) @log(logger, logging.CRITICAL) async def handle_shutdown(self): """ Notifies all clients of shutdown and closes their connections """ await self.send_to_all( Response(self.get_shutdown_notification(), Origin.SERVER)) for conn in self.connected.keys(): await conn.close() @log(logger, logging.INFO) async def change_name(self, websocket, new_name): """ Changes name of user connected with websocket to new_name Args: websocket (Websocket): connection to change name of new_name (str): new name for user """ old_name = self.connected[websocket].name # sanitize by removing all whitespace new_name = "".join(new_name.split()) self.connected[websocket].name = new_name await self.send_to_all( Response(self.get_name_change_notification(old_name, new_name), Origin.SERVER)) @log(logger, logging.INFO) async def private_message(self, message, from_websocket, to_websocket): outgoing = Response( self.get_outgoing_pm(message, self.connected[from_websocket].name), Origin.PRIVATE) receipt = Response( self.get_pm_receipt(message, self.connected[to_websocket].name), Origin.PRIVATE) await self.send(outgoing, to_websocket) await self.send(receipt, from_websocket) def generate_name(self): """ Generate an initial name for a new client Returns: str: Randomly generated name """ return self.name_generator.generate_name() def get_greeting(self, name): """ Generates greeting str for new connection Args: name (str): client name of new connection Returns: str: greeting for new connection """ return Template(self.config["greeting_temp"]).substitute(name=name) def get_connection_notification(self, name): """ Generates notification str for a new connection Args: name (str): name of new connection client Returns: str: notification for clients """ return Template(self.config["conn_notif_temp"]).substitute(name=name) def get_disconnect_notification(self, name): """ Generates disconnect notification str for disconnected client Args: name (str): name of disconnected client Returns: str: notification for clients """ return Template( self.config["disconn_notif_temp"]).substitute(name=name) def get_name_change_notification(self, old_name, new_name): """ Generates name change notification Args: old_name (str): old name, before change new_name (str): new name, after change Returns: str: notification for clients """ return Template(self.config["namechange_notif_temp"]).substitute( old=old_name, new=new_name) def get_shutdown_notification(self): """ Generates server shutdown notification Returns: str: notification for clients """ return self.config["shutdown_notif_temp"] def get_outgoing_pm(self, message, from_name): return Template(self.config["private_messate_from_temp"]).substitute( from_name=from_name, message=message) def get_pm_receipt(self, message, to_name): return Template(self.config["private_message_to_temp"]).substitute( to_name=to_name, message=message) def __repr__(self): return f"<Chatroom, connections: {len(self.connected)}>"
def run_simulation(): my_sim = FlightSimulator() my_commander = CommandHandler(command_poster_fn=my_sim.post_command) my_sim.set_commander(my_commander) my_commander.initialize_sdk() my_commander.take_off() my_commander.right(20) my_commander.rotate_clockwise(15) my_commander.land() my_commander.take_off() my_commander.rotate_clockwise(15) print('\n\n\ntracing route back...\n\n\n') my_commander.track_back() print('flight logs saved to logs')
def register_shortcut(name, path): CommandHandler.register(name.encode("utf-8"), CommandHandler.run, [path.encode("utf-8")], label='Shortcut', priority=1)
# -*- coding: utf-8 -*- from command_handler import CommandHandler import thread import time com = CommandHandler() while com.handle(): time.sleep(0.5)
def google(query=None): if query is None: # Register subcommands return google_suggest elif query != "Google...": # Terrible attempt at a fix CommandHandler.reset_mode() CommandHandler.run("https://www.google.co.uk/search?q=" + query)
def main(): main_parser = argparse.ArgumentParser(prog="cosmicpi", description="CosmicPi acquisition process", add_help=False) main_parser.add_argument("--config", help="Path to configuration file", default="/etc/cosmicpi.yaml") args, remaining_argv = main_parser.parse_known_args() # Merge the default config with the configuration file config = load_config(args.config) # Parse the command line for overrides parser = argparse.ArgumentParser(parents=[main_parser]) parser.set_defaults(**config) parser.add_argument("-i", "--host", **arg("broker.host", "Message broker host")) parser.add_argument("-p", "--port", **arg("broker.port", "Message broker port", type=int)) parser.add_argument("-a", "--username", **arg("broker.username", "Message broker username")) parser.add_argument("-b", "--password", **arg("broker.password", "Message broker password")) parser.add_argument("-n", "--no-publish", **arg("broker.enabled", "Disable event publication")) parser.add_argument("-u", "--usb", **arg("usb.device", "USB device name")) parser.add_argument("-d", "--debug", **arg("debug", "Enable debug mode")) parser.add_argument("-o", "--log-config", **arg("logging.config", "Path to logging configuration")) parser.add_argument("-l", "--no-log", **arg("logging.enabled", "Disable file logging")) parser.add_argument("-v", "--no-vib", **arg("monitoring.vibration", "Disable vibration monitoring")) parser.add_argument("-w", "--no-weather", **arg("monitoring.weather", "Disable weather monitoring")) parser.add_argument("-c", "--no-cosmics", **arg("monitoring.cosmics", "Disable cosmic ray monitoring")) parser.add_argument("-k", "--patk", **arg("patok", "Server push notification token")) options = parser.parse_args() log_config = options.logging["config"] print ("INFO: using logging configuration from %s" % log_config) logging.config.fileConfig(log_config, disable_existing_loggers=False) console = logging.getLogger(__name__) if options.debug: print_config(options) try: publisher = EventPublisher(options) except: console.error("Exception: Can't connect to broker") sys.exit(1) try: usb = UsbHandler(options.usb['device'], 9600, 60) usb.open() except Exception as e: console.error("Exception: Can't open USB device: %s" % e) sys.exit(1) detector = Detector(usb, publisher, options) try: detector.start() command_handler = CommandHandler(detector, usb, options) command_handler.start() while True: time.sleep(1) except Exception as e: console.info("Exception: main: %s" % e) traceback.print_exc() finally: detector.stop() console.info("Quitting ...") time.sleep(1) usb.close() publisher.close() sys.exit(0)
def __init__(self): self.command_handler = CommandHandler()
def main(): ch = CommandHandler() while True: result = ch.handle_command(input('>>>')) if result: print(result)
import discord import diy_parser from command_handler import CommandHandler import os token = os.environ['TOKEN'] color = 16098851 client = discord.Client() diy_list = diy_parser.get_diy_masterlist() ch = CommandHandler(client) # Not entirely sure what this method does but it was in the tutorial and I'm afraid to remove it @client.event async def on_ready(): print('We have logged in as {0.user}'.format(client)) # Method for sending message when author message starts with !diy @client.event async def on_message(message): if message.author == client.user: return if message.content.startswith('!ribbot'): await ch.command_handler(message) # ==================== # describe diy
class IRCModule: def __init__(self, servers, channels, name, password = ""): self.s = {}#IRC socket self.commandHandler = CommandHandler(self) self.user = name[0]#user self.nick = name[1]#nick self.readBuffer = ""#leftover from last block for partial IRC messages self.sendBuffer = b"" self.serverList = servers self.channels = channels self.users = {} self.password = password def connect(self, host=None): self._connect(host if host else servers[0]) def reconnect(self, host = None): if host == None: for server in self.serverList: if self.reconnect(server): return True logger.warning("Reconnect failed") return False else: logger.info("Reconnecting to",host) return self._connect(host) def _connect(self, host): try: self.s = socket.create_connection(host, SM__CONNECT_TIMEOUT) except socket.gaierror as err: logger.warning("Failed to resolve hostname:",host) return False except socket.timeout as err: logger.warning("Timed out connecting to IRC:",host) return False except OSError as err: logger.debug(err) return False self.s.setblocking(0) def _quitScrap(self, *args): pass self.commandHandler.add("QUIT", _quitScrap) def _nickScrap(self, *args): pass self.commandHandler.add("NICK", _nickScrap) def _partScrap(self, *args): pass self.commandHandler.add("PART", _partScrap) def _joinScrap(self, *args): pass self.commandHandler.add("JOIN", _joinScrap) def _kickScrap(self, *args): pass self.commandHandler.add("KICK", _kickScrap) def _onPing(self, prefix, server1, server2 = ""): self.sendCommand("PONG :"+server1) self.commandHandler.add("PING", _onPing) def _joinScrap(self, *args): self.joinChannels() self.commandHandler.removeTagged("joinChannels") self.commandHandler.addTagged("001", _joinScrap, "joinChannels") if False:#add ghosting support later def _ghostScrap(self, *args): pass self.commandHandler.addTagged("433", _ghostScrap, "joinChannels") if self.password != "": self.sendCommand("PASS "+self.password) self.sendCommand("NICK "+self.nick) self.sendCommand("USER "+self.user+" 0 * :me") return True def disconnect(self, reason = "Because reasons."): self.commandHandler.reset() self.sendCommand("QUIT :"+reason) self.s.shutdown(1)#change to 3? self.s.close() self.s = {} def prepareNameQuery(self, channel): self.users[channel.upper()] = [] handlerTag = "join "+channel def _getNames(self, prefix, me, equals, _channel, names): if channel.upper() == _channel.upper(): self.users[channel.upper()].append(names.split()) def _endNames(self, *args): self.commandHandler.removeTagged(handlerTag) self.commandHandler.addTagged("343", _getNames, handlerTag) self.commandHandler.addTagged("366", _endNames, handlerTag) def joinChannels(self): for channel in self.channels: self.prepareNameQuery(channel) self.sendCommand("JOIN "+channel) def sendCommand(self, command): if not self.s: logger.debug("tried to send command:",command,"to disconnected bot") return False [], writeable, [] = select.select([],[self.s],[],0) if len(writeable) == 0: logger.warning("sock couldn't be opened for writing") logger.debug("message lost: "+command) else: for sock in writeable:#This would need to be fixed for multiple IRC clients toSend = (command+"\r\n").encode("UTF-8","replace") if len(toSend) != self.s.send(toSend): logger.debug("Long message implicitly trimmed") def sendMessage(self, channel, message): #print(len(message),deUni(message)) while len(message) > 0: chunkSize = min(400,len(message)); self.sendCommand("PRIVMSG "+channel+" :"+message[:chunkSize]) message = message[chunkSize:] #returns false on bad socket def recvCommand(self): if not self.s: logger.debug("tried to poll disconnected bot") return False readable,[],errors = select.select([self.s],[],[self.s],0) if len(errors) != 0: logger.debug("socket error") self.reconnect() if len(readable) != 0: try: data = self.s.recv(SM__IRC_BUFFER_SIZE).decode("UTF-8","replace") except: return False if len(data) == 0: return False self.readBuffer += data commands = self.readBuffer.split("\r\n") for cmd in commands[:-1]: self.parseCommand(cmd) self.readBuffer = commands[-1] return True def parseCommand(self, command): follower = command.find(" :",1) if follower != -1: splitCommand = command[0:follower].split(" ") splitCommand.append(command[follower+2:]) else: splitCommand = command.split(" ") prefix = "" if splitCommand[0][0] != ":": splitCommand.insert(0,"") else: splitCommand[0] = splitCommand[0][1:] key = splitCommand.pop(1) if not self.commandHandler.run(key.upper(), *tuple(splitCommand)): if key in numerictoname: key = numerictoname[key]
def handle_cmd(self, data): CommandHandler().exec_cmd(self.transport, data)
class WindowHelper: handlers = {} status_label = None def __init__(self, plugin, window): self.window = window self.plugin = plugin self.command_handler = CommandHandler() self.set_status() for view in window.get_views(): self.connect_handlers(view) window.connect('tab_added', self.on_tab_added) def deactivate(self): debug.msg('deactivate function called') for view in self.handlers: view.disconnect(self.handlers[view]) self.window = None self.plugin = None def update_ui(self): self.set_status() def connect_handlers(self, view): handler = view.connect('key-press-event', self.on_key_press) self.handlers[view] = handler def on_tab_added(self, window, tab): self.connect_handlers(tab.get_view()) def set_status(self, text=None): if not self.status_label: self.status_label = gtk.Label('PP') self.status_label.set_alignment(0, 1) self.status_label.show() frame = gtk.Frame() frame.add(self.status_label) frame.show() statusbar = self.window.get_statusbar() statusbar.add(frame) label = '' if text: label = "AP: %s " % (text) self.status_label.set_text(label) def on_key_press(self, view, event): hotkey = { 'ctrl': False, 'shift': False, 'alt': False, 'key': event.keyval } if event.state & gtk.gdk.CONTROL_MASK: hotkey['ctrl'] = True if event.state & gtk.gdk.SHIFT_MASK: hotkey['shift'] = True if event.state & gtk.gdk.MOD1_MASK: hotkey['alt'] = True result = self.command_handler.handle(hotkey, view) status_text = self.command_handler.get_status_text() debug.msg('set status: %s' % status_text) self.set_status(status_text) return result
""" import _winreg as reg import subprocess def get_values(key): keys = {} key_count = reg.QueryInfoKey(key)[0] for i in xrange(key_count): try: key_name = reg.EnumKey(key, i) sub_key = reg.OpenKey(key, key_name) val = reg.QueryValue(sub_key, None) if val: keys[key_name] = val.decode("cp1252").encode("utf-8") except WindowsError as e: if e.errno == 22: # No more data is available break return keys registry = reg.ConnectRegistry(None, reg.HKEY_LOCAL_MACHINE) cpanel_items = reg.OpenKey(registry, r"Software\Microsoft\Windows\CurrentVersion\Explorer\ControlPanel\NameSpace", 0, reg.KEY_WOW64_64KEY + reg.KEY_READ) if __name__ != "__main__": from command_handler import CommandHandler for k, v in get_values(cpanel_items).items(): CommandHandler.register(v, subprocess.Popen, ["explorer shell:::" + k], label='Control Panel') else: print get_values(cpanel_items)
parser.add_argument( '-z', '--zabbix', default=False, action='store_true', help='Select whether to use zabbix as a health monitor or not.') parser.add_argument( '--log-level', action="store", type=str, choices=["critical", "error", "warning", "info", "debug", "notset"], default="info", help='Select the log level of the program.') parser.add_argument('--verbose', default=False, action='store_true', help='Select whether to output logs to the console.') args = parser.parse_args() port = 5006 handler = CommandHandler(args, port) server = ConnectionFactory(handler) try: server.run_server(port) except Exception as e: print str(e) raise e finally: server.handler.shutdown()
class WindowHelper: handlers = {} status_label = None def __init__(self, plugin, window): self.window = window self.plugin = plugin self.command_handler = CommandHandler() self.set_status() for view in window.get_views(): self.connect_handlers(view) window.connect('tab_added', self.on_tab_added) def deactivate(self): debug.msg('deactivate function called') for view in self.handlers: view.disconnect(self.handlers[view]) self.window = None self.plugin = None def update_ui(self): self.set_status() def connect_handlers(self, view): handler = view.connect('key-press-event', self.on_key_press) self.handlers[view] = handler def on_tab_added(self, window, tab): self.connect_handlers(tab.get_view()) def set_status(self, text=None): if not self.status_label: self.status_label = gtk.Label('PP') self.status_label.set_alignment(0, 1) self.status_label.show() frame = gtk.Frame() frame.add(self.status_label) frame.show() statusbar = self.window.get_statusbar() statusbar.add(frame) label = '' if text: label = "AP: %s " % (text) self.status_label.set_text(label) def on_key_press(self, view, event): hotkey = { 'ctrl' : False, 'shift' : False, 'alt' : False, 'key' : event.keyval } if event.state & gtk.gdk.CONTROL_MASK: hotkey['ctrl'] = True if event.state & gtk.gdk.SHIFT_MASK: hotkey['shift'] = True if event.state & gtk.gdk.MOD1_MASK: hotkey['alt'] = True result = self.command_handler.handle(hotkey, view) status_text = self.command_handler.get_status_text() debug.msg('set status: %s' % status_text) self.set_status(status_text) return result
# print output_list for output in output_list: # slack output should be parsed as a command if output and 'text' in output and AT_BOT in output['text']: return 'command' # slack output should be parsed by NLP engine if output and 'text' in output: return 'nlp' return None, None, None, None if __name__ == "__main__": text_parser = EmojiParser(slack_client) command_handler = CommandHandler(slack_client) READ_WEBSOCKET_DELAY = 0.5 # 1 second delay between reading from data stream if slack_client.rtm_connect(): print("ReactionAdder connected and running!") while True: output_list = slack_client.rtm_read() msg_type = determine_message_type(output_list) if msg_type == 'command': __message, channel = command_handler.get_command_info( output_list) command_handler.parse_command(__message.split(), channel) elif msg_type == 'nlp': print("in nlp branch") emoji_list, channel, timestamp, user = text_parser.parse_message( output_list) print emoji_list
import telebot from command_handler import CommandHandler from users_repository import UsersRepository from states import State from users_repository import UserInfo from requests.exceptions import ReadTimeout import time import os import requests from bs4 import BeautifulSoup API_TOKEN = '1391169462:AAG3l2DwCxs1Cys4kqh3L2cG32Od7ryb1ZY' bot = telebot.TeleBot(API_TOKEN) users = UsersRepository("users") handler = CommandHandler(bot, users) @bot.message_handler(commands=['help', 'start']) def send_welcome(message): user_id = message.from_user.id bot.send_message( message.chat.id, "Привет. Напиши запрос чтобы узнать курс валют на сегодня. Пример : Курс доллара в Москве" ) if not users.exists(user_id): user_info = UserInfo(user_id, state=State.MAIN) users.save(user_info) #handler.keyboard_in_tournaments(message) #else: #handler.keyboard_in_tournaments(message)
#Connect to users database dbedit.setup() #Get the list of folders and add to sys.path for root, dirs, files in os.walk(r'.'): for dir in dirs[:3]: sys.path.append(os.path.realpath(f'{root}/{dir}')) config = configparser.ConfigParser() config.read('data/config.ini', encoding='utf-8') #Create a discord client client = discord.Client() #Create handlers handler = CommandHandler(client, config) reactionHandler = ReactionHandler(client, config) #Register all commands handler.register_commands_in_dir('./commands') @client.event async def on_ready(): print("Logged in as: " + str(client.user.name)) @client.event async def on_reaction_add(reaction, user): #Pass reaction to handler await reactionHandler.handle(reaction, user)
class ChatProtocol(asyncio.Protocol): """Server behavior for all incoming/outgoing data Keyword arguments: None """ def __init__(self, user_database): self.user_database = user_database self._clients = set() self.last_message_sender = '' self.user_list = [] self.fernet = Fernet(FERNET_KEY) self.command_handler = CommandHandler(user_database, self.fernet) # atexit.register(self.server_shutdown) # def server_shutdown(self): # shutdown_command = (COMMAND_FLAG + COMMAND_CODE['server_shutdown']).encode('utf-8') # encrypted_shutdown_command = self.fernet.encrypt(shutdown_command) # if self._clients: # for client in self._clients: # client.writer.write(encrypted_shutdown_command) async def handle_input(self, reader, writer): """Routine when server receives input from a connection The main loop that listens for activity on the client stream """ while True: # If client connection isn't trying to close if not writer.is_closing(): # Listen for data indefinitely try: encrypted_data = await reader.read(MAX_SEND_SIZE) # Gracefully close connection if client improperly disconnected except ConnectionResetError: print("Improper client shutdown!") self.user_list = self.command_handler.close_connection( self._clients, writer, self.user_list)['data']['user_list'] self.send_updated_user_list() break # Decrypt received data data = self.fernet.decrypt(encrypted_data) message = data.decode('utf-8') # Find data sender self.update_last_message_sender(writer) print("Received from {}".format(self.last_message_sender)) # Determine if it's a command or a message if await is_command(message): await self.execute_command(message, writer) else: self.save_message_to_history(message) self.broadcast_message(message) print("Restarting Loop") # Close closing writer else: print("Connection closed. . .") break async def execute_command(self, message, writer): """"Respond to received command Process command in CommandHandler then execute final steps here. Types: private -- Message is private and should not be broadcasted close -- client wishes to disconnect new -- new user valid_credentials -- new client gave valid login credentials ignore -- client wishes to ignore another client """ result = await self.command_handler.process_command( message, writer, self._clients, self.user_list) if result['type'] == 'private': self.send_private_message(message, result['data']['receiving_client'], writer) elif result['type'] == 'close': self.user_list = result['data']['user_list'] self.send_updated_user_list() elif result['type'] in ['new', 'valid_credentials']: current_client = await self.add_new_connection(writer, message) await self.update_connected_user_list(current_client) if result['type'] == 'new': self.user_database = db.get_known_users() elif result['type'] in ['ignore']: pass def update_last_message_sender(self, writer): """Find name of most recent sender""" for client in self._clients: if client.writer == writer: self.last_message_sender = client.name async def update_connected_user_list(self, current_client): """Add a user to user list and send updated list to connected clients""" self.user_list.append(current_client.name) self.send_updated_user_list() def send_updated_user_list(self): """Send updated user list to all connected clients""" user_list = "\n".join(self.user_list) print("send update") for client in self._clients: data = (COMMAND_FLAG + COMMAND_CODE['update_user_list'] + user_list).encode('utf-8') encrypted_data = self.fernet.encrypt(data) client.writer.write(encrypted_data) def save_message_to_history(self, message): """Record message in chat history database""" db_data = (self.user_database[self.last_message_sender]['id'], message) db.insert_into_chat_history(db_data) def broadcast_message(self, message): """Send message to all connected clients""" message = ("{}: ".format(self.last_message_sender) + message).encode('utf-8') encrypted_message = self.fernet.encrypt(message) for client in self._clients: if sender_ignored(client, self.last_message_sender): pass else: client.writer.write(encrypted_message) print("is closing: {}".format(client.writer.is_closing())) def send_private_message(self, message, receiver, sender): """Send message to a specific client""" receiver_message = prepare_receiver_message(message, self.last_message_sender) sender_message = prepare_sender_message(message) encrypted_receiver_message = self.fernet.encrypt(receiver_message) encrypted_sender_message = self.fernet.encrypt(sender_message) if sender_ignored(receiver, self.last_message_sender): pass else: receiver.writer.write(encrypted_receiver_message) sender.write(encrypted_sender_message) async def add_new_connection(self, writer, message): """Add a Client""" username = message.split('||')[1] client = Client(writer, name=username) self._clients.add(client) return client
class WebhookHandler(object): def __init__( self, config: Config, store: Storage, github: Github, repo: Repository, ): self.config = config self.github = github self.repo = repo self.command_handler = CommandHandler(config, store, repo) # Start a flash webserver self.app = Flask(__name__) webhook = Webhook( self.app, endpoint=self.config.webhook_path, secret=self.config.webhook_secret, ) @self.app.route("/") def hello_world(): return "Hello, world!" @webhook.hook("issue_comment") def on_issue_comment(data): log.debug( f"Got comment: {json.dumps(data, indent=4, sort_keys=True)}") self._process_comment(data) @webhook.hook("pull_request_review_comment") def on_pull_request_review_comment(data): log.debug( f"Got PR review comment: {json.dumps(data, indent=4, sort_keys=True)}" ) self._process_comment(data) def run(self): from waitress import serve serve(self.app, host=self.config.webhook_host, port=self.config.webhook_port) def _process_comment(self, comment: Dict): log.debug("Processing comment: %s", comment) comment_author = comment["sender"] comment_author_login = comment_author["login"] # Ignore comments/edits from ourselves if comment_author_login == self.config.github_user.login: log.debug("Ignoring comment from ourselves") return # Account for issue and pull request review comments issue = comment["issue"] if "issue" in comment else comment[ "pull_request"] # Check if this is a proposal if not self._issue_has_label(issue, self.config.github_proposal_label): log.debug("Ignoring comment without appropriate proposal label") return # Ignore comments from people who aren't on the team if not self._comment_belongs_to_team_member(comment): log.debug("Ignoring comment that doesn't belong to team member") return # Process any commands this comment contains self.command_handler.handle_comment(comment) def _issue_has_label(self, issue: Dict, label_name: str) -> bool: """Check whether a given issue has a label""" for label in issue["labels"]: if label["name"] == label_name: return True return False def _comment_belongs_to_team_member(self, comment: Dict) -> bool: """Return whether a comment was posted by a known team member""" author = comment["sender"] for member in self.config.github_team.get_members(): if member.login == author["login"]: return True return False
def test_help_registered(self): handler = CommandHandler() self.assertIn("!help", handler.registered_commands)
from command_handler import CommandHandler import generators if __name__ == '__main__': """ 核心的背单词的文件 只需要运行此文件即可 y为认识此单词 n为不认识此单词 eof为退出 error为rollback上一个单词入单词池 excel需要提取的sheet在108行的sheets_set来指定 可以指定多个set 在背诵过程中error过或n过的单词在程序正常结束后会被记入此文件的difficulties的sheet中 需要人为创建这个名为difficulties的sheet或者自行指定一个名称 """ modules_name = list(map(lambda s: s.capitalize(), input("module_name:").split("_"))) module = getattr(generators, f"{''.join(modules_name)}Generator") wordsDb = module.init_all_words() handler = CommandHandler(wordsDb) handler.loop()
#!/usr/bin/python3 import sys from fachwoerter_bot import FachwoerterBot from command_handler import CommandHandler if __name__ == '__main__': bot = FachwoerterBot() if '--tweet' in sys.argv: word = bot.get_fachwort(bot.cursor) bot.tweet(word) quit() print('Fachwörter Bot v0.1') command_handler = CommandHandler(bot) while True: command_input = input('> ').lower() command_parts = command_input.split(' ') command = command_parts[0] args = command_parts[1:] command_handler.handle_command(command, args)