def __init__(self, server, language='aml'):
"""
@type server: firefly.containers.Server
@type language: C{str}
@param language: The language engine to use for this instance.
"""
# Set up logging
self._log = logging.getLogger('firefly')
self.language = None
"""@type : firefly.languages.interface.LanguageInterface"""
self._load_language_interface(language)
# Set up our registry and server containers, then run setup
self.registry = _Registry(self)
self.server_info = ServerInfo()
self.server = server
self._setup()
self.load_language_files()
# Set up our authentication manager
self.auth = Auth(self)
# Finally, now that everything is set up, load our plugins
self.plugins = pkg_resources.get_entry_map('firefly_irc', 'firefly.plugins')
scanner = venusian.Scanner(firefly=self)
scanner.scan(plugins)
class ServerInfoTestCase(unittest.TestCase):
FIRST_RESPONSE = ['CALLERID', 'CASEMAPPING=rfc1459', 'DEAF=D', 'KICKLEN=180', 'MODES=4', 'PREFIX=(ohv)@%+',
'STATUSMSG=@%+', 'EXCEPTS=e', 'INVEX=I', 'NICKLEN=15', 'NETWORK=TestCase', 'MAXLIST=beI:100',
'MAXTARGETS=4']
SECOND_RESPONSE = ['CHANTYPES=#&', 'CHANLIMIT=#:25,&:10', 'CHANNELLEN=50', 'TOPICLEN=300',
'CHANMODES=beI,k,l,imnprstORS', 'WATCH=60', 'ELIST=CMNTU', 'SAFELIST', 'AWAYLEN=240', 'KNOCK']
SUPPORTS = [('CASEMAPPING', 'rfc1459'), ('DEAF', 'D'), ('KICKLEN', '180'), ('MODES', '4'), ('PREFIX', '(ohv)@%+'),
('STATUSMSG', '@%+'), ('EXCEPTS', 'e'), ('INVEX', 'I'), ('NICKLEN', '15'), ('NETWORK', 'TestCase'),
('MAXLIST', 'beI:100'), ('MAXTARGETS', '4'), ('CHANTYPES', '#&'), ('CHANLIMIT', '#:25,&:10'),
('CHANNELLEN', '50'), ('TOPICLEN', '300'), ('CHANMODES', 'beI,k,l,imnprstORS'), ('WATCH', '60'),
('ELIST', 'CMNTU'), ('AWAYLEN', '240')]
CHANMODES = (['b', 'e', 'I'], ['k'], ['l'], ['i', 'm', 'n', 'p', 'r', 's', 't', 'O', 'R', 'S'])
PREFIX = (('o', '@'), ('h', '%'), ('v', '+'))
CHANTYPES = ['#', '&']
CHANLIMIT = [('#', 25), ('&', 10)]
def setUp(self):
self.server_info = ServerInfo()
def test_server_info_container_attributes(self):
# Support responses are usually split into multiple messages
self.server_info.parse_supports(self.FIRST_RESPONSE)
self.server_info.parse_supports(self.SECOND_RESPONSE)
self.assertEqual(self.server_info.network, 'TestCase')
self.assertListEqual(self.server_info.supports, self.SUPPORTS)
self.assertTupleEqual(self.server_info.channel_modes, self.CHANMODES)
self.assertTupleEqual(self.server_info.prefixes, self.PREFIX)
self.assertListEqual(self.server_info.channel_types, self.CHANTYPES)
self.assertListEqual(self.server_info.channel_limits, self.CHANLIMIT)
self.assertEqual(self.server_info.max_nick_length, 15)
self.assertEqual(self.server_info.max_channel_length, 50)
self.assertEqual(self.server_info.max_topic_length, 300)
self.assertEqual(self.server_info.max_kick_length, 180)
self.assertEqual(self.server_info.max_away_length, 240)
class FireflyIRC(IRCClient):
"""
Firefly IRC client.
"""
# Default nick
nickname = "Firefly"
# Path constants
CONFIG_DIR = os.path.join(appdirs.user_config_dir('firefly'), 'irc')
DATA_DIR = os.path.join(appdirs.user_data_dir('firefly'), 'irc')
LOG_DIR = os.path.join(appdirs.user_log_dir('firefly'), 'irc')
def __init__(self, server, language='aml'):
"""
@type server: firefly.containers.Server
@type language: C{str}
@param language: The language engine to use for this instance.
"""
# Set up logging
self._log = logging.getLogger('firefly')
self.language = None
"""@type : firefly.languages.interface.LanguageInterface"""
self._load_language_interface(language)
# Set up our registry and server containers, then run setup
self.registry = _Registry(self)
self.server_info = ServerInfo()
self.server = server
self._setup()
self.load_language_files()
# Set up our authentication manager
self.auth = Auth(self)
# Finally, now that everything is set up, load our plugins
self.plugins = pkg_resources.get_entry_map('firefly_irc', 'firefly.plugins')
scanner = venusian.Scanner(firefly=self)
scanner.scan(plugins)
@staticmethod
def load_configuration(name, plugin=None, basedir=None, default=None, ext='.cfg'):
"""
Load a single configuration file.
@type name: str
@param name: Name of the configuration file *WITHOUT* the .cfg file extension
@type plugin: PluginAbstract or None
@param plugin: Plugin to load a configuration file from, or None to load a system configuration file.
@type basedir: str or None
@param basedir: Optional config path prefix
@type default: str or None
@param default: Name of the default configuration file. Defaults to the name argument.
@type ext: str or None
@param ext: Configuration file extension. None for no extension (e.g. server configuration files).
@raise ValueError: Raised if the supplied configuration file does not exist
@rtype: ConfigParser
"""
log = logging.getLogger('firefly')
ext = ext or '' # If None, we need to convert the extension to an empty string
paths = []
################################
# Default Configuration #
################################
app_path = plugin.plugin_path if plugin else os.path.dirname(os.path.realpath(__file__))
app_path = os.path.join(app_path, 'config')
if basedir:
app_path = os.path.join(app_path, basedir)
app_path = os.path.join(app_path, '{fn}{ext}'.format(fn=default or name, ext='.cfg' if default else ext))
# Make sure the configuration file actually exists
if not os.path.isfile(app_path):
raise ValueError('Default configuration file %s does not exist', app_path)
paths.append(app_path)
################################
# User Configuration #
################################
user_path = os.path.join(FireflyIRC.CONFIG_DIR, 'config')
if plugin:
user_path = os.path.join(user_path, 'plugins', plugin.name)
if basedir:
user_path = os.path.join(user_path, basedir)
# Make sure the directory exists
if not os.path.isdir(user_path):
log.info('Creating user configuration directory: %s', user_path)
os.makedirs(user_path, 0o755)
user_path = os.path.join(user_path, '{fn}{ext}'.format(fn=name, ext=ext))
log.debug('Attempting to load user configuration file: %s', user_path)
if not os.path.isfile(user_path):
if default:
raise ValueError('User configuration file %s does not exist', app_path) # TODO: Ambiguous exceptions
log.debug('User configuration file does not exist, attempting to create it')
# Load the base system path
shutil.copyfile(app_path, user_path)
paths.append(user_path)
# Load the configuration files
config = ConfigParser()
log.debug('Attempting to load configuration files: %s', str(paths))
result = config.read(paths)
log.debug('Configuration files loaded: %s', str(result))
return config
def _load_language_interface(self, language):
"""
Load and instantiate the specific language engine.
@type language: C{str}
"""
self._log.info('Loading language interface: {lang}'.format(lang=language))
try:
module = importlib.import_module('firefly.languages.{module}'.format(module=language))
self.language = module.__LANGUAGE_CLASS__()
except ImportError as e:
self._log.error('ImportError raised when loading language')
raise LanguageImportError('Unable to import language engine "{lang}": {err}'
.format(lang=language, err=e.message))
except AttributeError:
self._log.error('Language module does not contain a specified language class, load failed')
raise LanguageImportError('Language "{lang}" does not have a defined __LANGUAGE_CLASS__'
.format(lang=language))
def load_language_files(self, plugin=None, basedir=None, container=None):
"""
Load language files.
@type plugin: PluginAbstract or None
@param plugin: Plugin to load language files from, or None to load user language files.
@type basedir: str or None
@param basedir: Language basedir. Defaults to lang
@type container: str or None
@param container: Name of the identity container. Defaults to the system configuration.
"""
basedir = basedir or 'lang'
container = container or self.server.identity.container
lang_path = plugin.plugin_path if plugin else FireflyIRC.CONFIG_DIR
lang_path = os.path.join(lang_path, basedir, container)
# Make sure the configuration file actually exists
if not os.path.exists(lang_path):
self._log.warn('Language directory %s does not exist', lang_path)
return
self.language.load_directory(lang_path)
def _setup(self):
"""
Run generic setup tasks.
"""
# Load language files
lang_dir = os.path.join(self.CONFIG_DIR, 'language')
if os.path.isdir(lang_dir):
self.language.load_directory(lang_dir)
# Make sure our configuration and data directories exist
if not os.path.isdir(self.CONFIG_DIR):
os.makedirs(self.CONFIG_DIR, 0o755)
if not os.path.isdir(self.DATA_DIR):
os.makedirs(self.DATA_DIR, 0o755)
def _fire_event(self, event_name, has_reply=False, is_command=False, **kwargs):
"""
Fire an IRC event.
@type event_name: C{str}
@param event_name: Name of the event to fire, see firefly.irc for a list of event constants
@type has_reply: bool
@param has_reply: Indicates that this event triggered a language response before firing
@type is_command: bool
@param is_command: Indicates that this event triggered a command before firing
@param kwargs: Arbitrary event arguments
"""
self._log.info('Firing event: %s', event_name)
events = self.registry.get_events(event_name)
for cls, func, params in events:
# Commands ok?
if is_command and not params['command_ok']:
self._log.info('Event is not responding to command triggers, skipping')
continue
# Replies ok?
if has_reply and not params['reply_ok']:
self._log.info('Event is not responding to language triggers, skipping')
continue
self._log.info('Firing event: %s (%s); Params: %s', str(cls), str(func), str(params))
# response = func(cls, **kwargs)
message = kwargs.get('message')
response = Response(
self,
message,
message.source if message else None,
message.destination if message and message.destination.is_channel else None
)
func(cls, response, **kwargs)
response.send()
def _fire_command(self, plugin, name, cmd_args, message):
"""
Fire an IRC command.
@type plugin: str
@param plugin: Name of the command plugin
@type name: str
@param name: Name of the command
@type cmd_args: list of str
@param cmd_args: List of command arguments
@type message: Message
@param message: Command message container
"""
self._log.info('Firing command: %s %s (%s)', plugin, name, str(cmd_args))
cls, func, argparse, params = self.registry.get_command(plugin, name)
# Make sure we have permission
perm = params['permission']
user = self.auth.check(message.source)
if (perm != 'guest') and not user:
error = 'You must be registered and authenticated in order to use this command.'
if self.server.public_errors:
self.msg(message.destination, error)
else:
self.notice(message.source, error)
return
if (perm == 'admin') and not user.is_admin:
error = 'You do not have permission to use this command.'
if self.server.public_errors:
self.msg(message.destination, error)
else:
self.notice(message.source, error)
return
# Execute the command
try:
response = Response(
self, message, message.source, message.destination if message.destination.is_channel else None
)
func(argparse.parse_args(cmd_args), response)
response.send()
except ArgumentParserError as e:
self._log.info('Argument parser error: %s', e.message)
usage = style(argparse.format_usage().strip(), bold=True)
desc = ' -- {desc}'.format(desc=argparse.description.strip()) if argparse.description else ''
help_msg = '({usage}){desc}'.format(usage=usage, desc=desc)
# If this command was sent in a query, return the error now
if message.destination.is_user:
self.msg(message.source, e.message)
self.msg(message.source, help_msg)
return
# Otherwise, check if we should send the messages as a notice or channel message
if self.server.public_errors:
self.msg(message.destination, e.message)
self.msg(message.destination, help_msg)
else:
self.notice(message.source, e.message)
self.notice(message.source, help_msg)
def msg(self, user, message, length=None):
"""
Send a message to a user or channel.
The message will be split into multiple commands to the server if:
- The message contains any newline characters
- Any span between newline characters is longer than the given
line-length.
@type user: Destination, Hostmask or str
@param user: The user or channel to send a notice to.
@type message: str
@param message: The contents of the notice to send.
@type length: int
@param length: Maximum number of octets to send in a single command, including the IRC protocol framing.
If None is given then IRCClient._safeMaximumLineLength is used to determine a value.
"""
if isinstance(user, Destination):
self._log.debug('Implicitly converting Destination to raw format for message delivery: %s --> %s',
repr(user), user.raw)
user = user.raw
if isinstance(user, Hostmask):
self._log.debug('Implicitly converting Hostmask to nick format for message delivery: %s --> %s',
repr(user), user.nick)
user = user.nick
self._log.debug('Delivering message to %s : %s', user, (message[:35] + '..') if len(message) > 35 else message)
IRCClient.msg(self, user, message.encode('utf-8'), length)
def notice(self, user, message):
"""
Send a notice to a user.
Notices are like normal message, but should never get automated
replies.
@type user: Destination, Hostmask or str
@param user: The user or channel to send a notice to.
@type message: str
@param message: The contents of the notice to send.
"""
if isinstance(user, Destination):
self._log.debug('Implicitly converting Destination to raw format for notice delivery: %s --> %s',
repr(user), user.raw)
user = user.raw
if isinstance(user, Hostmask):
self._log.debug('Implicitly converting Hostmask to nick format for notice delivery: %s --> %s',
repr(user), user.nick)
user = user.nick
IRCClient.notice(self, user, message)
def describe(self, channel, action):
"""
Strike a pose.
@type channel: Destination, Hostmask or str
@param channel: The user or channel to perform an action in.
@type action: str
@param action: The action to preform.
"""
if isinstance(channel, Destination):
self._log.debug('Implicitly converting Destination to raw format for action performance: %s --> %s',
repr(channel), channel.raw)
channel = channel.raw
if isinstance(channel, Hostmask):
self._log.debug('Implicitly converting Hostmask to nick format for action performance: %s --> %s',
repr(channel), channel.nick)
channel = channel.nick
IRCClient.describe(self, channel, action)
################################
# High-level IRC Events #
################################
def created(self, when):
"""
Called with creation date information about the server, usually at logon.
@type when: C{str}
@param when: A string describing when the server was created, probably.
"""
self._fire_event(irc.on_created, when=when)
def yourHost(self, info):
"""
Called with daemon information about the server, usually at logon.
# TODO: Consider integrating into ServerInfo container
@param info: A string describing what software the server is running, probably.
@type info: C{str}
"""
self._fire_event(irc.on_server_host, info=info)
def myInfo(self, server_name, version, umodes, cmodes):
"""
Called with information about the server, usually at logon.
@type server_name: C{str}
@param server_name: The hostname of this server.
@type version: C{str}
@param version: A description of what software this server runs.
@type umodes: C{str}
@param umodes: All the available user modes.
@type cmodes: C{str}
@param cmodes: All the available channel modes.
"""
self._fire_event(irc.on_client_info, server_name=server_name, version=version,
umodes=umodes, cmodes=cmodes)
def luserClient(self, info):
"""
Called with information about the number of connections, usually at logon.
@type info: C{str}
@param info: A description of the number of clients and servers connected to the network, probably.
"""
self._fire_event(irc.on_luser_client, info=info)
def bounce(self, info):
"""
Called with information about where the client should reconnect.
@type info: C{str}
@param info: A plaintext description of the address that should be connected to.
"""
self._fire_event(irc.on_bounce, info=info)
def isupport(self, options):
"""
Called with various information about what the server supports.
@type options: C{list} of C{str}
@param options: Descriptions of features or limits of the server, possibly in the form "NAME=VALUE".
"""
self.server_info.parse_supports(options)
self._fire_event(irc.on_server_supports, options=options)
def luserChannels(self, channels):
"""
Called with the number of channels existent on the server.
@type channels: C{int}
"""
self._fire_event(irc.on_luser_channels, channels=channels)
def luserOp(self, ops):
"""
Called with the number of ops logged on to the server.
@type ops: C{int}
"""
self._fire_event(irc.on_luser_ops, ops=ops)
def luserMe(self, info):
"""
Called with information about the server connected to.
@type info: C{str}
@param info: A plaintext string describing the number of users and servers
connected to this server.
"""
self._fire_event(irc.on_luser_connection, info=info)
def privmsg(self, user, channel, message):
"""
Called when I have a message from a user to me or a channel.
@type user: C{str}
@param user: Hostmask of the sender.
@type channel: C{str}
@param channel: Name of the source channel or user nick.
@type message: C{str}
"""
hostmask = Hostmask(user)
destination = Destination(self, channel)
message = Message(message, destination, hostmask)
is_command = False
has_reply = False
reply_dest = destination
groups = set()
# Log the message
self.server.get_or_create_channel(channel).message_log.add_message(message)
# Is the message a command?
if message.is_command:
self._log.debug('Message registered as a command: %s', repr(message))
is_command = True
groups.add('command')
command_plugin, command_name, command_args = message.command_parts
self._fire_command(command_plugin, command_name, command_args, message)
# Is this a private message?
if message.destination.is_user:
groups.add(None)
groups.add('private')
reply_dest = hostmask
# Have we been mentioned in this message?
nicks = self.server.identity.nicks
try:
nick, raw_message, match = message.get_mentions(nicks)
groups.add(None)
except TypeError:
self._log.debug('Message has no mentions at the beginning')
try:
nick, raw_message, match = message.get_mentions(nicks, message.MENTION_END)
groups.add(None)
except TypeError:
self._log.debug('Message has no mentions at the end')
nick = self.nickname
raw_message = message.stripped
match = False
if message.destination.is_channel:
groups.add('public')
# Do we have a language response?
reply = self.language.get_reply(raw_message, groups=groups)
if reply:
self._log.debug('Reply matched: %s', reply)
has_reply = True
self.msg(reply_dest, reply)
# Fire global event
self._fire_event(irc.on_message, has_reply, is_command, message=message)
# Fire custom events
if message.destination.is_channel:
self.channelMessage(message, has_reply, is_command)
elif message.destination.is_user:
self.privateMessage(message, has_reply, is_command)
def joined(self, channel):
"""
Called when I finish joining a channel.
@type channel: C{str}
@param channel: Name of the channel.
"""
self.server.add_channel(channel)
self._fire_event(irc.on_client_join, channel=Destination(self, channel))
def left(self, channel):
"""
Called when I have left a channel.
@type channel: C{str}
@param channel: Name of the channel.
"""
self.server.remove_channel(channel)
self._fire_event(irc.on_client_part, channel=Destination(self, channel))
def noticed(self, user, channel, message):
"""
Called when I have a notice from a user to me or a channel.
If the client makes any automated replies, it must not do so in response to a NOTICE message, per the RFC::
The difference between NOTICE and PRIVMSG is that
automatic replies MUST NEVER be sent in response to a
NOTICE message. [...] The object of this rule is to avoid
loops between clients automatically sending something in
response to something it received.
@type user: C{str}
@param user: Hostmask of the sender.
@type channel: C{str}
@param channel: Name of the source channel or user nick.
@type message: C{str}
"""
notice = Message(message, Destination(self, channel), Hostmask(user), Message.NOTICE)
self._fire_event(irc.on_notice, notice=notice)
# Fire custom events
if notice.destination.is_channel:
self.channelNotice(notice)
elif notice.destination.is_user:
self.privateNotice(notice)
def modeChanged(self, user, channel, set, modes, args):
"""
Called when users or channel's modes are changed.
TODO
@type user: C{str}
@param user: The user and hostmask which instigated this change.
@type channel: C{str}
@param channel: The channel where the modes are changed. If args is empty the channel for which the modes
are changing. If the changes are at server level it could be equal to C{user}.
@type set: C{bool} or C{int}
@param set: True if the mode(s) is being added, False if it is being removed. If some modes are added and
others removed at the same time this function will be called twice, the first time with all the added modes,
the second with the removed ones. (To change this behaviour override the irc_MODE method)
@type modes: C{str}
@param modes: The mode or modes which are being changed.
@type args: C{tuple}
@param args: Any additional information required for the mode change.
"""
self._fire_event(irc.on_mode_changed, user=Hostmask(user), source=Destination(self, channel), set=set, modes=modes, args=args)
def pong(self, user, secs):
"""
Called with the results of a CTCP PING query.
@type user: C{str}
@param user: The user and hostmask.
@type secs: C{float}
@param secs: Ping latency
"""
self._fire_event(irc.on_pong, user=Hostmask(user), secs=secs)
def signedOn(self):
"""
Called after successfully signing on to the server.
"""
# Connect to our autojoin channels
channels = self.server.autojoin_channels
for name, channel in channels.iteritems():
if channel.autojoin:
self.join(channel.name)
self._fire_event(irc.on_client_signed_on)
def kickedFrom(self, channel, kicker, message):
"""
Called when I am kicked from a channel.
@type channel: C{str}
@param channel: The channel we were kicked from.
@type kicker: C{str}
@param kicker: The user that kicked us.
@type message: C{str}
@param message: The kick message.
"""
self._fire_event(irc.on_client_kicked, channel=channel, kicker=kicker, message=message)
def nickChanged(self, nick):
"""
Called when my nick has been changed.
@type nick: C{str}
@param nick: Our new nick
"""
self.nickname = nick
self._fire_event(irc.on_client_nick, nick=nick)
def userJoined(self, user, channel):
"""
Called when I see another user joining a channel.
@type user: C{str}
@param user: The user joining the channel.
@type channel: C{str}
@param channel: The channel being joined.
"""
self._fire_event(irc.on_channel_join, user=Hostmask(user), channel=channel)
def userLeft(self, user, channel):
"""
Called when I see another user leaving a channel.
@type user: C{str}
@param user: The user parting the channel.
@type channel: C{str}
@param channel: The channel being parted.
"""
self._fire_event(irc.on_channel_part, user=Hostmask(user), channel=channel)
def userQuit(self, user, quitMessage):
"""
Called when I see another user disconnect from the network.
@type user: C{str}
@param user: The user quitting the network.
@type quitMessage: C{str}
@param quitMessage: The quit message.
"""
message = Message(quitMessage, None, Hostmask(user))
self._fire_event(irc.on_user_quit, user=Hostmask(user), quit_message=quitMessage, message=message)
def userKicked(self, kickee, channel, kicker, message):
"""
Called when I observe someone else being kicked from a channel.
@type kickee: C{str}
@param kickee: The user being kicked.
@type channel: C{str}
@param channel: The channel the user is being kicked from.
@type kicker: C{str}
@param kicker: The user that is kicking.
@type message: C{str}
@param message: The kick message.
"""
message = Message(message, Destination(self, channel), Hostmask(kicker))
self._fire_event(irc.on_channel_kick, kickee=kickee, channel=channel, kicker=kicker, message=message)
def action(self, user, channel, data):
"""
Called when I see a user perform an ACTION on a channel.
@type user: C{str}
@param user: The user performing the action.
@type channel: C{str}
@param channel: The user or channel.
@type data: C{str}
@param data: The action being performed.
"""
action = Message(data, Destination(self, channel), Hostmask(user), Message.ACTION)
self._fire_event(irc.on_action, action=action)
if action.destination.is_channel:
self.channelAction(action, False)
elif action.destination.is_user:
self.privateAction(action, False)
def topicUpdated(self, user, channel, newTopic):
"""
In channel, user changed the topic to newTopic.
Also called when first joining a channel.
@type user: C{str} or C{None}
@param user: The user updating the topic, if relevant.
@type channel: C{str}
@param channel: The channel the topic is being changed on.
@type newTopic: C{str}
@param newTopic: The updated topic.
"""
self._fire_event(irc.on_channel_topic_updated, user=Hostmask(user), channel=channel, new_topic=newTopic)
def userRenamed(self, oldname, newname):
"""
A user changed their name from oldname to newname.
@type oldname: C{str}
@param oldname: The users old nick.
@type newname: C{str}
@param newname: The users new nick.
"""
self._fire_event(irc.on_user_nick_changed, old_nick=oldname, new_nick=newname)
def receivedMOTD(self, motd):
"""
I received a message-of-the-day banner from the server.
motd is a list of strings, where each string was sent as a separate
message from the server. To display, you might want to use::
'\\n'.join(motd)
to get a nicely formatted string.
@type motd: C{list}
"""
self._fire_event(irc.on_server_motd, motd=motd)
################################
# Custom IRC Events #
################################
def channelMessage(self, message, has_reply, is_command):
"""
Called when I have a message from a user to a channel.
@type message: Message
@param message: The message container object.
@type has_reply: bool
@param has_reply: Indicates that this event triggered a language response before firing
@type is_command: bool
@param is_command: Indicates that this event triggered a command before firing
"""
self._fire_event(irc.on_channel_message, has_reply, is_command, message=message)
def privateMessage(self, message, has_reply, is_command):
"""
Called when I have a message from a user to me.
@type message: Message
@param message: The message container object.
@type has_reply: bool
@param has_reply: Indicates that this event triggered a language response before firing
@type is_command: bool
@param is_command: Indicates that this event triggered a command before firing
"""
self._fire_event(irc.on_private_message, has_reply, is_command, message=message)
def channelNotice(self, notice):
"""
Called when I have a notice from a user to a channel.
@type notice: Message
@param notice: The notice (message) container object.
"""
self._fire_event(irc.on_channel_notice, notice=notice)
def privateNotice(self, notice):
"""
Called when I have a notice from a user to me.
@type notice: Message
@param notice: The notice (message) container object.
"""
self._fire_event(irc.on_private_notice, notice=notice)
def channelAction(self, action, has_reply):
"""
Called when I see a user perform an ACTION on a channel.
@type action: Message
@param action: The action (message) container object.
@type has_reply: bool
@param has_reply: Indicates that this event triggered a language response before firing
"""
self._fire_event(irc.on_channel_action, has_reply, action=action)
def privateAction(self, action, has_reply):
"""
Called when I see a user perform an ACTION to me.
@type action: Message
@param action: The action (message) container object.
@type has_reply: bool
@param has_reply: Indicates that this event triggered a language response before firing
"""
self._fire_event(irc.on_private_action, has_reply, action=action)
################################
# Low-level IRC Events #
################################
def irc_ERR_NICKNAMEINUSE(self, prefix, params):
"""
Called when we try to register or change to a nickname that is already
taken.
"""
IRCClient.irc_ERR_NICKNAMEINUSE(self, prefix, params)
self._fire_event(irc.on_err_nick_in_use, prefix=prefix, params=params)
def irc_ERR_ERRONEUSNICKNAME(self, prefix, params):
"""
Called when we try to register or change to an illegal nickname.
The server should send this reply when the nickname contains any
disallowed characters. The bot will stall, waiting for RPL_WELCOME, if
we don't handle this during sign-on.
@note: The method uses the spelling I{erroneus}, as it appears in
the RFC, section 6.1.
"""
IRCClient.irc_ERR_ERRONEUSNICKNAME(self, prefix, params)
self._fire_event(irc.on_err_nick_in_use, prefix=prefix, params=params)
def irc_ERR_PASSWDMISMATCH(self, prefix, params):
"""
Called when the login was incorrect.
"""
IRCClient.irc_ERR_PASSWDMISMATCH(self, prefix, params)
self._fire_event(irc.on_err_bad_password, prefix=prefix, params=params)
def irc_RPL_WELCOME(self, prefix, params):
"""
Called when we have received the welcome from the server.
"""
IRCClient.irc_RPL_WELCOME(self, prefix, params)
self._fire_event(irc.on_server_welcome, prefix=prefix, params=params)
def irc_unknown(self, prefix, command, params):
self._log.debug('Unknown IRC event: ({pr} {c} {pa})'.format(pr=str(prefix), c=str(command), pa=str(params)))
self._fire_event(irc.on_unknown, prefix=prefix, command=command, params=params)
def ctcpQuery(self, user, channel, messages):
"""
Dispatch method for any CTCP queries received.
Duplicated CTCP queries are ignored and no dispatch is
made. Unrecognized CTCP queries invoke L{IRCClient.ctcpUnknownQuery}.
"""
self._fire_event(irc.on_ctcp, user=Hostmask(user), channel=channel, messages=messages)
IRCClient.ctcpQuery(self, user, channel, messages)
def ctcpQuery_PING(self, user, channel, data):
self._fire_event(irc.on_ctcp_ping, user=Hostmask(user), channel=channel, data=data)
IRCClient.ctcpQuery_PING(self, user, channel, data)
def ctcpQuery_FINGER(self, user, channel, data):
self._fire_event(irc.on_ctcp_finger, user=Hostmask(user), channel=channel, data=data)
IRCClient.ctcpQuery_FINGER(self, user, channel, data)
def ctcpQuery_VERSION(self, user, channel, data):
self._fire_event(irc.on_ctcp_version, user=Hostmask(user), channel=channel, data=data)
def ctcpQuery_SOURCE(self, user, channel, data):
self._fire_event(irc.on_ctcp_source, user=Hostmask(user), channel=channel, data=data)
def ctcpQuery_USERINFO(self, user, channel, data):
self._fire_event(irc.on_ctcp_userinfo, user=Hostmask(user), channel=channel, data=data)
IRCClient.ctcpQuery_USERINFO(self, user, channel, data)
def ctcpQuery_TIME(self, user, channel, data):
self._fire_event(irc.on_ctcp_time, user=Hostmask(user), channel=channel, data=data)
IRCClient.ctcpQuery_TIME(self, user, channel, data)
def setUp(self):
self.server_info = ServerInfo()
