def __init__(self, serverport, username, nick, gecos, extensions,
**kwargs):
"""Initialise the IRC base.
:param serverport:
(server, port) sequence, similar to the form passed to
socket.connect.
:param username:
The username to send to the server.
.. note:: identd may override this.
:param nick:
The nickname to use.
:param extensions:
Sequence of default extensions to use.
Keyword arguments (extensions may use others):
:key ssl:
Whether or not to use SSL. Set to an :py:class:`ssl.SSLContext``
to specify custom parameters, or ``True`` for defaults.
:key server_password:
Server password (PASS).
.. note::
Keyword arguments may be used by extensions. kwargs is passed
as-is to all extensions.
"""
super().__init__()
self.server, self.port = serverport
self.username = username
self.nick = nick
self.gecos = gecos
self.ssl = kwargs.get("ssl", False)
self.server_password = kwargs.get("server_password")
self.kwargs = kwargs
# Basic IRC state
self.connected = False
self.registered = False
self.case = IRCString.RFC1459
self.signals = SignalStorage()
# Extension manager system
if not extensions:
raise ValueError("Need at least one extension")
self.extensions = {}
for extension in extensions:
self.load_extension(extension)
# Do the signal storage binding for us now
self.signals.bind(self)
def __init__(self, serverport, username, nick, gecos, extensions,
**kwargs):
"""Initialise the IRC base.
:param serverport:
(server, port) sequence, similar to the form passed to
socket.connect.
:param username:
The username to send to the server.
.. note:: identd may override this.
:param nick:
The nickname to use.
:param extensions:
Sequence of default extensions to use.
Keyword arguments (extensions may use others):
:key ssl:
Whether or not to use SSL. Set to an :py:class:`ssl.SSLContext``
to specify custom parameters, or ``True`` for defaults.
:key server_password:
Server password (PASS).
.. note::
Keyword arguments may be used by extensions. kwargs is passed
as-is to all extensions.
"""
super().__init__()
self.server, self.port = serverport
self.username = username
self.nick = nick
self.gecos = gecos
self.ssl = kwargs.get("ssl", False)
self.server_password = kwargs.get("server_password")
self.kwargs = kwargs
# Basic IRC state
self.connected = False
self.registered = False
self.case = IRCString.RFC1459
self.signals = SignalStorage()
# Extension manager system
if not extensions:
raise ValueError("Need at least one extension")
self.extensions = {}
for extension in extensions:
self.load_extension(extension)
# Do the signal storage binding for us now
self.signals.bind(self)
class IRCBase(metaclass=ABCMeta):
"""The base IRC class meant to be used as a base for more concrete
implementations.
:ivar connected:
If True, we have connected to the server successfully.
:ivar registered:
If True, we have completed the server handshake and are ready
to send commands.
"""
# pylint: disable=too-many-arguments
def __init__(self, serverport, username, nick, gecos, extensions,
**kwargs):
"""Initialise the IRC base.
:param serverport:
(server, port) sequence, similar to the form passed to
socket.connect.
:param username:
The username to send to the server.
.. note:: identd may override this.
:param nick:
The nickname to use.
:param extensions:
Sequence of default extensions to use.
Keyword arguments (extensions may use others):
:key ssl:
Whether or not to use SSL. Set to an :py:class:`ssl.SSLContext``
to specify custom parameters, or ``True`` for defaults.
:key server_password:
Server password (PASS).
:key bindport:
(address, port) to bind to.
.. note::
Keyword arguments may be used by extensions. kwargs is passed
as-is to all extensions.
"""
super().__init__()
self.server, self.port = serverport
self.username = username
self.nick = nick
self.gecos = gecos
self.ssl = kwargs.get("ssl", False)
self.server_password = kwargs.get("server_password")
self.bindport = kwargs.get("bindport")
self.kwargs = kwargs
# Basic IRC state
self.connected = False
self.registered = False
self.case = IRCString.RFC1459
self.signals = SignalStorage()
# Extension manager system
if not extensions:
raise ValueError("Need at least one extension")
self.extensions = OrderedDict()
for extension in extensions:
self.load_extension(extension)
# Do the signal storage binding for us now
self.signals.bind(self)
def load_extension(self, extension):
"""Load a single extension.
:param extension:
The extension to load, either a string, or a
:py:class:`~PyIRC.extensions.BaseExtension` instance. If extension
is a string, the extension is looked up in the list of presently
known extensions, favouring built-in PyIRC functions by default.
"""
if isinstance(extension, str):
# Get the extension from a string
extname = extension
extension = get_extension(extension)
if extension is None:
raise ValueError("Extension not found: {}".format(extname))
else:
extname = extension.__name__
if extname in self.extensions:
return
requires = getattr(extension, "requires", ())
for require in requires:
self.load_extension(require)
extension = self.extensions[extname] = extension(base=self,
**self.kwargs)
self.signals.bind(extension)
def unload_extension(self, extension):
"""Unload an extension.
:param extension:
The extension to unload, either a string, or a
:py:class:`~PyIRC.extension.BaseExtension` instance.
.. warning::
Reverse dependencies are not yet checked! Be careful when
unloading extensions. Also, since state is not saved in the
default modules, this should never be reused for reloading.
"""
if isinstance(extension, str):
extname = extension
else:
extname = extension.__name__
extension = self.extensions.pop(extname, None)
if extname is None:
raise ValueError("Extension not found: {}".format(extname))
self.signals.unbind(extension)
def get_extension_subclasses(self, base_extension, filter_extensions=None):
"""Find all subclasses of the given extension.
For the given extension class, return all subclasses of that extension
that are actually loaded right now.
Extensions will be returned in order of loading.
:param base_extension:
Extension base class to search for subclasses.
:param filter_extensions:
A list of extensions to filter out with the given class.
:returns:
A list of tuples containing the extension names and instances, in
order of loading.
"""
if filter_extensions is None:
filter_extensions = ()
return [(n, e) for n, e in self.extensions.items() if
isinstance(e, base_extension) and e.__class__ not in
filter_extensions]
def case_change(self):
"""Change server casemapping semantics.
Do not call this unless you know what you're doing
"""
if not hasattr(self, "isupport"):
case = "RFC1459"
else:
isupport = self.isupport # pylint: disable=no-member
case = isupport.get("CASEMAPPING").upper()
if case == "ASCII":
case = IRCString.ASCII
elif case == "RFC1459":
case = IRCString.RFC1459
else:
case = IRCString.UNICODE
if case == self.case:
return
self.case = case
self.call_event("protocol", "case_change")
def casefold(self, string):
"""Fold a nick according to server case folding rules.
:param string:
The string to casefold according to the IRC server semantics.
"""
return IRCString(self.case, string).casefold()
def casecmp(self, string, other):
"""Do a caseless comparison of two strings.
Returns True if equal, or False if not.
:param string:
String to compare
:param other:
String to compare
"""
return self.casefold(string) == self.casefold(other)
def get_extension(self, extension):
"""Get the instance of a given extension.
:returns:
The extension requested.
"""
return self.extensions[extension]
def call_event(self, hclass, event, *args, **kwargs):
"""Call an (hclass, event) signal.
If no args are passed in, and the signal is in a deferred state, the
arguments from the last call_event will be used.
:returns:
An (:py:class:`~PyIRC.base.Event`, return values from events)
tuple.
.. warning::
This does not preserve the Event instance for deferred calls.
"""
signal_name = (hclass, event)
signal = self.signals.get_signal(signal_name)
event = Event(signal_name, self)
if not signal.slots:
return (event, [])
return (event, signal.call(event, *args, **kwargs))
# pylint: disable=inconsistent-return-statements
def resume_event(self, hclass, event):
"""Resume a deferred event.
This is a small wrapper around
:py:meth:`~PyIRC.base.IRCBase.call_event`, but checks that the signal
is deferred.
:returns:
An (:py:class:`~PyIRC.base.Event`, return values from events)
tuple, if the event is deferred; else it returns None.
"""
signal = self.signals.get_signal((hclass, event))
if signal.last_status != signal.STATUS_DEFER:
return
return self.call_event(hclass, event)
def connect(self):
"""Do the connection handshake."""
return self.call_event("link", "connected")
def close(self):
"""Do the connection teardown."""
return self.call_event("link", "disconnected")
def recv(self, line):
"""Receive a line.
:param line:
A :class:`~PyIRC.line.Line` instance to recieve from the wire.
"""
command = line.command
self.call_event("commands", command, line)
@abstractmethod
def send(self, command, params):
"""Send a line out onto the wire.
:param command:
IRC command to send.
:param params:
A Sequence of parameters to send with the command. Only the last
parameter may contain spaces due to IRC framing format
limitations.
"""
line = Line(command=command, params=params)
event, results = self.call_event("commands_out", command, line)
if event.cancelled:
return None
return line
@abstractmethod
def schedule(self, time, callback):
"""Schedule a callback for a specific time.
Returns an object that can be passed to unschedule. The object should
be treated as opaque.
:param float time:
Seconds into the future to perform the callback.
:param callback:
Callback to perform. Use :meth:`functools.partial` to pass
arguments.
"""
raise NotImplementedError()
@abstractmethod
def unschedule(self, sched):
"""Unschedule a callback previously registered with schedule.
:param sched:
Event to unschedule returned by schedule.
"""
raise NotImplementedError()
def wrap_ssl(self):
"""Wrap the underlying connection with an SSL connection.
.. warning:: Not all backends support this!
"""
raise NotImplementedError()
class IRCBase(metaclass=ABCMeta):
"""The base IRC class meant to be used as a base for more concrete
implementations.
:ivar connected:
If True, we have connected to the server successfully.
:ivar registered:
If True, we have completed the server handshake and are ready
to send commands.
"""
def __init__(self, serverport, username, nick, gecos, extensions,
**kwargs):
"""Initialise the IRC base.
:param serverport:
(server, port) sequence, similar to the form passed to
socket.connect.
:param username:
The username to send to the server.
.. note:: identd may override this.
:param nick:
The nickname to use.
:param extensions:
Sequence of default extensions to use.
Keyword arguments (extensions may use others):
:key ssl:
Whether or not to use SSL. Set to an :py:class:`ssl.SSLContext``
to specify custom parameters, or ``True`` for defaults.
:key server_password:
Server password (PASS).
.. note::
Keyword arguments may be used by extensions. kwargs is passed
as-is to all extensions.
"""
super().__init__()
self.server, self.port = serverport
self.username = username
self.nick = nick
self.gecos = gecos
self.ssl = kwargs.get("ssl", False)
self.server_password = kwargs.get("server_password")
self.kwargs = kwargs
# Basic IRC state
self.connected = False
self.registered = False
self.case = IRCString.RFC1459
self.signals = SignalStorage()
# Extension manager system
if not extensions:
raise ValueError("Need at least one extension")
self.extensions = {}
for extension in extensions:
self.load_extension(extension)
# Do the signal storage binding for us now
self.signals.bind(self)
def load_extension(self, extension):
"""Load a single extension.
:param extension:
The extension to load, either a string, or a
:py:class:`~PyIRC.extension.ExtensionBase` instance. If extension
is a string, the extension is looked up in the list of presently
known extensions, favouring built-in PyIRC functions by default.
"""
if isinstance(extension, str):
# Get the extension from a string
extname = extension
extension = get_extension(extension)
if extension is None:
raise ValueError("Extension not found: {}".format(extname))
else:
extname = extension.__name__
if extname in self.extensions:
return
requires = getattr(extension, "requires", ())
for require in requires:
self.load_extension(require)
extension = self.extensions[extname] = extension(base=self,
**self.kwargs)
self.signals.bind(extension)
def unload_extension(self, extension):
"""Unload an extension.
:param extension:
The extension to unload, either a string, or a
:py:class:`~PyIRC.extension.ExtensionBase` instance.
.. warning::
Reverse dependencies are not yet checked! Be careful when
unloading extensions. Also, since state is not saved in the
default modules, this should never be reused for reloading.
"""
if isinstance(extension, str):
extname = extension
else:
extname = extension.__name__
extension = self.extensions.pop(extname, None)
if extname is None:
raise ValueError("Extension not found: {}".format(extname))
self.signals.unbind(extension)
def case_change(self):
"""Change server casemapping semantics.
Do not call this unless you know what you're doing
"""
if not hasattr(self, "isupport"):
case = "RFC1459"
else: