def test_commands_output(self):
"""This test deals with testing whether correct description of
commands is returned by the server to client.
"""
commands = [
"""register : To register as a new user,
command:register <username> <password> \n""",
"""login : To login,
command:login <username> <password>""",
"""quit : To logout,
command:quit\n""",
"""change_folder : To change the current path,
command:change_folder <name>\n""",
"""list : Lists all files in the current path,
command:list\n""",
"""read_file : To read content from the file,
command:read_file <name>\n""",
"""write_file : To write content into the file,
command:write_file <name> <content>\n""",
"""create_folder : To create new folder,
command:create_folder <name>\n"""
]
expected = "".join(commands)
test_user = CommandHandler()
actual = test_user.commands()
self.assertEqual(expected, actual)
def test_registration(self):
"""This test deals with testing whether register command is working or not!
"""
test_user = CommandHandler()
expected = "\nSuccess! Registered test1"
actual = test_user.register("test1", "17bfdsbgl")
self.assertEqual(expected, actual)
test_user.quit()
def test_registration_with_weak_password(self):
"""This test checks the registretion method sends information
if the user attempts to register with a weak password
"""
test_user = CommandHandler()
expected = "\n Password length should be more than 8 characters."
actual = test_user.register("test2", "hdfgh")
self.assertEqual(expected, actual)
test_user.quit()
def __init__(self, *args, **kwargs):
super(Portland, self).__init__(*args, **kwargs)
self.command_handler = CommandHandler()
self.discoLogger, self.discoLogFile = None, None
self.init_logger()
try:
self.run(Config.discord_token)
except discord.errors.LoginFailure:
sys.exit(
'Token is incorrect. Please use one from a valid bot account on https://discord.com/developers/'
)
def test_create_folder(self):
"""Tests if the user able to create a folder
"""
test_user = CommandHandler()
test_user.register("test6", "jgldaoghgealg8014")
test_user.login("test6", "jgldaoghgealg8014")
expected = "\nSuccessfully created folder movies"
actual = test_user.create_folder("movies")
self.assertEqual(expected, actual)
test_user.quit()
def main():
parser = argparse.ArgumentParser(description="Audio component for ScreenCrash")
parser.add_argument("--enable-ws-debug", action="store_true", help="Enables debug messages from websocket module")
parser.add_argument("--no-reconnect", action="store_true", help="Do not reconnect if connection is lost")
parser.add_argument("--reconnect-time", type=int, default=3000, help="Time (in ms) between disconnect and reconnection attempt. Cannot be used with --no-reconnect flag. Default 3000ms")
args = parser.parse_args()
if args.enable_ws_debug:
websocket.enableTrace(True)
cmd_handler = CommandHandler()
core_connection = CoreConnection(cmd_handler.initial_message, cmd_handler.handle_message, not args.no_reconnect, args.reconnect_time)
cmd_handler.set_event_handler(core_connection.send)
core_connection.run()
print("Shutting down audio component...")
def test_read_non_existing_file(self):
"""Tests if the user is attempting to read content from non-existent
file
"""
test_user = CommandHandler()
test_user.register("test11", "hgrsbbgvngevlohbgvp0")
test_user.login("test11", "hgrsbbgvngevlohbgvp0")
filename = "abc.txt"
test_user.read_file(filename)
expected = "\nNo Such file " + filename + " exists!"
actual = test_user.read_file(filename)
async def handle_client(reader, writer):
"""This funtion acknowledges the connection from the client,
acknowledges the messages from the client
Parameters
----------
reader : StreamReader
Reads data from the client socket
writer : StreamWriter
Writes data to the client socket
"""
client_addr = writer.get_extra_info('peername')
message = f"{client_addr} is connected !!!!"
print(message)
commandhandler = CommandHandler()
while True:
data = await reader.read(4096)
message = data.decode().strip()
if message == 'exit':
break
print(f"Received {message} from {client_addr}")
writer.write(str(client_request(commandhandler, message)).encode())
await writer.drain()
print("Close the connection")
writer.close()
def main():
"""Thread that reads messages from the webapp."""
GoopgLogger()
handler = CommandHandler()
# a queue to store bundles received before the 'init' command
queue = []
while 1:
try:
bundle = read_bundle()
except struct.error as e:
logger.error("Error while reading stdin: \"{}\""
" - Exit.".format(e.message))
sys.exit(1)
if not handler.initialized and bundle['command'] != 'init':
# send init request
send_bundle({"command": "request_init"})
queue.append(bundle)
else:
def parse_and_send_result(b):
result = handler.parse(b)
if result is not None:
b['result'] = result
send_bundle(b)
parse_and_send_result(bundle)
if len(queue) > 0:
for bundle in queue:
parse_and_send_result(bundle)
queue = []
def test_write_file(self):
"""Tests if the user is attempting to create and
write content into a file
"""
test_user = CommandHandler()
test_user.register("test9", "nlndgsvns")
test_user.login("test9", "nlndgsvns")
expected = "\nCreated and written data to file k.txt successfully"
actual = test_user.write_file("k.txt", "Hello World")
self.assertEqual(expected, actual)
# Check also if the user able to append new data to the
# existing file
expected = "\nSuccess Written data to file k.txt successfully"
actual = test_user.write_file("k.txt", "Hello Second World")
self.assertEqual(expected, actual)
test_user.quit()
def test_quit(self):
"""Tests if the user able to safely quit from the system.
"""
test_user = CommandHandler()
test_user.register("test5", "bdghkga")
test_user.login("test5", "bdghkga")
expected = test_user.quit()
actual = "\nLogged Out"
self.assertEqual(expected, actual)
def test_login_with_wrong_password(self):
"""This test deals with testing when a user attempts to login with wrong
password the system throws an error 'Wrong Password'
"""
test_user = CommandHandler()
test_user.register("test4", "jsdlghosd")
expected = "\nSorry, The password you entered is wrong. Please Try Again"
actual = test_user.login("test4", "jsdlgholgegl")
self.assertEqual(expected, actual)
test_user.quit()
def test_login(self):
"""This test deals with testing whether a user after a proper registeration is
able to login into the system or not!
"""
test_user = CommandHandler()
test_user.register("test3", "125354nnn3883")
expected = "Success test3 Logged into the system"
actual = test_user.login("test3", "125354nnn3883")
self.assertEqual(expected, actual)
test_user.quit()
import discord
import os
from dotenv import load_dotenv
from commandhandler import CommandHandler, Command
load_dotenv() # take environment variables from .env
# Setup client, command handler, and get auth token
client = discord.Client()
token = os.environ.get('TOKEN')
c_handler = CommandHandler(client)
def help_func():
print('help_func')
help_command = Command('help', 0, 'Usage: ;sports help', help_func)
c_handler.add_command(help_command)
# Called when the bot first starts up
@client.event
async def on_ready():
print(f'{client.user} has connected to Discord!')
# Called everytime there is a new message
@client.event
async def on_message(message):
from commandhandler import CommandHandler
from observequantum import ObserveQuantum
# configuring the bot using config.json
with open('config.json') as f:
data = json.load(f)
token = data["token"]
command_prefix = data["prefix"]
# add this to config.json
observe_arguments = ["star", "wang"]
client = discord.Client()
# assigning external classes to objects
ch = CommandHandler(client)
oq = ObserveQuantum(observe_arguments)
# command functions
def test_command(message, client, args):
return 'Test'
def observe_command(message, client, args):
"""
Checks if user inputted guess matches the state of a qubit after observation.
"""
guess = message.content.lower()
if (observe_arguments[0] in guess) or (observe_arguments[1] in guess):
if oq.observed(guess) == True:
from __init__ import *
from window import Window
from player import Player
from commandhandler import CommandHandler
#(chr(ord(gch())))
p = Player(
input(('\n' * 11) + (' ' * 20) +
'Please enter the player character\'s name' + ('\n' * 12) +
(' ' * 32) + '> '), 2, 3, 23, 4)
os.system('cls')
w = Window(p)
ch = CommandHandler(p, w.p3.tile_map.m, w.p1.tile_map.m)
is_command_being_entered = False
while True:
w.p2.content[4].set_chars(f"({p.local_x}, {p.local_y})")
w.Print() #Output
is_command_being_entered = False
t_char = chr(ord(gch())) # Input
if t_char == '\r':
is_command_being_entered = True
w.p5.e = True
while is_command_being_entered:
w.Print()
t_char = chr(ord(gch())) # Input
returned_text = w.p5.Add_Char(0, t_char + "")
if not returned_text == None:
def __init__(self, host, request_handler):
self.handler = CommandHandler()
self.logger = logging.getLogger('http-main')
HTTPServer.__init__(self, host, request_handler)
def test_read_file(self):
"""Tests if the user is attempting to read content from already
existing file
"""
test_user = CommandHandler()
test_user.register("test10", "brsgvegveiotyq39ty")
test_user.login("test10", "brsgvegveiotyq39ty")
test_user.write_file("z.txt", "Hello World!n")
expected = "\nReading file from 0 bytes to 100 bytes\nHello World!n"
actual = test_user.read_file("z.txt")
self.assertEqual(expected, actual)
test_user.quit()
class Portland(discord.Client):
def __init__(self, *args, **kwargs):
super(Portland, self).__init__(*args, **kwargs)
self.command_handler = CommandHandler()
self.discoLogger, self.discoLogFile = None, None
self.init_logger()
try:
self.run(Config.discord_token)
except discord.errors.LoginFailure:
sys.exit(
'Token is incorrect. Please use one from a valid bot account on https://discord.com/developers/'
)
def init_logger(self):
self.discoLogger = logging.getLogger('discord')
self.discoLogger.setLevel(logging.INFO)
self.discoLogFile = logging.FileHandler(filename='portland.log',
encoding='utf-8',
mode='w')
self.discoLogger.addHandler(self.discoLogFile)
async def on_ready(self):
print('Portland is connected to Discord and logged in as {}'.format(
self.user.name))
self.command_handler.start_voice_info_loop(self)
if not Config.voice_auto_join or not self.command_handler.voice.voice_enabled:
return
channel = self.get_channel(Config.voice_auto_join_channel_id)
while 1:
member_count = len(
[a for a in channel.members if not a.id == self.user.id])
if channel.guild.voice_client is None and member_count > 0 and Config.voice_auto_join:
channel = self.get_channel(Config.voice_auto_join_channel_id)
self.command_handler.voice.voice_channels[
channel.guild.id] = await channel.connect(timeout=15,
reconnect=True)
if not self.command_handler.voice.voice_channels[
channel.guild.id].is_playing():
self.command_handler.voice.voice_channels[
channel.guild.id].play(
self.command_handler.voice.audio_source)
elif channel.guild.voice_client is not None and not member_count and Config.voice_auto_join:
self.command_handler.voice.voice_channels[
channel.guild.id].stop()
await self.command_handler.voice.voice_channels[
channel.guild.id].disconnect()
for proc in psutil.Process().children(recursive=True):
if 'ffmpeg' in proc.name():
proc.kill()
self.command_handler.voice.voice_channels.pop(channel.guild.id)
self.command_handler.voice.restart_source()
await asyncio.sleep(5)
async def on_message(self, msg):
if not msg.content.startswith(Config.default_prefix) or msg.author.bot:
return
try:
command, arguments = msg.content.split(' ', 1)
except ValueError:
command, arguments = msg.content, ''
await self.command_handler.resolve(command[1:], arguments, msg, self)
class ConfConverter:
def __init__(self, gGator):
self.logger = gGator.logger
self.conversionConf = gGator.conversionConf
self.commandHandler = CommandHandler(gGator)
# self.outputDir = gGator.outputDir
# self.useGenreSubFolders = gGator.useGenreSubFolders
# self.conversionType = gGator.conversionType
# self.conversionConf = gGator.conversionConf
# self.collectionVersion = gGator.collectionVersion
# self.commandHandler = CommandHandler(gGator)
# Handle Parameter in ExpertMod
def getExpertParam(self, parameter, defaultValue):
if self.conversionConf['useExpertMode']:
return self.conversionConf[parameter]
else:
return defaultValue
# Converts exo collection dosbox.conf to dosbox.cfg and dosbox.bat
def process(self, gGator):
self.logger.log(" create dosbox.bat")
exoDosboxConf = open(
os.path.join(gGator.getLocalGameDataOutputDir(), "dosbox.conf"),
'r') # original
retroDosboxCfg = open(
os.path.join(gGator.getLocalGameOutputDir(), "dosbox.cfg"),
'w') # retroarch dosbox.cfg
retroDosboxBat = open(
os.path.join(gGator.getLocalGameOutputDir(), "dosbox.bat"),
'w') # retroarch dosbox.bat
count = 0
lines = exoDosboxConf.readlines()
for cmdline in lines:
if cmdline.startswith("fullscreen"):
retroDosboxCfg.write("fullscreen=true\n")
elif cmdline.startswith("fullresolution"):
if gGator.conversionType == util.retrobat:
retroDosboxCfg.write(cmdline)
else:
retroDosboxCfg.write(
"fullresolution=" +
self.getExpertParam("fullresolutionCfg", "desktop") +
"\n")
elif cmdline.startswith("output"):
if gGator.conversionType == util.retrobat:
retroDosboxCfg.write(cmdline)
else:
retroDosboxCfg.write(
"output=" +
self.getExpertParam("outputCfg", "texture") + "\n")
retroDosboxCfg.write(
"renderer=" + self.getExpertParam("rendererCfg", "auto") +
"\n")
if gGator.conversionConf['vsyncCfg']:
retroDosboxCfg.write("vsync=true\n")
else:
retroDosboxCfg.write("vsync=false\n")
# Always write these
elif cmdline.startswith("aspect"):
retroDosboxCfg.write("aspect=true\n")
elif cmdline.startswith("buttonwrap"):
retroDosboxCfg.write("buttonwrap=false\n")
elif cmdline.startswith("mapperfile"):
retroDosboxCfg.write("mapperfile=mapper.map\n")
elif cmdline.startswith("ultradir"):
retroDosboxCfg.write(r"ultradir=C:\ULTRASND")
retroDosboxCfg.write("\n")
elif cmdline.startswith("[autoexec]"):
retroDosboxCfg.write(cmdline)
self.createDosboxBat(lines[count + 1:], retroDosboxBat,
retroDosboxCfg, gGator)
break
else:
retroDosboxCfg.write(cmdline)
count = count + 1
exoDosboxConf.close()
os.remove(
os.path.join(gGator.getLocalGameDataOutputDir(), "dosbox.conf"))
retroDosboxCfg.close()
retroDosboxBat.close()
# Creates dosbox.bat from dosbox.conf [autoexec] part
def createDosboxBat(self, cmdlines, retroDosboxBat, retroDosboxCfg,
gGator):
for cmdline in cmdlines:
# keep conf in dosbox.cfg but comment it
if self.conversionConf['useDebugMode']:
retroDosboxCfg.write("# " + cmdline)
self.convertLine(cmdline, retroDosboxBat, gGator)
# Convert command line to dosbox.bat
def convertLine(self, cmdline, retroDosboxBat, gGator):
cutLines = [
"cd ..", "cls", "mount c", "#", "exit", "echo off", "echo on"
]
# always remove @
cmdline = cmdline.lstrip('@ ')
# TODO whereWeAt identifies where we are in the game tree based on instructions, use in the future ?
whereWeAt = ['c:', '.']
if self.commandHandler.useLine(cmdline, cutLines):
if cmdline.lower().startswith("c:"):
retroDosboxBat.write(cmdline)
if not gGator.isWin3x():
# First add move into game subdir
retroDosboxBat.write("cd %s\n" % gGator.game)
whereWeAt.append('game')
# remove cd to gamedir as it is already done, but keep others cd
elif cmdline.lower().startswith("cd "):
path = self.commandHandler.reducePath(
cmdline.rstrip('\n\r ').split(" ")[-1].rstrip('\n\r '))
if path.lower() == gGator.game.lower() and not os.path.exists(
os.path.join(gGator.getLocalGameDataOutputDir(),
path)):
self.logger.log(
" cd command: '%s' -> path is game name and no existing subpath, removed"
% cmdline.rstrip('\n\r '))
else:
self.logger.log(" cd command: '%s' -> kept" %
cmdline.rstrip('\n\r '))
retroDosboxBat.write(cmdline)
whereWeAt.append(path)
elif cmdline.lower().startswith("imgmount "):
retroDosboxBat.write(
self.commandHandler.handleImgmount(
cmdline.rstrip('\n\r ')))
if self.conversionConf['useDebugMode']:
retroDosboxBat.write("\npause\n")
else:
retroDosboxBat.write("\n")
elif cmdline.lower().startswith("mount "):
retroDosboxBat.write(
self.commandHandler.handleMount(cmdline.rstrip('\n\r ')))
if self.conversionConf['useDebugMode']:
retroDosboxBat.write("\npause\n")
else:
retroDosboxBat.write("\n")
elif cmdline.lower().startswith("boot "):
retroDosboxBat.write(
self.commandHandler.handleBoot(cmdline.rstrip('\n\r ')))
elif cmdline.lower().rstrip(
' \n\r') == 'call run' or cmdline.lower().rstrip(
' \n\r') == 'call run.bat':
self.logger.log(" <WARNING> game uses call run.bat",
self.logger.WARNING)
if gGator.game in [
'bisle2', 'Blood', 'Carmaged', 'comcon', 'comconra',
'CrypticP', 'lemm3', 'LewLeon', 'MechW2', 'rarkani1',
'Resurrec', 'stjudgec', 'heromm2d'
]:
self.handleRunBat(gGator)
self.handlePotentialSubFile(cmdline, gGator)
retroDosboxBat.write(cmdline)
else:
self.handlePotentialSubFile(cmdline, gGator)
retroDosboxBat.write(cmdline)
# Handle potential sub files and problems in it
def handlePotentialSubFile(self, subPath, gGator, handledSubFiles=[]):
subPath = subPath.lstrip('@ ').lower().replace(
'call ', '') if subPath.lstrip('@ ').lower().startswith(
"call ") else subPath
subBat = os.path.join(gGator.getLocalGameDataOutputDir(),
subPath.rstrip(' \n\r') + '.bat')
if os.path.exists(subBat) and not os.path.isdir(
subBat) and subBat.lower() not in handledSubFiles:
self.logger.log(' Handle Bat File %s' % subBat,
self.logger.WARNING)
handledSubFiles.append(subBat.lower())
subBatFile = open(subBat, 'r')
subBatFileClone = open(subBat + '1', 'w', newline='\r\n')
for cmdline in subBatFile.readlines():
# always remove @
cmdline = cmdline.lstrip('@ ')
if cmdline.lower().rstrip(
' \n\r'
) == 'c:' and gGator.conversionType == util.mister:
self.logger.log(' Remove c: for MiSTeR',
self.logger.WARNING)
else:
if 'c:\\' in cmdline.lower():
if gGator.conversionType == util.mister:
# TODO might need win3x fix
cmdline = cmdline.replace(
'c:', 'E:\\GAMES\\' + gGator.game).replace(
'C:', 'E:\\GAMES\\' + gGator.game)
else:
if not gGator.isWin3x():
cmdline = cmdline.replace(
'c:', 'c:\\' + gGator.game).replace(
'C:', 'C:\\' + gGator.game)
else:
self.handlePotentialSubFile(cmdline, gGator,
handledSubFiles)
subBatFileClone.write(cmdline)
subBatFileClone.close()
subBatFile.close()
# Delete runbat and rename runbat clone to runbat
os.remove(subBat)
os.rename(subBat + '1', subBat)
# Treat run.bat command inside game directory
def handleRunBat(self, gGator):
runBat = os.path.join(gGator.getLocalGameDataOutputDir(), 'run.bat')
if os.path.exists(runBat):
runFile = open(runBat, 'r')
runFileClone = open(runBat + '1', 'w', newline='\r\n')
# Clone run.bat and only modify imgmount lines
# Add some hardcoded lines which are impossible to handle
handled = {
'imgmount d ".\\eXoDOS\\comcon\\cd\\Command & Conquer CD-2.iso" ".\\eXoDOS\\comcon\\cd\\Command & Conquer CD-1.iso" ".\\eXoDOS\\comcon\\cd\\Covert Operations.cue" -t cdrom \n':
'imgmount d ".\\cd\\comma2.iso" ".\\cd\\comma1.iso" ".\\cd\\cover3.cue" -t cdrom',
'imgmount d ".\\eXoDOS\\comcon\\cd\\Covert Operations.cue" ".\\eXoDOS\\comcon\\cd\\Command & Conquer CD-2.iso" ".\\eXoDOS\\comcon\\cd\\Command & Conquer CD-1.iso" -t cdrom \n':
'imgmount d ".\\cd\\cover3.cue" ".\\cd\\comma2.iso" ".\\cd\\comma1.iso" -t cdrom',
'imgmount d ".\\eXoDOS\\comconra\\cd\\Red Alert CD2.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert CD1.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert Counterstrike CD3.cue" ".\\eXoDOS\\comconra\\cd\\Red Alert Aftermath CD4.cue" -t cdrom \n':
'imgmount d ".\\cd\\redal2.iso" ".\\cd\\redal1.iso" ".\\cd\\redal3.cue" ".\\cd\\redal4.cue" -t cdrom',
'imgmount d ".\\eXoDOS\\comconra\\cd\\Red Alert Aftermath CD4.cue" ".\\eXoDOS\\comconra\\cd\\Red Alert CD1.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert CD2.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert Counterstrike CD3.cue" -t cdrom \n':
'imgmount d ".\\cd\\redal4.cue" ".\\cd\\redal1.iso" ".\\cd\\redal2.iso" ".\\cd\\redal3.cue" -t cdrom',
'imgmount d ".\\eXoDOS\\comconra\\cd\\Red Alert Counterstrike CD3.cue" ".\\eXoDOS\\comconra\\cd\\Red Alert CD1.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert CD2.iso" ".\\eXoDOS\\comconra\\cd\\Red Alert Aftermath CD4.cue" -t cdrom \n':
'imgmount d ".\\cd\\redal3.cue" ".\\cd\\redal1.iso" ".\\cd\\redal2.iso" ".\\cd\\redal4.cue" -t cdrom',
'imgmount d ".\\eXoDOS\\comconra\\cd\\Red Alert Aftermath CD4.cue" -t cdrom \n':
'imgmount d .\\cd\\redal4.cue -t cdrom',
'imgmount -u d\n':
'\n'
}
for cmdline in runFile.readlines():
# always remove @
cmdline = cmdline.lstrip('@ ')
if cmdline.lower().startswith("imgmount "):
if cmdline not in handled:
handled[cmdline] = self.commandHandler.handleImgmount(
cmdline, True)
runFileClone.write(handled[cmdline])
if self.conversionConf['useDebugMode']:
runFileClone.write("\npause\n")
else:
runFileClone.write("\n")
else:
runFileClone.write(cmdline)
runFileClone.close()
runFile.close()
# Delete runbat and rename runbat clone to runbat
os.remove(
os.path.join(gGator.getLocalGameDataOutputDir(), 'run.bat'))
os.rename(
os.path.join(gGator.getLocalGameDataOutputDir(), 'run.bat1'),
os.path.join(gGator.getLocalGameDataOutputDir(), 'run.bat'))
else:
self.logger.log(' <ERROR> run.bat not found',
self.logger.ERROR)
def test_change_folder(self):
"""Tests if the user is attempting to move the location
of the directory tree.
"""
test_user = CommandHandler()
test_user.register("test8", "rgglherglse9421-4")
test_user.login("test8", "rgglherglse9421-4")
test_user.create_folder("movies")
expected = "\nSuccessfully Moved to folder Root/test8\movies"
actual = test_user.change_folder("movies")
self.assertEqual(expected, actual)
test_user.quit()
def test_create_already_existing_folder(self):
"""Tests if the user is attempting to create
a folder which is already existing.
"""
test_user = CommandHandler()
test_user.register("test7", "lognslb402193570")
test_user.login("test7", "lognslb402193570")
test_user.create_folder("movies")
expected = "\nThe folder already exists!"
actual = test_user.create_folder("movies")
self.assertEqual(expected, actual)
test_user.quit()
from rollhandler import RollHandler
if __name__ == '__main__':
client = discord.Client()
rocks_db_location = os.getenv('ROCKS_DB_LOCATION', 'anathema.db')
kv = KV(DB(rocks_db_location, Options(create_if_missing=True)))
handlers = [
RollHandler(kv),
InspireHandler(),
CharacterHandler(kv),
ConditionHandler()
]
command_handler = CommandHandler(kv, handlers.copy())
handlers.append(command_handler)
@client.event
async def on_ready():
"""Handles bot start"""
print('We have logged in as {0.user}'.format(client))
@client.event
async def on_message(message):
"""Entry point for all message handling"""
if message.author == client.user:
return
for handler in handlers:
def __init__(self, gGator):
self.logger = gGator.logger
self.conversionConf = gGator.conversionConf
self.commandHandler = CommandHandler(gGator)
