def reloadModules(self):
global MODULES_LOADED
print(Fore.RED + "-------------------------------------------------")
print(Fore.RED + "MODULE RELOADING (or die tryin) ")
print(Fore.RED + "------------------------------------------------")
resetColors()
for module_name in MODULES_LOADED:
module_instance = MODULES_LOADED[module_name]
try:
print("Trying to Reload: {0}".format(self.namespace + module_name))
if DEBUG_MODE:
with(open("external_modules.log", "w")) as fp:
fp.write(self.namespace + module_name)
module = "{0}.{1}".format(self.namespace, module_name)
imp.reload(minicbircbot.bot)
# imp.reload(MODULES_LOADED[module_name])
except Exception as ex:
msg = "Exception Ocurred: {0}".format(str(ex))
logger.critical(msg)
print(msg)
pass
def instantiateModule(self, module_name):
"""
when the module is in memory it tried to create a new instance of the module
returns the module object - ircBotInterface child class
"""
inst = None
module = None
try:
inst = __import__(self.namespace + module_name,
fromlist=module_name) # importlib.import_module(namespace + module_name, module_name)
return getattr(inst, module_name)
if DEBUG_MODE:
print("Loaded: {0}.{1}".format(self.namespace, module_name))
except Exception as ex:
exc_info = sys.exc_info()
print(Fore.RED + "ERROR: Cannot Instantiate {0}".format(module))
print(Fore.RED + "Exception: {0} - Line Number {1} - Frame: {2}".format(str(ex), str(exc_info[2].tb_lineno),tr(exc_info[2].tb_frame) ))
print(Fore.RED + "Please Check the Log")
logger.critical(
"Exception Occurred when tried instantiate a module: {0} - {1}".format(module_name, str(ex)))
resetColors()
return None
def motd():
msg = ""
try:
with(open("motd.txt", "r")) as f:
for c in f.read():
msg += c
except:
pass
print(Fore.YELLOW + msg)
resetColors()
def motd():
msg = ""
try:
with(open("motd.txt", "r")) as f:
for c in f.read():
msg += c
except:
pass
print(Fore.YELLOW + msg)
resetColors()
def initModules(self):
""" init all modules you wrote in config.json
search in minicbircbot.bot.* for modules
and create a new instance in the global variable
MODULES_LOADED
"""
global MODULES_LOADED
for mod in self.config.get("modules"):
# Who's bad?
# i'm so evil that i'm using eval
# the devil of programming
# >=)
try:
module_loaded = self.instantiateModule(mod)
MODULES_LOADED[mod] = module_loaded(self)
except Exception as ex:
print(Fore.RED + "-------------------------------------------------")
print(Fore.RED + "Occurred an Exception in Module \"{0}\" and will be ignored".format(mod))
print(Fore.RED + "Exception: {0}".format(ex))
print(Fore.RED + "Please FIX it: bot/{0}/__init__.py Check the Log".format(mod))
print(Fore.RED + "-------------------------------------------------")
print(Fore.RED + "Please Check the Log")
logger.critical(
"Exception Occurred when tried to load module: {0}. Please Check {1}/__init__.py - {2}".format(mod,
mod,
str(
ex)))
resetColors()
if DEBUG_MODE:
with(open("modules.txt", 'w')) as fp:
for m in sys.modules:
module_name = "{0}\n".format(m)
fp.write(module_name)
pass
print("OWNERS : {0}".format(",".join([str(x) for x in self.config.get('owners')])))
print(" MODULES Running ------------------------------------------:")
for k in MODULES_LOADED:
print(k)
print("-----------------------------------------------------")
async def parseServerData(self, message):
"""
this method generates the events for the bot and trigger them in all external modules
"""
try:
# decode the message to utf8, sanitize the string removing '\r\n' or the regex will fail so badly
server_msg = clean_str(message.decode("utf-8"))
task = None
# before make a check we must have sure is a message
# PRIVMSG stand for 2 kinds of message, send to other person, or regular message in the channel
# the difference is the receiver
if server_msg:
self.BotServerDataSent(server_msg, None)
if server_msg.find("PRIVMSG") != -1: # is this a message?
is_message = re.search("^:(.+[aA-zZ0-0])!(.*) PRIVMSG (.+?) :(.+[aA-zZ0-9])$",
server_msg) # strip all contents useful for me
if is_message: # regex is successfull
data = {
'sender': is_message.groups()[0], # sender's nickname
'ident': is_message.groups()[1], # ident
'receiver': is_message.groups()[2], # channel or receiver's nickname
'message': is_message.groups()[3], # message
}
if DEBUG_MODE:
print('DATA DEBUG: ')
print(data)
# if the receiver is a channel trigger self.ReceivedMessageChannel, otherwise trigger self.ReceivedPrivateMessages
if data['receiver'].startswith("#"):
# means you are sending message directly to a channel
message_received = IrcMessageEvent.register(**data)
task = asyncio.create_task(self.ReceivedMessageChannel(message_received))
await task
print(Fore.BLUE + "<" + Fore.WHITE + data['receiver'] + "> " + Fore.CYAN + data["message"])
resetColors();
else:
# means you are sending message directly to someone
message_received = IrcPrivateMessageEvent.register(**data)
#self.ReceivedPrivateMessages(message_received)
await self.ReceivedPrivateMessages(message_received)
print(Fore.BLUE + "<" + Fore.WHITE + data['sender'] + ": " + data["receiver"] + "> " + Fore.CYAN +
data["message"])
resetColors()
if server_msg.find("JOIN") != -1: # join event?
# message example
#:[email protected] JOIN :#python
is_join = re.search(":(.+[aA-zZ0-0])!(.*) JOIN :(.+?)$", server_msg)
if is_join:
data = {
'sender': is_join.groups()[0],
'ident': is_join.groups()[1],
'channel_joined': is_join.groups()[2],
}
join_event = IrcJoinEvent(**data)
await self.ReceivedJoinEvent(join_event)
print(Fore.YELLOW + "{0} Joined {1}".format(join_event.sender, join_event.channel_joined))
resetColors()
if server_msg.find("PART") != -1: # join event?
is_part = re.search(":(.+[aA-zZ0-0])!(.*) PART (.+?) :\"(.+[aA-zZ0-9])\"$", server_msg)
if is_part:
data = {
'sender': is_part.groups()[0],
'ident': is_part.groups()[1],
'channel_part': is_part.groups()[2],
'quit_msg': is_part.groups()[3],
}
part_event = IrcPartEvent(**data)
await self.ReceivedPartEvent(part_event)
print(Fore.YELLOW + "{0} Part {1}".format(join_event.sender, join_event.channel_joined))
resetColors()
if (len(self.server_message) <= 10):
self.server_message.append(server_msg)
else:
self.server_msg = self.server_message[1:]
except ValueError:
print("Error Task\n");
def __init__(self, *args, **kwargs):
self.use_envvars = False
self.use_params = False
cfg = {}
self.config = ConfigJson("config.json", use_env=self.use_envvars)
for key, value in kwargs.items():
if key == 'use_env':
self.use_envvars = kwargs['use_env']
if key == 'params':
self.use_params = kwargs['params']
#processing params from shell/cmd
params = kwargs['params']
cfg = {
'address': params['address'],
'port': int(params['port']),
'chans': params['channel'],
'nickname': params['nickname'],
'identd': params['identd'],
'console': False,
'modules': params['modules']
}
if not params['modules']:
params['modules'] = '*'
cfg['modules'] = cfg['modules'].split(';')
self.isIdentified = False
self.identify = IrcIdentify(self)
self.allow_auth = self.config.get('auth')
if self.use_params:
self.config.setDefaultOpts()
pass
self.config.load()
self.initModules()
if DEBUG_MODE:
print(Fore.YELLOW + "Loading Modules: ")
print(Fore.YELLOW + self.config.get("modules"))
print(Fore.YELLOW + MODULES_LOADED)
print(Fore.YELLOW + "------------------------")
resetColors()
self.ircsocket = IrcSocket(self.config.get("address"), self.config.get("port"))
self.isRunning = False
self.isJoined = False
self.isConnected = False
self.server_message = []
if self.config.get("console"):
self.Console = IrcConsoleCommands(self)