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 __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 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)
# -*- coding: utf-8 -*- from command_handler import CommandHandler import thread import time com = CommandHandler() while com.handle(): time.sleep(0.5)
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)
