147 lines
4.7 KiB
Python
147 lines
4.7 KiB
Python
# Nemubot is a smart and modulable IM bot.
|
|
# Copyright (C) 2012-2017 Mercier Pierre-Olivier
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
class _ModuleContext:
|
|
|
|
def __init__(self, module=None):
|
|
self.module = module
|
|
|
|
if module is not None:
|
|
self.module_name = (module.__spec__.name if hasattr(module, "__spec__") else module.__name__).replace("nemubot.module.", "")
|
|
else:
|
|
self.module_name = ""
|
|
|
|
self.hooks = list()
|
|
self.events = list()
|
|
self.debug = False
|
|
|
|
from nemubot.config.module import Module
|
|
self.config = Module(self.module_name)
|
|
|
|
|
|
def load_data(self):
|
|
from nemubot.tools.xmlparser import module_state
|
|
return module_state.ModuleState("nemubotstate")
|
|
|
|
def add_hook(self, hook, *triggers):
|
|
from nemubot.hooks import Abstract as AbstractHook
|
|
assert isinstance(hook, AbstractHook), hook
|
|
self.hooks.append((triggers, hook))
|
|
|
|
def del_hook(self, hook, *triggers):
|
|
from nemubot.hooks import Abstract as AbstractHook
|
|
assert isinstance(hook, AbstractHook), hook
|
|
self.hooks.remove((triggers, hook))
|
|
|
|
def subtreat(self, msg):
|
|
return None
|
|
|
|
def add_event(self, evt, eid=None):
|
|
return self.events.append((evt, eid))
|
|
|
|
def del_event(self, evt):
|
|
for i in self.events:
|
|
e, eid = i
|
|
if e == evt:
|
|
self.events.remove(i)
|
|
return True
|
|
return False
|
|
|
|
def send_response(self, server, res):
|
|
self.module.logger.info("Send response: %s", res)
|
|
|
|
def save(self):
|
|
self.context.datastore.save(self.module_name, self.data)
|
|
|
|
def subparse(self, orig, cnt):
|
|
if orig.server in self.context.servers:
|
|
return self.context.servers[orig.server].subparse(orig, cnt)
|
|
|
|
@property
|
|
def data(self):
|
|
if not hasattr(self, "_data"):
|
|
self._data = self.load_data()
|
|
return self._data
|
|
|
|
|
|
def unload(self):
|
|
"""Perform actions for unloading the module"""
|
|
|
|
# Remove registered hooks
|
|
for (s, h) in self.hooks:
|
|
self.del_hook(h, *s)
|
|
|
|
# Remove registered events
|
|
for evt, eid, module_src in self.events:
|
|
self.del_event(evt)
|
|
|
|
self.save()
|
|
|
|
|
|
class ModuleContext(_ModuleContext):
|
|
|
|
def __init__(self, context, *args, **kwargs):
|
|
"""Initialize the module context
|
|
|
|
arguments:
|
|
context -- the bot context
|
|
module -- the module
|
|
"""
|
|
|
|
super().__init__(*args, **kwargs)
|
|
|
|
# Load module configuration if exists
|
|
if self.module_name in context.modules_configuration:
|
|
self.config = context.modules_configuration[self.module_name]
|
|
|
|
self.context = context
|
|
self.debug = context.debug
|
|
|
|
|
|
def load_data(self):
|
|
return self.context.datastore.load(self.module_name)
|
|
|
|
def add_hook(self, hook, *triggers):
|
|
from nemubot.hooks import Abstract as AbstractHook
|
|
assert isinstance(hook, AbstractHook), hook
|
|
self.hooks.append((triggers, hook))
|
|
return self.context.treater.hm.add_hook(hook, *triggers)
|
|
|
|
def del_hook(self, hook, *triggers):
|
|
from nemubot.hooks import Abstract as AbstractHook
|
|
assert isinstance(hook, AbstractHook), hook
|
|
self.hooks.remove((triggers, hook))
|
|
return self.context.treater.hm.del_hooks(*triggers, hook=hook)
|
|
|
|
def subtreat(self, msg):
|
|
yield from self.context.treater.treat_msg(msg)
|
|
|
|
def add_event(self, evt, eid=None):
|
|
return self.context.add_event(evt, eid, module_src=self.module)
|
|
|
|
def del_event(self, evt):
|
|
return self.context.del_event(evt, module_src=self.module)
|
|
|
|
def send_response(self, server, res):
|
|
if server in self.context.servers:
|
|
if res.server is not None:
|
|
return self.context.servers[res.server].send_response(res)
|
|
else:
|
|
return self.context.servers[server].send_response(res)
|
|
else:
|
|
self.module.logger.error("Try to send a message to the unknown server: %s", server)
|
|
return False
|