first commit

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*/__pycache__/
+logs/
+modules_old/
+default.cfg
+*.db
+*.pid
+*.dat
+*.txt
+tourettes.py
+

README.md

@@ -0,0 +1,4 @@
+NIGGER DICKS
+NIGGER DICKS
+NIGGER DICKS
+NIGGER DICKS

__init__.py

@@ -0,0 +1,101 @@
+# coding=utf-8
+# ASCII ONLY IN THIS FILE THOUGH!!!!!!!
+# Python does some stupid bullshit of respecting LC_ALL over the encoding on the
+# file, so in order to undo Python's ridiculous fucking idiocy, we have to have
+# our own check.
+
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Copyright 2012, Elsie Powell, http://embolalia.com
+# Copyright 2012, Elad Alfassa <elad@fedoraproject.org>
+#
+# Licensed under the Eiffel Forum License 2.
+import locale
+import sys
+loc = locale.getlocale()
+if sys.version_info.major > 2:
+    if not loc[1] or 'UTF-8' not in loc[1]:
+        print('WARNING!!! You are running with a non-UTF8 locale environment '
+              'variables (e.g. LC_ALL is set to "C"), which makes Python 3 do '
+              'stupid things. If you get strange errors, please set it to '
+              'something like "en_US.UTF-8".', file=sys.stderr)
+
+
+from collections import namedtuple
+import os
+import re
+import time
+import traceback
+import signal
+
+__version__ = '6.5.0'
+
+
+def _version_info(version=__version__):
+    regex = re.compile(r'(\d+)\.(\d+)\.(\d+)(?:(a|b|rc)(\d+))?.*')
+    version_groups = regex.match(__version__).groups()
+    major, minor, micro = (int(piece) for piece in version_groups[0:3])
+    level = version_groups[3]
+    serial = int(version_groups[4] or 0)
+    if level == 'a':
+        level = 'alpha'
+    elif level == 'b':
+        level = 'beta'
+    elif level == 'rc':
+        level = 'candidate'
+    elif not level and version_groups[4] is None:
+        level = 'final'
+    else:
+        level = 'alpha'
+    version_type = namedtuple('version_info',
+                              'major, minor, micro, releaselevel, serial')
+    return version_type(major, minor, micro, level, serial)
+version_info = _version_info()
+
+
+def run(config, pid_file, daemon=False):
+    import bot
+    import logger
+    from tools import stderr
+    delay = 20
+    # Inject ca_certs from config to web for SSL validation of web requests
+    if not config.core.ca_certs:
+        stderr('Could not open CA certificates file. SSL will not '
+               'work properly.')
+
+    def signal_handler(sig, frame):
+        if sig == signal.SIGUSR1 or sig == signal.SIGTERM:
+            stderr('Got quit signal, shutting down.')
+            p.quit('Closing')
+    while True:
+        try:
+            p = bot.Sopel(config, daemon=daemon)
+            if hasattr(signal, 'SIGUSR1'):
+                signal.signal(signal.SIGUSR1, signal_handler)
+            if hasattr(signal, 'SIGTERM'):
+                signal.signal(signal.SIGTERM, signal_handler)
+            logger.setup_logging(p)
+            p.run(config.core.host, int(config.core.port))
+        except KeyboardInterrupt:
+            break
+        except Exception:
+            trace = traceback.format_exc()
+            try:
+                stderr(trace)
+            except:
+                pass
+            logfile = open(os.path.join(config.core.logdir, 'exceptions.log'), 'a')
+            logfile.write('Critical exception in core')
+            logfile.write(trace)
+            logfile.write('----------------------------------------\n\n')
+            logfile.close()
+            os.unlink(pid_file)
+            os._exit(1)
+
+        if not isinstance(delay, int):
+            break
+        if p.hasquit:
+            break
+        stderr('Warning: Disconnected. Reconnecting in %s seconds...' % delay)
+        time.sleep(delay)
+    os.unlink(pid_file)
+    os._exit(0)

bot.py

@@ -0,0 +1,635 @@
+# coding=utf-8
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+# Copyright 2012-2015, Elsie Powell, http://embolalia.com
+#
+# Licensed under the Eiffel Forum License 2.
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import collections
+import os
+import re
+import sys
+import threading
+import time
+
+import tools
+import irc
+from db import SopelDB
+from tools import stderr, Identifier
+import tools.jobs
+from trigger import Trigger
+from module import NOLIMIT
+from logger import get_logger
+import loader
+
+
+LOGGER = get_logger(__name__)
+
+if sys.version_info.major >= 3:
+	unicode = str
+	basestring = str
+	py3 = True
+else:
+	py3 = False
+
+
+class _CapReq(object):
+	def __init__(self, prefix, module, failure=None, arg=None, success=None):
+		def nop(bot, cap):
+			pass
+		# TODO at some point, reorder those args to be sane
+		self.prefix = prefix
+		self.module = module
+		self.arg = arg
+		self.failure = failure or nop
+		self.success = success or nop
+
+
+class Sopel(irc.Bot):
+	def __init__(self, config, daemon=False):
+		irc.Bot.__init__(self, config)
+		self._daemon = daemon  # Used for iPython. TODO something saner here
+		# `re.compile('.*') is re.compile('.*')` because of caching, so we need
+		# to associate a list with each regex, since they are unexpectedly
+		# indistinct.
+		self._callables = {
+			'high': collections.defaultdict(list),
+			'medium': collections.defaultdict(list),
+			'low': collections.defaultdict(list)
+		}
+		self.config = config
+		"""The :class:`sopel.config.Config` for the current Sopel instance."""
+		self.doc = {}
+		"""
+		A dictionary of command names to their docstring and example, if
+		declared. The first item in a callable's commands list is used as the
+		key in version *3.2* onward. Prior to *3.2*, the name of the function
+		as declared in the source code was used.
+		"""
+		self._command_groups = collections.defaultdict(list)
+		"""A mapping of module names to a list of commands in it."""
+		self.stats = {}  # deprecated, remove in 7.0
+		self._times = {}
+		"""
+		A dictionary mapping lower-case'd nicks to dictionaries which map
+		funtion names to the time which they were last used by that nick.
+		"""
+
+		self.server_capabilities = {}
+		"""A dict mapping supported IRCv3 capabilities to their options.
+
+		For example, if the server specifies the capability ``sasl=EXTERNAL``,
+		it will be here as ``{"sasl": "EXTERNAL"}``. Capabilities specified
+		without any options will have ``None`` as the value.
+
+		For servers that do not support IRCv3, this will be an empty set."""
+		self.enabled_capabilities = set()
+		"""A set containing the IRCv3 capabilities that the bot has enabled."""
+		self._cap_reqs = dict()
+		"""A dictionary of capability names to a list of requests"""
+
+		self.privileges = dict()
+		"""A dictionary of channels to their users and privilege levels
+
+		The value associated with each channel is a dictionary of
+		:class:`sopel.tools.Identifier`\s to
+		a bitwise integer value, determined by combining the appropriate
+		constants from :mod:`sopel.module`.
+
+		.. deprecated:: 6.2.0
+			Use :attr:`channels` instead.
+		"""
+
+		self.channels = tools.SopelMemory()  # name to chan obj
+		"""A map of the channels that Sopel is in.
+
+		The keys are Identifiers of the channel names, and map to
+		:class:`sopel.tools.target.Channel` objects which contain the users in
+		the channel and their permissions.
+		"""
+		self.users = tools.SopelMemory()  # name to user obj
+		"""A map of the users that Sopel is aware of.
+
+		The keys are Identifiers of the nicknames, and map to
+		:class:`sopel.tools.target.User` instances. In order for Sopel to be
+		aware of a user, it must be in at least one channel which they are also
+		in.
+		"""
+
+		self.db = SopelDB(config)
+		"""The bot's database, as a :class:`sopel.db.SopelDB` instance."""
+
+		self.memory = tools.SopelMemory()
+		"""
+		A thread-safe dict for storage of runtime data to be shared between
+		modules. See :class:`sopel.tools.Sopel.SopelMemory`
+		"""
+
+		self.scheduler = tools.jobs.JobScheduler(self)
+		self.scheduler.start()
+
+		# Set up block lists
+		# Default to empty
+		if not self.config.core.nick_blocks:
+			self.config.core.nick_blocks = []
+		if not self.config.core.host_blocks:
+			self.config.core.host_blocks = []
+		self.setup()
+
+	# Backwards-compatibility aliases to attributes made private in 6.2. Remove
+	# these in 7.0
+	times = property(lambda self: getattr(self, '_times'))
+	command_groups = property(lambda self: getattr(self, '_command_groups'))
+
+	def write(self, args, text=None):  # Shim this in here for autodocs
+		"""Send a command to the server.
+
+		``args`` is an iterable of strings, which are joined by spaces.
+		``text`` is treated as though it were the final item in ``args``, but
+		is preceeded by a ``:``. This is a special case which  means that
+		``text``, unlike the items in ``args`` may contain spaces (though this
+		constraint is not checked by ``write``).
+
+		In other words, both ``sopel.write(('PRIVMSG',), 'Hello, world!')``
+		and ``sopel.write(('PRIVMSG', ':Hello, world!'))`` will send
+		``PRIVMSG :Hello, world!`` to the server.
+
+		Newlines and carriage returns ('\\n' and '\\r') are removed before
+		sending. Additionally, if the message (after joining) is longer than
+		than 510 characters, any remaining characters will not be sent.
+		"""
+		irc.Bot.write(self, args, text=text)
+
+	def setup(self):
+		stderr("\nWelcome to Sopel. Loading modules...\n\n")
+
+		modules = loader.enumerate_modules(self.config)
+
+		error_count = 0
+		success_count = 0
+		for name in modules:
+			path, type_ = modules[name]
+
+			try:
+				module, _ = loader.load_module(name, path, type_)
+			except Exception as e:
+				error_count = error_count + 1
+				filename, lineno = tools.get_raising_file_and_line()
+				rel_path = os.path.relpath(filename, os.path.dirname(__file__))
+				raising_stmt = "%s:%d" % (rel_path, lineno)
+				stderr("Error loading %s: %s (%s)" % (name, e, raising_stmt))
+			else:
+				try:
+					if hasattr(module, 'setup'):
+						module.setup(self)
+					relevant_parts = loader.clean_module(
+						module, self.config)
+				except Exception as e:
+					error_count = error_count + 1
+					filename, lineno = tools.get_raising_file_and_line()
+					rel_path = os.path.relpath(
+						filename, os.path.dirname(__file__)
+					)
+					raising_stmt = "%s:%d" % (rel_path, lineno)
+					stderr("Error in %s setup procedure: %s (%s)"
+						   % (name, e, raising_stmt))
+				else:
+					self.register(*relevant_parts)
+					success_count += 1
+
+		if len(modules) > 1:  # coretasks is counted
+			stderr('\n\nRegistered %d modules,' % (success_count - 1))
+			stderr('%d modules failed to load\n\n' % error_count)
+		else:
+			stderr("Warning: Couldn't load any modules")
+
+	def unregister(self, obj):
+		if not callable(obj):
+			return
+		if hasattr(obj, 'rule'):  # commands and intents have it added
+			for rule in obj.rule:
+				callb_list = self._callables[obj.priority][rule]
+				if obj in callb_list:
+					callb_list.remove(obj)
+		if hasattr(obj, 'interval'):
+			# TODO this should somehow find the right job to remove, rather than
+			# clearing the entire queue. Issue #831
+			self.scheduler.clear_jobs()
+		if (getattr(obj, '__name__', None) == 'shutdown'
+				and obj in self.shutdown_methods):
+			self.shutdown_methods.remove(obj)
+
+	def register(self, callables, jobs, shutdowns, urls):
+		self.shutdown_methods = shutdowns
+		for callbl in callables:
+			for rule in callbl.rule:
+				self._callables[callbl.priority][rule].append(callbl)
+			if hasattr(callbl, 'commands'):
+				module_name = callbl.__module__.rsplit('.', 1)[-1]
+				# TODO doc and make decorator for this. Not sure if this is how
+				# it should work yet, so not making it public for 6.0.
+				category = getattr(callbl, 'category', module_name)
+				self._command_groups[category].append(callbl.commands[0])
+			for command, docs in callbl._docs.items():
+				self.doc[command] = docs
+		for func in jobs:
+			for interval in func.interval:
+				job = tools.jobs.Job(interval, func)
+				self.scheduler.add_job(job)
+
+		if not self.memory.contains('url_callbacks'):
+			self.memory['url_callbacks'] = tools.SopelMemory()
+		for func in urls:
+			self.memory['url_callbacks'][func.url_regex] = func
+
+	def part(self, channel, msg=None):
+		"""Part a channel."""
+		self.write(['PART', channel], msg)
+
+	def join(self, channel, password=None):
+		"""Join a channel
+
+		If `channel` contains a space, and no `password` is given, the space is
+		assumed to split the argument into the channel to join and its
+		password.  `channel` should not contain a space if `password` is given.
+
+		"""
+		if password is None:
+			self.write(('JOIN', channel))
+		else:
+			self.write(['JOIN', channel, password])
+
+	def msg(self, recipient, text, max_messages=1):
+		# Deprecated, but way too much of a pain to remove.
+		self.say(text, recipient, max_messages)
+
+	def say(self, text, recipient, max_messages=1):
+		"""Send ``text`` as a PRIVMSG to ``recipient``.
+
+		In the context of a triggered callable, the ``recipient`` defaults to
+		the channel (or nickname, if a private message) from which the message
+		was received.
+
+		By default, this will attempt to send the entire ``text`` in one
+		message. If the text is too long for the server, it may be truncated.
+		If ``max_messages`` is given, the ``text`` will be split into at most
+		that many messages, each no more than 400 bytes. The split is made at
+		the last space character before the 400th byte, or at the 400th byte if
+		no such space exists. If the ``text`` is too long to fit into the
+		specified number of messages using the above splitting, the final
+		message will contain the entire remainder, which may be truncated by
+		the server.
+		"""
+		# We're arbitrarily saying that the max is 400 bytes of text when
+		# messages will be split. Otherwise, we'd have to acocunt for the bot's
+		# hostmask, which is hard.
+		max_text_length = 400
+		max_messages=1000
+		# Encode to bytes, for propper length calculation
+		if isinstance(text, unicode):
+			encoded_text = text.encode('utf-8')
+		else:
+			encoded_text = text
+		excess = ''
+		if b'\n' in encoded_text:
+			excess = encoded_text.split(b"\n", 1)[1]
+			encoded_text = encoded_text.split(b"\n", 1)[0]
+
+		if max_messages > 1 and len(encoded_text) > max_text_length:
+			last_space = encoded_text.rfind(' '.encode('utf-8'), 0, max_text_length)
+			if last_space == -1:
+				excess = encoded_text[max_text_length:]
+				encoded_text = encoded_text[:max_text_length]
+			else:
+				excess = encoded_text[last_space + 1:]
+				encoded_text = encoded_text[:last_space]
+		# We'll then send the excess at the end
+		# Back to unicode again, so we don't screw things up later.
+		text = encoded_text.decode('utf-8')
+		try:
+			self.sending.acquire()
+
+			# No messages within the last 3 seconds? Go ahead!
+			# Otherwise, wait so it's been at least 0.8 seconds + penalty
+
+			recipient_id = Identifier(recipient)
+
+			if recipient_id not in self.stack:
+				self.stack[recipient_id] = []
+
+			self.write(('PRIVMSG', recipient), text)
+			self.stack[recipient_id].append((time.time(), self.safe(text)))
+			self.stack[recipient_id] = self.stack[recipient_id][-10:]
+		finally:
+			self.sending.release()
+		# Now that we've sent the first part, we need to send the rest. Doing
+		# this recursively seems easier to me than iteratively
+		if excess:
+			self.msg(recipient, excess, max_messages - 1)
+
+	def notice(self, text, dest):
+		"""Send an IRC NOTICE to a user or a channel.
+
+		Within the context of a triggered callable, ``dest`` will default to
+		the channel (or nickname, if a private message), in which the trigger
+		happened.
+		"""
+		self.write(('NOTICE', dest), text)
+
+	def action(self, text, dest):
+		"""Send ``text`` as a CTCP ACTION PRIVMSG to ``dest``.
+
+		The same loop detection and length restrictions apply as with
+		:func:`say`, though automatic message splitting is not available.
+
+		Within the context of a triggered callable, ``dest`` will default to
+		the channel (or nickname, if a private message), in which the trigger
+		happened.
+		"""
+		self.say('\001ACTION {}\001'.format(text), dest)
+
+	def reply(self, text, dest, reply_to, notice=False):
+		"""Prepend ``reply_to`` to ``text``, and send as a PRIVMSG to ``dest``.
+
+		If ``notice`` is ``True``, send a NOTICE rather than a PRIVMSG.
+
+		The same loop detection and length restrictions apply as with
+		:func:`say`, though automatic message splitting is not available.
+
+		Within the context of a triggered callable, ``reply_to`` will default to
+		the nickname of the user who triggered the call, and ``dest`` to the
+		channel (or nickname, if a private message), in which the trigger
+		happened.
+		"""
+		text = '%s: %s' % (reply_to, text)
+		if notice:
+			self.notice(text, dest)
+		else:
+			self.say(text, dest)
+
+	class SopelWrapper(object):
+		def __init__(self, sopel, trigger):
+			# The custom __setattr__ for this class sets the attribute on the
+			# original bot object. We don't want that for these, so we set them
+			# with the normal __setattr__.
+			object.__setattr__(self, '_bot', sopel)
+			object.__setattr__(self, '_trigger', trigger)
+
+		def __dir__(self):
+			classattrs = [attr for attr in self.__class__.__dict__
+						  if not attr.startswith('__')]
+			return list(self.__dict__) + classattrs + dir(self._bot)
+
+		def __getattr__(self, attr):
+			return getattr(self._bot, attr)
+
+		def __setattr__(self, attr, value):
+			return setattr(self._bot, attr, value)
+
+		def say(self, message, destination=None, max_messages=1):
+			if destination is None:
+				destination = self._trigger.sender
+			self._bot.say(message, destination, max_messages)
+
+		def action(self, message, destination=None):
+			if destination is None:
+				destination = self._trigger.sender
+			self._bot.action(message, destination)
+
+		def notice(self, message, destination=None):
+			if destination is None:
+				destination = self._trigger.sender
+			self._bot.notice(message, destination)
+
+		def reply(self, message, destination=None, reply_to=None, notice=False):
+			if destination is None:
+				destination = self._trigger.sender
+			if reply_to is None:
+				reply_to = self._trigger.nick
+			self._bot.reply(message, destination, reply_to, notice)
+
+	def call(self, func, sopel, trigger):
+		nick = trigger.nick
+		current_time = time.time()
+		if nick not in self._times:
+			self._times[nick] = dict()
+		if self.nick not in self._times:
+			self._times[self.nick] = dict()
+		if not trigger.is_privmsg and trigger.sender not in self._times:
+			self._times[trigger.sender] = dict()
+
+		if not trigger.admin and not func.unblockable:
+			if func in self._times[nick]:
+				usertimediff = current_time - self._times[nick][func]
+				if func.rate > 0 and usertimediff < func.rate:
+					#self._times[nick][func] = current_time
+					LOGGER.info(
+						"%s prevented from using %s in %s due to user limit: %d < %d",
+						trigger.nick, func.__name__, trigger.sender, usertimediff,
+						func.rate
+					)
+					return
+			if func in self._times[self.nick]:
+				globaltimediff = current_time - self._times[self.nick][func]
+				if func.global_rate > 0 and globaltimediff < func.global_rate:
+					#self._times[self.nick][func] = current_time
+					LOGGER.info(
+						"%s prevented from using %s in %s due to global limit: %d < %d",
+						trigger.nick, func.__name__, trigger.sender, globaltimediff,
+						func.global_rate
+					)
+					return
+
+			if not trigger.is_privmsg and func in self._times[trigger.sender]:
+				chantimediff = current_time - self._times[trigger.sender][func]
+				if func.channel_rate > 0 and chantimediff < func.channel_rate:
+					#self._times[trigger.sender][func] = current_time
+					LOGGER.info(
+						"%s prevented from using %s in %s due to channel limit: %d < %d",
+						trigger.nick, func.__name__, trigger.sender, chantimediff,
+						func.channel_rate
+					)
+					return
+
+		try:
+			exit_code = func(sopel, trigger)
+		except Exception:
+			exit_code = None
+			self.error(trigger)
+
+		if exit_code != NOLIMIT:
+			self._times[nick][func] = current_time
+			self._times[self.nick][func] = current_time
+			if not trigger.is_privmsg:
+				self._times[trigger.sender][func] = current_time
+
+	def dispatch(self, pretrigger):
+		args = pretrigger.args
+		event, args, text = pretrigger.event, args, args[-1] if args else ''
+
+		if self.config.core.nick_blocks or self.config.core.host_blocks:
+			nick_blocked = self._nick_blocked(pretrigger.nick)
+			host_blocked = self._host_blocked(pretrigger.host)
+		else:
+			nick_blocked = host_blocked = None
+
+		list_of_blocked_functions = []
+		for priority in ('high', 'medium', 'low'):
+			items = self._callables[priority].items()
+
+			for regexp, funcs in items:
+				match = regexp.match(text)
+				if not match:
+					continue
+				user_obj = self.users.get(pretrigger.nick)
+				account = user_obj.account if user_obj else None
+				trigger = Trigger(self.config, pretrigger, match, account)
+				wrapper = self.SopelWrapper(self, trigger)
+
+				for func in funcs:
+					if (not trigger.admin and
+							not func.unblockable and
+							(nick_blocked or host_blocked)):
+						function_name = "%s.%s" % (
+							func.__module__, func.__name__
+						)
+						list_of_blocked_functions.append(function_name)
+						continue
+
+					if event not in func.event:
+						continue
+					if (hasattr(func, 'intents') and
+							trigger.tags.get('intent') not in func.intents):
+						continue
+					if func.thread:
+						targs = (func, wrapper, trigger)
+						t = threading.Thread(target=self.call, args=targs)
+						t.start()
+					else:
+						self.call(func, wrapper, trigger)
+
+		if list_of_blocked_functions:
+			if nick_blocked and host_blocked:
+				block_type = 'both'
+			elif nick_blocked:
+				block_type = 'nick'
+			else:
+				block_type = 'host'
+			LOGGER.info(
+				"[%s]%s prevented from using %s.",
+				block_type,
+				trigger.nick,
+				', '.join(list_of_blocked_functions)
+			)
+
+	def _host_blocked(self, host):
+		bad_masks = self.config.core.host_blocks
+		for bad_mask in bad_masks:
+			bad_mask = bad_mask.strip()
+			if not bad_mask:
+				continue
+			if (re.match(bad_mask + '$', host, re.IGNORECASE) or
+					bad_mask == host):
+				return True
+		return False
+
+	def _nick_blocked(self, nick):
+		bad_nicks = self.config.core.nick_blocks
+		for bad_nick in bad_nicks:
+			bad_nick = bad_nick.strip()
+			if not bad_nick:
+				continue
+			if (re.match(bad_nick + '$', nick, re.IGNORECASE) or
+					Identifier(bad_nick) == nick):
+				return True
+		return False
+
+	def _shutdown(self):
+		stderr(
+			'Calling shutdown for %d modules.' % (len(self.shutdown_methods),)
+		)
+
+		for shutdown_method in self.shutdown_methods:
+			try:
+				stderr(
+					"calling %s.%s" % (
+						shutdown_method.__module__, shutdown_method.__name__,
+					)
+				)
+				shutdown_method(self)
+			except Exception as e:
+				stderr(
+					"Error calling shutdown method for module %s:%s" % (
+						shutdown_method.__module__, e
+					)
+				)
+
+	def cap_req(self, module_name, capability, arg=None, failure_callback=None,
+				success_callback=None):
+		"""Tell Sopel to request a capability when it starts.
+
+		By prefixing the capability with `-`, it will be ensured that the
+		capability is not enabled. Simmilarly, by prefixing the capability with
+		`=`, it will be ensured that the capability is enabled. Requiring and
+		disabling is "first come, first served"; if one module requires a
+		capability, and another prohibits it, this function will raise an
+		exception in whichever module loads second. An exception will also be
+		raised if the module is being loaded after the bot has already started,
+		and the request would change the set of enabled capabilities.
+
+		If the capability is not prefixed, and no other module prohibits it, it
+		will be requested.  Otherwise, it will not be requested. Since
+		capability requests that are not mandatory may be rejected by the
+		server, as well as by other modules, a module which makes such a
+		request should account for that possibility.
+
+		The actual capability request to the server is handled after the
+		completion of this function. In the event that the server denies a
+		request, the `failure_callback` function will be called, if provided.
+		The arguments will be a `Sopel` object, and the capability which was
+		rejected. This can be used to disable callables which rely on the
+		capability. It will be be called either if the server NAKs the request,
+		or if the server enabled it and later DELs it.
+
+		The `success_callback` function will be called upon acknowledgement of
+		the capability from the server, whether during the initial capability
+		negotiation, or later.
+
+		If ``arg`` is given, and does not exactly match what the server
+		provides or what other modules have requested for that capability, it is
+		considered a conflict.
+		"""
+		# TODO raise better exceptions
+		cap = capability[1:]
+		prefix = capability[0]
+
+		entry = self._cap_reqs.get(cap, [])
+		if any((ent.arg != arg for ent in entry)):
+			raise Exception('Capability conflict')
+
+		if prefix == '-':
+			if self.connection_registered and cap in self.enabled_capabilities:
+				raise Exception('Can not change capabilities after server '
+								'connection has been completed.')
+			if any((ent.prefix != '-' for ent in entry)):
+				raise Exception('Capability conflict')
+			entry.append(_CapReq(prefix, module_name, failure_callback, arg,
+								 success_callback))
+			self._cap_reqs[cap] = entry
+		else:
+			if prefix != '=':
+				cap = capability
+				prefix = ''
+			if self.connection_registered and (cap not in
+											   self.enabled_capabilities):
+				raise Exception('Can not change capabilities after server '
+								'connection has been completed.')
+			# Non-mandatory will callback at the same time as if the server
+			# rejected it.
+			if any((ent.prefix == '-' for ent in entry)) and prefix == '=':
+				raise Exception('Capability conflict')
+			entry.append(_CapReq(prefix, module_name, failure_callback, arg,
+								 success_callback))
+			self._cap_reqs[cap] = entry

config/__init__.py

@@ -0,0 +1,263 @@
+# coding=utf-8
+"""
+The config object provides a simplified to access Sopel's configuration file.
+The sections of the file are attributes of the object, and the keys in the
+section are attributes of that. So, for example, the ``eggs`` attribute in the
+``[spam]`` section can be accessed from ``config.spam.eggs``.
+
+Section definitions (see "Section configuration sections" below) can be added
+to the config object with ``define_section``. When this is done, only the
+defined keys will be available. A section can not be given more than one
+definition. The ``[core]`` section is defined with ``CoreSection`` when the
+object is initialized.
+
+.. versionadded:: 6.0.0
+"""
+# Copyright 2012-2015, Elsie Powell, embolalia.com
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+# Licensed under the Eiffel Forum License 2.
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+from tools import iteritems, stderr
+import tools
+from tools import get_input
+import loader
+import os
+import sys
+if sys.version_info.major < 3:
+    import ConfigParser
+else:
+    basestring = str
+    import configparser as ConfigParser
+import config.core_section
+from config.types import StaticSection
+
+
+class ConfigurationError(Exception):
+    """ Exception type for configuration errors """
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return 'ConfigurationError: %s' % self.value
+
+
+class Config(object):
+    def __init__(self, filename, validate=True):
+        """The bot's configuration.
+
+        The given filename will be associated with the configuration, and is
+        the file which will be written if write() is called. If load is not
+        given or True, the configuration object will load the attributes from
+        the file at filename.
+
+        A few default values will be set here if they are not defined in the
+        config file, or a config file is not loaded. They are documented below.
+        """
+        self.filename = filename
+        """The config object's associated file, as noted above."""
+        self.parser = ConfigParser.RawConfigParser(allow_no_value=True)
+        self.parser.read(self.filename)
+        self.define_section('core', config.core_section.CoreSection,
+                            validate=validate)
+        self.get = self.parser.get
+
+    @property
+    def homedir(self):
+        """An alias to config.core.homedir"""
+        # Technically it's the other way around, so we can bootstrap filename
+        # attributes in the core section, but whatever.
+        configured = None
+        if self.parser.has_option('core', 'homedir'):
+            configured = self.parser.get('core', 'homedir')
+        if configured:
+            return configured
+        else:
+            return os.path.dirname(self.filename)
+
+    def save(self):
+        """Save all changes to the config file."""
+        cfgfile = open(self.filename, 'w')
+        self.parser.write(cfgfile)
+        cfgfile.flush()
+        cfgfile.close()
+
+    def add_section(self, name):
+        """Add a section to the config file.
+
+        Returns ``False`` if already exists.
+        """
+        try:
+            return self.parser.add_section(name)
+        except ConfigParser.DuplicateSectionError:
+            return False
+
+    def define_section(self, name, cls_, validate=True):
+        """Define the available settings in a section.
+
+        ``cls_`` must be a subclass of ``StaticSection``. If the section has
+        already been defined with a different class, ValueError is raised.
+
+        If ``validate`` is True, the section's values will be validated, and an
+        exception raised if they are invalid. This is desirable in a module's
+        setup function, for example, but might not be in the configure function.
+        """
+        if not issubclass(cls_, StaticSection):
+            raise ValueError("Class must be a subclass of StaticSection.")
+        current = getattr(self, name, None)
+        current_name = str(current.__class__)
+        new_name = str(cls_)
+        if (current is not None and not isinstance(current, self.ConfigSection)
+                and not current_name == new_name):
+            raise ValueError(
+                "Can not re-define class for section from {} to {}.".format(
+                    current_name, new_name)
+            )
+        setattr(self, name, cls_(self, name, validate=validate))
+
+    class ConfigSection(object):
+
+        """Represents a section of the config file.
+
+        Contains all keys in thesection as attributes.
+
+        """
+
+        def __init__(self, name, items, parent):
+            object.__setattr__(self, '_name', name)
+            object.__setattr__(self, '_parent', parent)
+            for item in items:
+                value = item[1].strip()
+                if not value.lower() == 'none':
+                    if value.lower() == 'false':
+                        value = False
+                    object.__setattr__(self, item[0], value)
+
+        def __getattr__(self, name):
+            return None
+
+        def __setattr__(self, name, value):
+            object.__setattr__(self, name, value)
+            if type(value) is list:
+                value = ','.join(value)
+            self._parent.parser.set(self._name, name, value)
+
+        def get_list(self, name):
+            value = getattr(self, name)
+            if not value:
+                return []
+            if isinstance(value, basestring):
+                value = value.split(',')
+                # Keep the split value, so we don't have to keep doing this
+                setattr(self, name, value)
+            return value
+
+    def __getattr__(self, name):
+        if name in self.parser.sections():
+            items = self.parser.items(name)
+            section = self.ConfigSection(name, items, self)  # Return a section
+            setattr(self, name, section)
+            return section
+        else:
+            raise AttributeError("%r object has no attribute %r"
+                                 % (type(self).__name__, name))
+
+    def option(self, question, default=False):
+        """Ask "y/n" and return the corresponding boolean answer.
+
+        Show user in terminal a "y/n" prompt, and return true or false based on
+        the response. If default is passed as true, the default will be shown
+        as ``[y]``, else it will be ``[n]``. ``question`` should be phrased as
+        a question, but without a question mark at the end.
+
+        """
+        d = 'n'
+        if default:
+            d = 'y'
+        ans = get_input(question + ' (y/n)? [' + d + '] ')
+        if not ans:
+            ans = d
+        return ans.lower() == 'y'
+
+    def _modules(self):
+        home = os.getcwd()
+        modules_dir = os.path.join(home, 'modules')
+        filenames = sopel.loader.enumerate_modules(self)
+        os.sys.path.insert(0, modules_dir)
+        for name, mod_spec in iteritems(filenames):
+            path, type_ = mod_spec
+            try:
+                module, _ = sopel.loader.load_module(name, path, type_)
+            except Exception as e:
+                filename, lineno = sopel.tools.get_raising_file_and_line()
+                rel_path = os.path.relpath(filename, os.path.dirname(__file__))
+                raising_stmt = "%s:%d" % (rel_path, lineno)
+                stderr("Error loading %s: %s (%s)" % (name, e, raising_stmt))
+            else:
+                if hasattr(module, 'configure'):
+                    prompt = name + ' module'
+                    if module.__doc__:
+                        doc = module.__doc__.split('\n', 1)[0]
+                        if doc:
+                            prompt = doc
+                    prompt = 'Configure {} (y/n)? [n]'.format(prompt)
+                    do_configure = get_input(prompt)
+                    do_configure = do_configure and do_configure.lower() == 'y'
+                    if do_configure:
+                        module.configure(self)
+        self.save()
+
+
+def _wizard(section, config=None):
+    dotdir = os.path.expanduser('~/.sopel')
+    configpath = os.path.join(dotdir, (config or 'default') + '.cfg')
+    if section == 'all':
+        _create_config(configpath)
+    elif section == 'mod':
+        _check_dir(False)
+        if not os.path.isfile(configpath):
+            print("No config file found." +
+                  " Please make one before configuring these options.")
+            sys.exit(1)
+        config = Config(configpath, validate=False)
+        config._modules()
+
+
+def _check_dir(create=True):
+    dotdir = os.path.join(os.path.expanduser('~'), '.sopel')
+    if not os.path.isdir(dotdir):
+        if create:
+            print('Creating a config directory at ~/.sopel...')
+            try:
+                os.makedirs(dotdir)
+            except Exception as e:
+                print('There was a problem creating %s:' % dotdir, file=sys.stderr)
+                print('%s, %s' % (e.__class__, str(e)), file=sys.stderr)
+                print('Please fix this and then run Sopel again.', file=sys.stderr)
+                sys.exit(1)
+        else:
+            print("No config file found. Please make one before configuring these options.")
+            sys.exit(1)
+
+
+def _create_config(configpath):
+    _check_dir()
+    print("Please answer the following questions" +
+          " to create your configuration file:\n")
+    try:
+        config = Config(configpath, validate=False)
+        sopel.config.core_section.configure(config)
+        if config.option(
+            'Would you like to see if there are any modules'
+            ' that need configuring'
+        ):
+            config._modules()
+        config.save()
+    except Exception:
+        print("Encountered an error while writing the config file." +
+              " This shouldn't happen. Check permissions.")
+        raise
+        sys.exit(1)
+    print("Config file written sucessfully!")

config/core_section.py

@@ -0,0 +1,200 @@
+# coding=utf-8
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import os.path
+
+from config.types import (
+    StaticSection, ValidatedAttribute, ListAttribute, ChoiceAttribute,
+    FilenameAttribute, NO_DEFAULT
+)
+from tools import Identifier
+
+
+def _find_certs():
+    certs = '/etc/pki/tls/cert.pem'
+    if not os.path.isfile(certs):
+        certs = '/etc/ssl/certs/ca-certificates.crt'
+        if not os.path.isfile(certs):
+            return None
+    return certs
+
+
+def configure(config):
+    config.core.configure_setting('nick', 'Enter the nickname for your bot.')
+    config.core.configure_setting('host', 'Enter the server to connect to.')
+    config.core.configure_setting('use_ssl', 'Should the bot connect with SSL?')
+    if config.core.use_ssl:
+        default_port = 6697
+    else:
+        default_port = 6667
+    config.core.configure_setting('port', 'Enter the port to connect on.',
+                                  default=default_port)
+    config.core.configure_setting(
+        'owner', "Enter your own IRC name (or that of the bot's owner)")
+    config.core.configure_setting(
+        'channels',
+        'Enter the channels to connect to at startup, separated by commas.'
+    )
+
+
+class CoreSection(StaticSection):
+    """The config section used for configuring the bot itself."""
+    admins = ListAttribute('admins')
+    """The list of people (other than the owner) who can administer the bot"""
+
+    admin_accounts = ListAttribute('admin_accounts')
+    """The list of accounts (other than the owner's) who can administer the bot.
+
+    This should not be set for networks that do not support IRCv3 account
+    capabilities."""
+
+    auth_method = ChoiceAttribute('auth_method', choices=[
+        'nickserv', 'authserv', 'Q', 'sasl', 'server'])
+    """The method to use to authenticate with the server.
+
+    Can be ``nickserv``, ``authserv``, ``Q``, ``sasl``, or ``server``."""
+
+    auth_password = ValidatedAttribute('auth_password')
+    """The password to use to authenticate with the server."""
+
+    auth_target = ValidatedAttribute('auth_target')
+    """The user to use for nickserv authentication, or the SASL mechanism.
+
+    May not apply, depending on ``auth_method``. Defaults to NickServ for
+    nickserv auth, and PLAIN for SASL auth."""
+
+    auth_username = ValidatedAttribute('auth_username')
+    """The username/account to use to authenticate with the server.
+
+    May not apply, depending on ``auth_method``."""
+
+    bind_host = ValidatedAttribute('bind_host')
+    """Bind the connection to a specific IP"""
+
+    ca_certs = FilenameAttribute('ca_certs', default=_find_certs())
+    """The path of the CA certs pem file"""
+
+    channels = ListAttribute('channels')
+    """List of channels for the bot to join when it connects"""
+
+    db_filename = ValidatedAttribute('db_filename')
+    """The filename for Sopel's database."""
+
+    default_time_format = ValidatedAttribute('default_time_format',
+                                             default='%Y-%m-%d - %T%Z')
+    """The default format to use for time in messages."""
+
+    default_timezone = ValidatedAttribute('default_timezone')
+    """The default timezone to use for time in messages."""
+
+    enable = ListAttribute('enable')
+    """A whitelist of the only modules you want to enable."""
+
+    exclude = ListAttribute('exclude')
+    """A list of modules which should not be loaded."""
+
+    extra = ListAttribute('extra')
+    """A list of other directories you'd like to include modules from."""
+
+    help_prefix = ValidatedAttribute('help_prefix', default='.')
+    """The prefix to use in help"""
+
+    @property
+    def homedir(self):
+        """The directory in which various files are stored at runtime.
+
+        By default, this is the same directory as the config. It can not be
+        changed at runtime.
+        """
+        return self._parent.homedir
+
+    host = ValidatedAttribute('host', default='irc.dftba.net')
+    """The server to connect to."""
+
+    host_blocks = ListAttribute('host_blocks')
+    """A list of hostmasks which Sopel should ignore.
+
+    Regular expression syntax is used"""
+
+    log_raw = ValidatedAttribute('log_raw', bool, default=True)
+    """Whether a log of raw lines as sent and recieved should be kept."""
+
+    logdir = FilenameAttribute('logdir', directory=True, default='logs')
+    """Directory in which to place logs."""
+
+    logging_channel = ValidatedAttribute('logging_channel', Identifier)
+    """The channel to send logging messages to."""
+
+    logging_level = ChoiceAttribute('logging_level',
+                                    ['CRITICAL', 'ERROR', 'WARNING', 'INFO',
+                                     'DEBUG'],
+                                    'WARNING')
+    """The lowest severity of logs to display."""
+
+    modes = ValidatedAttribute('modes', default='B')
+    """User modes to be set on connection."""
+
+    name = ValidatedAttribute('name', default='Sopel: http://sopel.chat')
+    """The "real name" of your bot for WHOIS responses."""
+
+    nick = ValidatedAttribute('nick', Identifier, default=Identifier('Sopel'))
+    """The nickname for the bot"""
+
+    nick_blocks = ListAttribute('nick_blocks')
+    """A list of nicks which Sopel should ignore.
+
+    Regular expression syntax is used."""
+
+    not_configured = ValidatedAttribute('not_configured', bool, default=False)
+    """For package maintainers. Not used in normal configurations.
+
+    This allows software packages to install a default config file, with this
+    set to true, so that the bot will not run until it has been properly
+    configured."""
+
+    owner = ValidatedAttribute('owner', default=NO_DEFAULT)
+    """The IRC name of the owner of the bot."""
+
+    owner_account = ValidatedAttribute('owner_account')
+    """The services account name of the owner of the bot.
+
+    This should only be set on networks which support IRCv3 account
+    capabilities.
+    """
+
+    pid_dir = FilenameAttribute('pid_dir', directory=True, default='.')
+    """The directory in which to put the file Sopel uses to track its process ID.
+
+    You probably do not need to change this unless you're managing Sopel with
+    systemd or similar."""
+
+    port = ValidatedAttribute('port', int, default=6667)
+    """The port to connect on."""
+
+    prefix = ValidatedAttribute('prefix', default='\.')
+    """The prefix to add to the beginning of commands.
+
+    It is a regular expression (so the default, ``\.``, means commands start
+    with a period), though using capturing groups will create problems."""
+
+    reply_errors = ValidatedAttribute('reply_errors', bool, default=True)
+    """Whether to message the sender of a message that triggered an error with the exception."""
+
+    throttle_join = ValidatedAttribute('throttle_join', int)
+    """Slow down the initial join of channels to prevent getting kicked.
+
+    Sopel will only join this many channels at a time, sleeping for a second
+    between each batch. This is unnecessary on most networks."""
+
+    timeout = ValidatedAttribute('timeout', int, default=120)
+    """The amount of time acceptable between pings before timing out."""
+
+    use_ssl = ValidatedAttribute('use_ssl', bool, default=False)
+    """Whether to use a SSL secured connection."""
+
+    user = ValidatedAttribute('user', default='sopel')
+    """The "user" for your bot (the part before the @ in the hostname)."""
+
+    verify_ssl = ValidatedAttribute('verify_ssl', bool, default=True)
+    """Whether to require a trusted SSL certificate for SSL connections."""

config/types.py

@@ -0,0 +1,351 @@
+# coding=utf-8
+"""Types for creating section definitions.
+
+A section definition consists of a subclass of ``StaticSection``, on which any
+number of subclasses of ``BaseValidated`` (a few common ones of which are
+available in this module) are assigned as attributes. These descriptors define
+how to read values from, and write values to, the config file.
+
+As an example, if one wanted to define the ``[spam]`` section as having an
+``eggs`` option, which contains a list of values, they could do this:
+
+    >>> class SpamSection(StaticSection):
+    ...     eggs = ListAttribute('eggs')
+    ...
+    >>> SpamSection(config, 'spam')
+    >>> print(config.spam.eggs)
+    []
+    >>> config.spam.eggs = ['goose', 'turkey', 'duck', 'chicken', 'quail']
+    >>> print(config.spam.eggs)
+    ['goose', 'turkey', 'duck', 'chicken', 'quail']
+    >>> config.spam.eggs = 'herring'
+    Traceback (most recent call last):
+        ...
+    ValueError: ListAttribute value must be a list.
+"""
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+import os.path
+import sys
+from tools import get_input
+
+try:
+    import configparser
+except ImportError:
+    import ConfigParser as configparser
+
+if sys.version_info.major >= 3:
+    unicode = str
+    basestring = (str, bytes)
+
+
+class NO_DEFAULT(object):
+    """A special value to indicate that there should be no default."""
+
+
+class StaticSection(object):
+    """A configuration section with parsed and validated settings.
+
+    This class is intended to be subclassed with added ``ValidatedAttribute``\s.
+    """
+    def __init__(self, config, section_name, validate=True):
+        if not config.parser.has_section(section_name):
+            config.parser.add_section(section_name)
+        self._parent = config
+        self._parser = config.parser
+        self._section_name = section_name
+        for value in dir(self):
+            try:
+                getattr(self, value)
+            except ValueError as e:
+                raise ValueError(
+                    'Invalid value for {}.{}: {}'.format(section_name, value,
+                                                         str(e))
+                )
+            except AttributeError:
+                if validate:
+                    raise ValueError(
+                        'Missing required value for {}.{}'.format(section_name,
+                                                                  value)
+                    )
+
+    def configure_setting(self, name, prompt, default=NO_DEFAULT):
+        """Return a validated value for this attribute from the terminal.
+
+        ``prompt`` will be the docstring of the attribute if not given.
+
+        If ``default`` is passed, it will be used if no value is given by the
+        user. If it is not passed, the current value of the setting, or the
+        default value if it's unset, will be used. Note that if ``default`` is
+        passed, the current value of the setting will be ignored, even if it is
+        not the attribute's default.
+        """
+        clazz = getattr(self.__class__, name)
+        if default is NO_DEFAULT:
+            try:
+                default = getattr(self, name)
+            except AttributeError:
+                pass
+            except ValueError:
+                print('The configured value for this option was invalid.')
+                if clazz.default is not NO_DEFAULT:
+                    default = clazz.default
+        while True:
+            try:
+                value = clazz.configure(prompt, default, self._parent, self._section_name)
+            except ValueError as exc:
+                print(exc)
+            else:
+                break
+        setattr(self, name, value)
+
+
+class BaseValidated(object):
+    """The base type for a descriptor in a ``StaticSection``."""
+    def __init__(self, name, default=None):
+        """
+        ``name`` is the name of the setting in the section.
+        ``default`` is the value to be returned if the setting is not set. If
+        not given, AttributeError will be raised instead.
+        """
+        self.name = name
+        self.default = default
+
+    def configure(self, prompt, default, parent, section_name):
+        """With the prompt and default, parse and return a value from terminal.
+        """
+        if default is not NO_DEFAULT and default is not None:
+            prompt = '{} [{}]'.format(prompt, default)
+        value = get_input(prompt + ' ')
+        if not value and default is NO_DEFAULT:
+            raise ValueError("You must provide a value for this option.")
+        value = value or default
+        return self.parse(value)
+
+    def serialize(self, value):
+        """Take some object, and return the string to be saved to the file.
+
+        Must be implemented in subclasses.
+        """
+        raise NotImplemented("Serialize method must be implemented in subclass")
+
+    def parse(self, value):
+        """Take a string from the file, and return the appropriate object.
+
+        Must be implemented in subclasses."""
+        raise NotImplemented("Parse method must be implemented in subclass")
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            # If instance is None, we're getting from a section class, not an
+            # instance of a session class. It makes the wizard code simpler
+            # (and is really just more intuitive) to return the descriptor
+            # instance here.
+            return self
+
+        if instance._parser.has_option(instance._section_name, self.name):
+            value = instance._parser.get(instance._section_name, self.name)
+        else:
+            if self.default is not NO_DEFAULT:
+                return self.default
+            raise AttributeError(
+                "Missing required value for {}.{}".format(
+                    instance._section_name, self.name
+                )
+            )
+        return self.parse(value)
+
+    def __set__(self, instance, value):
+        if value is None:
+            instance._parser.remove_option(instance._section_name, self.name)
+            return
+        value = self.serialize(value)
+        instance._parser.set(instance._section_name, self.name, value)
+
+    def __delete__(self, instance):
+        instance._parser.remove_option(instance._section_name, self.name)
+
+
+def _parse_boolean(value):
+    if value is True or value == 1:
+        return value
+    if isinstance(value, basestring):
+        return value.lower() in ['1', 'yes', 'y', 'true', 'on']
+    return bool(value)
+
+
+def _serialize_boolean(value):
+    return 'true' if _parse_boolean(value) else 'false'
+
+
+class ValidatedAttribute(BaseValidated):
+    def __init__(self, name, parse=None, serialize=None, default=None):
+        """A descriptor for settings in a ``StaticSection``
+
+        ``parse`` is the function to be used to read the string and create the
+        appropriate object. If not given, return the string as-is.
+        ``serialize`` takes an object, and returns the value to be written to
+        the file. If not given, defaults to ``unicode``.
+        """
+        self.name = name
+        if parse == bool:
+            parse = _parse_boolean
+            if not serialize or serialize == bool:
+                serialize = _serialize_boolean
+        self.parse = parse or self.parse
+        self.serialize = serialize or self.serialize
+        self.default = default
+
+    def serialize(self, value):
+        return unicode(value)
+
+    def parse(self, value):
+        return value
+
+    def configure(self, prompt, default, parent, section_name):
+        if self.parse == _parse_boolean:
+            prompt += ' (y/n)'
+            default = 'y' if default else 'n'
+        return super(ValidatedAttribute, self).configure(prompt, default, parent, section_name)
+
+
+class ListAttribute(BaseValidated):
+    """A config attribute containing a list of string values.
+
+    Values are saved to the file as a comma-separated list. It does not
+    currently support commas within items in the list. By default, the spaces
+    before and after each item are stripped; you can override this by passing
+    ``strip=False``."""
+    def __init__(self, name, strip=True, default=None):
+        default = default or []
+        super(ListAttribute, self).__init__(name, default=default)
+        self.strip = strip
+
+    def parse(self, value):
+        value = value.split(',')
+        if self.strip:
+            return [v.strip() for v in value]
+        else:
+            return value
+
+    def serialize(self, value):
+        if not isinstance(value, (list, set)):
+            raise ValueError('ListAttribute value must be a list.')
+        return ','.join(value)
+
+    def configure(self, prompt, default, parent, section_name):
+        each_prompt = '?'
+        if isinstance(prompt, tuple):
+            each_prompt = prompt[1]
+            prompt = prompt[0]
+
+        if default is not NO_DEFAULT:
+            default = ','.join(default)
+            prompt = '{} [{}]'.format(prompt, default)
+        else:
+            default = ''
+        print(prompt)
+        values = []
+        value = get_input(each_prompt + ' ') or default
+        while value:
+            values.append(value)
+            value = get_input(each_prompt + ' ')
+        return self.parse(','.join(values))
+
+
+class ChoiceAttribute(BaseValidated):
+    """A config attribute which must be one of a set group of options.
+
+    Currently, the choices can only be strings."""
+    def __init__(self, name, choices, default=None):
+        super(ChoiceAttribute, self).__init__(name, default=default)
+        self.choices = choices
+
+    def parse(self, value):
+        if value in self.choices:
+            return value
+        else:
+            raise ValueError('Value must be in {}'.format(self.choices))
+
+    def serialize(self, value):
+        if value in self.choices:
+            return value
+        else:
+            raise ValueError('Value must be in {}'.format(self.choices))
+
+
+class FilenameAttribute(BaseValidated):
+    """A config attribute which must be a file or directory."""
+    def __init__(self, name, relative=True, directory=False, default=None):
+        """
+        ``relative`` is whether the path should be relative to the location
+        of the config file (absolute paths will still be absolute). If
+        ``directory`` is True, the path must indicate a directory, rather than
+        a file.
+        """
+        super(FilenameAttribute, self).__init__(name, default=default)
+        self.relative = relative
+        self.directory = directory
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if instance._parser.has_option(instance._section_name, self.name):
+            value = instance._parser.get(instance._section_name, self.name)
+        else:
+            if self.default is not NO_DEFAULT:
+                value = self.default
+            else:
+                raise AttributeError(
+                    "Missing required value for {}.{}".format(
+                        instance._section_name, self.name
+                    )
+                )
+        main_config = instance._parent
+        this_section = getattr(main_config, instance._section_name)
+        return self.parse(main_config, this_section, value)
+
+    def __set__(self, instance, value):
+        main_config = instance._parent
+        this_section = getattr(main_config, instance._section_name)
+        value = self.serialize(main_config, this_section, value)
+        instance._parser.set(instance._section_name, self.name, value)
+
+    def configure(self, prompt, default, parent, section_name):
+        """With the prompt and default, parse and return a value from terminal.
+        """
+        if default is not NO_DEFAULT and default is not None:
+            prompt = '{} [{}]'.format(prompt, default)
+        value = get_input(prompt + ' ')
+        if not value and default is NO_DEFAULT:
+            raise ValueError("You must provide a value for this option.")
+        value = value or default
+        return self.parse(parent, section_name, value)
+
+    def parse(self, main_config, this_section, value):
+        if value is None:
+            return
+
+        value = os.path.expanduser(value)
+
+        if not os.path.isabs(value):
+            if not self.relative:
+                raise ValueError("Value must be an absolute path.")
+            value = os.path.join(main_config.homedir, value)
+
+        if self.directory and not os.path.isdir(value):
+            try:
+                os.makedirs(value)
+            except OSError:
+                raise ValueError(
+                    "Value must be an existing or creatable directory.")
+        if not self.directory and not os.path.isfile(value):
+            try:
+                open(value, 'w').close()
+            except OSError:
+                raise ValueError("Value must be an existant or creatable file.")
+        return value
+
+    def serialize(self, main_config, this_section, value):
+        self.parse(main_config, this_section, value)
+        return value  # So that it's still relative

coretasks.py

@@ -0,0 +1,719 @@
+# coding=utf-8
+"""Tasks that allow the bot to run, but aren't user-facing functionality
+
+This is written as a module to make it easier to extend to support more
+responses to standard IRC codes without having to shove them all into the
+dispatch function in bot.py and making it easier to maintain.
+"""
+# Copyright 2008-2011, Sean B. Palmer (inamidst.com) and Michael Yanovich
+# (yanovich.net)
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+# Copyright 2012-2015, Elsie Powell embolalia.com
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+
+from random import randint
+import re
+import sys
+import time
+import module
+from bot import _CapReq
+from tools import Identifier, iteritems, events
+from tools.target import User, Channel
+import base64
+from logger import get_logger
+
+if sys.version_info.major >= 3:
+    unicode = str
+
+LOGGER = get_logger(__name__)
+
+batched_caps = {}
+who_reqs = {}  # Keeps track of reqs coming from this module, rather than others
+
+
+def auth_after_register(bot):
+    """Do NickServ/AuthServ auth"""
+    if bot.config.core.auth_method == 'nickserv':
+        nickserv_name = bot.config.core.auth_target or 'NickServ'
+        bot.msg(
+            nickserv_name,
+            'IDENTIFY %s' % bot.config.core.auth_password
+        )
+
+    elif bot.config.core.auth_method == 'authserv':
+        account = bot.config.core.auth_username
+        password = bot.config.core.auth_password
+        bot.write((
+            'AUTHSERV auth',
+            account + ' ' + password
+        ))
+    
+    elif bot.config.core.auth_method == 'Q':
+        account = bot.config.core.auth_username
+        password = bot.config.core.auth_password
+        bot.write((
+            'AUTH',
+            account + ' ' + password
+        ))
+
+
+@module.event(events.RPL_WELCOME, events.RPL_LUSERCLIENT)
+@module.rule('.*')
+@module.thread(False)
+@module.unblockable
+def startup(bot, trigger):
+    """Do tasks related to connecting to the network.
+
+    001 RPL_WELCOME is from RFC2812 and is the first message that is sent after
+    the connection has been registered on the network.
+
+    251 RPL_LUSERCLIENT is a mandatory message that is sent after client
+    connects to the server in rfc1459. RFC2812 does not require it and all
+    networks might not send it. We support both.
+
+    """
+    if bot.connection_registered:
+        return
+
+    bot.connection_registered = True
+
+    auth_after_register(bot)
+
+    modes = bot.config.core.modes
+    bot.write(('MODE ', '%s +%s' % (bot.nick, modes)))
+
+    bot.memory['retry_join'] = dict()
+
+    if bot.config.core.throttle_join:
+        throttle_rate = int(bot.config.core.throttle_join)
+        channels_joined = 0
+        for channel in bot.config.core.channels:
+            channels_joined += 1
+            if not channels_joined % throttle_rate:
+                time.sleep(1)
+            bot.join(channel)
+    else:
+        for channel in bot.config.core.channels:
+            bot.join(channel)
+
+    if (not bot.config.core.owner_account and
+            'account-tag' in bot.enabled_capabilities and
+            '@' not in bot.config.core.owner):
+        msg = (
+            "This network supports using network services to identify you as "
+            "my owner, rather than just matching your nickname. This is much "
+            "more secure. If you'd like to do this, make sure you're logged in "
+            "and reply with \"{}useserviceauth\""
+        ).format(bot.config.core.help_prefix)
+        bot.msg(bot.config.core.owner, msg)
+
+
+@module.require_privmsg()
+@module.require_owner()
+@module.commands('useserviceauth')
+def enable_service_auth(bot, trigger):
+    if bot.config.core.owner_account:
+        return
+    if 'account-tag' not in bot.enabled_capabilities:
+        bot.say('This server does not fully support services auth, so this '
+                'command is not available.')
+        return
+    if not trigger.account:
+        bot.say('You must be logged in to network services before using this '
+                'command.')
+        return
+    bot.config.core.owner_account = trigger.account
+    bot.config.save()
+    bot.say('Success! I will now use network services to identify you as my '
+            'owner.')
+
+
+@module.event(events.ERR_NOCHANMODES)
+@module.rule('.*')
+@module.priority('high')
+def retry_join(bot, trigger):
+    """Give NickServer enough time to identify on a +R channel.
+
+    Give NickServ enough time to identify, and retry rejoining an
+    identified-only (+R) channel. Maximum of ten rejoin attempts.
+
+    """
+    channel = trigger.args[1]
+    if channel in bot.memory['retry_join'].keys():
+        bot.memory['retry_join'][channel] += 1
+        if bot.memory['retry_join'][channel] > 10:
+            LOGGER.warning('Failed to join %s after 10 attempts.', channel)
+            return
+    else:
+        bot.memory['retry_join'][channel] = 0
+        bot.join(channel)
+        return
+
+    time.sleep(6)
+    bot.join(channel)
+
+
+@module.rule('(.*)')
+@module.event(events.RPL_NAMREPLY)
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def handle_names(bot, trigger):
+    """Handle NAMES response, happens when joining to channels."""
+    names = trigger.split()
+
+    #TODO specific to one channel type. See issue 281.
+    channels = re.search('(#\S*)', trigger.raw)
+    if not channels:
+        return
+    channel = Identifier(channels.group(1))
+    if channel not in bot.privileges:
+        bot.privileges[channel] = dict()
+
+    # This could probably be made flexible in the future, but I don't think
+    # it'd be worth it.
+    mapping = {'+': module.VOICE,
+               '%': module.HALFOP,
+               '@': module.OP,
+               '&': module.ADMIN,
+               '~': module.OWNER}
+
+    for name in names:
+        priv = 0
+        for prefix, value in iteritems(mapping):
+            if prefix in name:
+                priv = priv | value
+        nick = Identifier(name.lstrip(''.join(mapping.keys())))
+        bot.privileges[channel][nick] = priv
+
+
+@module.rule('(.*)')
+@module.event('MODE')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_modes(bot, trigger):
+    """Track usermode changes and keep our lists of ops up to date."""
+    # Mode message format: <channel> *( ( "-" / "+" ) *<modes> *<modeparams> )
+    channel = Identifier(trigger.args[0])
+    line = trigger.args[1:]
+
+    # If the first character of where the mode is being set isn't a #
+    # then it's a user mode, not a channel mode, so we'll ignore it.
+    if channel.is_nick():
+        return
+
+    mapping = {'v': module.VOICE,
+               'h': module.HALFOP,
+               'o': module.OP,
+               'a': module.ADMIN,
+               'q': module.OWNER}
+
+    modes = []
+    for arg in line:
+        if len(arg) == 0:
+            continue
+        if arg[0] in '+-':
+            # There was a comment claiming IRC allows e.g. MODE +aB-c foo, but
+            # I don't see it in any RFCs. Leaving in the extra parsing for now.
+            sign = ''
+            modes = []
+            for char in arg:
+                if char == '+' or char == '-':
+                    sign = char
+                else:
+                    modes.append(sign + char)
+        else:
+            arg = Identifier(arg)
+            for mode in modes:
+                priv = bot.privileges[channel].get(arg, 0)
+                value = mapping.get(mode[1])
+                if value is not None:
+                    if mode[0] == '+':
+                        priv = priv | value
+                    else:
+                        priv = priv & ~value
+                    bot.privileges[channel][arg] = priv
+
+
+@module.rule('.*')
+@module.event('NICK')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_nicks(bot, trigger):
+    """Track nickname changes and maintain our chanops list accordingly."""
+    old = trigger.nick
+    new = Identifier(trigger)
+
+    # Give debug mssage, and PM the owner, if the bot's own nick changes.
+    if old == bot.nick and new != bot.nick:
+        privmsg = ("Hi, I'm your bot, %s."
+                   "Something has made my nick change. "
+                   "This can cause some problems for me, "
+                   "and make me do weird things. "
+                   "You'll probably want to restart me, "
+                   "and figure out what made that happen "
+                   "so you can stop it happening again. "
+                   "(Usually, it means you tried to give me a nick "
+                   "that's protected by NickServ.)") % bot.nick
+        debug_msg = ("Nick changed by server. "
+            "This can cause unexpected behavior. Please restart the bot.")
+        LOGGER.critical(debug_msg)
+        bot.msg(bot.config.core.owner, privmsg)
+        return
+
+    for channel in bot.privileges:
+        channel = Identifier(channel)
+        if old in bot.privileges[channel]:
+            value = bot.privileges[channel].pop(old)
+            bot.privileges[channel][new] = value
+
+    for channel in bot.channels.values():
+        channel.rename_user(old, new)
+    if old in bot.users:
+        bot.users[new] = bot.users.pop(old)
+
+
+@module.rule('(.*)')
+@module.event('PART')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_part(bot, trigger):
+    nick = trigger.nick
+    channel = trigger.sender
+    _remove_from_channel(bot, nick, channel)
+
+
+@module.rule('.*')
+@module.event('KICK')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_kick(bot, trigger):
+    nick = Identifier(trigger.args[1])
+    channel = trigger.sender
+    _remove_from_channel(bot, nick, channel)
+
+
+def _remove_from_channel(bot, nick, channel):
+    if nick == bot.nick:
+        bot.privileges.pop(channel, None)
+        bot.channels.pop(channel, None)
+
+        lost_users = []
+        for nick_, user in bot.users.items():
+            user.channels.pop(channel, None)
+            if not user.channels:
+                lost_users.append(nick_)
+        for nick_ in lost_users:
+            bot.users.pop(nick_, None)
+    else:
+        bot.privileges[channel].pop(nick, None)
+
+        user = bot.users.get(nick)
+        if user and channel in user.channels:
+            bot.channels[channel].clear_user(nick)
+            if not user.channels:
+                bot.users.pop(nick, None)
+
+
+def _whox_enabled(bot):
+    # Either privilege tracking or away notification. For simplicity, both
+    # account notify and extended join must be there for account tracking.
+    return (('account-notify' in bot.enabled_capabilities and
+             'extended-join' in bot.enabled_capabilities) or
+            'away-notify' in bot.enabled_capabilities)
+
+
+def _send_who(bot, channel):
+    if _whox_enabled(bot):
+        # WHOX syntax, see http://faerion.sourceforge.net/doc/irc/whox.var
+        # Needed for accounts in who replies. The random integer is a param
+        # to identify the reply as one from this command, because if someone
+        # else sent it, we have no fucking way to know what the format is.
+        rand = str(randint(0, 999))
+        while rand in who_reqs:
+            rand = str(randint(0, 999))
+        who_reqs[rand] = channel
+        bot.write(['WHO', channel, 'a%nuachtf,' + rand])
+    else:
+        # We might be on an old network, but we still care about keeping our
+        # user list updated
+        bot.write(['WHO', channel])
+
+
+@module.rule('.*')
+@module.event('JOIN')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_join(bot, trigger):
+    if trigger.nick == bot.nick and trigger.sender not in bot.channels:
+        bot.write(('TOPIC', trigger.sender))
+
+        bot.privileges[trigger.sender] = dict()
+        bot.channels[trigger.sender] = Channel(trigger.sender)
+        _send_who(bot, trigger.sender)
+
+    bot.privileges[trigger.sender][trigger.nick] = 0
+
+    user = bot.users.get(trigger.nick)
+    if user is None:
+        user = User(trigger.nick, trigger.user, trigger.host)
+        bot.users[trigger.nick] = user
+    bot.channels[trigger.sender].add_user(user)
+
+    if len(trigger.args) > 1 and trigger.args[1] != '*' and (
+            'account-notify' in bot.enabled_capabilities and
+            'extended-join' in bot.enabled_capabilities):
+        user.account = trigger.args[1]
+
+
+@module.rule('.*')
+@module.event('QUIT')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_quit(bot, trigger):
+    for chanprivs in bot.privileges.values():
+        chanprivs.pop(trigger.nick, None)
+    for channel in bot.channels.values():
+        channel.clear_user(trigger.nick)
+    bot.users.pop(trigger.nick, None)
+
+
+@module.rule('.*')
+@module.event('CAP')
+@module.thread(False)
+@module.priority('high')
+@module.unblockable
+def recieve_cap_list(bot, trigger):
+    cap = trigger.strip('-=~')
+    # Server is listing capabilites
+    if trigger.args[1] == 'LS':
+        recieve_cap_ls_reply(bot, trigger)
+    # Server denied CAP REQ
+    elif trigger.args[1] == 'NAK':
+        entry = bot._cap_reqs.get(cap, None)
+        # If it was requested with bot.cap_req
+        if entry:
+            for req in entry:
+                # And that request was mandatory/prohibit, and a callback was
+                # provided
+                if req.prefix and req.failure:
+                    # Call it.
+                    req.failure(bot, req.prefix + cap)
+    # Server is removing a capability
+    elif trigger.args[1] == 'DEL':
+        entry = bot._cap_reqs.get(cap, None)
+        # If it was requested with bot.cap_req
+        if entry:
+            for req in entry:
+                # And that request wasn't prohibit, and a callback was
+                # provided
+                if req.prefix != '-' and req.failure:
+                    # Call it.
+                    req.failure(bot, req.prefix + cap)
+    # Server is adding new capability
+    elif trigger.args[1] == 'NEW':
+        entry = bot._cap_reqs.get(cap, None)
+        # If it was requested with bot.cap_req
+        if entry:
+            for req in entry:
+                # And that request wasn't prohibit
+                if req.prefix != '-':
+                    # Request it
+                    bot.write(('CAP', 'REQ', req.prefix + cap))
+    # Server is acknowledging a capability
+    elif trigger.args[1] == 'ACK':
+        caps = trigger.args[2].split()
+        for cap in caps:
+            cap.strip('-~= ')
+            bot.enabled_capabilities.add(cap)
+            entry = bot._cap_reqs.get(cap, [])
+            for req in entry:
+                if req.success:
+                    req.success(bot, req.prefix + trigger)
+            if cap == 'sasl':  # TODO why is this not done with bot.cap_req?
+                recieve_cap_ack_sasl(bot)
+
+
+def recieve_cap_ls_reply(bot, trigger):
+    if bot.server_capabilities:
+        # We've already seen the results, so someone sent CAP LS from a module.
+        # We're too late to do SASL, and we don't want to send CAP END before
+        # the module has done what it needs to, so just return
+        return
+
+    for cap in trigger.split():
+        c = cap.split('=')
+        if len(c) == 2:
+            batched_caps[c[0]] = c[1]
+        else:
+            batched_caps[c[0]] = None
+
+    # Not the last in a multi-line reply. First two args are * and LS.
+    if trigger.args[2] == '*':
+        return
+
+    bot.server_capabilities = batched_caps
+
+    # If some other module requests it, we don't need to add another request.
+    # If some other module prohibits it, we shouldn't request it.
+    core_caps = ['multi-prefix', 'away-notify', 'cap-notify', 'server-time']
+    for cap in core_caps:
+        if cap not in bot._cap_reqs:
+            bot._cap_reqs[cap] = [_CapReq('', 'coretasks')]
+
+    def acct_warn(bot, cap):
+        LOGGER.info('Server does not support %s, or it conflicts with a custom '
+                    'module. User account validation unavailable or limited.',
+                    cap[1:])
+        if bot.config.core.owner_account or bot.config.core.admin_accounts:
+            LOGGER.warning(
+                'Owner or admin accounts are configured, but %s is not '
+                'supported by the server. This may cause unexpected behavior.',
+                cap[1:])
+    auth_caps = ['account-notify', 'extended-join', 'account-tag']
+    for cap in auth_caps:
+        if cap not in bot._cap_reqs:
+            bot._cap_reqs[cap] = [_CapReq('=', 'coretasks', acct_warn)]
+
+    for cap, reqs in iteritems(bot._cap_reqs):
+        # At this point, we know mandatory and prohibited don't co-exist, but
+        # we need to call back for optionals if they're also prohibited
+        prefix = ''
+        for entry in reqs:
+            if prefix == '-' and entry.prefix != '-':
+                entry.failure(bot, entry.prefix + cap)
+                continue
+            if entry.prefix:
+                prefix = entry.prefix
+
+        # It's not required, or it's supported, so we can request it
+        if prefix != '=' or cap in bot.server_capabilities:
+            # REQs fail as a whole, so we send them one capability at a time
+            bot.write(('CAP', 'REQ', entry.prefix + cap))
+        # If it's required but not in server caps, we need to call all the
+        # callbacks
+        else:
+            for entry in reqs:
+                if entry.failure and entry.prefix == '=':
+                    entry.failure(bot, entry.prefix + cap)
+
+    # If we want to do SASL, we have to wait before we can send CAP END. So if
+    # we are, wait on 903 (SASL successful) to send it.
+    if bot.config.core.auth_method == 'sasl':
+        bot.write(('CAP', 'REQ', 'sasl'))
+    else:
+        bot.write(('CAP', 'END'))
+
+
+def recieve_cap_ack_sasl(bot):
+    # Presumably we're only here if we said we actually *want* sasl, but still
+    # check anyway.
+    password = bot.config.core.auth_password
+    if not password:
+        return
+    mech = bot.config.core.auth_target or 'PLAIN'
+    bot.write(('AUTHENTICATE', mech))
+
+
+@module.event('AUTHENTICATE')
+@module.rule('.*')
+def auth_proceed(bot, trigger):
+    if trigger.args[0] != '+':
+        # How did we get here? I am not good with computer.
+        return
+    # Is this right?
+    sasl_username = bot.config.core.auth_username or bot.nick
+    sasl_password = bot.config.core.auth_password
+    sasl_token = '\0'.join((sasl_username, sasl_username, sasl_password))
+    # Spec says we do a base 64 encode on the SASL stuff
+    bot.write(('AUTHENTICATE', base64.b64encode(sasl_token.encode('utf-8'))))
+
+
+@module.event(events.RPL_SASLSUCCESS)
+@module.rule('.*')
+def sasl_success(bot, trigger):
+    bot.write(('CAP', 'END'))
+
+
+#Live blocklist editing
+
+
+@module.commands('blocks')
+@module.priority('low')
+@module.thread(False)
+@module.unblockable
+def blocks(bot, trigger):
+    """Manage Sopel's blocking features.
+
+    https://github.com/sopel-irc/sopel/wiki/Making-Sopel-ignore-people
+
+    """
+    if not trigger.admin:
+        return
+
+    STRINGS = {
+        "success_del": "Successfully deleted block: %s",
+        "success_add": "Successfully added block: %s",
+        "no_nick": "No matching nick block found for: %s",
+        "no_host": "No matching hostmask block found for: %s",
+        "invalid": "Invalid format for %s a block. Try: .blocks add (nick|hostmask) sopel",
+        "invalid_display": "Invalid input for displaying blocks.",
+        "nonelisted": "No %s listed in the blocklist.",
+        'huh': "I could not figure out what you wanted to do.",
+    }
+
+    masks = set(s for s in bot.config.core.host_blocks if s != '')
+    nicks = set(Identifier(nick)
+                for nick in bot.config.core.nick_blocks
+                if nick != '')
+    text = trigger.group().split()
+
+    if len(text) == 3 and text[1] == "list":
+        if text[2] == "hostmask":
+            if len(masks) > 0:
+                blocked = ', '.join(unicode(mask) for mask in masks)
+                bot.say("Blocked hostmasks: {}".format(blocked))
+            else:
+                bot.reply(STRINGS['nonelisted'] % ('hostmasks'))
+        elif text[2] == "nick":
+            if len(nicks) > 0:
+                blocked = ', '.join(unicode(nick) for nick in nicks)
+                bot.say("Blocked nicks: {}".format(blocked))
+            else:
+                bot.reply(STRINGS['nonelisted'] % ('nicks'))
+        else:
+            bot.reply(STRINGS['invalid_display'])
+
+    elif len(text) == 4 and text[1] == "add":
+        if text[2] == "nick":
+            nicks.add(text[3])
+            bot.config.core.nick_blocks = nicks
+            bot.config.save()
+        elif text[2] == "hostmask":
+            masks.add(text[3].lower())
+            bot.config.core.host_blocks = list(masks)
+        else:
+            bot.reply(STRINGS['invalid'] % ("adding"))
+            return
+
+        bot.reply(STRINGS['success_add'] % (text[3]))
+
+    elif len(text) == 4 and text[1] == "del":
+        if text[2] == "nick":
+            if Identifier(text[3]) not in nicks:
+                bot.reply(STRINGS['no_nick'] % (text[3]))
+                return
+            nicks.remove(Identifier(text[3]))
+            bot.config.core.nick_blocks = [unicode(n) for n in nicks]
+            bot.config.save()
+            bot.reply(STRINGS['success_del'] % (text[3]))
+        elif text[2] == "hostmask":
+            mask = text[3].lower()
+            if mask not in masks:
+                bot.reply(STRINGS['no_host'] % (text[3]))
+                return
+            masks.remove(mask)
+            bot.config.core.host_blocks = [unicode(m) for m in masks]
+            bot.config.save()
+            bot.reply(STRINGS['success_del'] % (text[3]))
+        else:
+            bot.reply(STRINGS['invalid'] % ("deleting"))
+            return
+    else:
+        bot.reply(STRINGS['huh'])
+
+
+@module.event('ACCOUNT')
+@module.rule('.*')
+def account_notify(bot, trigger):
+    if trigger.nick not in bot.users:
+        bot.users[trigger.nick] = User(trigger.nick, trigger.user, trigger.host)
+    account = trigger.args[0]
+    if account == '*':
+        account = None
+    bot.users[trigger.nick].account = account
+
+
+@module.event(events.RPL_WHOSPCRPL)
+@module.rule('.*')
+@module.priority('high')
+@module.unblockable
+def recv_whox(bot, trigger):
+    if len(trigger.args) < 2 or trigger.args[1] not in who_reqs:
+        # Ignored, some module probably called WHO
+        return
+    if len(trigger.args) != 8:
+        return LOGGER.warning('While populating `bot.accounts` a WHO response was malformed.')
+    _, _, channel, user, host, nick, status, account = trigger.args
+    away = 'G' in status
+    _record_who(bot, channel, user, host, nick, account, away)
+
+
+def _record_who(bot, channel, user, host, nick, account=None, away=None):
+    nick = Identifier(nick)
+    channel = Identifier(channel)
+    if nick not in bot.users:
+        bot.users[nick] = User(nick, user, host)
+    user = bot.users[nick]
+    if account == '0':
+        user.account = None
+    else:
+        user.account = account
+    user.away = away
+    if channel not in bot.channels:
+        bot.channels[channel] = Channel(channel)
+    bot.channels[channel].add_user(user)
+
+
+@module.event(events.RPL_WHOREPLY)
+@module.rule('.*')
+@module.priority('high')
+@module.unblockable
+def recv_who(bot, trigger):
+    channel, user, host, _, nick, = trigger.args[1:6]
+    _record_who(bot, channel, user, host, nick)
+
+
+@module.event(events.RPL_ENDOFWHO)
+@module.rule('.*')
+@module.priority('high')
+@module.unblockable
+def end_who(bot, trigger):
+    if _whox_enabled(bot):
+        who_reqs.pop(trigger.args[1], None)
+
+
+@module.rule('.*')
+@module.event('AWAY')
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_notify(bot, trigger):
+    if trigger.nick not in bot.users:
+        bot.users[trigger.nick] = User(trigger.nick, trigger.user, trigger.host)
+    user = bot.users[trigger.nick]
+    user.away = bool(trigger.args)
+
+
+@module.rule('.*')
+@module.event('TOPIC')
+@module.event(events.RPL_TOPIC)
+@module.priority('high')
+@module.thread(False)
+@module.unblockable
+def track_topic(bot, trigger):
+    if trigger.event != 'TOPIC':
+        channel = trigger.args[1]
+    else:
+        channel = trigger.args[0]
+    if channel not in bot.channels:
+        return
+    bot.channels[channel].topic = trigger.args[-1]

db.py

@@ -0,0 +1,247 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import json
+import os.path
+import sys
+import sqlite3
+
+from tools import Identifier
+
+if sys.version_info.major >= 3:
+    unicode = str
+    basestring = str
+
+
+def _deserialize(value):
+    if value is None:
+        return None
+    # sqlite likes to return ints for strings that look like ints, even though
+    # the column type is string. That's how you do dynamic typing wrong.
+    value = unicode(value)
+    # Just in case someone's mucking with the DB in a way we can't account for,
+    # ignore json parsing errors
+    try:
+        value = json.loads(value)
+    except:
+        pass
+    return value
+
+
+class SopelDB(object):
+    """*Availability: 5.0+*
+
+    This defines an interface for basic, common operations on a sqlite
+    database. It simplifies those common operations, and allows direct access
+    to the database, wherever the user has configured it to be.
+
+    When configured with a relative filename, it is assumed to be in the same
+    directory as the config."""
+
+    def __init__(self, config):
+        path = config.core.db_filename
+        config_dir, config_file = os.path.split(config.filename)
+        config_name, _ = os.path.splitext(config_file)
+        if path is None:
+            path = os.path.join(config_dir, config_name + '.db')
+        path = os.path.expanduser(path)
+        if not os.path.isabs(path):
+            path = os.path.normpath(os.path.join(config_dir, path))
+        self.filename = path
+        self._create()
+
+    def connect(self):
+        """Return a raw database connection object."""
+        return sqlite3.connect(self.filename, timeout=10)
+
+    def execute(self, *args, **kwargs):
+        """Execute an arbitrary SQL query against the database.
+
+        Returns a cursor object, on which things like `.fetchall()` can be
+        called per PEP 249."""
+        with self.connect() as conn:
+            cur = conn.cursor()
+            return cur.execute(*args, **kwargs)
+
+    def _create(self):
+        """Create the basic database structure."""
+        # Do nothing if the db already exists.
+        try:
+            self.execute('SELECT * FROM nick_ids;')
+            self.execute('SELECT * FROM nicknames;')
+            self.execute('SELECT * FROM nick_values;')
+            self.execute('SELECT * FROM channel_values;')
+        except:
+            pass
+        else:
+            return
+
+        self.execute(
+            'CREATE TABLE nick_ids (nick_id INTEGER PRIMARY KEY AUTOINCREMENT)'
+        )
+        self.execute(
+            'CREATE TABLE nicknames '
+            '(nick_id INTEGER REFERENCES nick_ids, '
+            'slug STRING PRIMARY KEY, canonical string)'
+        )
+        self.execute(
+            'CREATE TABLE nick_values '
+            '(nick_id INTEGER REFERENCES nick_ids(nick_id), '
+            'key STRING, value STRING, '
+            'PRIMARY KEY (nick_id, key))'
+        )
+        self.execute(
+            'CREATE TABLE channel_values '
+            '(channel STRING, key STRING, value STRING, '
+            'PRIMARY KEY (channel, key))'
+        )
+
+    def get_uri(self):
+        """Returns a URL for the database, usable to connect with SQLAlchemy.
+        """
+        return 'sqlite://{}'.format(self.filename)
+
+    # NICK FUNCTIONS
+
+    def get_nick_id(self, nick, create=True):
+        """Return the internal identifier for a given nick.
+
+        This identifier is unique to a user, and shared across all of that
+        user's aliases. If create is True, a new ID will be created if one does
+        not already exist"""
+        slug = nick.lower()
+        nick_id = self.execute('SELECT nick_id from nicknames where slug = ?',
+                               [slug]).fetchone()
+        if nick_id is None:
+            if not create:
+                raise ValueError('No ID exists for the given nick')
+            with self.connect() as conn:
+                cur = conn.cursor()
+                cur.execute('INSERT INTO nick_ids VALUES (NULL)')
+                nick_id = cur.execute('SELECT last_insert_rowid()').fetchone()[0]
+                cur.execute(
+                    'INSERT INTO nicknames (nick_id, slug, canonical) VALUES '
+                    '(?, ?, ?)',
+                    [nick_id, slug, nick]
+                )
+            nick_id = self.execute('SELECT nick_id from nicknames where slug = ?',
+                                   [slug]).fetchone()
+        return nick_id[0]
+
+    def alias_nick(self, nick, alias):
+        """Create an alias for a nick.
+
+        Raises ValueError if the alias already exists. If nick does not already
+        exist, it will be added along with the alias."""
+        nick = Identifier(nick)
+        alias = Identifier(alias)
+        nick_id = self.get_nick_id(nick)
+        sql = 'INSERT INTO nicknames (nick_id, slug, canonical) VALUES (?, ?, ?)'
+        values = [nick_id, alias.lower(), alias]
+        try:
+            self.execute(sql, values)
+        except sqlite3.IntegrityError:
+            raise ValueError('Alias already exists.')
+
+    def set_nick_value(self, nick, key, value):
+        """Sets the value for a given key to be associated with the nick."""
+        nick = Identifier(nick)
+        value = json.dumps(value, ensure_ascii=False)
+        nick_id = self.get_nick_id(nick)
+        self.execute('INSERT OR REPLACE INTO nick_values VALUES (?, ?, ?)',
+                     [nick_id, key, value])
+
+    def get_nick_value(self, nick, key):
+        """Retrieves the value for a given key associated with a nick."""
+        nick = Identifier(nick)
+        result = self.execute(
+            'SELECT value FROM nicknames JOIN nick_values '
+            'ON nicknames.nick_id = nick_values.nick_id '
+            'WHERE slug = ? AND key = ?',
+            [nick.lower(), key]
+        ).fetchone()
+        if result is not None:
+            result = result[0]
+        return _deserialize(result)
+
+    def unalias_nick(self, alias):
+        """Removes an alias.
+
+        Raises ValueError if there is not at least one other nick in the group.
+        To delete an entire group, use `delete_group`.
+        """
+        alias = Identifier(alias)
+        nick_id = self.get_nick_id(alias, False)
+        count = self.execute('SELECT COUNT(*) FROM nicknames WHERE nick_id = ?',
+                             [nick_id]).fetchone()[0]
+        if count <= 1:
+            raise ValueError('Given alias is the only entry in its group.')
+        self.execute('DELETE FROM nicknames WHERE slug = ?', [alias.lower()])
+
+    def delete_nick_group(self, nick):
+        """Removes a nickname, and all associated aliases and settings.
+        """
+        nick = Identifier(nick)
+        nick_id = self.get_nick_id(nick, False)
+        self.execute('DELETE FROM nicknames WHERE nick_id = ?', [nick_id])
+        self.execute('DELETE FROM nick_values WHERE nick_id = ?', [nick_id])
+
+    def merge_nick_groups(self, first_nick, second_nick):
+        """Merges the nick groups for the specified nicks.
+
+        Takes two nicks, which may or may not be registered.  Unregistered
+        nicks will be registered. Keys which are set for only one of the given
+        nicks will be preserved. Where multiple nicks have values for a given
+        key, the value set for the first nick will be used.
+
+        Note that merging of data only applies to the native key-value store.
+        If modules define their own tables which rely on the nick table, they
+        will need to have their merging done separately."""
+        first_id = self.get_nick_id(Identifier(first_nick))
+        second_id = self.get_nick_id(Identifier(second_nick))
+        self.execute(
+            'UPDATE OR IGNORE nick_values SET nick_id = ? WHERE nick_id = ?',
+            [first_id, second_id])
+        self.execute('DELETE FROM nick_values WHERE nick_id = ?', [second_id])
+        self.execute('UPDATE nicknames SET nick_id = ? WHERE nick_id = ?',
+                     [first_id, second_id])
+
+    # CHANNEL FUNCTIONS
+
+    def set_channel_value(self, channel, key, value):
+        channel = Identifier(channel).lower()
+        value = json.dumps(value, ensure_ascii=False)
+        self.execute('INSERT OR REPLACE INTO channel_values VALUES (?, ?, ?)',
+                     [channel, key, value])
+
+    def get_channel_value(self, channel, key):
+        """Retrieves the value for a given key associated with a channel."""
+        channel = Identifier(channel).lower()
+        result = self.execute(
+            'SELECT value FROM channel_values WHERE channel = ? AND key = ?',
+            [channel, key]
+        ).fetchone()
+        if result is not None:
+            result = result[0]
+        return _deserialize(result)
+
+    # NICK AND CHANNEL FUNCTIONS
+
+    def get_nick_or_channel_value(self, name, key):
+        """Gets the value `key` associated to the nick or channel  `name`.
+        """
+        name = Identifier(name)
+        if name.is_nick():
+            return self.get_nick_value(name, key)
+        else:
+            return self.get_channel_value(name, key)
+
+    def get_preferred_value(self, names, key):
+        """Gets the value for the first name which has it set.
+
+        `names` is a list of channel and/or user names. Returns None if none of
+        the names have the key set."""
+        for name in names:
+            value = self.get_nick_or_channel_value(name, key)
+            if value is not None:
+                return value

formatting.py

@@ -0,0 +1,107 @@
+# coding=utf-8
+"""The formatting module includes functions to apply IRC formatting to text.
+
+*Availability: 4.5+*
+"""
+# Copyright 2014, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+import sys
+if sys.version_info.major >= 3:
+    unicode = str
+
+# Color names are as specified at http://www.mirc.com/colors.html
+
+CONTROL_NORMAL = '\x0f'
+"""The control code to reset formatting"""
+CONTROL_COLOR = '\x03'
+"""The control code to start or end color formatting"""
+CONTROL_UNDERLINE = '\x1f'
+"""The control code to start or end underlining"""
+CONTROL_BOLD = '\x02'
+"""The control code to start or end bold formatting"""
+
+
+# TODO when we can move to 3.3+ completely, make this an Enum.
+class colors:
+    WHITE = '00'
+    BLACK = '01'
+    BLUE = '02'
+    NAVY = BLUE
+    GREEN = '03'
+    RED = '04'
+    BROWN = '05'
+    MAROON = BROWN
+    PURPLE = '06'
+    ORANGE = '07'
+    OLIVE = ORANGE
+    YELLOW = '08'
+    LIGHT_GREEN = '09'
+    LIME = LIGHT_GREEN
+    TEAL = '10'
+    LIGHT_CYAN = '11'
+    CYAN = LIGHT_CYAN
+    LIGHT_BLUE = '12'
+    ROYAL = LIGHT_BLUE
+    PINK = '13'
+    LIGHT_PURPLE = PINK
+    FUCHSIA = PINK
+    GREY = '14'
+    LIGHT_GREY = '15'
+    SILVER = LIGHT_GREY
+
+    #Create aliases.
+    GRAY = GREY
+    LIGHT_GRAY = LIGHT_GREY
+
+
+def _get_color(color):
+    if color is None:
+        return None
+
+    # You can pass an int or string of the code
+    try:
+        color = int(color)
+    except ValueError:
+        pass
+    if isinstance(color, int):
+        if color > 99:
+            raise ValueError('Can not specify a color above 99.')
+        return unicode(color).rjust(2, '0')
+
+    # You can also pass the name of the color
+    color_name = color.upper()
+    color_dict = colors.__dict__
+    try:
+        return color_dict[color_name]
+    except KeyError:
+        raise ValueError('Unknown color name {}'.format(color))
+
+
+def color(text, fg=None, bg=None):
+    """Return the text, with the given colors applied in IRC formatting.
+
+    The color can be a string of the color name, or an integer between 0 and
+    99. The known color names can be found in the `colors` class of this
+    module."""
+    if not fg and not bg:
+        return text
+
+    fg = _get_color(fg)
+    bg = _get_color(bg)
+
+    if not bg:
+        text = ''.join([CONTROL_COLOR, fg, text, CONTROL_COLOR])
+    else:
+        text = ''.join([CONTROL_COLOR, fg, ',', bg, text, CONTROL_COLOR])
+    return text
+
+
+def bold(text):
+    """Return the text, with bold IRC formatting."""
+    return ''.join([CONTROL_BOLD, text, CONTROL_BOLD])
+
+
+def underline(text):
+    """Return the text, with underline IRC formatting."""
+    return ''.join([CONTROL_UNDERLINE, text, CONTROL_UNDERLINE])

irc.py

@@ -0,0 +1,411 @@
+# coding=utf-8
+# irc.py - An Utility IRC Bot
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Copyright 2012, Elsie Powell, http://embolalia.com
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+#
+# Licensed under the Eiffel Forum License 2.
+#
+# When working on core IRC protocol related features, consult protocol
+# documentation at http://www.irchelp.org/irchelp/rfc/
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import sys
+import time
+import socket
+import asyncore
+import asynchat
+import os
+import codecs
+import traceback
+from logger import get_logger
+from tools import stderr, Identifier
+from trigger import PreTrigger
+try:
+    import ssl
+    if not hasattr(ssl, 'match_hostname'):
+        # Attempt to import ssl_match_hostname from python-backports
+        import backports.ssl_match_hostname
+        ssl.match_hostname = backports.ssl_match_hostname.match_hostname
+        ssl.CertificateError = backports.ssl_match_hostname.CertificateError
+    has_ssl = True
+except ImportError:
+    # no SSL support
+    has_ssl = False
+
+import errno
+import threading
+from datetime import datetime
+if sys.version_info.major >= 3:
+    unicode = str
+
+LOGGER = get_logger(__name__)
+
+
+class Bot(asynchat.async_chat):
+    def __init__(self, config):
+        ca_certs = config.core.ca_certs
+
+        asynchat.async_chat.__init__(self)
+        self.set_terminator(b'\n')
+        self.buffer = ''
+
+        self.nick = Identifier(config.core.nick)
+        """Sopel's current ``Identifier``. Changing this while Sopel is running is
+        untested."""
+        self.user = config.core.user
+        """Sopel's user/ident."""
+        self.name = config.core.name
+        """Sopel's "real name", as used for whois."""
+
+        self.stack = {}
+        self.ca_certs = ca_certs
+        self.enabled_capabilities = set()
+        self.hasquit = False
+
+        self.sending = threading.RLock()
+        self.writing_lock = threading.Lock()
+        self.raw = None
+
+        # Right now, only accounting for two op levels.
+        # This might be expanded later.
+        # These lists are filled in startup.py, as of right now.
+        # Are these even touched at all anymore? Remove in 7.0.
+        self.ops = dict()
+        """Deprecated. Use bot.channels instead."""
+        self.halfplus = dict()
+        """Deprecated. Use bot.channels instead."""
+        self.voices = dict()
+        """Deprecated. Use bot.channels instead."""
+
+        # We need this to prevent error loops in handle_error
+        self.error_count = 0
+
+        self.connection_registered = False
+        """ Set to True when a server has accepted the client connection and
+        messages can be sent and received. """
+
+        # Work around bot.connecting missing in Python older than 2.7.4
+        if not hasattr(self, "connecting"):
+            self.connecting = False
+
+    def log_raw(self, line, prefix):
+        """Log raw line to the raw log."""
+        if not self.config.core.log_raw:
+            return
+        if not os.path.isdir(self.config.core.logdir):
+            try:
+                os.mkdir(self.config.core.logdir)
+            except Exception as e:
+                stderr('There was a problem creating the logs directory.')
+                stderr('%s %s' % (str(e.__class__), str(e)))
+                stderr('Please fix this and then run Sopel again.')
+                os._exit(1)
+        f = codecs.open(os.path.join(self.config.core.logdir, 'raw.log'),
+                        'a', encoding='utf-8')
+        f.write(prefix + unicode(time.time()) + "\t")
+        temp = line.replace('\n', '')
+
+        f.write(temp)
+        f.write("\n")
+        f.close()
+
+    def safe(self, string):
+        """Remove newlines from a string."""
+        if sys.version_info.major >= 3 and isinstance(string, bytes):
+                string = string.decode('utf8')
+        elif sys.version_info.major < 3:
+            if not isinstance(string, unicode):
+                string = unicode(string, encoding='utf8')
+        string = string.replace('\n', '')
+        string = string.replace('\r', '')
+        return string
+
+    def write(self, args, text=None):
+        args = [self.safe(arg) for arg in args]
+        if text is not None:
+            text = self.safe(text)
+        try:
+            self.writing_lock.acquire()  # Blocking lock, can't send two things
+                                         # at a time
+
+            # From RFC2812 Internet Relay Chat: Client Protocol
+            # Section 2.3
+            #
+            # https://tools.ietf.org/html/rfc2812.html
+            #
+            # IRC messages are always lines of characters terminated with a
+            # CR-LF (Carriage Return - Line Feed) pair, and these messages SHALL
+            # NOT exceed 512 characters in length, counting all characters
+            # including the trailing CR-LF. Thus, there are 510 characters
+            # maximum allowed for the command and its parameters.  There is no
+            # provision for continuation of message lines.
+
+            if text is not None:
+                temp = (' '.join(args) + ' :' + text)[:510] + '\r\n'
+            else:
+                temp = ' '.join(args)[:510] + '\r\n'
+            self.log_raw(temp, '>>')
+            self.send(temp.encode('utf-8'))
+        finally:
+            self.writing_lock.release()
+
+    def run(self, host, port=6667):
+        try:
+            self.initiate_connect(host, port)
+        except socket.error as e:
+            stderr('Connection error: %s' % e)
+
+    def initiate_connect(self, host, port):
+        stderr('Connecting to %s:%s...' % (host, port))
+        source_address = ((self.config.core.bind_host, 0)
+                          if self.config.core.bind_host else None)
+        self.set_socket(socket.create_connection((host, port),
+                        source_address=source_address))
+        if self.config.core.use_ssl and has_ssl:
+            self.send = self._ssl_send
+            self.recv = self._ssl_recv
+        elif not has_ssl and self.config.core.use_ssl:
+            stderr('SSL is not avilable on your system, attempting connection '
+                   'without it')
+        self.connect((host, port))
+        try:
+            asyncore.loop()
+        except KeyboardInterrupt:
+            print('KeyboardInterrupt')
+            self.quit('KeyboardInterrupt')
+
+    def quit(self, message):
+        """Disconnect from IRC and close the bot."""
+        self.write(['QUIT'], message)
+        self.hasquit = True
+        # Wait for acknowledgement from the server. By RFC 2812 it should be
+        # an ERROR msg, but many servers just close the connection. Either way
+        # is fine by us.
+        # Closing the connection now would mean that stuff in the buffers that
+        # has not yet been processed would never be processed. It would also
+        # release the main thread, which is problematic because whomever called
+        # quit might still want to do something before main thread quits.
+
+    def handle_close(self):
+        self.connection_registered = False
+
+        if hasattr(self, '_shutdown'):
+            self._shutdown()
+        stderr('Closed!')
+
+        # This will eventually call asyncore dispatchers close method, which
+        # will release the main thread. This should be called last to avoid
+        # race conditions.
+        self.close()
+
+    def handle_connect(self):
+        if self.config.core.use_ssl and has_ssl:
+            if not self.config.core.verify_ssl:
+                self.ssl = ssl.wrap_socket(self.socket,
+                                           do_handshake_on_connect=True,
+                                           suppress_ragged_eofs=True)
+            else:
+                self.ssl = ssl.wrap_socket(self.socket,
+                                           do_handshake_on_connect=True,
+                                           suppress_ragged_eofs=True,
+                                           cert_reqs=ssl.CERT_REQUIRED,
+                                           ca_certs=self.ca_certs)
+                try:
+                    ssl.match_hostname(self.ssl.getpeercert(), self.config.core.host)
+                except ssl.CertificateError:
+                    stderr("Invalid certficate, hostname mismatch!")
+                    os.unlink(self.config.core.pid_file_path)
+                    os._exit(1)
+            self.set_socket(self.ssl)
+
+        # Request list of server capabilities. IRCv3 servers will respond with
+        # CAP * LS (which we handle in coretasks). v2 servers will respond with
+        # 421 Unknown command, which we'll ignore
+        self.write(('CAP', 'LS', '302'))
+
+        if self.config.core.auth_method == 'server':
+            password = self.config.core.auth_password
+            self.write(('PASS', password))
+        self.write(('NICK', self.nick))
+        self.write(('USER', self.user, '+iw', self.nick), self.name)
+
+        stderr('Connected.')
+        self.last_ping_time = datetime.now()
+        timeout_check_thread = threading.Thread(target=self._timeout_check)
+        timeout_check_thread.daemon = True
+        timeout_check_thread.start()
+        ping_thread = threading.Thread(target=self._send_ping)
+        ping_thread.daemon = True
+        ping_thread.start()
+
+    def _timeout_check(self):
+        while self.connected or self.connecting:
+            if (datetime.now() - self.last_ping_time).seconds > int(self.config.core.timeout):
+                stderr('Ping timeout reached after %s seconds, closing connection' % self.config.core.timeout)
+                self.handle_close()
+                break
+            else:
+                time.sleep(int(self.config.core.timeout))
+
+    def _send_ping(self):
+        while self.connected or self.connecting:
+            if self.connected and (datetime.now() - self.last_ping_time).seconds > int(self.config.core.timeout) / 2:
+                try:
+                    self.write(('PING', self.config.core.host))
+                except socket.error:
+                    pass
+            time.sleep(int(self.config.core.timeout) / 2)
+
+    def _ssl_send(self, data):
+        """Replacement for self.send() during SSL connections."""
+        try:
+            result = self.socket.send(data)
+            return result
+        except ssl.SSLError as why:
+            if why[0] in (asyncore.EWOULDBLOCK, errno.ESRCH):
+                return 0
+            else:
+                raise why
+            return 0
+
+    def _ssl_recv(self, buffer_size):
+        """Replacement for self.recv() during SSL connections.
+
+        From: http://evanfosmark.com/2010/09/ssl-support-in-asynchatasync_chat
+
+        """
+        try:
+            data = self.socket.read(buffer_size)
+            if not data:
+                self.handle_close()
+                return b''
+            return data
+        except ssl.SSLError as why:
+            if why[0] in (asyncore.ECONNRESET, asyncore.ENOTCONN,
+                          asyncore.ESHUTDOWN):
+                self.handle_close()
+                return ''
+            elif why[0] == errno.ENOENT:
+                # Required in order to keep it non-blocking
+                return b''
+            else:
+                raise
+
+    def collect_incoming_data(self, data):
+        # We can't trust clients to pass valid unicode.
+        try:
+            data = unicode(data, encoding='utf-8')
+        except UnicodeDecodeError:
+            # not unicode, let's try cp1252
+            try:
+                data = unicode(data, encoding='cp1252')
+            except UnicodeDecodeError:
+                # Okay, let's try ISO8859-1
+                try:
+                    data = unicode(data, encoding='iso8859-1')
+                except:
+                    # Discard line if encoding is unknown
+                    return
+
+        if data:
+            self.log_raw(data, '<<')
+        self.buffer += data
+
+    def found_terminator(self):
+        line = self.buffer
+        if line.endswith('\r'):
+            line = line[:-1]
+        self.buffer = ''
+        self.last_ping_time = datetime.now()
+        pretrigger = PreTrigger(self.nick, line)
+        if all(cap not in self.enabled_capabilities for cap in ['account-tag', 'extended-join']):
+            pretrigger.tags.pop('account', None)
+
+        if pretrigger.event == 'PING':
+            self.write(('PONG', pretrigger.args[-1]))
+        elif pretrigger.event == 'ERROR':
+            LOGGER.error("ERROR recieved from server: %s", pretrigger.args[-1])
+            if self.hasquit:
+                self.close_when_done()
+        elif pretrigger.event == '433':
+            stderr('Nickname already in use!')
+            self.handle_close()
+
+        self.dispatch(pretrigger)
+
+    def dispatch(self, pretrigger):
+        pass
+
+    def error(self, trigger=None):
+        """Called internally when a module causes an error."""
+        try:
+            trace = traceback.format_exc()
+            if sys.version_info.major < 3:
+                trace = trace.decode('utf-8', errors='xmlcharrefreplace')
+            stderr(trace)
+            try:
+                lines = list(reversed(trace.splitlines()))
+                report = [lines[0].strip()]
+                for line in lines:
+                    line = line.strip()
+                    if line.startswith('File "'):
+                        report.append(line[0].lower() + line[1:])
+                        break
+                else:
+                    report.append('source unknown')
+
+                signature = '%s (%s)' % (report[0], report[1])
+                # TODO: make not hardcoded
+                log_filename = os.path.join(self.config.core.logdir, 'exceptions.log')
+                with codecs.open(log_filename, 'a', encoding='utf-8') as logfile:
+                    logfile.write('Signature: %s\n' % signature)
+                    if trigger:
+                        logfile.write('from {} at {}. Message was: {}\n'.format(
+                            trigger.nick, str(datetime.now()), trigger.group(0)))
+                    logfile.write(trace)
+                    logfile.write(
+                        '----------------------------------------\n\n'
+                    )
+            except Exception as e:
+                stderr("Could not save full traceback!")
+                LOGGER.error("Could not save traceback from %s to file: %s", trigger.sender, str(e))
+
+            if trigger and self.config.core.reply_errors and trigger.sender is not None:
+                self.msg(trigger.sender, signature)
+            if trigger:
+                LOGGER.error('Exception from {}: {} ({})'.format(trigger.sender, str(signature), trigger.raw))
+        except Exception as e:
+            if trigger and self.config.core.reply_errors and trigger.sender is not None:
+                self.msg(trigger.sender, "Got an error.")
+            if trigger:
+                LOGGER.error('Exception from {}: {} ({})'.format(trigger.sender, str(e), trigger.raw))
+
+    def handle_error(self):
+        """Handle any uncaptured error in the core.
+
+        Overrides asyncore's handle_error.
+
+        """
+        trace = traceback.format_exc()
+        stderr(trace)
+        LOGGER.error('Fatal error in core, please review exception log')
+        # TODO: make not hardcoded
+        logfile = codecs.open(
+            os.path.join(self.config.core.logdir, 'exceptions.log'),
+            'a',
+            encoding='utf-8'
+        )
+        logfile.write('Fatal error in core, handle_error() was called\n')
+        logfile.write('last raw line was %s' % self.raw)
+        logfile.write(trace)
+        logfile.write('Buffer:\n')
+        logfile.write(self.buffer)
+        logfile.write('----------------------------------------\n\n')
+        logfile.close()
+        if self.error_count > 10:
+            if (datetime.now() - self.last_error_timestamp).seconds < 5:
+                stderr("Too many errors, can't continue")
+                os._exit(1)
+        self.last_error_timestamp = datetime.now()
+        self.error_count = self.error_count + 1

loader.py

@@ -0,0 +1,227 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import imp
+import os.path
+import re
+import sys
+
+from tools import itervalues, get_command_regexp
+
+if sys.version_info.major >= 3:
+    basestring = (str, bytes)
+
+# Can be implementation-dependent
+_regex_type = type(re.compile(''))
+
+
+def get_module_description(path):
+    good_file = (os.path.isfile(path) and path.endswith('.py')
+                 and not path.startswith('_'))
+    good_dir = (os.path.isdir(path) and
+                os.path.isfile(os.path.join(path, '__init__.py')))
+    if good_file:
+        name = os.path.basename(path)[:-3]
+        return (name, path, imp.PY_SOURCE)
+    elif good_dir:
+        name = os.path.basename(path)
+        return (name, path, imp.PKG_DIRECTORY)
+    else:
+        return None
+
+
+def _update_modules_from_dir(modules, directory):
+    # Note that this modifies modules in place
+    for path in os.listdir(directory):
+        path = os.path.join(directory, path)
+        result = get_module_description(path)
+        if result:
+            modules[result[0]] = result[1:]
+
+
+def enumerate_modules(config, show_all=False):
+    """Map the names of modules to the location of their file.
+
+    Return a dict mapping the names of modules to a tuple of the module name,
+    the pathname and either `imp.PY_SOURCE` or `imp.PKG_DIRECTORY`. This
+    searches the regular modules directory and all directories specified in the
+    `core.extra` attribute of the `config` object. If two modules have the same
+    name, the last one to be found will be returned and the rest will be
+    ignored. Modules are found starting in the regular directory, followed by
+    `~/.sopel/modules`, and then through the extra directories in the order
+    that the are specified.
+
+    If `show_all` is given as `True`, the `enable` and `exclude`
+    configuration options will be ignored, and all modules will be shown
+    (though duplicates will still be ignored as above).
+    """
+    modules = {}
+
+    # First, add modules from the regular modules directory
+    main_dir = os.path.dirname(os.path.abspath(__file__))
+    modules_dir = os.path.join(main_dir, 'modules')
+    _update_modules_from_dir(modules, modules_dir)
+    for path in os.listdir(modules_dir):
+        break
+
+    # Then, find PyPI installed modules
+    # TODO does this work with all possible install mechanisms?
+    try:
+        import sopel_modules
+    except:
+        pass
+    else:
+        for directory in sopel_modules.__path__:
+            _update_modules_from_dir(modules, directory)
+
+    # Next, look in ~/.sopel/modules
+    home_modules_dir = os.path.join(config.homedir, 'modules')
+    if not os.path.isdir(home_modules_dir):
+        os.makedirs(home_modules_dir)
+    _update_modules_from_dir(modules, home_modules_dir)
+
+    # Last, look at all the extra directories.
+    for directory in config.core.extra:
+        _update_modules_from_dir(modules, directory)
+
+    # Coretasks is special. No custom user coretasks.
+    ct_path = os.path.join(main_dir, 'coretasks.py')
+    modules['coretasks'] = (ct_path, imp.PY_SOURCE)
+
+    # If caller wants all of them, don't apply white and blacklists
+    if show_all:
+        return modules
+
+    # Apply whitelist, if present
+    enable = config.core.enable
+    if enable:
+        enabled_modules = {'coretasks': modules['coretasks']}
+        for module in enable:
+            if module in modules:
+                enabled_modules[module] = modules[module]
+        modules = enabled_modules
+
+    # Apply blacklist, if present
+    exclude = config.core.exclude
+    for module in exclude:
+        if module in modules:
+            del modules[module]
+
+    return modules
+
+
+def compile_rule(nick, pattern):
+    # Not sure why this happens on reloads, but it shouldn't cause problems…
+    if isinstance(pattern, _regex_type):
+        return pattern
+
+    nick = re.escape(nick)
+    pattern = pattern.replace('$nickname', nick)
+    pattern = pattern.replace('$nick', r'{}[,:]\s+'.format(nick))
+    flags = re.IGNORECASE
+    if '\n' in pattern:
+        flags |= re.VERBOSE
+    return re.compile(pattern, flags)
+
+
+def trim_docstring(doc):
+    """Get the docstring as a series of lines that can be sent"""
+    if not doc:
+        return []
+    lines = doc.expandtabs().splitlines()
+    indent = sys.maxsize
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+    trimmed = [lines[0].strip()]
+    if indent < sys.maxsize:
+        for line in lines[1:]:
+            trimmed.append(line[:].rstrip())
+    while trimmed and not trimmed[-1]:
+        trimmed.pop()
+    while trimmed and not trimmed[0]:
+        trimmed.pop(0)
+    return trimmed
+
+
+def clean_callable(func, config):
+    """Compiles the regexes, moves commands into func.rule, fixes up docs and
+    puts them in func._docs, and sets defaults"""
+    nick = config.core.nick
+    prefix = config.core.prefix
+    help_prefix = config.core.help_prefix
+    func._docs = {}
+    doc = trim_docstring(func.__doc__)
+    example = None
+
+    func.unblockable = getattr(func, 'unblockable', False)
+    func.priority = getattr(func, 'priority', 'medium')
+    func.thread = getattr(func, 'thread', True)
+    func.rate = getattr(func, 'rate', 0)
+    func.channel_rate = getattr(func, 'channel_rate', 0)
+    func.global_rate = getattr(func, 'global_rate', 0)
+
+    if not hasattr(func, 'event'):
+        func.event = ['PRIVMSG']
+    else:
+        if isinstance(func.event, basestring):
+            func.event = [func.event.upper()]
+        else:
+            func.event = [event.upper() for event in func.event]
+
+    if hasattr(func, 'rule'):
+        if isinstance(func.rule, basestring):
+            func.rule = [func.rule]
+        func.rule = [compile_rule(nick, rule) for rule in func.rule]
+
+    if hasattr(func, 'commands'):
+        func.rule = getattr(func, 'rule', [])
+        for command in func.commands:
+            regexp = get_command_regexp(prefix, command)
+            func.rule.append(regexp)
+        if hasattr(func, 'example'):
+            example = func.example[0]["example"]
+            example = example.replace('$nickname', nick)
+            if example[0] != help_prefix and not example.startswith(nick):
+                example = help_prefix + example[len(help_prefix):]
+        if doc or example:
+            for command in func.commands:
+                func._docs[command] = (doc, example)
+
+
+def load_module(name, path, type_):
+    """Load a module, and sort out the callables and shutdowns"""
+    if type_ == imp.PY_SOURCE:
+        with open(path) as mod:
+            module = imp.load_module(name, mod, path, ('.py', 'U', type_))
+    elif type_ == imp.PKG_DIRECTORY:
+        module = imp.load_module(name, None, path, ('', '', type_))
+    else:
+        raise TypeError('Unsupported module type')
+    return module, os.path.getmtime(path)
+
+
+def is_triggerable(obj):
+    return any(hasattr(obj, attr) for attr in ('rule', 'rule', 'intent',
+                                               'commands'))
+
+
+def clean_module(module, config):
+    callables = []
+    shutdowns = []
+    jobs = []
+    urls = []
+    for obj in itervalues(vars(module)):
+        if callable(obj):
+            if getattr(obj, '__name__', None) == 'shutdown':
+                shutdowns.append(obj)
+            elif is_triggerable(obj):
+                clean_callable(obj, config)
+                callables.append(obj)
+            elif hasattr(obj, 'interval'):
+                clean_callable(obj, config)
+                jobs.append(obj)
+            elif hasattr(obj, 'url_regex'):
+                urls.append(obj)
+    return callables, jobs, shutdowns, urls

logger.py

@@ -0,0 +1,55 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import logging
+
+
+class IrcLoggingHandler(logging.Handler):
+    def __init__(self, bot, level):
+        super(IrcLoggingHandler, self).__init__(level)
+        self._bot = bot
+        self._channel = bot.config.core.logging_channel
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            self._bot.msg(self._channel, msg)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:
+            self.handleError(record)
+
+
+class ChannelOutputFormatter(logging.Formatter):
+    def __init__(self):
+        super(ChannelOutputFormatter, self).__init__(
+            fmt='[%(filename)s] %(msg)s'
+        )
+
+    def formatException(self, exc_info):
+        # logging will through a newline between the message and this, but
+        # that's fine because Sopel will strip it back out anyway
+        return ' - ' + repr(exc_info[1])
+
+
+def setup_logging(bot):
+    level = bot.config.core.logging_level or 'WARNING'
+    logging.basicConfig(level=level)
+    logger = logging.getLogger('sopel')
+    if bot.config.core.logging_channel:
+        handler = IrcLoggingHandler(bot, level)
+        handler.setFormatter(ChannelOutputFormatter())
+        logger.addHandler(handler)
+
+
+def get_logger(name=None):
+    """Return a logger for a module, if the name is given.
+
+    This is equivalent to `logging.getLogger('sopel.modules.' + name)` when
+    name is given, and `logging.getLogger('sopel')` when it is not. The latter
+    case is intended for use in Sopel's core; modules should call
+    `get_logger(__name__)` to get a logger."""
+    if name:
+        return logging.getLogger('sopel.modules.' + name)
+    else:
+        return logging.getLogger('sopel')

module.py

@@ -0,0 +1,460 @@
+# coding=utf-8
+"""This contains decorators and tools for creating callable plugin functions.
+"""
+# Copyright 2013, Ari Koivula, <ari@koivu.la>
+# Copyright © 2013, Elad Alfassa <elad@fedoraproject.org>
+# Copyright 2013, Lior Ramati <firerogue517@gmail.com>
+# Licensed under the Eiffel Forum License 2.
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+import test_tools
+import functools
+
+NOLIMIT = 1
+"""Return value for ``callable``\s, which supresses rate limiting for the call.
+
+Returning this value means the triggering user will not be
+prevented from triggering the command again within the rate limit. This can
+be used, for example, to allow a user to rety a failed command immediately.
+
+.. versionadded:: 4.0
+"""
+
+VOICE = 1
+HALFOP = 2
+OP = 4
+ADMIN = 8
+OWNER = 16
+
+
+def unblockable(function):
+    """Decorator which exempts the function from nickname and hostname blocking.
+
+    This can be used to ensure events such as JOIN are always recorded.
+    """
+    function.unblockable = True
+    return function
+
+
+def interval(*args):
+    """Decorates a function to be called by the bot every X seconds.
+
+    This decorator can be used multiple times for multiple intervals, or all
+    intervals can be given at once as arguments. The first time the function
+    will be called is X seconds after the bot was started.
+
+    Unlike other plugin functions, ones decorated by interval must only take a
+    :class:`sopel.bot.Sopel` as their argument; they do not get a trigger. The
+    bot argument will not have a context, so functions like ``bot.say()`` will
+    not have a default destination.
+
+    There is no guarantee that the bot is connected to a server or joined a
+    channel when the function is called, so care must be taken.
+
+    Example:::
+
+        import sopel.module
+        @sopel.module.interval(5)
+        def spam_every_5s(bot):
+            if "#here" in bot.channels:
+                bot.msg("#here", "It has been five seconds!")
+
+    """
+    def add_attribute(function):
+        if not hasattr(function, "interval"):
+            function.interval = []
+        for arg in args:
+            function.interval.append(arg)
+        return function
+
+    return add_attribute
+
+
+def rule(value):
+    """Decorate a function to be called when a line matches the given pattern
+
+    This decorator can be used multiple times to add more rules.
+
+    Args:
+        value: A regular expression which will trigger the function.
+
+    If the Sopel instance is in a channel, or sent a PRIVMSG, where a string
+    matching this expression is said, the function will execute. Note that
+    captured groups here will be retrievable through the Trigger object later.
+
+    Inside the regular expression, some special directives can be used. $nick
+    will be replaced with the nick of the bot and , or :, and $nickname will be
+    replaced with the nick of the bot.
+    """
+    def add_attribute(function):
+        if not hasattr(function, "rule"):
+            function.rule = []
+        function.rule.append(value)
+        return function
+
+    return add_attribute
+
+
+def thread(value):
+    """Decorate a function to specify if it should be run in a separate thread.
+
+    Functions run in a separate thread (as is the default) will not prevent the
+    bot from executing other functions at the same time. Functions not run in a
+    separate thread may be started while other functions are still running, but
+    additional functions will not start until it is completed.
+
+    Args:
+        value: Either True or False. If True the function is called in
+            a separate thread. If False from the main thread.
+
+    """
+    def add_attribute(function):
+        function.thread = value
+        return function
+    return add_attribute
+
+
+def commands(*command_list):
+    """Decorate a function to set one or more commands to trigger it.
+
+    This decorator can be used to add multiple commands to one callable in a
+    single line. The resulting match object will have the command as the first
+    group, rest of the line, excluding leading whitespace, as the second group.
+    Parameters 1 through 4, seperated by whitespace, will be groups 3-6.
+
+    Args:
+        command: A string, which can be a regular expression.
+
+    Returns:
+        A function with a new command appended to the commands
+        attribute. If there is no commands attribute, it is added.
+
+    Example:
+        @commands("hello"):
+            If the command prefix is "\.", this would trigger on lines starting
+            with ".hello".
+
+        @commands('j', 'join')
+            If the command prefix is "\.", this would trigger on lines starting
+            with either ".j" or ".join".
+
+    """
+    def add_attribute(function):
+        if not hasattr(function, "commands"):
+            function.commands = []
+        function.commands.extend(command_list)
+        return function
+    return add_attribute
+
+
+def nickname_commands(*command_list):
+    """Decorate a function to trigger on lines starting with "$nickname: command".
+
+    This decorator can be used multiple times to add multiple rules. The
+    resulting match object will have the command as the first group, rest of
+    the line, excluding leading whitespace, as the second group. Parameters 1
+    through 4, seperated by whitespace, will be groups 3-6.
+
+    Args:
+        command: A string, which can be a regular expression.
+
+    Returns:
+        A function with a new regular expression appended to the rule
+        attribute. If there is no rule attribute, it is added.
+
+    Example:
+        @nickname_commands("hello!"):
+            Would trigger on "$nickname: hello!", "$nickname,   hello!",
+            "$nickname hello!", "$nickname hello! parameter1" and
+            "$nickname hello! p1 p2 p3 p4 p5 p6 p7 p8 p9".
+        @nickname_commands(".*"):
+            Would trigger on anything starting with "$nickname[:,]? ", and
+            would have never have any additional parameters, as the command
+            would match the rest of the line.
+
+    """
+    def add_attribute(function):
+        if not hasattr(function, "rule"):
+            function.rule = []
+        rule = r"""
+        ^
+        $nickname[:,]? # Nickname.
+        \s+({command}) # Command as group 1.
+        (?:\s+         # Whitespace to end command.
+        (              # Rest of the line as group 2.
+        (?:(\S+))?     # Parameters 1-4 as groups 3-6.
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        .*             # Accept anything after the parameters. Leave it up to
+                       # the module to parse the line.
+        ))?            # Group 1 must be None, if there are no parameters.
+        $              # EoL, so there are no partial matches.
+        """.format(command='|'.join(command_list))
+        function.rule.append(rule)
+        return function
+
+    return add_attribute
+
+
+def priority(value):
+    """Decorate a function to be executed with higher or lower priority.
+
+    Args:
+        value: Priority can be one of "high", "medium", "low". Defaults to
+            medium.
+
+    Priority allows you to control the order of callable execution, if your
+    module needs it.
+
+    """
+    def add_attribute(function):
+        function.priority = value
+        return function
+    return add_attribute
+
+
+def event(*event_list):
+    """Decorate a function to be triggered on specific IRC events.
+
+    This is one of a number of events, such as 'JOIN', 'PART', 'QUIT', etc.
+    (More details can be found in RFC 1459.) When the Sopel bot is sent one of
+    these events, the function will execute. Note that functions with an event
+    must also be given a rule to match (though it may be '.*', which will
+    always match) or they will not be triggered.
+
+    :class:`sopel.tools.events` provides human-readable names for many of the
+    numeric events, which may help your code be clearer.
+    """
+    def add_attribute(function):
+        if not hasattr(function, "event"):
+            function.event = []
+        function.event.extend(event_list)
+        return function
+    return add_attribute
+
+
+def intent(*intent_list):
+    """Decorate a callable trigger on a message with any of the given intents.
+
+    .. versionadded:: 5.2.0
+    """
+    def add_attribute(function):
+        if not hasattr(function, "intents"):
+            function.intents = []
+        function.intents.extend(intent_list)
+        return function
+    return add_attribute
+
+
+def rate(user=0, channel=0, server=0):
+    """Decorate a function to limit how often it can be triggered on a per-user
+    basis, in a channel, or across the server (bot). A value of zero means no
+    limit. If a function is given a rate of 20, that function may only be used
+    once every 20 seconds in the scope corresponding to the parameter.
+    Users on the admin list in Sopel’s configuration are exempted from rate
+    limits.
+
+    Rate-limited functions that use scheduled future commands should import
+    threading.Timer() instead of sched, or rate limiting will not work properly.
+    """
+    def add_attribute(function):
+        function.rate = user
+        function.channel_rate = channel
+        function.global_rate = server
+        return function
+    return add_attribute
+
+
+def require_privmsg(message=None):
+    """Decorate a function to only be triggerable from a private message.
+
+    If it is triggered in a channel message, `message` will be said if given.
+    """
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def _nop(*args, **kwargs):
+            # Assign trigger and bot for easy access later
+            bot, trigger = args[0:2]
+            if trigger.is_privmsg:
+                return function(*args, **kwargs)
+            else:
+                if message and not callable(message):
+                    bot.say(message)
+        return _nop
+    # Hack to allow decorator without parens
+    if callable(message):
+        return actual_decorator(message)
+    return actual_decorator
+
+
+def require_chanmsg(message=None):
+    """Decorate a function to only be triggerable from a channel message.
+
+    If it is triggered in a private message, `message` will be said if given.
+    """
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def _nop(*args, **kwargs):
+            # Assign trigger and bot for easy access later
+            bot, trigger = args[0:2]
+            if not trigger.is_privmsg:
+                return function(*args, **kwargs)
+            else:
+                if message and not callable(message):
+                    bot.say(message)
+        return _nop
+    # Hack to allow decorator without parens
+    if callable(message):
+        return actual_decorator(message)
+    return actual_decorator
+
+
+def require_privilege(level, message=None):
+    """Decorate a function to require at least the given channel permission.
+
+    `level` can be one of the privilege levels defined in this module. If the
+    user does not have the privilege, `message` will be said if given. If it is
+    a private message, no checking will be done."""
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def guarded(bot, trigger, *args, **kwargs):
+            # If this is a privmsg, ignore privilege requirements
+            if trigger.is_privmsg:
+                return function(bot, trigger, *args, **kwargs)
+            channel_privs = bot.privileges[trigger.sender]
+            allowed = channel_privs.get(trigger.nick, 0) >= level
+            if not trigger.is_privmsg and not allowed:
+                if message and not callable(message):
+                    bot.say(message)
+            else:
+                return function(bot, trigger, *args, **kwargs)
+        return guarded
+    return actual_decorator
+
+
+def require_admin(message=None):
+    """Decorate a function to require the triggering user to be a bot admin.
+
+    If they are not, `message` will be said if given."""
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def guarded(bot, trigger, *args, **kwargs):
+            if not trigger.admin:
+                if message and not callable(message):
+                    bot.say(message)
+            else:
+                return function(bot, trigger, *args, **kwargs)
+        return guarded
+    # Hack to allow decorator without parens
+    if callable(message):
+        return actual_decorator(message)
+    return actual_decorator
+
+
+def require_owner(message=None):
+    """Decorate a function to require the triggering user to be the bot owner.
+
+    If they are not, `message` will be said if given."""
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def guarded(bot, trigger, *args, **kwargs):
+            if not trigger.owner:
+                if message and not callable(message):
+                    bot.say(message)
+            else:
+                return function(bot, trigger, *args, **kwargs)
+        return guarded
+    # Hack to allow decorator without parens
+    if callable(message):
+        return actual_decorator(message)
+    return actual_decorator
+
+
+def url(url_rule):
+    """Decorate a function to handle URLs.
+
+    This decorator takes a regex string that will be matched against URLs in a
+    message. The function it decorates, in addition to the bot and trigger,
+    must take a third argument ``match``, which is the regular expression match
+    of the url. This should be used rather than the matching in trigger, in
+    order to support e.g. the ``.title`` command.
+    """
+    def actual_decorator(function):
+        @functools.wraps(function)
+        def helper(bot, trigger, match=None):
+            match = match or trigger
+            return function(bot, trigger, match)
+        helper.url_regex = re.compile(url_rule)
+        return helper
+    return actual_decorator
+
+
+class example(object):
+    """Decorate a function with an example.
+
+    Add an example attribute into a function and generate a test.
+    """
+    # TODO dat doc doe >_<
+    def __init__(self, msg, result=None, privmsg=False, admin=False,
+                 owner=False, repeat=1, re=False, ignore=None):
+        """Accepts arguments for the decorator.
+
+        Args:
+            msg - The example message to give to the function as input.
+            result - Resulting output from calling the function with msg.
+            privmsg - If true, make the message appear to have sent in a
+                private message to the bot. If false, make it appear to have
+                come from a channel.
+            admin - Bool. Make the message appear to have come from an admin.
+            owner - Bool. Make the message appear to have come from an owner.
+            repeat - How many times to repeat the test. Usefull for tests that
+                return random stuff.
+            re - Bool. If true, result is interpreted as a regular expression.
+            ignore - a list of outputs to ignore.
+
+        """
+        # Wrap result into a list for get_example_test
+        if isinstance(result, list):
+            self.result = result
+        elif result is not None:
+            self.result = [result]
+        else:
+            self.result = None
+        self.use_re = re
+        self.msg = msg
+        self.privmsg = privmsg
+        self.admin = admin
+        self.owner = owner
+        self.repeat = repeat
+
+        if isinstance(ignore, list):
+            self.ignore = ignore
+        elif ignore is not None:
+            self.ignore = [ignore]
+        else:
+            self.ignore = []
+
+    def __call__(self, func):
+        if not hasattr(func, "example"):
+            func.example = []
+
+        if self.result:
+            test = test_tools.get_example_test(
+                func, self.msg, self.result, self.privmsg, self.admin,
+                self.owner, self.repeat, self.use_re, self.ignore
+            )
+            test_tools.insert_into_module(
+                test, func.__module__, func.__name__, 'test_example'
+            )
+
+        record = {
+            "example": self.msg,
+            "result": self.result,
+            "privmsg": self.privmsg,
+            "admin": self.admin,
+        }
+        func.example.append(record)
+        return func

modules/8ball.py

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Classic 8ball.
+"""
+import module
+import random
+
+@module.commands('8ball')
+def eightball(bot, trigger):
+	"""
+	Classic 8ball.
+	"""
+	response = [ "No", "Probably not", "Don't count on it", "It'll never happen",
+				"Stop trying", "Uncertain", "Who knows~", "Doubtful", "I don't know",
+				"Maybe", "It could happen", "Yes", "Fate is a curious mistress",
+				"Your life is meaningless", "Who knows~", "The winds of change are always blowing",
+				"Nah", "The tides have turned" ]
+
+	msg = response[ random.randint(0, len(response)-1) ]
+	bot.reply(msg)

modules/admin.py

@@ -0,0 +1,229 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+admin.py - Sopel Admin Module
+Copyright 2010-2011, Sean B. Palmer (inamidst.com) and Michael Yanovich
+(yanovich.net)
+Copyright © 2012, Elad Alfassa, <elad@fedoraproject.org>
+Copyright 2013, Ari Koivula <ari@koivu.la>
+
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+from config.types import (
+    StaticSection, ValidatedAttribute, FilenameAttribute
+)
+import module
+
+
+class AdminSection(StaticSection):
+    hold_ground = ValidatedAttribute('hold_ground', bool, default=False)
+    """Auto re-join on kick"""
+    auto_accept_invite = ValidatedAttribute('auto_accept_invite', bool,
+                                            default=True)
+
+
+def configure(config):
+    config.define_section('admin', AdminSection)
+    config.admin.configure_setting('hold_ground',
+                                   "Automatically re-join after being kicked?")
+    config.admin.configure_setting('auto_accept_invite',
+                                   'Automatically join channels when invited?')
+
+
+def setup(bot):
+    bot.config.define_section('admin', AdminSection)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('join')
+@module.priority('low')
+@module.example('.join #example or .join #example key')
+def join(bot, trigger):
+    """Join the specified channel. This is an admin-only command."""
+    channel, key = trigger.group(3), trigger.group(4)
+    if not channel:
+        return
+    elif not key:
+        bot.join(channel)
+    else:
+        bot.join(channel, key)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('part')
+@module.priority('low')
+@module.example('.part #example')
+def part(bot, trigger):
+    """Part the specified channel. This is an admin-only command."""
+    channel, _sep, part_msg = trigger.group(2).partition(' ')
+    if part_msg:
+        bot.part(channel, part_msg)
+    else:
+        bot.part(channel)
+
+
+@module.require_owner
+@module.commands('quit')
+@module.priority('low')
+def quit(bot, trigger):
+    """Quit from the server. This is an owner-only command."""
+    quit_message = trigger.group(2)
+    if not quit_message:
+        quit_message = 'Quitting on command from %s' % trigger.nick
+
+    bot.quit(quit_message)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('msg')
+@module.priority('low')
+@module.example('.msg #YourPants Does anyone else smell neurotoxin?')
+def msg(bot, trigger):
+    """
+    Send a message to a given channel or nick. Can only be done in privmsg by an
+    admin.
+    """
+    if trigger.group(2) is None:
+        return
+
+    channel, _sep, message = trigger.group(2).partition(' ')
+    message = message.strip()
+    if not channel or not message:
+        return
+
+    bot.msg(channel, message)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('me')
+@module.priority('low')
+def me(bot, trigger):
+    """
+    Send an ACTION (/me) to a given channel or nick. Can only be done in privmsg
+    by an admin.
+    """
+    if trigger.group(2) is None:
+        return
+
+    channel, _sep, action = trigger.group(2).partition(' ')
+    action = action.strip()
+    if not channel or not action:
+        return
+
+    msg = '\x01ACTION %s\x01' % action
+    bot.msg(channel, msg)
+
+
+@module.event('INVITE')
+@module.rule('.*')
+@module.priority('low')
+def invite_join(bot, trigger):
+    """
+    Join a channel sopel is invited to, if the inviter is an admin.
+    """
+    if trigger.admin or bot.config.admin.auto_accept_invite:
+        bot.join(trigger.args[1])
+        return
+
+
+@module.event('KICK')
+@module.rule(r'.*')
+@module.priority('low')
+def hold_ground(bot, trigger):
+    """
+    This function monitors all kicks across all channels sopel is in. If it
+    detects that it is the one kicked it'll automatically join that channel.
+
+    WARNING: This may not be needed and could cause problems if sopel becomes
+    annoying. Please use this with caution.
+    """
+    if bot.config.admin.hold_ground:
+        channel = trigger.sender
+        if trigger.args[1] == bot.nick:
+            bot.join(channel)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('mode')
+@module.priority('low')
+def mode(bot, trigger):
+    """Set a user mode on Sopel. Can only be done in privmsg by an admin."""
+    mode = trigger.group(3)
+    bot.write(('MODE ', bot.nick + ' ' + mode))
+
+
+@module.require_privmsg("This command only works as a private message.")
+@module.require_admin("This command requires admin privileges.")
+@module.commands('set')
+@module.example('.set core.owner Me')
+def set_config(bot, trigger):
+    """See and modify values of sopels config object.
+
+    Trigger args:
+        arg1 - section and option, in the form "section.option"
+        arg2 - value
+
+    If there is no section, section will default to "core".
+    If value is None, the option will be deleted.
+    """
+    # Get section and option from first argument.
+    arg1 = trigger.group(3).split('.')
+    if len(arg1) == 1:
+        section_name, option = "core", arg1[0]
+    elif len(arg1) == 2:
+        section_name, option = arg1
+    else:
+        bot.reply("Usage: .set section.option value")
+        return
+    section = getattr(bot.config, section_name)
+    static_sec = isinstance(section, StaticSection)
+
+    if static_sec and not hasattr(section, option):
+        bot.say('[{}] section has no option {}.'.format(section_name, option))
+        return
+
+    # Display current value if no value is given.
+    value = trigger.group(4)
+    if not value:
+        if not static_sec and bot.config.parser.has_option(section, option):
+            bot.reply("Option %s.%s does not exist." % (section_name, option))
+            return
+        # Except if the option looks like a password. Censor those to stop them
+        # from being put on log files.
+        if option.endswith("password") or option.endswith("pass"):
+            value = "(password censored)"
+        else:
+            value = getattr(section, option)
+        bot.reply("%s.%s = %s" % (section_name, option, value))
+        return
+
+    # Otherwise, set the value to one given as argument 2.
+    if static_sec:
+        descriptor = getattr(section.__class__, option)
+        try:
+            if isinstance(descriptor, FilenameAttribute):
+                value = descriptor.parse(bot.config, descriptor, value)
+            else:
+                value = descriptor.parse(value)
+        except ValueError as exc:
+            bot.say("Can't set attribute: " + str(exc))
+            return
+    setattr(section, option, value)
+
+
+@module.require_privmsg
+@module.require_admin
+@module.commands('save')
+@module.example('.save')
+def save_config(bot, trigger):
+    """Save state of sopels config object to the configuration file."""
+    bot.config.save()

modules/adminchannel.py

@@ -0,0 +1,276 @@
+# coding=utf-8
+# Copyright 2010-2011, Michael Yanovich, Alek Rollyson, and Elsie Powell
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+import formatting
+from module import commands, priority, OP, HALFOP, require_privilege, require_chanmsg
+from tools import Identifier
+
+
+def default_mask(trigger):
+	welcome = formatting.color('Welcome to:', formatting.colors.PURPLE)
+	chan = formatting.color(trigger.sender, formatting.colors.TEAL)
+	topic_ = formatting.bold('Topic:')
+	topic_ = formatting.color('| ' + topic_, formatting.colors.PURPLE)
+	arg = formatting.color('{}', formatting.colors.GREEN)
+	return '{} {} {} {}'.format(welcome, chan, topic_, arg)
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('kick')
+@priority('high')
+def kick(bot, trigger):
+	"""
+	Kick a user from the channel.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < HALFOP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 2:
+		return
+	opt = Identifier(text[1])
+	nick = opt
+	channel = trigger.sender
+	reasonidx = 2
+	if not opt.is_nick():
+		if argc < 3:
+			return
+		nick = text[2]
+		channel = opt
+		reasonidx = 3
+	reason = ' '.join(text[reasonidx:])
+	if nick != bot.config.core.nick:
+		bot.write(['KICK', channel, nick], reason)
+
+
+def configureHostMask(mask):
+	if mask == '*!*@*':
+		return mask
+	if re.match('^[^.@!/]+$', mask) is not None:
+		return '%s!*@*' % mask
+	if re.match('^[^@!]+$', mask) is not None:
+		return '*!*@%s' % mask
+
+	m = re.match('^([^!@]+)@$', mask)
+	if m is not None:
+		return '*!%s@*' % m.group(1)
+
+	m = re.match('^([^!@]+)@([^@!]+)$', mask)
+	if m is not None:
+		return '*!%s@%s' % (m.group(1), m.group(2))
+
+	m = re.match('^([^!@]+)!(^[!@]+)@?$', mask)
+	if m is not None:
+		return '%s!%s@*' % (m.group(1), m.group(2))
+	return ''
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('ban')
+@priority('high')
+def ban(bot, trigger):
+	"""
+	This give admins the ability to ban a user.
+	The bot must be a Channel Operator for this command to work.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < HALFOP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 2:
+		return
+	opt = Identifier(text[1])
+	banmask = opt
+	channel = trigger.sender
+	if not opt.is_nick():
+		if argc < 3:
+			return
+		channel = opt
+		banmask = text[2]
+	banmask = configureHostMask(banmask)
+	if banmask == '':
+		return
+	bot.write(['MODE', channel, '+b', banmask])
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('unban')
+def unban(bot, trigger):
+	"""
+	This give admins the ability to unban a user.
+	The bot must be a Channel Operator for this command to work.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < HALFOP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 2:
+		return
+	opt = Identifier(text[1])
+	banmask = opt
+	channel = trigger.sender
+	if not opt.is_nick():
+		if argc < 3:
+			return
+		channel = opt
+		banmask = text[2]
+	banmask = configureHostMask(banmask)
+	if banmask == '':
+		return
+	bot.write(['MODE', channel, '-b', banmask])
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('quiet')
+def quiet(bot, trigger):
+	"""
+	This gives admins the ability to quiet a user.
+	The bot must be a Channel Operator for this command to work.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < OP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 2:
+		return
+	opt = Identifier(text[1])
+	quietmask = opt
+	channel = trigger.sender
+	if not opt.is_nick():
+		if argc < 3:
+			return
+		quietmask = text[2]
+		channel = opt
+	quietmask = configureHostMask(quietmask)
+	if quietmask == '':
+		return
+	bot.write(['MODE', channel, '+q', quietmask])
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('unquiet')
+def unquiet(bot, trigger):
+	"""
+	This gives admins the ability to unquiet a user.
+	The bot must be a Channel Operator for this command to work.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < OP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 2:
+		return
+	opt = Identifier(text[1])
+	quietmask = opt
+	channel = trigger.sender
+	if not opt.is_nick():
+		if argc < 3:
+			return
+		quietmask = text[2]
+		channel = opt
+	quietmask = configureHostMask(quietmask)
+	if quietmask == '':
+		return
+	bot.write(['MODE', channel, '-q', quietmask])
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('kickban', 'kb')
+@priority('high')
+def kickban(bot, trigger):
+	"""
+	This gives admins the ability to kickban a user.
+	The bot must be a Channel Operator for this command to work.
+	.kickban [#chan] user1 user!*@* get out of here
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < HALFOP:
+		return bot.reply("I'm not a channel operator!")
+	text = trigger.group().split()
+	argc = len(text)
+	if argc < 4:
+		return
+	opt = Identifier(text[1])
+	nick = opt
+	mask = text[2]
+	channel = trigger.sender
+	reasonidx = 3
+	if not opt.is_nick():
+		if argc < 5:
+			return
+		channel = opt
+		nick = text[2]
+		mask = text[3]
+		reasonidx = 4
+	reason = ' '.join(text[reasonidx:])
+	mask = configureHostMask(mask)
+	if mask == '':
+		return
+	bot.write(['MODE', channel, '+b', mask])
+	bot.write(['KICK', channel, nick], reason)
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('topic')
+def topic(bot, trigger):
+	"""
+	This gives ops the ability to change the topic.
+	The bot must be a Channel Operator for this command to work.
+	"""
+	if bot.privileges[trigger.sender][bot.nick] < HALFOP:
+		return bot.reply("I'm not a channel operator!")
+	if not trigger.group(2):
+		return
+	channel = trigger.sender.lower()
+
+	narg = 1
+	mask = None
+	mask = bot.db.get_channel_value(channel, 'topic_mask')
+	mask = mask or default_mask(trigger)
+	mask = mask.replace('%s', '{}')
+	narg = len(re.findall('{}', mask))
+
+	top = trigger.group(2)
+	args = []
+	if top:
+		args = top.split('~', narg)
+
+	if len(args) != narg:
+		message = "Not enough arguments. You gave {}, it requires {}.".format(
+			len(args), narg)
+		return bot.say(message)
+	topic = mask.format(*args)
+
+	bot.write(('TOPIC', channel + ' :' + topic))
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('tmask')
+def set_mask(bot, trigger):
+	"""
+	Set the mask to use for .topic in the current channel. {} is used to allow
+	substituting in chunks of text.
+	"""
+	bot.db.set_channel_value(trigger.sender, 'topic_mask', trigger.group(2))
+	bot.say("Gotcha, " + trigger.nick)
+
+
+@require_chanmsg
+@require_privilege(OP, 'You are not a channel operator.')
+@commands('showmask')
+def show_mask(bot, trigger):
+	"""Show the topic mask for the current channel."""
+	mask = bot.db.get_channel_value(trigger.sender, 'topic_mask')
+	mask = mask or default_mask(trigger)
+	bot.say(mask)

modules/announce.py

@@ -0,0 +1,22 @@
+# coding=utf-8
+"""
+announce.py - Send a message to all channels
+Copyright © 2013, Elad Alfassa, <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+"""
+from module import commands, example
+
+
+@commands('announce')
+@example('.announce Some important message here')
+def announce(bot, trigger):
+    """
+    Send an announcement to all channels the bot is in
+    """
+    if not trigger.admin:
+        bot.reply('Sorry, I can\'t let you do that')
+        return
+    for channel in bot.channels:
+        bot.msg(channel, '[ANNOUNCEMENT] %s' % trigger.group(2))
+    bot.reply('Announce complete.')

modules/ascii.py

@@ -0,0 +1,192 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from io import BytesIO
+from PIL import Image
+import requests
+import module
+from tools import web
+from PIL import ImageFont
+from PIL import ImageDraw
+
+ASCII_CHARS = "$@%#*+=-:. "
+headers = {'User-Agent': 'we wuz ascii and shiet'}
+
+
+def scale_image(image, size=(100,100)):
+	"""
+	Resizes an image while preserving the aspect ratio. Chooses the
+	dimension to scale by based on whichever is larger, ensuring that
+	neither width or height is ever larger than the accepted size tuple.
+	"""
+	original_width, original_height = image.size
+	original_width = original_width * 2 # because characters are generally
+	if original_width > original_height:  # displayed as a 1:2 square
+		if original_width > size[0]:
+			new_width = 100
+			aspect_ratio = original_height/float(original_width)
+			new_height = int(aspect_ratio * new_width)
+		else:
+			new_width, new_height = image.size
+	else:
+		if original_height > size[1]:
+			new_height = 100
+			aspect_ratio = original_width/float(original_height)
+			new_width = int(aspect_ratio * new_height)
+		else:
+			new_width, new_height = image.size
+	image = image.resize((new_width, new_height))
+	return image
+
+
+def pixels_to_chars(image, reverse=False):
+	"""
+	Maps each pixel to an ascii char based on the range
+	in which it lies.
+
+	0-255 is divided into 11 ranges of 25 pixels each.
+	"""
+	range_width = int(255 / len(ASCII_CHARS)) + (255 % len(ASCII_CHARS) > 0)
+
+	pixels_in_image = list(image.getdata())
+	pixels_to_chars = []
+	for pixel_value in pixels_in_image:
+		if reverse:
+			index = -int(pixel_value/range_width)-1
+		else:
+			index = int(pixel_value/range_width)
+		pixels_to_chars.append(ASCII_CHARS[ index ])
+
+	return "".join(pixels_to_chars)
+
+
+def open_image(imagePath):
+	"""
+	Opens the image at the supplied file path in PIL. If an internet URL
+	is supplied, it will download the image and then open it.
+	"""
+	try:
+		if imagePath.startswith("http"):
+			res = requests.get(imagePath, headers=headers, verify=True, timeout=20)
+			res.raise_for_status()
+			image = Image.open(BytesIO(res.content))
+		else:
+			image = Image.open(imagePath)
+	except FileNotFoundError as e:
+		return e
+	except OSError:
+		return e
+	except Exception as e:
+		return("Error opening image file: " + imagePath)
+
+	return image
+
+
+def image_to_ascii(image, reverse=False):
+	"""
+	Reads an image file and converts it to ascii art. Returns a
+	newline-delineated string. If reverse is True, the ascii scale is
+	reversed.
+	"""
+	image = scale_image(image)
+	image = image.convert('L')
+
+	chars = pixels_to_chars(image, reverse)
+
+	image_ascii = []
+	for index in range(0, len(chars), image.size[0]):
+		image_ascii.append( chars[index: index + image.size[0]] )
+	image.close()
+	del image
+	return "\n".join(image_ascii)
+
+
+def ascii_to_image(image_ascii):
+	"""
+	Creates a plain image and draws text on it.
+	"""
+	width = len(image_ascii[:image_ascii.index("\n")]) * 8
+	height = (image_ascii.count("\n")+1) * 12 + 4
+
+	font = ImageFont.truetype("LiberationMono-Regular.ttf", 14)
+	image = Image.new("RGB", (width, height), (255,255,255))
+	draw = ImageDraw.Draw(image)
+	draw.text((0,0), image_ascii, (0,0,0), font=font, spacing=0)
+	return image
+
+
+def handle_gif(output, reverse=False):
+	image = open_image(args.imagePath)
+	ascii_seq = []
+	new_image = ascii_to_image(image_to_ascii(image, reverse))
+	image.seek(1)
+	while True:
+		try:
+			im = ascii_to_image(image_to_ascii(image, reverse))
+			ascii_seq.append()
+			image.seek(image.tell()+1)
+		except EOFError:
+			break # end of sequence
+
+	new_image.save(args.output, save_all=True, append_images=ascii_seq, duration=60, loop=0, optimize=True)
+
+
+@module.rate(user=60)
+@module.require_chanmsg(message="It's impolite to whisper.")
+@module.commands('ascii')
+@module.example('.ascii [-r] https://www.freshports.org/images/freshports.jpg')
+def ascii(bot, trigger):
+	"""
+	Downloads an image and converts it to ascii.
+	"""
+	reverse = False
+	if trigger.group(3) == "-r":
+		imagePath = trigger.group(4)
+		reverse = True
+	else:
+		imagePath = trigger.group(2)
+
+	if not web.secCheck(bot, imagePath):
+		return bot.reply("Known malicious site. Ignoring.")
+
+	if not imagePath.startswith("http"):
+		bot.reply("Internet requests only.")
+		return
+
+	image = open_image(imagePath)
+	image_ascii = image_to_ascii(image, reverse)
+	bot.say(image_ascii)
+
+
+if __name__=='__main__':
+	import argparse
+
+	# TODO: satisfy PEP8
+	parser = argparse.ArgumentParser(description="Converts an image file to ascii art.")
+	parser.add_argument("imagePath", help="The full path to the image file.")
+	parser.add_argument("-r", "--reverse", action="store_true", help="Reverses the ascii scale.")
+	parser.add_argument("-o", "--output", help="Outputs the ascii art into a file at the specified path.")
+	parser.add_argument("-i", "--image", action="store_true", help="Outputs the ascii art as an image rather than plain text. Requires --output.")
+	parser.add_argument("-a", "--animated", action="store_true", help="Handles animated GIFs. Includes --image.")
+	parser.set_defaults(reverse=False, image=False, animated=False)
+	args = parser.parse_args()
+
+	if args.animated:	# --animated includes --image
+		args.image = True
+	if args.image:		# --image requires --output
+		if not args.output:
+			parser.error("--image requires --output")
+
+	if args.animated:
+		handle_gif(args.output, args.reverse)
+	else:
+		image = open_image(args.imagePath)
+		image_ascii = image_to_ascii(image, args.reverse)
+		if args.image:
+			image = ascii_to_image(image_ascii)
+			image.save(args.output, "PNG")
+		elif args.output:
+			with open(args.output, "w+") as file:
+				file.write(image_ascii)
+		else:
+			print(image_ascii)

modules/away.py

@@ -0,0 +1,56 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Marks a user as away with an optional message and informs anyone who attempt
+to ping them of their away status. Goes away when the user talks again.
+"""
+from module import commands, example, rule, priority
+from tools import Identifier
+
+def setup(bot):
+	bot.memory['away'] = {}
+
+
+@commands('away')
+@example('.away Gonna go kill myself.', 'User is now away: Gonna go kill myself.')
+def away(bot, trigger):
+	"""
+	Stores in the user's name and away message in memory.
+	"""
+	if not trigger.group(2):
+		bot.memory['away'][trigger.nick] = ""
+	else:
+		bot.memory['away'][trigger.nick] = trigger.group(2)
+
+
+@rule('(.*)')
+@priority('low')
+def message(bot, trigger):
+	"""
+	If an away users name is said, print their away message.
+	"""
+	for key in bot.memory['away'].keys():
+		msg = "\x0308" + key + "\x03 is away: \x0311" + \
+				bot.memory['away'][key]
+		if trigger.startswith(key+":"):
+			return bot.say(msg)
+		elif trigger.startswith(key+","):
+			return bot.say(msg)
+		elif trigger == key:
+			return bot.say(msg)
+"""
+	name = Identifier(trigger.group(1))
+	if name in bot.memory['away'].keys():
+		msg = "\x0308" + name + "\x03 is away: \x0311" + \
+				bot.memory['away'][name]
+		bot.say(msg)
+"""
+
+@rule('(.*)')
+@priority('low')
+def notAway(bot, trigger):
+	"""
+	If an away user says something, remove them from the away dict.
+	"""
+	if trigger.nick in bot.memory['away'].keys() and not trigger.group(0).startswith(".away"):
+		bot.memory['away'].pop(trigger.nick, None)

modules/banhe.py

@@ -0,0 +1,49 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ban he
+ban he
+ban he
+"""
+import module
+import modules.adminchannel
+import time
+from trigger import PreTrigger, Trigger
+from tools import Identifier, get_command_regexp
+
+@module.commands('banhe')
+@module.example('.banhe assfaggot 30m')
+def banhe(bot, trigger):
+	"""
+	Bans he for a set period of time. Admins may set the period of time,
+	non-admins only get 20 second bans.
+	"""
+	banhee, period = trigger.group(3), trigger.group(4)
+
+	# here we construct a brand new trigger from scratch becasue doing
+	# things the right way just isn't in the budget.
+	fake_line = ":" + bot.nick + trigger.raw[trigger.raw.find("!"):]
+	fake_pretrigger = PreTrigger(trigger.nick, fake_line)
+	fake_regexp = get_command_regexp(".", "banhe")
+	fake_match = fake_regexp.match(fake_pretrigger.args[-1])
+	fake_trigger = Trigger(bot.config, fake_pretrigger, fake_match)
+
+	if not trigger.admin:
+		period = 20
+	else:
+		conv = {'s':1, 'm':60, 'h':3600, 'd':86400}
+		try:
+			period = conv[period[-1]] * int(period[:-1])
+		except (KeyError, ValueError, TypeError):
+			period = 0
+
+	modules.adminchannel.ban(bot, fake_trigger)
+	if period > 2592000:
+		bot.reply("It's too big, Onii-chan.")
+	if not period or period > 2592000:
+		return bot.say("Banned \x0304" + banhee + "\x03 for \x0309∞\x03 seconds.")
+
+	bot.say("Banned \x0304" + banhee + "\x03 for \x0309" + str(period) + "\x03 seconds.")
+	time.sleep(period)
+	modules.adminchannel.unban(bot, fake_trigger)
+	bot.say("Unbanned \x0304" + banhee + "\x03")

modules/bq.py

@@ -0,0 +1,20 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Various things related to Banished Quest.
+"""
+from module import commands
+from tools.time import relativeTime
+#from datetime import datetime
+
+@commands('bq')
+def BQstatus(bot, trigger):
+	"""
+	Displays the current status of BQ.
+	"""
+	status = "\x0304DEAD"
+	#deathdate = datetime(year=2017, month=2, day=16, hour=0, minute=19)
+	deathdate = "[2017-02-16 00:19:00]"
+	msg = "Banished Quest status: " + status + "\nTime since death: "
+	msg += relativeTime(bot, trigger.nick, deathdate)
+	bot.say(msg)

modules/bugzilla.py

@@ -0,0 +1,97 @@
+# coding=utf-8
+"""Bugzilla issue reporting module
+
+Copyright 2013-2015, Embolalia, embolalia.com
+Licensed under the Eiffel Forum License 2.
+"""
+import re
+
+import xmltodict
+import requests
+
+import tools
+from config.types import StaticSection, ListAttribute
+from logger import get_logger
+from module import rule
+
+
+regex = None
+LOGGER = get_logger(__name__)
+
+
+class BugzillaSection(StaticSection):
+    domains = ListAttribute('domains')
+    """The domains of the Bugzilla instances from which to get information."""
+
+
+def configure(config):
+    config.define_section('bugzilla', BugzillaSection)
+    config.bugzilla.configure_setting(
+        'domains',
+        'Enter the domains of the Bugzillas you want extra information '
+        'from (e.g. bugzilla.gnome.org)'
+    )
+
+
+def setup(bot):
+    global regex
+    bot.config.define_section('bugzilla', BugzillaSection)
+
+    if not bot.config.bugzilla.domains:
+        return
+    if not bot.memory.contains('url_callbacks'):
+        bot.memory['url_callbacks'] = tools.SopelMemory()
+
+    domains = '|'.join(bot.config.bugzilla.domains)
+    regex = re.compile((r'https?://(%s)'
+                        '(/show_bug.cgi\?\S*?)'
+                        '(id=\d+)')
+                       % domains)
+    bot.memory['url_callbacks'][regex] = show_bug
+
+
+def shutdown(bot):
+    del bot.memory['url_callbacks'][regex]
+
+
+@rule(r'.*https?://(\S+?)'
+      '(/show_bug.cgi\?\S*?)'
+      '(id=\d+).*')
+def show_bug(bot, trigger, match=None):
+    """Show information about a Bugzilla bug."""
+    match = match or trigger
+    domain = match.group(1)
+    if domain not in bot.config.bugzilla.domains:
+        return
+    url = 'https://%s%sctype=xml&%s' % match.groups()
+    data = requests.get(url)
+    bug = xmltodict.parse(data).get('bugzilla').get('bug')
+    error = bug.get('@error', None)  # error="NotPermitted"
+
+    if error:
+        LOGGER.warning('Bugzilla error: %s' % error)
+        bot.say('[BUGZILLA] Unable to get infomation for '
+                'linked bug (%s)' % error)
+        return
+
+    message = ('[BUGZILLA] %s | Product: %s | Component: %s | Version: %s | ' +
+               'Importance: %s |  Status: %s | Assigned to: %s | ' +
+               'Reported: %s | Modified: %s')
+
+    resolution = bug.get('resolution')
+    if resolution is not None:
+        status = bug.get('bug_status') + ' ' + resolution
+    else:
+        status = bug.get('bug_status')
+
+    assigned_to = bug.get('assigned_to')
+    if isinstance(assigned_to, dict):
+        assigned_to = assigned_to.get('@name')
+
+    message = message % (
+        bug.get('short_desc'), bug.get('product'),
+        bug.get('component'), bug.get('version'),
+        (bug.get('priority') + ' ' + bug.get('bug_severity')),
+        status, assigned_to, bug.get('creation_ts'),
+        bug.get('delta_ts'))
+    bot.say(message)

modules/calc.py

@@ -0,0 +1,66 @@
+# coding=utf-8
+"""
+calc.py - Sopel Calculator Module
+Copyright 2008, Sean B. Palmer, inamidst.com
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+from module import commands, example
+from tools.calculation import eval_equation
+import sys, requests
+if sys.version_info.major >= 3:
+    unichr = chr
+
+
+BASE_TUMBOLIA_URI = 'https://tumbolia-two.appspot.com/'
+
+
+@commands('c', 'calc')
+@example('.c 5 + 3', '8')
+@example('.c 0.9*10', '9')
+@example('.c 10*0.9', '9')
+@example('.c 2*(1+2)*3', '18')
+@example('.c 2**10', '1024')
+@example('.c 5 // 2', '2')
+@example('.c 5 / 2', '2.5')
+def c(bot, trigger):
+    """Evaluate some calculation."""
+    if not trigger.group(2):
+        return bot.reply("Nothing to calculate.")
+    # Account for the silly non-Anglophones and their silly radix point.
+    eqn = trigger.group(2).replace(',', '.')
+    try:
+        result = eval_equation(eqn)
+        result = "{:.10g}".format(result)
+    except ZeroDivisionError:
+        result = "Division by zero is not supported in this universe."
+    except Exception as e:
+        result = "{error}: {msg}".format(error=type(e), msg=e)
+    bot.reply(result)
+
+
+@commands('py')
+@example('.py len([1,2,3])', '3')
+def py(bot, trigger):
+    """Evaluate a Python expression."""
+    if not trigger.group(2):
+        return bot.say("Need an expression to evaluate")
+
+    query = trigger.group(2)
+    uri = BASE_TUMBOLIA_URI + 'py/'
+    res = requests.get(uri + query)
+    res.raise_for_status()
+    answer = res.text
+    if answer:
+        #bot.say can potentially lead to 3rd party commands triggering.
+        bot.say(answer)
+    else:
+        bot.reply('Sorry, no result.')
+
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/clock.py

@@ -0,0 +1,276 @@
+# coding=utf-8
+# Copyright 2008-9, Sean B. Palmer, inamidst.com
+# Copyright 2012, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+
+try:
+    import pytz
+except ImportError:
+    pytz = None
+
+from module import commands, example, OP
+from tools.time import (
+    get_timezone, format_time, validate_format, validate_timezone
+)
+from config.types import StaticSection, ValidatedAttribute
+
+
+class TimeSection(StaticSection):
+    tz = ValidatedAttribute(
+        'tz',
+        parse=validate_timezone,
+        serialize=validate_timezone,
+        default='UTC'
+    )
+    """Default time zone (see http://sopel.chat/tz)"""
+    time_format = ValidatedAttribute(
+        'time_format',
+        parse=validate_format,
+        default='%Y-%m-%d - %T%Z'
+    )
+    """Default time format (see http://strftime.net)"""
+
+
+def configure(config):
+    config.define_section('clock', TimeSection)
+    config.clock.configure_setting(
+        'tz', 'Preferred time zone (http://sopel.chat/tz)')
+    config.clock.configure_setting(
+        'time_format', 'Preferred time format (http://strftime.net)')
+
+
+def setup(bot):
+    bot.config.define_section('clock', TimeSection)
+
+
+@commands('t', 'time')
+@example('.t America/New_York')
+def f_time(bot, trigger):
+    """Returns the current time."""
+    if trigger.group(2):
+        zone = get_timezone(bot.db, bot.config, trigger.group(2).strip(), None, None)
+        if not zone:
+            bot.say('Could not find timezone %s.' % trigger.group(2).strip())
+            return
+    else:
+        zone = get_timezone(bot.db, bot.config, None, trigger.nick,
+                            trigger.sender)
+    time = format_time(bot.db, bot.config, zone, trigger.nick, trigger.sender)
+    bot.say(time)
+
+
+@commands('settz', 'settimezone')
+@example('.settz America/New_York')
+def update_user(bot, trigger):
+    """
+    Set your preferred time zone. Most timezones will work, but it's best to
+    use one from http://sopel.chat/tz
+    """
+    if not pytz:
+        bot.reply("Sorry, I don't have timezone support installed.")
+    else:
+        tz = trigger.group(2)
+        if not tz:
+            bot.reply("What timezone do you want to set? Try one from "
+                      "http://sopel.chat/tz")
+            return
+        if tz not in pytz.all_timezones:
+            bot.reply("I don't know that time zone. Try one from "
+                      "http://sopel.chat/tz")
+            return
+
+        bot.db.set_nick_value(trigger.nick, 'timezone', tz)
+        if len(tz) < 7:
+            bot.say("Okay, {}, but you should use one from http://sopel.chat/tz "
+                    "if you use DST.".format(trigger.nick))
+        else:
+            bot.reply('I now have you in the %s time zone.' % tz)
+
+
+@commands('gettz', 'gettimezone')
+@example('.gettz [nick]')
+def get_user_tz(bot, trigger):
+    """
+    Gets a user's preferred time zone, will show yours if no user specified
+    """
+    if not pytz:
+        bot.reply("Sorry, I don't have timezone support installed.")
+    else:
+        nick = trigger.group(2)
+        if not nick:
+            nick = trigger.nick
+
+        nick = nick.strip()
+
+        tz = bot.db.get_nick_value(nick, 'timezone')
+        if tz:
+            bot.say('%s\'s time zone is %s.' % (nick, tz))
+        else:
+            bot.say('%s has not set their time zone' % nick)
+
+
+@commands('settimeformat', 'settf')
+@example('.settf %Y-%m-%dT%T%z')
+def update_user_format(bot, trigger):
+    """
+    Sets your preferred format for time. Uses the standard strftime format. You
+    can use http://strftime.net or your favorite search engine to learn more.
+    """
+    tformat = trigger.group(2)
+    if not tformat:
+        bot.reply("What format do you want me to use? Try using"
+                  " http://strftime.net to make one.")
+        return
+
+    tz = get_timezone(bot.db, bot.config, None, trigger.nick, trigger.sender)
+
+    # Get old format as back-up
+    old_format = bot.db.get_nick_value(trigger.nick, 'time_format')
+
+    # Save the new format in the database so we can test it.
+    bot.db.set_nick_value(trigger.nick, 'time_format', tformat)
+
+    try:
+        timef = format_time(db=bot.db, zone=tz, nick=trigger.nick)
+    except:
+        bot.reply("That format doesn't work. Try using"
+                  " http://strftime.net to make one.")
+        # New format doesn't work. Revert save in database.
+        bot.db.set_nick_value(trigger.nick, 'time_format', old_format)
+        return
+    bot.reply("Got it. Your time will now appear as %s. (If the "
+              "timezone is wrong, you might try the settz command)"
+              % timef)
+
+
+@commands('gettimeformat', 'gettf')
+@example('.gettf [nick]')
+def get_user_format(bot, trigger):
+    """
+    Gets a user's preferred time format, will show yours if no user specified
+    """
+    nick = trigger.group(2)
+    if not nick:
+        nick = trigger.nick
+
+    nick = nick.strip()
+
+    # Get old format as back-up
+    format = bot.db.get_nick_value(nick, 'time_format')
+
+    if format:
+        bot.say("%s's time format: %s." % (nick, format))
+    else:
+        bot.say("%s hasn't set a custom time format" % nick)
+
+
+@commands('setchanneltz', 'setctz')
+@example('.setctz America/New_York')
+def update_channel(bot, trigger):
+    """
+    Set the preferred time zone for the channel.
+    """
+    if bot.privileges[trigger.sender][trigger.nick] < OP:
+        return
+    elif not pytz:
+        bot.reply("Sorry, I don't have timezone support installed.")
+    else:
+        tz = trigger.group(2)
+        if not tz:
+            bot.reply("What timezone do you want to set? Try one from "
+                      "http://sopel.chat/tz")
+            return
+        if tz not in pytz.all_timezones:
+            bot.reply("I don't know that time zone. Try one from "
+                      "http://sopel.chat/tz")
+            return
+
+        bot.db.set_channel_value(trigger.sender, 'timezone', tz)
+        if len(tz) < 7:
+            bot.say("Okay, {}, but you should use one from http://sopel.chat/tz "
+                    "if you use DST.".format(trigger.nick))
+        else:
+            bot.reply(
+                'I now have {} in the {} time zone.'.format(trigger.sender, tz))
+
+
+@commands('getchanneltz', 'getctz')
+@example('.getctz [channel]')
+def get_channel_tz(bot, trigger):
+    """
+    Gets the preferred channel timezone, or the current channel timezone if no
+    channel given.
+    """
+    if not pytz:
+        bot.reply("Sorry, I don't have timezone support installed.")
+    else:
+        channel = trigger.group(2)
+        if not channel:
+            channel = trigger.sender
+
+        channel = channel.strip()
+
+        timezone = bot.db.get_channel_value(channel, 'timezone')
+        if timezone:
+            bot.say('%s\'s timezone: %s' % (channel, timezone))
+        else:
+            bot.say('%s has no preferred timezone' % channel)
+
+
+@commands('setchanneltimeformat', 'setctf')
+@example('.setctf %Y-%m-%dT%T%z')
+def update_channel_format(bot, trigger):
+    """
+    Sets your preferred format for time. Uses the standard strftime format. You
+    can use http://strftime.net or your favorite search engine to learn more.
+    """
+    if bot.privileges[trigger.sender][trigger.nick] < OP:
+        return
+
+    tformat = trigger.group(2)
+    if not tformat:
+        bot.reply("What format do you want me to use? Try using"
+                  " http://strftime.net to make one.")
+
+    tz = get_timezone(bot.db, bot.config, None, None, trigger.sender)
+
+    # Get old format as back-up
+    old_format = bot.db.get_channel_value(trigger.sender, 'time_format')
+
+    # Save the new format in the database so we can test it.
+    bot.db.set_channel_value(trigger.sender, 'time_format', tformat)
+
+    try:
+        timef = format_time(db=bot.db, zone=tz, channel=trigger.sender)
+    except:
+        bot.reply("That format doesn't work. Try using"
+                  " http://strftime.net to make one.")
+        # New format doesn't work. Revert save in database.
+        bot.db.set_channel_value(trigger.sender, 'time_format', old_format)
+        return
+    bot.db.set_channel_value(trigger.sender, 'time_format', tformat)
+    bot.reply("Got it. Times in this channel  will now appear as %s "
+              "unless a user has their own format set. (If the timezone"
+              " is wrong, you might try the settz and channeltz "
+              "commands)" % timef)
+
+
+@commands('getchanneltimeformat', 'getctf')
+@example('.getctf [channel]')
+def get_channel_format(bot, trigger):
+    """
+    Gets the channel's preferred time format, will return current channel's if
+    no channel name is given
+    """
+
+    channel = trigger.group(2)
+    if not channel:
+        channel = trigger.sender
+
+    channel = channel.strip()
+
+    tformat = bot.db.get_channel_value(channel, 'time_format')
+    if tformat:
+        bot.say('%s\'s time format: %s' % (channel, tformat))
+    else:
+        bot.say('%s has no preferred time format' % channel)

modules/countdown.py

@@ -0,0 +1,39 @@
+# coding=utf-8
+"""
+countdown.py - Sopel Countdown Module
+Copyright 2011, Michael Yanovich, yanovich.net
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+import datetime
+
+from module import commands, NOLIMIT
+
+
+@commands('countdown')
+def generic_countdown(bot, trigger):
+    """
+    .countdown <year> <month> <day> - displays a countdown to a given date.
+    """
+    text = trigger.group(2)
+    if not text:
+        bot.say("Please use correct format: .countdown 2012 12 21")
+        return NOLIMIT
+    text = trigger.group(2).split()
+    if text and (len(text) == 3 and text[0].isdigit() and text[1].isdigit()
+                 and text[2].isdigit()):
+        try:
+            diff = (datetime.datetime(int(text[0]), int(text[1]), int(text[2]))
+                    - datetime.datetime.today())
+        except:
+            bot.say("Please use correct format: .countdown 2012 12 21")
+            return NOLIMIT
+        bot.say(str(diff.days) + " days, " + str(diff.seconds // 3600)
+                   + " hours and "
+                   + str(diff.seconds % 3600 // 60)
+                   + " minutes until "
+                   + text[0] + " " + text[1] + " " + text[2])
+    else:
+        bot.say("Please use correct format: .countdown 2012 12 21")
+        return NOLIMIT

modules/currency.py

@@ -0,0 +1,51 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+from module import commands, example
+import wolfram
+import requests
+
+
+@commands('cur', 'currency', 'exchange')
+@example('.cur 20 EUR in USD')
+def exchange(bot, trigger):
+	"""Show the exchange rate between two currencies"""
+	if not trigger.group(2):
+		bot.say('You must provide a query.')
+		return
+	if not bot.config.wolfram.app_id:
+		bot.say('Wolfram|Alpha API app ID not configured.')
+		return
+
+	lines = wolfram.wa_query(bot.config.wolfram.app_id, trigger.group(2), bot.config.wolfram.units)
+	bot.say(lines)
+
+
+@commands('btc', 'bitcoin')
+@example('.btc 20 EUR')
+def bitcoin(bot, trigger):
+	args = trigger.args[1].split(' ')	# because trigger.group() is stupid
+	if len(args) == 3:		# two arguments were supplied
+		amount = args[1]
+		to = args[2]
+		if not amount.replace('.','').isdigit():
+			bot.say("Stop being dumb.")
+			return
+	elif len(args) == 2:			# one argument was supplied
+		if args[1].replace('.','').isdigit():	# argument is the amount
+			amount = args[1]
+			to = 'USD'
+		else:
+			to = args[1]
+			amount = 1
+	else:		# no arguments were supplied
+		amount = 1
+		to = 'USD'
+	to = to.upper()
+
+	res = requests.get("https://api.coindesk.com/v1/bpi/currentprice/{}.json".format(to), verify=True)
+	if res.text[:5] == "Sorry":
+		bot.say(res.text)
+		return
+	rate = res.json()['bpi'][to]['rate_float']
+	calc = float(amount) * rate
+	bot.say('\x0310' + str(amount) + ' BTC\x03 = \x0312' + str(calc) + ' ' + to + ' (' + res.json()['bpi'][to]['description'] + ')')

modules/dice.py

@@ -0,0 +1,259 @@
+# coding=utf-8
+"""
+dice.py - Dice Module
+Copyright 2010-2013, Dimitri "Tyrope" Molenaars, TyRope.nl
+Copyright 2013, Ari Koivula, <ari@koivu.la>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat/
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+import random
+import re
+import operator
+
+import module
+from tools.calculation import eval_equation
+
+
+class DicePouch:
+	def __init__(self, num_of_die, type_of_die, addition):
+		"""Initialize dice pouch and roll the dice.
+
+		Args:
+			num_of_die: number of dice in the pouch.
+			type_of_die: how many faces the dice have.
+			addition: how much is added to the result of the dice.
+		"""
+		self.num = num_of_die
+		self.type = type_of_die
+		self.addition = addition
+
+		self.dice = {}
+		self.dropped = {}
+
+		self.roll_dice()
+
+	def roll_dice(self):
+		"""Roll all the dice in the pouch."""
+		self.dice = {}
+		self.dropped = {}
+		for __ in range(self.num):
+			number = random.randint(1, self.type)
+			count = self.dice.setdefault(number, 0)
+			self.dice[number] = count + 1
+
+	def drop_lowest(self, n):
+		"""Drop n lowest dice from the result.
+
+		Args:
+			n: the number of dice to drop.
+		"""
+
+		sorted_x = sorted(self.dice.items(), key=operator.itemgetter(0))
+
+		for i, count in sorted_x:
+			count = self.dice[i]
+			if n == 0:
+				break
+			elif n < count:
+				self.dice[i] = count - n
+				self.dropped[i] = n
+				break
+			else:
+				self.dice[i] = 0
+				self.dropped[i] = count
+				n = n - count
+
+		for i, count in self.dropped.items():
+			if self.dice[i] == 0:
+				del self.dice[i]
+
+	def get_simple_string(self):
+		"""Return the values of the dice like (2+2+2[+1+1])+1."""
+		dice = self.dice.items()
+		faces = ("+".join([str(face)] * times) for face, times in dice)
+		dice_str = "+".join(faces)
+
+		dropped_str = ""
+		if self.dropped:
+			dropped = self.dropped.items()
+			dfaces = ("+".join([str(face)] * times) for face, times in dropped)
+			dropped_str = "[+%s]" % ("+".join(dfaces),)
+
+		plus_str = ""
+		if self.addition:
+			plus_str = "{:+d}".format(self.addition)
+
+		return "(%s%s)%s" % (dice_str, dropped_str, plus_str)
+
+	def get_compressed_string(self):
+		"""Return the values of the dice like (3x2[+2x1])+1."""
+		dice = self.dice.items()
+		faces = ("%dx%d" % (times, face) for face, times in dice)
+		dice_str = "+".join(faces)
+
+		dropped_str = ""
+		if self.dropped:
+			dropped = self.dropped.items()
+			dfaces = ("%dx%d" % (times, face) for face, times in dropped)
+			dropped_str = "[+%s]" % ("+".join(dfaces),)
+
+		plus_str = ""
+		if self.addition:
+			plus_str = "{:+d}".format(self.addition)
+
+		return "(%s%s)%s" % (dice_str, dropped_str, plus_str)
+
+	def get_sum(self):
+		"""Get the sum of non-dropped dice and the addition."""
+		result = self.addition
+		for face, times in self.dice.items():
+			result += face * times
+		return result
+
+	def get_number_of_faces(self):
+		"""Returns sum of different faces for dropped and not dropped dice
+
+		This can be used to estimate, whether the result can be shown in
+		compressed form in a reasonable amount of space.
+		"""
+		return len(self.dice) + len(self.dropped)
+
+
+def _roll_dice(bot, dice_expression):
+	result = re.search(
+		r"""
+		(?P<dice_num>-?\d*)
+		d
+		(?P<dice_type>-?\d+)
+		(v(?P<drop_lowest>-?\d+))?
+		$""",
+		dice_expression,
+		re.IGNORECASE | re.VERBOSE)
+
+	dice_num = int(result.group('dice_num') or 1)
+	dice_type = int(result.group('dice_type'))
+
+	# Dice can't have zero or a negative number of sides.
+	if dice_type <= 0:
+		bot.reply("I don't have any dice with %d sides. =(" % dice_type)
+		return None  # Signal there was a problem
+
+	# Can't roll a negative number of dice.
+	if dice_num < 0:
+		bot.reply("I'd rather not roll a negative amount of dice. =(")
+		return None  # Signal there was a problem
+
+	# Upper limit for dice should be at most a million. Creating a dict with
+	# more than a million elements already takes a noticeable amount of time
+	# on a fast computer and ~55kB of memory.
+	if dice_num > 1000:
+		bot.reply('I only have 1000 dice. =(')
+		return None  # Signal there was a problem
+
+	dice = DicePouch(dice_num, dice_type, 0)
+
+	if result.group('drop_lowest'):
+		drop = int(result.group('drop_lowest'))
+		if drop >= 0:
+			dice.drop_lowest(drop)
+		else:
+			bot.reply("I can't drop the lowest %d dice. =(" % drop)
+
+	return dice
+
+
+@module.commands("roll")
+@module.commands("dice")
+@module.commands("d")
+@module.priority("medium")
+@module.example(".roll 3d1+1", 'You roll 3d1+1: (1+1+1)+1 = 4')
+@module.example(".roll 3d1v2+1", 'You roll 3d1v2+1: (1[+1+1])+1 = 2')
+@module.example(".roll 2d4", 'You roll 2d4: \(\d\+\d\) = \d', re=True)
+@module.example(".roll 100d1", '[^:]*: \(100x1\) = 100', re=True)
+@module.example(".roll 1001d1", 'I only have 1000 dice. =(')
+@module.example(".roll 1d1 + 1d1", 'You roll 1d1 + 1d1: (1) + (1) = 2')
+@module.example(".roll 1d1+1d1", 'You roll 1d1+1d1: (1)+(1) = 2')
+def roll(bot, trigger):
+	""".dice XdY[vZ][+N], rolls dice and reports the result.
+
+	X is the number of dice. Y is the number of faces in the dice. Z is the
+	number of lowest dice to be dropped from the result. N is the constant to
+	be applied to the end result.
+	"""
+	# This regexp is only allowed to have one captured group, because having
+	# more would alter the output of re.findall.
+	dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?"
+
+	# Get a list of all dice expressions, evaluate them and then replace the
+	# expressions in the original string with the results. Replacing is done
+	# using string formatting, so %-characters must be escaped.
+	if not trigger.group(2):
+		return bot.reply("No dice to roll.")
+	arg_str = trigger.group(2)
+	dice_expressions = re.findall(dice_regexp, arg_str)
+	arg_str = arg_str.replace("%", "%%")
+	arg_str = re.sub(dice_regexp, "%s", arg_str)
+
+	f = lambda dice_expr: _roll_dice(bot, dice_expr)
+	dice = list(map(f, dice_expressions))
+
+	if None in dice:
+		# Stop computing roll if there was a problem rolling dice.
+		return
+
+	def _get_eval_str(dice):
+		return "(%d)" % (dice.get_sum(),)
+
+	def _get_pretty_str(dice):
+		if dice.num <= 10:
+			return dice.get_simple_string()
+		elif dice.get_number_of_faces() <= 10:
+			return dice.get_compressed_string()
+		else:
+			return "(...)"
+
+	eval_str = arg_str % (tuple(map(_get_eval_str, dice)))
+	pretty_str = arg_str % (tuple(map(_get_pretty_str, dice)))
+
+	# Showing the actual error will hopefully give a better hint of what is
+	# wrong with the syntax than a generic error message.
+	try:
+		result = eval_equation(eval_str)
+	except Exception as e:
+		bot.reply("SyntaxError, eval(%s), %s" % (eval_str, e))
+		return
+
+	bot.reply("You roll %s: %s = %d" % (
+		trigger.group(2), pretty_str, result))
+
+
+@module.commands("choice")
+@module.commands("ch")
+@module.commands("choose")
+@module.priority("medium")
+def choose(bot, trigger):
+	"""
+	.choice option1|option2|option3 - Makes a difficult choice easy.
+	"""
+	if not trigger.group(2):
+		return bot.reply('I\'d choose an option, but you didn\'t give me any.')
+	choices = [trigger.group(2)]
+	for delim in '|\\/,':
+		choices = trigger.group(2).split(delim)
+		if len(choices) > 1:
+			break
+	# Use a different delimiter in the output, to prevent ambiguity.
+	for show_delim in ',|/\\':
+		if show_delim not in trigger.group(2):
+			show_delim += ' '
+			break
+
+	pick = random.choice(choices)
+	return bot.reply('Your options: %s. My choice: %s' % (show_delim.join(choices), pick))
+
+
+if __name__ == "__main__":
+	from test_tools import run_example_tests
+	run_example_tests(__file__)

modules/echo.py

@@ -0,0 +1,13 @@
+#! /usr/bin/env python3
+#-*- coding:utf-8 -*-
+"""
+Echo.
+"""
+import module
+
+@module.commands('echo')
+@module.example('.echo balloons')
+def echo(bot, trigger):
+	"""Echos the given string."""
+	if trigger.group(2):
+		bot.say(trigger.group(2))

modules/etymology.py

@@ -0,0 +1,97 @@
+# coding=utf-8
+"""
+etymology.py - Sopel Etymology Module
+Copyright 2007-9, Sean B. Palmer, inamidst.com
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+import re
+
+import requests
+
+from module import commands, example, NOLIMIT
+
+etyuri = 'http://etymonline.com/?term=%s'
+etysearch = 'http://etymonline.com/?search=%s'
+
+r_definition = re.compile(r'(?ims)<dd[^>]*>.*?</dd>')
+r_tag = re.compile(r'<(?!!)[^>]+>')
+r_whitespace = re.compile(r'[\t\r\n ]+')
+
+abbrs = [
+    'cf', 'lit', 'etc', 'Ger', 'Du', 'Skt', 'Rus', 'Eng', 'Amer.Eng', 'Sp',
+    'Fr', 'N', 'E', 'S', 'W', 'L', 'Gen', 'J.C', 'dial', 'Gk',
+    '19c', '18c', '17c', '16c', 'St', 'Capt', 'obs', 'Jan', 'Feb', 'Mar',
+    'Apr', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'c', 'tr', 'e', 'g'
+]
+t_sentence = r'^.*?(?<!%s)(?:\.(?= [A-Z0-9]|\Z)|\Z)'
+r_sentence = re.compile(t_sentence % ')(?<!'.join(abbrs))
+
+
+def unescape(s):
+    s = s.replace('&gt;', '>')
+    s = s.replace('&lt;', '<')
+    s = s.replace('&amp;', '&')
+    return s
+
+
+def text(html):
+    html = r_tag.sub('', html)
+    html = r_whitespace.sub(' ', html)
+    return unescape(html).strip()
+
+
+def etymology(word):
+    # @@ <nsh> sbp, would it be possible to have a flag for .ety to get 2nd/etc
+    # entries? - http://swhack.com/logs/2006-07-19#T15-05-29
+
+    if len(word) > 25:
+        raise ValueError("Word too long: %s[...]" % word[:10])
+    word = {'axe': 'ax/axe'}.get(word, word)
+
+    bytes = requests.get(etyuri % word)
+    definitions = r_definition.findall(bytes)
+
+    if not definitions:
+        return None
+
+    defn = text(definitions[0])
+    m = r_sentence.match(defn)
+    if not m:
+        return None
+    sentence = m.group(0)
+
+    maxlength = 275
+    if len(sentence) > maxlength:
+        sentence = sentence[:maxlength]
+        words = sentence[:-5].split(' ')
+        words.pop()
+        sentence = ' '.join(words) + ' [...]'
+
+    sentence = '"' + sentence.replace('"', "'") + '"'
+    return sentence + ' - ' + (etyuri % word)
+
+
+@commands('ety')
+@example('.ety word')
+def f_etymology(bot, trigger):
+    """Look up the etymology of a word"""
+    word = trigger.group(2)
+
+    try:
+        result = etymology(word)
+    except IOError:
+        msg = "Can't connect to etymonline.com (%s)" % (etyuri % word)
+        bot.msg(trigger.sender, msg)
+        return NOLIMIT
+    except (AttributeError, TypeError):
+        result = None
+
+    if result is not None:
+        bot.msg(trigger.sender, result)
+    else:
+        uri = etysearch % word
+        msg = 'Can\'t find the etymology for "%s". Try %s' % (word, uri)
+        bot.msg(trigger.sender, msg)
+        return NOLIMIT

modules/find.py

@@ -0,0 +1,139 @@
+# coding=utf-8
+"""Sopel Spelling correction module
+
+This module will fix spelling errors if someone corrects them
+using the sed notation (s///) commonly found in vi/vim.
+"""
+# Copyright 2011, Michael Yanovich, yanovich.net
+# Copyright 2013, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+# Contributions from: Matt Meinwald and Morgan Goose
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+from tools import Identifier, SopelMemory
+from module import rule, priority
+from formatting import bold
+
+
+def setup(bot):
+    bot.memory['find_lines'] = SopelMemory()
+
+
+@rule('.*')
+@priority('low')
+def collectlines(bot, trigger):
+    """Create a temporary log of what people say"""
+
+    # Don't log things in PM
+    if trigger.is_privmsg:
+        return
+
+    # Add a log for the channel and nick, if there isn't already one
+    if trigger.sender not in bot.memory['find_lines']:
+        bot.memory['find_lines'][trigger.sender] = SopelMemory()
+    if Identifier(trigger.nick) not in bot.memory['find_lines'][trigger.sender]:
+        bot.memory['find_lines'][trigger.sender][Identifier(trigger.nick)] = list()
+
+    # Create a temporary list of the user's lines in a channel
+    templist = bot.memory['find_lines'][trigger.sender][Identifier(trigger.nick)]
+    line = trigger.group()
+    if line.startswith("s/"):  # Don't remember substitutions
+        return
+    elif line.startswith("\x01ACTION"):  # For /me messages
+        line = line[:-1]
+        templist.append(line)
+    else:
+        templist.append(line)
+
+    del templist[:-10]  # Keep the log to 10 lines per person
+
+    bot.memory['find_lines'][trigger.sender][Identifier(trigger.nick)] = templist
+
+
+#Match nick, s/find/replace/flags. Flags and nick are optional, nick can be
+#followed by comma or colon, anything after the first space after the third
+#slash is ignored, you can escape slashes with backslashes, and if you want to
+#search for an actual backslash followed by an actual slash, you're shit out of
+#luck because this is the fucking regex of death as it is.
+@rule(r"""(?:
+            (\S+)           # Catch a nick in group 1
+          [:,]\s+)?         # Followed by colon/comma and whitespace, if given
+          s/                # The literal s/
+          (                 # Group 2 is the thing to find
+            (?:\\/ | [^/])+ # One or more non-slashes or escaped slashes
+          )/(               # Group 3 is what to replace with
+            (?:\\/ | [^/])* # One or more non-slashes or escaped slashes
+          )
+          (?:/(\S+))?       # Optional slash, followed by group 4 (flags)
+          """)
+@priority('high')
+def findandreplace(bot, trigger):
+    # Don't bother in PM
+    if trigger.is_privmsg:
+        return
+
+    # Correcting other person vs self.
+    rnick = Identifier(trigger.group(1) or trigger.nick)
+
+    search_dict = bot.memory['find_lines']
+    # only do something if there is conversation to work with
+    if trigger.sender not in search_dict:
+        return
+    if Identifier(rnick) not in search_dict[trigger.sender]:
+        return
+
+    #TODO rest[0] is find, rest[1] is replace. These should be made variables of
+    #their own at some point.
+    rest = [trigger.group(2), trigger.group(3)]
+    rest[0] = rest[0].replace(r'\/', '/')
+    rest[1] = rest[1].replace(r'\/', '/')
+    me = False  # /me command
+    flags = (trigger.group(4) or '')
+
+    # If g flag is given, replace all. Otherwise, replace once.
+    if 'g' in flags:
+        count = -1
+    else:
+        count = 1
+
+    # repl is a lambda function which performs the substitution. i flag turns
+    # off case sensitivity. re.U turns on unicode replacement.
+    if 'i' in flags:
+        regex = re.compile(re.escape(rest[0]), re.U | re.I)
+        repl = lambda s: re.sub(regex, rest[1], s, count == 1)
+    else:
+        repl = lambda s: re.sub(rest[0], rest[1], s, count)
+
+    # Look back through the user's lines in the channel until you find a line
+    # where the replacement works
+    new_phrase = None
+    for line in reversed(search_dict[trigger.sender][rnick]):
+        if line.startswith("\x01ACTION"):
+            me = True  # /me command
+            line = line[8:]
+        else:
+            me = False
+        new_phrase = repl(line)
+        if new_phrase != line:  # we are done
+            break
+
+    if not new_phrase or new_phrase == line:
+        return  # Didn't find anything
+
+    # Save the new "edited" message.
+    action = (me and '\x01ACTION ') or ''  # If /me message, prepend \x01ACTION
+    templist = search_dict[trigger.sender][rnick]
+    templist.append(action + new_phrase)
+    search_dict[trigger.sender][rnick] = templist
+    bot.memory['find_lines'] = search_dict
+
+    # output
+    if not me:
+        new_phrase = '%s to say: %s' % (bold('meant'), new_phrase)
+    if trigger.group(1):
+        phrase = '%s thinks %s %s' % (trigger.nick, rnick, new_phrase)
+    else:
+        phrase = '%s %s' % (trigger.nick, new_phrase)
+
+    bot.say(phrase)

modules/hangman.py

@@ -0,0 +1,92 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Hangman.
+"""
+import random
+import module
+
+class Hangman():
+	def __init__(self):
+		self.running = False
+
+	def newgame(self):
+		self.running = True
+		self.tries = 8
+		self.word = self._PickWord()
+		self.working = [x for x in self.word]
+		self.blanks = list('_' * len(self.word))
+		for n,char in enumerate(self.word):
+			if char == ' ':
+				self.blanks[n] = ' '
+
+	def _PickWord(self):
+		with open("/home/iou1name/.sopel/wordlist.txt",'r') as file:
+			lines = file.readlines()
+		wrd = list(lines[ random.randint(0, len(lines))-1 ].strip())
+		return wrd
+
+	def solve(self, guess):
+		if list(guess) == self.word:
+			self.running = False
+			self.blanks = self.word
+			return 'win'
+
+		elif guess in self.word and len(guess) == 1:
+			while guess in self.working:
+				index = self.working.index(guess)
+				self.blanks[index] = guess
+				self.working[index] = '_'
+			return 'correct'
+		else:
+			self.tries = self.tries - 1
+			if self.tries == 0:
+				self.running = False
+				self.blanks = self.word
+				return 'lose'
+			else:
+				return 'incorrect'
+
+	def return_blanks(self):
+		return ''.join(self.blanks)
+
+
+hangman = Hangman()
+
+@module.commands('hangman')
+@module.example('.hangman')
+def hangman_start(bot, trigger):
+	"""Starts a game of hangman."""
+	if hangman.running:
+		bot.reply("There is already a game running.")
+		return
+
+	hangman.newgame()
+	bot.say(trigger.nick + " has started a game of hangman! Type .guess to guess a letter or the entire phrase.")
+	bot.say(hangman.return_blanks())
+
+
+@module.commands('guess')
+@module.example('.guess a')
+@module.example('.guess anus')
+def guess(bot, trigger):
+	"""Makes a guess in hangman. May either guess a single letter or the entire word/phrase."""
+	if not hangman.running:
+		bot.reply('There is no game currently running. Use .hangman to start one')
+		return
+
+	response = hangman.solve(trigger.group(2))
+
+	if response == 'win':
+		bot.say(trigger.nick + " has won!")
+	elif response == 'correct':
+		pass
+	elif response == 'lose':
+		bot.say("Game over.")
+	elif response == 'incorrect':
+		bot.reply("incorrect.")
+		bot.say( str(hangman.tries) + " tries left." )
+	else:
+		bot.say('Fuck.')
+
+	bot.say(hangman.return_blanks())

modules/help.py

@@ -0,0 +1,51 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+help.py - Sopel Help Module
+Copyright 2008, Sean B. Palmer, inamidst.com
+Copyright © 2013, Elad Alfassa, <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import textwrap
+import collections
+import json
+
+from logger import get_logger
+from module import commands, rule, example, priority
+
+logger = get_logger(__name__)
+
+
+@rule('$nick' '(?i)(help|doc) +([A-Za-z]+)(?:\?+)?$')
+@example('.help tell')
+@commands('help', 'commands')
+@priority('low')
+def help(bot, trigger):
+	"""Shows a command's documentation, and possibly an example."""
+	if trigger.group(2):
+		name = trigger.group(2)
+		name = name.lower()
+
+		if name in bot.doc:
+			newlines = ['']
+			lines = list(filter(None, bot.doc[name][0]))
+			lines = list(map(str.strip, lines))
+			for line in lines:
+				newlines[-1] = newlines[-1] + ' ' + line
+				if line[-1] is '.':
+					newlines.append('')
+			newlines = list(map(str.strip, newlines))
+			if bot.doc[name][1]:
+				newlines.append('Ex. ' + bot.doc[name][1])
+
+			for msg in newlines:
+				bot.say(msg)
+	else:
+		helps = list(bot.command_groups)
+		helps.sort()
+		msg = "Available commands: " + ', '.join(helps)
+		bot.say(msg)

modules/ip.py

@@ -0,0 +1,136 @@
+# coding=utf-8
+"""GeoIP lookup module"""
+# Copyright 2011, Dimitri Molenaars, TyRope.nl,
+# Copyright © 2013, Elad Alfassa <elad@fedoraproject.org>
+# Licensed under the Eiffel Forum License 2.
+import pygeoip
+import socket
+import os
+import gzip
+
+urlretrieve = None
+try:
+    from urllib import urlretrieve
+except ImportError:
+    try:
+        # urlretrieve has been put under urllib.request in Python 3.
+        # It's also deprecated so this should probably be replaced with
+        # urllib2.
+        from urllib.request import urlretrieve
+    except ImportError:
+        pass
+
+from config.types import StaticSection, FilenameAttribute
+from module import commands, example
+from logger import get_logger
+
+LOGGER = get_logger(__name__)
+
+
+class GeoipSection(StaticSection):
+    GeoIP_db_path = FilenameAttribute('GeoIP_db_path', directory=True)
+    """Path of the directory containing the GeoIP db files."""
+
+
+def configure(config):
+    config.define_section('ip', GeoipSection)
+    config.ip.configure_setting('GeoIP_db_path',
+                                'Path of the GeoIP db files')
+
+
+def setup(bot=None):
+    if not bot:
+        return  # Because of some weird pytest thing?
+
+    bot.config.define_section('ip', GeoipSection)
+
+
+def _decompress(source, target, delete_after_decompression=True):
+    """ Decompress a GZip file """
+    f_in = gzip.open(source, 'rb')
+    f_out = open(target, 'wb')
+    f_out.writelines(f_in)
+    f_out.close()
+    f_in.close()
+    if delete_after_decompression:
+        os.remove(source)
+
+
+def _find_geoip_db(bot):
+    """ Find the GeoIP database """
+    config = bot.config
+    if config.ip.GeoIP_db_path:
+        cities_db = os.path.join(config.ip.GeoIP_db_path, 'GeoLiteCity.dat')
+        ipasnum_db = os.path.join(config.ip.GeoIP_db_path, 'GeoIPASNum.dat')
+        if os.path.isfile(cities_db) and os.path.isfile(ipasnum_db):
+            return config.ip.GeoIP_db_path
+        else:
+            LOGGER.warning(
+                'GeoIP path configured but DB not found in configured path'
+            )
+    if (os.path.isfile(os.path.join(bot.config.core.homedir, 'GeoLiteCity.dat')) and
+            os.path.isfile(os.path.join(bot.config.core.homedir, 'GeoIPASNum.dat'))):
+        return bot.config.core.homedir
+    elif (os.path.isfile(os.path.join('/usr/share/GeoIP', 'GeoLiteCity.dat')) and
+            os.path.isfile(os.path.join('/usr/share/GeoIP', 'GeoIPASNum.dat'))):
+        return '/usr/share/GeoIP'
+    elif urlretrieve:
+        LOGGER.warning('Downloading GeoIP database')
+        bot.say('Downloading GeoIP database, please wait...')
+        geolite_city_url = 'http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz'
+        geolite_ASN_url = 'http://download.maxmind.com/download/geoip/database/asnum/GeoIPASNum.dat.gz'
+        geolite_city_filepath = os.path.join(bot.config.core.homedir, 'GeoLiteCity.dat.gz')
+        geolite_ASN_filepath = os.path.join(bot.config.core.homedir, 'GeoIPASNum.dat.gz')
+        urlretrieve(geolite_city_url, geolite_city_filepath)
+        urlretrieve(geolite_ASN_url, geolite_ASN_filepath)
+        _decompress(geolite_city_filepath, geolite_city_filepath[:-3])
+        _decompress(geolite_ASN_filepath, geolite_ASN_filepath[:-3])
+        return bot.config.core.homedir
+    else:
+        return False
+
+
+@commands('iplookup', 'ip')
+@example('.ip 8.8.8.8',
+         r'[IP/Host Lookup] Hostname: google-public-dns-a.google.com | Location: United States | Region: CA | ISP: AS15169 Google Inc.',
+         re=True,
+         ignore='Downloading GeoIP database, please wait...')
+def ip(bot, trigger):
+    """IP Lookup tool"""
+    if not trigger.group(2):
+        return bot.reply("No search term.")
+    query = trigger.group(2)
+    db_path = _find_geoip_db(bot)
+    if db_path is False:
+        LOGGER.error('Can\'t find (or download) usable GeoIP database')
+        bot.say('Sorry, I don\'t have a GeoIP database to use for this lookup')
+        return False
+    geolite_city_filepath = os.path.join(_find_geoip_db(bot), 'GeoLiteCity.dat')
+    geolite_ASN_filepath = os.path.join(_find_geoip_db(bot), 'GeoIPASNum.dat')
+    gi_city = pygeoip.GeoIP(geolite_city_filepath)
+    gi_org = pygeoip.GeoIP(geolite_ASN_filepath)
+    host = socket.getfqdn(query)
+    response = "[IP/Host Lookup] Hostname: %s" % host
+    try:
+        response += " | Location: %s" % gi_city.country_name_by_name(query)
+    except AttributeError:
+        response += ' | Location: Unknown'
+    except socket.gaierror:
+        return bot.say('[IP/Host Lookup] Unable to resolve IP/Hostname')
+
+    region_data = gi_city.region_by_name(query)
+    try:
+        region = region_data['region_code']  # pygeoip >= 0.3.0
+    except KeyError:
+        region = region_data['region_name']  # pygeoip < 0.3.0
+    if region:
+        response += " | Region: %s" % region
+
+    isp = gi_org.org_by_name(query)
+    response += " | ISP: %s" % isp
+    bot.say(response)
+
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/ipython.py

@@ -0,0 +1,78 @@
+# coding=utf-8
+"""
+ipython.py - sopel ipython console!
+Copyright © 2014, Elad Alfassa <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+Sopel: http://sopel.chat/
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+import sys
+import module
+if sys.version_info.major >= 3:
+    # Backup stderr/stdout wrappers
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+
+    # IPython wants actual stderr and stdout. In Python 2, it only needed that
+    # when actually starting the console, but in Python 3 it seems to need that
+    # on import as well
+    sys.stdout = sys.__stdout__
+    sys.stderr = sys.__stderr__
+try:
+    import IPython
+    if hasattr(IPython, 'terminal'):
+        from IPython.terminal.embed import InteractiveShellEmbed
+    else:
+        from IPython.frontend.terminal.embed import InteractiveShellEmbed
+finally:
+    if sys.version_info.major >= 3:
+        # Restore stderr/stdout wrappers
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+console = None
+
+
+@module.commands('console')
+def interactive_shell(bot, trigger):
+    """
+    Starts an interactive IPython console
+    """
+    global console
+    if not trigger.admin:
+        bot.say('Only admins can start the interactive console')
+        return
+    if 'iconsole_running' in bot.memory and bot.memory['iconsole_running']:
+        bot.say('Console already running')
+        return
+    if not sys.__stdout__.isatty():
+        bot.say('A tty is required to start the console')
+        return
+    if bot._daemon:
+        bot.say('Can\'t start console when running as a daemon')
+        return
+
+    # Backup stderr/stdout wrappers
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+
+    # IPython wants actual stderr and stdout
+    sys.stdout = sys.__stdout__
+    sys.stderr = sys.__stderr__
+
+    banner1 = 'Sopel interactive shell (embedded IPython)'
+    banner2 = '`bot` and `trigger` are available. To exit, type exit'
+    exitmsg = 'Interactive shell closed'
+
+    console = InteractiveShellEmbed(banner1=banner1, banner2=banner2,
+                                    exit_msg=exitmsg)
+
+    bot.memory['iconsole_running'] = True
+    bot.say('console started')
+    console()
+    bot.memory['iconsole_running'] = False
+
+    # Restore stderr/stdout wrappers
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr

modules/isup.py

@@ -0,0 +1,46 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Checks if a website is up by sending a HEAD request to it.
+"""
+import requests
+
+from module import commands, require_chanmsg
+from tools import web
+
+@require_chanmsg(message="It's not polite to whisper.")
+@commands('isup')
+def isup(bot, trigger):
+	"""Queries the given url to check if it's up or not."""
+	url = trigger.group(2)
+
+	if not url:
+		return bot.reply("What URL do you want to check?")
+	if url.startswith("192") and not trigger.owner:
+		return bot.reply("Do not violate the LAN.")
+
+	if not web.secCheck(bot, url):
+		return bot.reply("Known malicious url. Ignoring.")
+
+	if not url.startswith("http"):
+		url = "http://" + url
+
+	try:
+		res = requests.head(url, verify=True)
+	except (requests.exceptions.MissingSchema,
+			requests.exceptions.InvalidSchema):
+		return bot.say("Missing or invalid schema. Check the URL.")
+	except requests.exceptions.ConnectionError:
+		return bot.say("Connection error. Are you sure this is a real website?")
+	except requests.exceptions.InvalidURL:
+		return bot.say("Invalid URL.")
+	except Exception as e:
+		print(e)
+		return bot.say("Listen buddy. I don't know what you're doing, but \
+			you're not doing it right.")
+
+	try:
+		res.raise_for_status()
+		return bot.say(url + " appears to be working from here.")
+	except requests.exceptions.HTTPError:
+		return bot.say(url + " looks down from here.")

modules/light.py

@@ -0,0 +1,41 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Long live the Internet of Things!
+"""
+import requests
+
+import module
+
+
+@module.require_admin
+@module.commands('lamp')
+def lampToggle(bot, trigger):
+	"""
+	Turns my lamp on and off. The glory of IoT!
+	"""
+	try:
+		res = requests.get("http://192.168.1.12/gpio?0=toggle", timeout=10)
+	except requests.exceptions.ReadTimeout:
+		return bot.say("Connection error. Timeout reached.")
+	except requests.exceptions.ConnectionError:
+		return bot.say("Connection error. Is the unit dead?")
+	if res.text[32] == 'L':
+		bot.say("Lamp is now OFF.")
+	elif res.text[32] == 'H':
+		bot.say("Lamp is now ON.")
+
+
+#@module.require_admin
+@module.commands('roomtemp')
+def roomTemp(bot, trigger):
+	"""
+	Gets the temperature of my room.
+	"""
+	try:
+		res = requests.get("http://192.168.1.25/", timeout=10)
+	except requests.exceptions.ReadTimeout:
+		return bot.say("Connection error. Timeout reached.")
+	except requests.exceptions.ConnectionError:
+		return bot.say("Connection error. Is the unit dead?")
+	bot.say(res.text)

modules/lmgtfy.py

@@ -0,0 +1,18 @@
+# coding=utf-8
+"""
+lmgtfy.py - Sopel Let me Google that for you module
+Copyright 2013, Dimitri Molenaars http://tyrope.nl/
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat/
+"""
+from module import commands
+
+
+@commands('lmgtfy', 'lmgify', 'gify', 'gtfy')
+def googleit(bot, trigger):
+    """Let me just... google that for you."""
+    #No input
+    if not trigger.group(2):
+        return bot.say('http://google.com/')
+    bot.say('http://lmgtfy.com/?q=' + trigger.group(2).replace(' ', '+'))

modules/meetbot.py

@@ -0,0 +1,432 @@
+# coding=utf-8
+"""
+meetbot.py - Sopel meeting logger module
+Copyright © 2012, Elad Alfassa, <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+This module is an attempt to implement at least some of the functionallity of Debian's meetbot
+"""
+import time
+import os
+from config.types import StaticSection, FilenameAttribute, ValidatedAttribute
+from module import example, commands, rule, priority
+from tools import Ddict, Identifier
+import codecs
+
+
+class MeetbotSection(StaticSection):
+    meeting_log_path = FilenameAttribute('meeting_log_path', directory=True,
+                                         default='~/www/meetings')
+    """Path to meeting logs storage directory
+
+    This should be an absolute path, accessible on a webserver."""
+    meeting_log_baseurl = ValidatedAttribute(
+        'meeting_log_baseurl',
+        default='http://localhost/~sopel/meetings'
+    )
+    """Base URL for the meeting logs directory"""
+
+
+def configure(config):
+    config.define_section('meetbot', MeetbotSection)
+    config.meetbot.configure_setting(
+        'meeting_log_path',
+        'Enter the directory to store logs in.'
+    )
+    config.meetbot.configure_setting(
+        'meeting_log_baseurl',
+        'Enter the base URL for the meeting logs.',
+    )
+
+
+def setup(bot):
+    bot.config.define_section('meetbot', MeetbotSection)
+
+
+meetings_dict = Ddict(dict)  # Saves metadata about currently running meetings
+"""
+meetings_dict is a 2D dict.
+
+Each meeting should have:
+channel
+time of start
+head (can stop the meeting, plus all abilities of chairs)
+chairs (can add infolines to the logs)
+title
+current subject
+comments (what people who aren't voiced want to add)
+
+Using channel as the meeting ID as there can't be more than one meeting in a channel at the same time.
+"""
+meeting_log_path = ''  # To be defined on meeting start as part of sanity checks, used by logging functions so we don't have to pass them bot
+meeting_log_baseurl = ''  # To be defined on meeting start as part of sanity checks, used by logging functions so we don't have to pass them bot
+meeting_actions = {}  # A dict of channels to the actions that have been created in them. This way we can have .listactions spit them back out later on.
+
+
+#Get the logfile name for the meeting in the requested channel
+#Used by all logging functions
+def figure_logfile_name(channel):
+    if meetings_dict[channel]['title'] is 'Untitled meeting':
+        name = 'untitled'
+    else:
+        name = meetings_dict[channel]['title']
+    # Real simple sluggifying. This bunch of characters isn't exhaustive, but
+    # whatever. It's close enough for most situations, I think.
+    for c in ' ./\\:*?"<>|&*`':
+        name = name.replace(c, '-')
+    timestring = time.strftime('%Y-%m-%d-%H:%M', time.gmtime(meetings_dict[channel]['start']))
+    filename = timestring + '_' + name
+    return filename
+
+
+#Start HTML log
+def logHTML_start(channel):
+    logfile = codecs.open(meeting_log_path + channel + '/' + figure_logfile_name(channel) + '.html', 'a', encoding='utf-8')
+    timestring = time.strftime('%Y-%m-%d %H:%M', time.gmtime(meetings_dict[channel]['start']))
+    title = '%s at %s, %s' % (meetings_dict[channel]['title'], channel, timestring)
+    logfile.write('<!doctype html>\n<html>\n<head>\n<meta charset="utf-8">\n<title>%TITLE%</title>\n</head>\n<body>\n<h1>%TITLE%</h1>\n'.replace('%TITLE%', title))
+    logfile.write('<h4>Meeting started by %s</h4><ul>\n' % meetings_dict[channel]['head'])
+    logfile.close()
+
+
+#Write a list item in the HTML log
+def logHTML_listitem(item, channel):
+    logfile = codecs.open(meeting_log_path + channel + '/' + figure_logfile_name(channel) + '.html', 'a', encoding='utf-8')
+    logfile.write('<li>' + item + '</li>\n')
+    logfile.close()
+
+
+#End the HTML log
+def logHTML_end(channel):
+    logfile = codecs.open(meeting_log_path + channel + '/' + figure_logfile_name(channel) + '.html', 'a', encoding='utf-8')
+    current_time = time.strftime('%H:%M:%S', time.gmtime())
+    logfile.write('</ul>\n<h4>Meeting ended at %s UTC</h4>\n' % current_time)
+    plainlog_url = meeting_log_baseurl + channel + '/' + figure_logfile_name(channel) + '.log'
+    logfile.write('<a href="%s">Full log</a>' % plainlog_url)
+    logfile.write('\n</body>\n</html>')
+    logfile.close()
+
+
+#Write a string to the plain text log
+def logplain(item, channel):
+    current_time = time.strftime('%H:%M:%S', time.gmtime())
+    logfile = codecs.open(meeting_log_path + channel + '/' + figure_logfile_name(channel) + '.log', 'a', encoding='utf-8')
+    logfile.write('[' + current_time + '] ' + item + '\r\n')
+    logfile.close()
+
+
+#Check if a meeting is currently running
+def ismeetingrunning(channel):
+    try:
+        if meetings_dict[channel]['running']:
+            return True
+        else:
+            return False
+    except:
+        return False
+
+
+#Check if nick is a chair or head of the meeting
+def ischair(nick, channel):
+    try:
+        if nick.lower() == meetings_dict[channel]['head'] or nick.lower() in meetings_dict[channel]['chairs']:
+            return True
+        else:
+            return False
+    except:
+        return False
+
+
+#Start meeting (also preforms all required sanity checks)
+@commands('startmeeting')
+@example('.startmeeting title or .startmeeting')
+def startmeeting(bot, trigger):
+    """
+    Start a meeting.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, there is already a meeting in progress here!')
+        return
+    if trigger.is_privmsg:
+        bot.say('Can only start meetings in channels')
+        return
+    #Start the meeting
+    meetings_dict[trigger.sender]['start'] = time.time()
+    if not trigger.group(2):
+        meetings_dict[trigger.sender]['title'] = 'Untitled meeting'
+    else:
+        meetings_dict[trigger.sender]['title'] = trigger.group(2)
+    meetings_dict[trigger.sender]['head'] = trigger.nick.lower()
+    meetings_dict[trigger.sender]['running'] = True
+    meetings_dict[trigger.sender]['comments'] = []
+
+    global meeting_log_path
+    meeting_log_path = bot.config.meetbot.meeting_log_path
+    if not meeting_log_path.endswith('/'):
+        meeting_log_path = meeting_log_path + '/'
+    global meeting_log_baseurl
+    meeting_log_baseurl = bot.config.meetbot.meeting_log_baseurl
+    if not meeting_log_baseurl.endswith('/'):
+        meeting_log_baseurl = meeting_log_baseurl + '/'
+    if not os.path.isdir(meeting_log_path + trigger.sender):
+        try:
+            os.makedirs(meeting_log_path + trigger.sender)
+        except Exception:
+            bot.say("Can't create log directory for this channel, meeting not started!")
+            meetings_dict[trigger.sender] = Ddict(dict)
+            raise
+            return
+    #Okay, meeting started!
+    logplain('Meeting started by ' + trigger.nick.lower(), trigger.sender)
+    logHTML_start(trigger.sender)
+    meeting_actions[trigger.sender] = []
+    bot.say('Meeting started! use .action, .agreed, .info, .chairs, .subject and .comments to control the meeting. to end the meeting, type .endmeeting')
+    bot.say('Users without speaking permission can use .comment ' +
+            trigger.sender + ' followed by their comment in a PM with me to '
+            'vocalize themselves.')
+
+
+#Change the current subject (will appear as <h3> in the HTML log)
+@commands('subject')
+@example('.subject roll call')
+def meetingsubject(bot, trigger):
+    """
+    Change the meeting subject.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('what is the subject?')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    meetings_dict[trigger.sender]['current_subject'] = trigger.group(2)
+    logfile = codecs.open(meeting_log_path + trigger.sender + '/' + figure_logfile_name(trigger.sender) + '.html', 'a', encoding='utf-8')
+    logfile.write('</ul><h3>' + trigger.group(2) + '</h3><ul>')
+    logfile.close()
+    logplain('Current subject: ' + trigger.group(2) + ', (set by ' + trigger.nick + ')', trigger.sender)
+    bot.say('Current subject: ' + trigger.group(2))
+
+
+#End the meeting
+@commands('endmeeting')
+@example('.endmeeting')
+def endmeeting(bot, trigger):
+    """
+    End a meeting.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    meeting_length = time.time() - meetings_dict[trigger.sender]['start']
+    #TODO: Humanize time output
+    bot.say("Meeting ended! total meeting length %d seconds" % meeting_length)
+    logHTML_end(trigger.sender)
+    htmllog_url = meeting_log_baseurl + trigger.sender + '/' + figure_logfile_name(trigger.sender) + '.html'
+    logplain('Meeting ended by %s, total meeting length %d seconds' % (trigger.nick, meeting_length), trigger.sender)
+    bot.say('Meeting minutes: ' + htmllog_url)
+    meetings_dict[trigger.sender] = Ddict(dict)
+    del meeting_actions[trigger.sender]
+
+
+#Set meeting chairs (people who can control the meeting)
+@commands('chairs')
+@example('.chairs Tyrope Jason elad')
+def chairs(bot, trigger):
+    """
+    Set the meeting chairs.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('Who are the chairs?')
+        return
+    if trigger.nick.lower() == meetings_dict[trigger.sender]['head']:
+        meetings_dict[trigger.sender]['chairs'] = trigger.group(2).lower().split(' ')
+        chairs_readable = trigger.group(2).lower().replace(' ', ', ')
+        logplain('Meeting chairs are: ' + chairs_readable, trigger.sender)
+        logHTML_listitem('<span style="font-weight: bold">Meeting chairs are: </span>' + chairs_readable, trigger.sender)
+        bot.say('Meeting chairs are: ' + chairs_readable)
+    else:
+        bot.say("Only meeting head can set chairs")
+
+
+#Log action item in the HTML log
+@commands('action')
+@example('.action elad will develop a meetbot')
+def meetingaction(bot, trigger):
+    """
+    Log an action in the meeting log
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('try .action someone will do something')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    logplain('ACTION: ' + trigger.group(2), trigger.sender)
+    logHTML_listitem('<span style="font-weight: bold">Action: </span>' + trigger.group(2), trigger.sender)
+    meeting_actions[trigger.sender].append(trigger.group(2))
+    bot.say('ACTION: ' + trigger.group(2))
+
+
+@commands('listactions')
+@example('.listactions')
+def listactions(bot, trigger):
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    for action in meeting_actions[trigger.sender]:
+        bot.say('ACTION: ' + action)
+
+
+#Log agreed item in the HTML log
+@commands('agreed')
+@example('.agreed Bowties are cool')
+def meetingagreed(bot, trigger):
+    """
+    Log an agreement in the meeting log.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('try .action someone will do something')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    logplain('AGREED: ' + trigger.group(2), trigger.sender)
+    logHTML_listitem('<span style="font-weight: bold">Agreed: </span>' + trigger.group(2), trigger.sender)
+    bot.say('AGREED: ' + trigger.group(2))
+
+
+#Log link item in the HTML log
+@commands('link')
+@example('.link http://example.com')
+def meetinglink(bot, trigger):
+    """
+    Log a link in the meeing log.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('try .action someone will do something')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    link = trigger.group(2)
+    if not link.startswith("http"):
+        link = "http://" + link
+    try:
+        #title = find_title(link, verify=bot.config.core.verify_ssl)
+        pass
+    except:
+        title = ''
+    logplain('LINK: %s [%s]' % (link, title), trigger.sender)
+    logHTML_listitem('<a href="%s">%s</a>' % (link, title), trigger.sender)
+    bot.say('LINK: ' + link)
+
+
+#Log informational item in the HTML log
+@commands('info')
+@example('.info all board members present')
+def meetinginfo(bot, trigger):
+    """
+    Log an informational item in the meeting log
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        bot.say('Can\'t do that, start meeting first')
+        return
+    if not trigger.group(2):
+        bot.say('try .info some informative thing')
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    logplain('INFO: ' + trigger.group(2), trigger.sender)
+    logHTML_listitem(trigger.group(2), trigger.sender)
+    bot.say('INFO: ' + trigger.group(2))
+
+
+#called for every single message
+#Will log to plain text only
+@rule('(.*)')
+@priority('low')
+def log_meeting(bot, trigger):
+    if not ismeetingrunning(trigger.sender):
+        return
+    if trigger.startswith('.endmeeting') or trigger.startswith('.chairs') or trigger.startswith('.action') or trigger.startswith('.info') or trigger.startswith('.startmeeting') or trigger.startswith('.agreed') or trigger.startswith('.link') or trigger.startswith('.subject'):
+        return
+    logplain('<' + trigger.nick + '> ' + trigger, trigger.sender)
+
+
+@commands('comment')
+def take_comment(bot, trigger):
+    """
+    Log a comment, to be shown with other comments when a chair uses .comments.
+    Intended to allow commentary from those outside the primary group of people
+    in the meeting.
+
+    Used in private message only, as `.comment <#channel> <comment to add>`
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not trigger.sender.is_nick():
+        return
+    if not trigger.group(4):  # <2 arguements were given
+        bot.say('Usage: .comment <#channel> <comment to add>')
+        return
+
+    target, message = trigger.group(2).split(None, 1)
+    target = Identifier(target)
+    if not ismeetingrunning(target):
+        bot.say("There's not currently a meeting in that channel.")
+    else:
+        meetings_dict[trigger.group(3)]['comments'].append((trigger.nick, message))
+        bot.say("Your comment has been recorded. It will be shown when the"
+                " chairs tell me to show the comments.")
+        bot.msg(meetings_dict[trigger.group(3)]['head'], "A new comment has been recorded.")
+
+
+@commands('comments')
+def show_comments(bot, trigger):
+    """
+    Show the comments that have been logged for this meeting with .comment.
+    https://github.com/sopel-irc/sopel/wiki/Using-the-meetbot-module
+    """
+    if not ismeetingrunning(trigger.sender):
+        return
+    if not ischair(trigger.nick, trigger.sender):
+        bot.say('Only meeting head or chairs can do that')
+        return
+    comments = meetings_dict[trigger.sender]['comments']
+    if comments:
+        msg = 'The following comments were made:'
+        bot.say(msg)
+        logplain('<%s> %s' % (bot.nick, msg), trigger.sender)
+        for comment in comments:
+            msg = '<%s> %s' % comment
+            bot.say(msg)
+            logplain('<%s> %s' % (bot.nick, msg), trigger.sender)
+        meetings_dict[trigger.sender]['comments'] = []
+    else:
+        bot.say('No comments have been logged.')

modules/movie.py

@@ -0,0 +1,161 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+This module exracts various information from imbd.
+It also contains functionality for the local movie database.
+"""
+import os
+import threading
+import random
+
+import requests
+import bs4
+
+import module
+
+def setup(bot):
+	bot.memory['movie_lock'] = threading.Lock()
+
+
+@module.commands('movie', 'tmdb')
+@module.example('.movie ThisTitleDoesNotExist', '[MOVIE] Movie not found!')
+@module.example('.movie Citizen Kane', '[MOVIE] Title: Citizen Kane | Year: \
+	1941 | Rating: 8.4 | Genre: Drama, Mystery | IMDB Link: \
+	http://imdb.com/title/tt0033467')
+def movie(bot, trigger):
+	"""
+	Returns some information about a movie, like Title, Year, Rating,
+	Genre and IMDB Link.
+	"""
+	if not trigger.group(2):
+		return
+	word = trigger.group(2).strip().replace(" ", "+")
+
+	api_key = bot.config.movie.tmdb_api_key
+	uri = "https://api.themoviedb.org/3/search/movie?" + \
+		f"api_key={api_key}&query={word}"
+	data = requests.get(uri, timeout=30, verify=True).json()
+	try:
+		data = data['results'][0]
+	except IndexError:
+		return bot.reply("No results found.")
+	except KeyError:
+		print(data)
+		return bot.reply("An error. Please notify an adult.")
+
+	uri = "https://api.themoviedb.org/3/genre/movie/list?" + \
+		f"api_key={api_key}&language=en-US"
+	genres = requests.get(uri, timeout=30, verify=True).json()
+	try:
+		genres = genres['genres']
+	except KeyError:
+		return bot.reply("An error. Please notify an adult.")
+
+	movieGenres = []
+	for genre in genres:
+		if genre['id'] in data['genre_ids']:
+			movieGenres.append(genre['name'])
+
+	msg = "[\x0304MOVIE\x03] \x0310Title\x03: \x0312" + data['title'] + \
+			"\x03 | \x0310Year\x03: \x0308" + data['release_date'][:4] + \
+			"\x03 | \x0310Rating\x03: \x0312" + str(data['vote_average']) + \
+			"\x03 | \x0310Genre\x03: \x0312" + ", ".join(movieGenres) + \
+			"\x03 | \x0310TMDb Link\x03: \x0307" + \
+			"https://www.themoviedb.org/movie/" + str(data['id'])
+
+	msg += "\n\x0310Theater release date\x03: \x0308" + data['release_date'] + \
+			"\x03 | \x0310Physical release date\x03: \x0308" + \
+				phyiscalRelease(word, data['id'], api_key)
+
+	msg += "\n\x0310Overview\x03: " + data['overview']
+
+	bot.say(msg)
+
+
+def phyiscalRelease(word, tmdb_id=None, api_key=None):
+	"""
+	Attempts to find a physical US release from TMDb. Failing that, it will
+	find a date on www.dvdreleasedates.com.
+	"""
+	if not tmdb_id:
+		return "Feature not yet implemented."
+
+	uri = f"https://api.themoviedb.org/3/movie/{tmdb_id}/release_dates?" + \
+		f"api_key={api_key}"
+	res = requests.get(uri, timeout=30, verify=True)
+	res.raise_for_status()
+	try:
+		releases = res.json()['results']
+	except KeyError:
+		return "No results found."
+
+	for release in releases:
+		if release["iso_3166_1"] != "US":
+			continue
+		for date in  release["release_dates"]:
+			if date["type"] == 5:
+				return date["release_date"][:10]
+	#return "No physical US release found."
+	return dvdReleaseDates(word)
+
+
+def dvdReleaseDates(word):
+	"""
+	Scrapes www.dvdsreleasedates.com for physical release dates.
+	"""
+	uri = f"http://www.dvdsreleasedates.com/search.php?searchStr={word}"
+	res = requests.get(uri, timeout=30, verify=True)
+	soup = bs4.BeautifulSoup(res.text, "html.parser")
+	rDate = soup.title.text[soup.title.text.rfind("Date")+4:]
+	if not rDate:
+		rDate = "Not announced."
+	elif rDate.startswith("rch results for"):
+		rDate = "Not found."
+	return rDate.strip()
+
+
+@module.commands('pickmovie', 'getmovie')
+@module.example('.pickmovie', 'Commandos')
+def pickMovie(bot, trigger):
+	"""
+	Picks a random movie title out of the database.
+	"""
+	bot.memory['movie_lock'].acquire()
+	conn = bot.db.connect()
+	cur = conn.cursor()
+	cur.execute("SELECT * FROM movie WHERE times_watched < 1 AND shitpost = 0")
+	movieList = cur.fetchall()
+	conn.close()
+
+	roll = random.randint(0, len(movieList)-1)
+	bot.memory['movie_lock'].release()
+	bot.reply(movieList[roll][0])
+
+
+@module.require_admin
+@module.commands('addmovie')
+@module.example('.addmovie Gay Niggers From Outer Space')
+def addMovie(bot, trigger):
+	"""
+	Adds the specified movie to the movie database.
+	"""
+	bot.memory['movie_lock'].acquire()
+	movie = trigger.group(2)
+	conn = bot.db.connect()
+	cur = conn.cursor()
+	insert = (movie, trigger.nick)
+	try:
+		cur.execute("INSERT INTO movie (movie_title, added_by) VALUES(?,?)", 
+			insert)
+		confirm = "Added movie: " + movie
+	except sqlite3.IntegrityError:
+		confirm = "Error: " + movie + " is already in the database."
+	conn.commit()
+	conn.close()
+	bot.memory['movie_lock'].release()
+	bot.say(confirm)
+
+
+if __name__ == "__main__":
+	from test_tools import run_example_tests
+	run_example_tests(__file__)

modules/ping.py

@@ -0,0 +1,28 @@
+# coding=utf-8
+"""
+ping.py - Sopel Ping Module
+Author: Sean B. Palmer, inamidst.com
+About: http://sopel.chat
+"""
+import random
+
+from module import rule, priority, thread
+
+
+@rule(r'(?i)(hi|hello|hey),? $nickname[ \t]*$')
+def hello(bot, trigger):
+    greeting = random.choice(('Hi', 'Hey', 'Hello'))
+    punctuation = random.choice(('', '!'))
+    bot.say(greeting + ' ' + trigger.nick + punctuation)
+
+
+@rule(r'(?i)(Fuck|Screw) you,? $nickname[ \t]*$')
+def rude(bot, trigger):
+    bot.say('Watch your mouth, ' + trigger.nick + ', or I\'ll tell your mother!')
+
+
+@rule('$nickname!')
+@priority('high')
+@thread(False)
+def interjection(bot, trigger):
+    bot.say(trigger.nick + '!')

modules/pingall.py

@@ -0,0 +1,17 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Pings everyone in the channel.
+"""
+import module
+
+@module.commands('pingall', 'names')
+def pingAll(bot, trigger):
+	"""
+	Says the nick of everyone in the channel. Great way to get thier
+	attention, or just annoy them.
+	"""
+	msg = ""
+	for name, priv in  bot.privileges[trigger.sender].items():
+		msg += name + ' '
+	bot.say(msg.strip())

modules/rand.py

@@ -0,0 +1,48 @@
+# coding=utf-8
+"""
+rand.py - Rand Module
+Copyright 2013, Ari Koivula, <ari@koivu.la>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+
+from module import commands, example
+import random
+import sys
+
+
+@commands('rand')
+@example('.rand 2', r'random\(0, 2\) = (0|1|2)', re=True, repeat=10)
+@example('.rand -1 -1', 'random(-1, -1) = -1')
+@example('.rand', r'random\(0, \d+\) = \d+', re=True)
+@example('.rand 99 10', r'random\(10, 99\) = \d\d', re=True, repeat=10)
+@example('.rand 10 99', r'random\(10, 99\) = \d\d', re=True, repeat=10)
+def rand(bot, trigger):
+    """Replies with a random number between first and second argument."""
+    arg1 = trigger.group(3)
+    arg2 = trigger.group(4)
+
+    try:
+        if arg2 is not None:
+            low = int(arg1)
+            high = int(arg2)
+        elif arg1 is not None:
+            low = 0
+            high = int(arg1)
+        else:
+            low = 0
+            high = sys.maxsize
+    except (ValueError, TypeError):
+        return bot.reply("Arguments must be of integer type")
+
+    if low > high:
+        low, high = high, low
+
+    number = random.randint(low, high)
+    bot.reply("random(%d, %d) = %d" % (low, high, number))
+
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/reload.py

@@ -0,0 +1,110 @@
+# coding=utf-8
+"""
+reload.py - Sopel Module Reloader Module
+Copyright 2008, Sean B. Palmer, inamidst.com
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import collections
+import sys
+import time
+from tools import iteritems
+import loader
+import module
+import subprocess
+
+
+def load_module(bot, name, path, type_):
+    module, mtime = loader.load_module(name, path, type_)
+    relevant_parts = loader.clean_module(module, bot.config)
+
+    bot.register(*relevant_parts)
+
+    # TODO sys.modules[name] = module
+    if hasattr(module, 'setup'):
+        module.setup(bot)
+
+    modified = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(mtime))
+
+    bot.reply('%r (version: %s)' % (module, modified))
+
+
+@module.require_admin
+@module.commands("reload")
+@module.priority("low")
+@module.thread(False)
+def f_reload(bot, trigger):
+    """Reloads a module, for use by admins only."""
+
+    name = trigger.group(2)
+
+    if not name or name == '*' or name.upper() == 'ALL THE THINGS':
+        bot._callables = {
+            'high': collections.defaultdict(list),
+            'medium': collections.defaultdict(list),
+            'low': collections.defaultdict(list)
+        }
+        bot._command_groups = collections.defaultdict(list)
+        bot.setup()
+        return bot.reply('done')
+
+    if name not in sys.modules:
+        return bot.reply('%s: not loaded, try the `load` command' % name)
+
+    old_module = sys.modules[name]
+
+    old_callables = {}
+    for obj_name, obj in iteritems(vars(old_module)):
+        bot.unregister(obj)
+
+    # Also remove all references to sopel callables from top level of the
+    # module, so that they will not get loaded again if reloading the
+    # module does not override them.
+    for obj_name in old_callables.keys():
+        delattr(old_module, obj_name)
+
+    # Also delete the setup function
+    if hasattr(old_module, "setup"):
+        delattr(old_module, "setup")
+
+    modules = loader.enumerate_modules(bot.config)
+    path, type_ = modules[name]
+    load_module(bot, name, path, type_)
+
+
+@module.require_admin
+@module.commands('update')
+def f_update(bot, trigger):
+
+    """Pulls the latest versions of all modules from Git"""
+    proc = subprocess.Popen('/usr/bin/git pull',
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE, shell=True)
+    bot.reply(proc.communicate()[0])
+
+    f_reload(bot, trigger)
+
+
+@module.require_admin
+@module.commands("load")
+@module.priority("low")
+@module.thread(False)
+def f_load(bot, trigger):
+    """Loads a module, for use by admins only."""
+
+    name = trigger.group(2)
+    path = ''
+    if not name:
+        return bot.reply('Load what?')
+
+    if name in sys.modules:
+        return bot.reply('Module already loaded, use reload')
+
+    mods = loader.enumerate_modules(bot.config)
+    if name not in mods:
+        return bot.reply('Module %s not found' % name)
+    path, type_ = mods[name]
+    load_module(bot, name, path, type_)

modules/remind.py

@@ -0,0 +1,229 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+remind.py - Sopel Reminder Module
+Copyright 2011, Sean B. Palmer, inamidst.com
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import os
+import re
+import time
+import threading
+import collections
+import codecs
+from datetime import datetime
+from module import commands, example, NOLIMIT
+import tools
+from tools.time import get_timezone, format_time
+
+try:
+	import pytz
+except:
+	pytz = None
+
+
+def filename(self):
+	name = self.nick + '-' + self.config.core.host + '.reminders.db'
+	return os.path.join(self.config.core.homedir, name)
+
+
+def load_database(name):
+	data = {}
+	if os.path.isfile(name):
+		f = codecs.open(name, 'r', encoding='utf-8')
+		for line in f:
+			unixtime, channel, nick, message = line.split('\t')
+			message = message.rstrip('\n')
+			t = int(float(unixtime))  # WTFs going on here?
+			reminder = (channel, nick, message)
+			try:
+				data[t].append(reminder)
+			except KeyError:
+				data[t] = [reminder]
+		f.close()
+	return data
+
+
+def dump_database(name, data):
+	f = codecs.open(name, 'w', encoding='utf-8')
+	for unixtime, reminders in tools.iteritems(data):
+		for channel, nick, message in reminders:
+			f.write('%s\t%s\t%s\t%s\n' % (unixtime, channel, nick, message))
+	f.close()
+
+
+def setup(bot):
+	bot.rfn = filename(bot)
+	bot.rdb = load_database(bot.rfn)
+
+	def monitor(bot):
+		time.sleep(5)
+		while True:
+			now = int(time.time())
+			unixtimes = [int(key) for key in bot.rdb]
+			oldtimes = [t for t in unixtimes if t <= now]
+			if oldtimes:
+				for oldtime in oldtimes:
+					for (channel, nick, message) in bot.rdb[oldtime]:
+						if message:
+							bot.msg(channel, nick + ': ' + message)
+						else:
+							bot.msg(channel, nick + '!')
+					del bot.rdb[oldtime]
+				dump_database(bot.rfn, bot.rdb)
+			time.sleep(2.5)
+
+	targs = (bot,)
+	t = threading.Thread(target=monitor, args=targs)
+	t.start()
+
+scaling = collections.OrderedDict([
+	('years', 365.25 * 24 * 3600),
+	('year', 365.25 * 24 * 3600),
+	('yrs', 365.25 * 24 * 3600),
+	('y', 365.25 * 24 * 3600),
+
+	('months', 29.53059 * 24 * 3600),
+	('month', 29.53059 * 24 * 3600),
+	('mo', 29.53059 * 24 * 3600),
+
+	('weeks', 7 * 24 * 3600),
+	('week', 7 * 24 * 3600),
+	('wks', 7 * 24 * 3600),
+	('wk', 7 * 24 * 3600),
+	('w', 7 * 24 * 3600),
+
+	('days', 24 * 3600),
+	('day', 24 * 3600),
+	('d', 24 * 3600),
+
+	('hours', 3600),
+	('hour', 3600),
+	('hrs', 3600),
+	('hr', 3600),
+	('h', 3600),
+
+	('minutes', 60),
+	('minute', 60),
+	('mins', 60),
+	('min', 60),
+	('m', 60),
+
+	('seconds', 1),
+	('second', 1),
+	('secs', 1),
+	('sec', 1),
+	('s', 1),
+])
+
+periods = '|'.join(scaling.keys())
+
+
+@commands('remind')
+@example('.remind 3h45m Go to class')
+def remind(bot, trigger):
+	"""Gives you a reminder in the given amount of time."""
+	if not trigger.group(2):
+		bot.say("Missing arguments for reminder command.")
+		return NOLIMIT
+	if trigger.group(3) and not trigger.group(4):
+		bot.say("No message given for reminder.")
+		return NOLIMIT
+	duration = 0
+	message = filter(None, re.split('(\d+(?:\.\d+)? ?(?:(?i)' + periods + ')) ?',
+									trigger.group(2))[1:])
+	reminder = ''
+	stop = False
+	for piece in message:
+		grp = re.match('(\d+(?:\.\d+)?) ?(.*) ?', piece)
+		if grp and not stop:
+			length = float(grp.group(1))
+			factor = scaling.get(grp.group(2).lower(), 60)
+			duration += length * factor
+		else:
+			reminder = reminder + piece
+			stop = True
+	if duration == 0:
+		return bot.reply("Sorry, didn't understand the input.")
+
+	if duration % 1:
+		duration = int(duration) + 1
+	else:
+		duration = int(duration)
+	timezone = get_timezone(
+		bot.db, bot.config, None, trigger.nick, trigger.sender)
+	create_reminder(bot, trigger, duration, reminder, timezone)
+
+
+@commands('at')
+@example('.at 13:47 Do your homework!')
+def at(bot, trigger):
+	"""
+	Gives you a reminder at the given time. Takes hh:mm:ssTimezone
+	message. Timezone is any timezone Sopel takes elsewhere; the best choices
+	are those from the tzdb; a list of valid options is available at
+	http://sopel.chat/tz . The seconds and timezone are optional.
+	"""
+	if not trigger.group(2):
+		bot.say("No arguments given for reminder command.")
+		return NOLIMIT
+	if trigger.group(3) and not trigger.group(4):
+		bot.say("No message given for reminder.")
+		return NOLIMIT
+	regex = re.compile(r'(\d+):(\d+)(?::(\d+))?([^\s\d]+)? (.*)')
+	match = regex.match(trigger.group(2))
+	if not match:
+		bot.reply("Sorry, but I didn't understand your input.")
+		return NOLIMIT
+	hour, minute, second, tz, message = match.groups()
+	if not second:
+		second = '0'
+
+	if pytz:
+		timezone = get_timezone(bot.db, bot.config, tz,
+								trigger.nick, trigger.sender)
+		if not timezone:
+			timezone = 'UTC'
+		now = datetime.now(pytz.timezone(timezone))
+		at_time = datetime(now.year, now.month, now.day,
+						   int(hour), int(minute), int(second),
+						   tzinfo=now.tzinfo)
+		timediff = at_time - now
+	else:
+		if tz and tz.upper() != 'UTC':
+			bot.reply("I don't have timzeone support installed.")
+			return NOLIMIT
+		now = datetime.now()
+		at_time = datetime(now.year, now.month, now.day,
+						   int(hour), int(minute), int(second))
+		timediff = at_time - now
+
+	duration = timediff.seconds
+
+	if duration < 0:
+		duration += 86400
+	create_reminder(bot, trigger, duration, message, 'UTC')
+
+
+def create_reminder(bot, trigger, duration, message, tz):
+	t = int(time.time()) + duration
+	reminder = (trigger.sender, trigger.nick, message)
+	try:
+		bot.rdb[t].append(reminder)
+	except KeyError:
+		bot.rdb[t] = [reminder]
+
+	dump_database(bot.rfn, bot.rdb)
+
+	if duration >= 60:
+		remind_at = datetime.utcfromtimestamp(t)
+		timef = format_time(bot.db, bot.config, tz, trigger.nick,
+							trigger.sender, remind_at)
+
+		bot.reply('Okay, will remind at %s' % timef)
+	else:
+		bot.reply('Okay, will remind in %s secs' % duration)

modules/resistor.py

@@ -0,0 +1,46 @@
+#! /usr/bin/env python3
+# coding=utf-8
+"""
+Resistor color band codes.
+"""
+import module
+
+@module.commands('resist')
+@module.example('.resist 10k', 'brown black orange gold')
+def resist(bot, trigger):
+	"""Displays the color band code of a resistor for the given resistance."""
+	suffix = {'k': 1000, 'm': 10000000}
+	digit = {'0': 'black', '1': 'brown', '2': 'red', '3': 'orange', '4': 'yellow',
+			'5': 'green', '6': 'blue', '7': 'violet', '8': 'grey', '9': 'white',
+			'-1': 'gold', '-2': 'silver'}
+
+	if not trigger.group(2)[-1].isdigit():
+		value = trigger.group(2)[:-1]
+	else:
+		value = trigger.group(2)
+
+	try:	
+		value = float(value)
+	except ValueError:
+		return 'Invalid input'
+
+	if not trigger.group(2)[-1].isdigit():	
+		value = value * suffix[trigger.group(2)[-1]]
+	valueStr = str(value)
+
+	if value >= 10:
+		colorCode = digit[valueStr[0]] + " " + digit[valueStr[1]] + " "
+	else:
+		colorCode = digit[valueStr[2]] + " " + digit['0'] + " "
+
+	if value < 0.1:
+		return "Value to small. Just like your dick."
+	elif value < 1:
+		colorCode = colorCode + digit['-2']
+	elif value < 10:
+		colorCode = colorCode + digit['-1']
+	else:
+		colorCode = colorCode + digit[str(len(valueStr)-4)]
+
+	colorCode = colorCode  + " gold"
+	bot.say(colorCode)

modules/safety.py

@@ -0,0 +1,198 @@
+# coding=utf-8
+"""
+safety.py - Alerts about malicious URLs
+Copyright © 2014, Elad Alfassa, <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+This module uses virustotal.com
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import requests
+from config.types import StaticSection, ValidatedAttribute, ListAttribute
+from formatting import color, bold
+from logger import get_logger
+from module import OP
+import tools
+import sys
+import json
+import time
+import os.path
+import re
+import module
+
+if sys.version_info.major > 2:
+	unicode = str
+	from urllib.request import urlretrieve
+	from urllib.parse import urlparse
+else:
+	from urllib import urlretrieve
+	from urlparse import urlparse
+
+LOGGER = get_logger(__name__)
+
+vt_base_api_url = 'https://www.virustotal.com/vtapi/v2/url/'
+malware_domains = set()
+known_good = []
+
+
+class SafetySection(StaticSection):
+	enabled_by_default = ValidatedAttribute('enabled_by_default', bool, default=True)
+	"""Enable URL safety in all channels where it isn't explicitly disabled."""
+	known_good = ListAttribute('known_good')
+	"""List of "known good" domains to ignore."""
+	vt_api_key = ValidatedAttribute('vt_api_key')
+	"""Optional VirusTotal API key."""
+
+
+def configure(config):
+	config.define_section('safety', SafetySection)
+	config.safety.configure_setting(
+		'enabled_by_default',
+		"Enable URL safety in channels that don't specifically disable it?",
+	)
+	config.safety.configure_setting(
+		'known_good',
+		'Enter any domains to whitelist',
+	)
+	config.safety.configure_setting(
+		'vt_api_key',
+		"Optionally, enter a VirusTotal API key to improve malicious URL "
+		"protection.\nOtherwise, only the Malwarebytes DB will be used."
+	)
+
+
+def setup(bot):
+	bot.config.define_section('safety', SafetySection)
+
+	bot.memory['safety_cache'] = tools.SopelMemory()
+	for item in bot.config.safety.known_good:
+		known_good.append(re.compile(item, re.I))
+
+	loc = os.path.join(bot.config.homedir, 'malwaredomains.txt')
+	if os.path.isfile(loc):
+		if os.path.getmtime(loc) < time.time() - 24 * 60 * 60 * 7:
+			# File exists but older than one week, update
+			_download_malwaredomains_db(loc)
+	else:
+		_download_malwaredomains_db(loc)
+	with open(loc, 'r') as f:
+		for line in f:
+			clean_line = unicode(line).strip().lower()
+			if clean_line != '':
+				malware_domains.add(clean_line)
+
+
+def _download_malwaredomains_db(path):
+	print('Downloading malwaredomains db...')
+	urlretrieve('http://mirror1.malwaredomains.com/files/justdomains', path)
+
+
+@module.rule('(?u).*(https?://\S+).*')
+@module.priority('high')
+def url_handler(bot, trigger):
+	""" Check for malicious URLs """
+	check = True	# Enable URL checking
+	strict = False  # Strict mode: kick on malicious URL
+	positives = 0   # Number of engines saying it's malicious
+	total = 0	   # Number of total engines
+	use_vt = True   # Use VirusTotal
+	check = bot.config.safety.enabled_by_default
+	if check is None:
+		# If not set, assume default
+		check = True
+	# DB overrides config:
+	setting = bot.db.get_channel_value(trigger.sender, 'safety')
+	if setting is not None:
+		if setting == 'off':
+			return  # Not checking
+		elif setting in ['on', 'strict', 'local', 'local strict']:
+			check = True
+		if setting == 'strict' or setting == 'local strict':
+			strict = True
+		if setting == 'local' or setting == 'local strict':
+			use_vt = False
+
+	if not check:
+		return  # Not overriden by DB, configured default off
+
+	netloc = urlparse(trigger.group(1)).netloc
+	if any(regex.search(netloc) for regex in known_good):
+		return  # Whitelisted
+
+	apikey = bot.config.safety.vt_api_key
+	try:
+		if apikey is not None and use_vt:
+			payload = {'resource': unicode(trigger),
+					   'apikey': apikey,
+					   'scan': '1'}
+
+			if trigger not in bot.memory['safety_cache']:
+				result = requests.post(vt_base_api_url + 'report', payload)
+				if sys.version_info.major > 2:
+					result = result.decode('utf-8')
+				result = json.loads(result)
+				age = time.time()
+				data = {'positives': result['positives'],
+						'total': result['total'],
+						'age': age}
+				bot.memory['safety_cache'][trigger] = data
+				if len(bot.memory['safety_cache']) > 1024:
+					_clean_cache(bot)
+			else:
+				print('using cache')
+				result = bot.memory['safety_cache'][trigger]
+			positives = result['positives']
+			total = result['total']
+	except Exception:
+		LOGGER.debug('Error from checking URL with VT.', exc_info=True)
+		pass  # Ignoring exceptions with VT so MalwareDomains will always work
+
+	if unicode(netloc).lower() in malware_domains:
+		# malwaredomains is more trustworthy than some VT engines
+		# therefor it gets a weight of 10 engines when calculating confidence
+		positives += 10
+		total += 10
+
+	if positives > 1:
+		# Possibly malicious URL detected!
+		confidence = '{}%'.format(round((positives / total) * 100))
+		msg = 'link posted by %s is possibly malicious ' % bold(trigger.nick)
+		msg += '(confidence %s - %s/%s)' % (confidence, positives, total)
+		bot.say('[' + bold(color('WARNING', 'red')) + '] ' + msg)
+		if strict:
+			bot.write(['KICK', trigger.sender, trigger.nick,
+					   'Posted a malicious link'])
+
+
+@module.commands('safety')
+def toggle_safety(bot, trigger):
+	""" Set safety setting for channel """
+	if not trigger.admin and bot.privileges[trigger.sender][trigger.nick] < OP:
+		bot.reply('Only channel operators can change safety settings')
+		return
+	allowed_states = ['strict', 'on', 'off', 'local', 'local strict']
+	if not trigger.group(2) or trigger.group(2).lower() not in allowed_states:
+		options = ' / '.join(allowed_states)
+		bot.reply('Available options: %s' % options)
+		return
+
+	channel = trigger.sender.lower()
+	bot.db.set_channel_value(channel, 'safety', trigger.group(2).lower())
+	bot.reply('Safety is now set to "%s" on this channel' % trigger.group(2))
+
+
+# Clean the cache every day, also when > 1024 entries
+@module.interval(24 * 60 * 60)
+def _clean_cache(bot):
+	""" Cleanup old entries in URL cache """
+	# TODO probably should be using locks here, to make sure stuff doesn't
+	# explode
+	oldest_key_age = 0
+	oldest_key = ''
+	for key, data in tools.iteritems(bot.memory['safety_cache']):
+		if data['age'] > oldest_key_age:
+			oldest_key_age = data['age']
+			oldest_key = key
+	if oldest_key in bot.memory['safety_cache']:
+		del bot.memory['safety_cache'][oldest_key]

modules/scramble.py

@@ -0,0 +1,79 @@
+# coding=utf-8
+"""
+Scramble.
+"""
+import random
+import module
+
+class Scramble():
+	def __init__(self):
+		self.running = False
+
+	def newgame(self):
+		self.running = True
+		self.word = self._PickWord()
+		self.shuffled = [x for x in self.word]
+		random.shuffle(self.shuffled)
+
+	def _PickWord(self):
+		with open("/home/iou1name/.sopel/words6.txt",'r') as file:
+			lines = file.readlines()
+		wrd = list(lines[ random.randint(0, len(lines))-1 ].strip())
+		return wrd
+
+	def gameover(self):
+		self.running = False
+		self.shuffled = self.word
+
+
+def isAnagram(givenWord, givenGuess):
+	word = [x for x in givenWord]
+	guess = [x for x in givenGuess]
+	with open('/home/iou1name/.sopel/words6.txt', 'r') as file:
+		words = file.readlines()
+	if not ''.join(guess)+'\n' in words:
+		return "notaword"
+	del words
+
+	for char in word:
+		if char in guess:
+			guess.pop(guess.index(char))
+		else:
+			return 'incorrect'
+	return 'correct'
+
+
+scramble = Scramble()
+
+@module.commands('scramble')
+@module.example('.scramble')
+def scramble_start(bot, trigger):
+	"""Starts a game of scramble."""
+	if scramble.running:
+		bot.reply("There is already a game running.")
+		return
+
+	scramble.newgame()
+	bot.say(trigger.nick + " has started a game of scramble! Type .sc to guess the solution.")
+	bot.say(''.join(scramble.shuffled))
+
+
+@module.commands('sc')
+@module.example('.sc anus')
+def guess(bot, trigger):
+	"""Makes a guess in scramble."""
+	if not scramble.running:
+		bot.reply('There is no game currently running. Use .scramble to start one')
+		return
+
+	response = isAnagram(scramble.word, list(trigger.group(2)))
+
+	if response == 'correct':
+		bot.say(trigger.nick + " has won!")
+		scramble.gameover()
+	elif response == 'notaword':
+		bot.say("I don't recognize that word.")
+	elif response == 'incorrect':
+		bot.reply("incorrect.")
+
+	bot.say(''.join(scramble.shuffled))

modules/search.py

@@ -0,0 +1,128 @@
+# coding=utf-8
+# Copyright 2008-9, Sean B. Palmer, inamidst.com
+# Copyright 2012, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+import requests
+from module import commands, example
+import json
+import sys
+
+if sys.version_info.major < 3:
+    from urllib import quote_plus
+else:
+    from urllib.parse import quote_plus
+
+
+def formatnumber(n):
+    """Format a number with beautiful commas."""
+    parts = list(str(n))
+    for i in range((len(parts) - 3), 0, -3):
+        parts.insert(i, ',')
+    return ''.join(parts)
+
+r_bing = re.compile(r'<h3><a href="([^"]+)"')
+
+
+def bing_search(query, lang='en-GB'):
+    base = 'http://www.bing.com/search?mkt=%s&q=' % lang
+    bytes = requests.get(base + query)
+    m = r_bing.search(bytes)
+    if m:
+        return m.group(1)
+
+r_duck = re.compile(r'nofollow" class="[^"]+" href="(?!https?:\/\/r\.search\.yahoo)(.*?)">')
+
+
+def duck_search(query):
+    query = query.replace('!', '')
+    uri = 'http://duckduckgo.com/html/?q=%s&kl=uk-en' % query
+    bytes = requests.get(uri)
+    if 'requests-result' in bytes:  # filter out the adds on top of the page
+        bytes = bytes.split('requests-result')[1]
+    m = r_duck.search(bytes)
+    if m:
+        return requests.decode(m.group(1))
+
+# Alias google_search to duck_search
+google_search = duck_search
+
+
+def duck_api(query):
+    if '!bang' in query.lower():
+        return 'https://duckduckgo.com/bang.html'
+
+    # This fixes issue #885 (https://github.com/sopel-irc/sopel/issues/885)
+    # It seems that duckduckgo api redirects to its Instant answer API html page
+    # if the query constains special charactares that aren't urlencoded.
+    # So in order to always get a JSON response back the query is urlencoded
+    query = quote_plus(query)
+    uri = 'http://api.duckduckgo.com/?q=%s&format=json&no_html=1&no_redirect=1' % query
+    results = json.loads(requests.get(uri))
+    if results['Redirect']:
+        return results['Redirect']
+    else:
+        return None
+
+
+@commands('duck', 'ddg', 'g')
+@example('.duck privacy or .duck !mcwiki obsidian')
+def duck(bot, trigger):
+    """Queries Duck Duck Go for the specified input."""
+    query = trigger.group(2)
+    if not query:
+        return bot.reply('.ddg what?')
+
+    # If the API gives us something, say it and stop
+    result = duck_api(query)
+    if result:
+        bot.reply(result)
+        return
+
+    # Otherwise, look it up on the HTMl version
+    uri = duck_search(query)
+
+    if uri:
+        bot.reply(uri)
+        if 'last_seen_url' in bot.memory:
+            bot.memory['last_seen_url'][trigger.sender] = uri
+    else:
+        bot.reply("No results found for '%s'." % query)
+
+
+@commands('search')
+@example('.search nerdfighter')
+def search(bot, trigger):
+    """Searches Bing and Duck Duck Go."""
+    if not trigger.group(2):
+        return bot.reply('.search for what?')
+    query = trigger.group(2)
+    bu = bing_search(query) or '-'
+    du = duck_search(query) or '-'
+
+    if bu == du:
+        result = '%s (b, d)' % bu
+    else:
+        if len(bu) > 150:
+            bu = '(extremely long link)'
+        if len(du) > 150:
+            du = '(extremely long link)'
+        result = '%s (b), %s (d)' % (bu, du)
+
+    bot.reply(result)
+
+
+@commands('suggest')
+def suggest(bot, trigger):
+    """Suggest terms starting with given input"""
+    if not trigger.group(2):
+        return bot.reply("No query term.")
+    query = trigger.group(2)
+    uri = 'http://requestssitedev.de/temp-bin/suggest.pl?q='
+    answer = requests.get(uri + query.replace('+', '%2B'))
+    if answer:
+        bot.say(answer)
+    else:
+        bot.reply('Sorry, no result.')

modules/seen.py

@@ -0,0 +1,50 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+When was this user last seen.
+"""
+import time
+import datetime
+from tools import Identifier
+from tools.time import get_timezone, format_time, relativeTime
+from module import commands, rule, priority, thread
+
+
+@commands('seen')
+def seen(bot, trigger):
+	"""Reports when and where the user was last seen."""
+	if not trigger.group(2):
+		bot.say(".seen <nick> - Reports when <nick> was last seen.")
+		return
+	nick = trigger.group(2).strip()
+	if nick == bot.nick:
+		bot.reply("I'm right here!")
+		return
+	timestamp = bot.db.get_nick_value(nick, 'seen_timestamp')
+	if timestamp:
+		channel = bot.db.get_nick_value(nick, 'seen_channel')
+		message = bot.db.get_nick_value(nick, 'seen_message')
+		action = bot.db.get_nick_value(nick, 'seen_action')
+
+		tz = get_timezone(bot.db, bot.config, None, trigger.nick, trigger.sender)
+		saw = datetime.datetime.utcfromtimestamp(timestamp)
+		timestamp = format_time(bot.db, bot.config, tz, trigger.nick,
+								trigger.sender, saw)
+
+		reltime = relativeTime(bot, nick, timestamp)
+		msg = "Last heard from \x0308{}\x03 at {} (\x0312{}\x03) in \x0312{}".format(nick, timestamp, reltime, channel)
+
+		bot.reply(msg)
+	else:
+		bot.say("I haven't seen \x0308{}".format(nick))
+
+
+@thread(False)
+@rule('(.*)')
+@priority('low')
+def note(bot, trigger):
+	if not trigger.is_privmsg:
+		bot.db.set_nick_value(trigger.nick, 'seen_timestamp', time.time())
+		bot.db.set_nick_value(trigger.nick, 'seen_channel', trigger.sender)
+		bot.db.set_nick_value(trigger.nick, 'seen_message', trigger)
+		bot.db.set_nick_value(trigger.nick, 'seen_action', 'intent' in trigger.tags)

modules/spellcheck.py

@@ -0,0 +1,53 @@
+# coding=utf-8
+"""
+spellcheck.py - Sopel spell check Module
+Copyright © 2012, Elad Alfassa, <elad@fedoraproject.org>
+Copyright © 2012, Lior Ramati
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+
+This module relies on pyenchant, on Fedora and Red Hat based system, it can be found in the package python-enchant
+"""
+try:
+    import enchant
+except ImportError:
+    enchant = None
+from module import commands, example
+
+
+@commands('spellcheck', 'spell')
+@example('.spellcheck stuff')
+def spellcheck(bot, trigger):
+    """
+    Says whether the given word is spelled correctly, and gives suggestions if
+    it's not.
+    """
+    if not enchant:
+        bot.say("Missing pyenchant module.")
+    if not trigger.group(2):
+        return
+    word = trigger.group(2).rstrip()
+    if " " in word:
+        bot.say("One word at a time, please")
+        return
+    dictionary = enchant.Dict("en_US")
+    dictionary_uk = enchant.Dict("en_GB")
+    # I don't want to make anyone angry, so I check both American and British English.
+    if dictionary_uk.check(word):
+        if dictionary.check(word):
+            bot.say(word + " is spelled correctly")
+        else:
+            bot.say(word + " is spelled correctly (British)")
+    elif dictionary.check(word):
+        bot.say(word + " is spelled correctly (American)")
+    else:
+        msg = word + " is not spelled correctly. Maybe you want one of these spellings:"
+        sugWords = []
+        for suggested_word in dictionary.suggest(word):
+                sugWords.append(suggested_word)
+        for suggested_word in dictionary_uk.suggest(word):
+                sugWords.append(suggested_word)
+        for suggested_word in sorted(set(sugWords)):  # removes duplicates
+            msg = msg + " '" + suggested_word + "',"
+        bot.say(msg)

modules/tell.py

@@ -0,0 +1,174 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Leave a message for someone.
+"""
+import os
+from datetime import datetime
+import threading
+import sys
+
+from tools import Identifier, iterkeys
+from tools.time import get_timezone, format_time, relativeTime
+from module import commands, nickname_commands, rule, priority, example
+
+maximum = 40
+
+
+def loadReminders(fname, lock):
+	lock.acquire()
+	try:
+		result = {}
+		f = open(fname)
+		for line in f:
+			line = line.strip()
+			if sys.version_info.major < 3:
+				line = line.decode('utf-8')
+			if line:
+				try:
+					tellee, teller, timenow, msg = line.split('\t', 4)
+				except ValueError:
+					continue  # @@ hmm
+				result.setdefault(tellee, []).append((teller, timenow, msg))
+		f.close()
+	finally:
+		lock.release()
+	return result
+
+
+def dumpReminders(fname, data, lock):
+	lock.acquire()
+	try:
+		f = open(fname, 'w')
+		for tellee in iterkeys(data):
+			for remindon in data[tellee]:
+				line = '\t'.join((tellee,) + remindon)
+				try:
+					to_write = line + '\n'
+					if sys.version_info.major < 3:
+						to_write = to_write.encode('utf-8')
+					f.write(to_write)
+				except IOError:
+					break
+		try:
+			f.close()
+		except IOError:
+			pass
+	finally:
+		lock.release()
+	return True
+
+
+def setup(bot):
+	fname = bot.nick + '-' + bot.config.core.host + '.tell.db'
+	bot.tell_filename = os.path.join(bot.config.core.homedir, fname)
+	if not os.path.exists(bot.tell_filename):
+		try:
+			f = open(bot.tell_filename, 'w')
+		except OSError:
+			pass
+		else:
+			f.write('')
+			f.close()
+	bot.memory['tell_lock'] = threading.Lock()
+	bot.memory['reminders'] = loadReminders(bot.tell_filename, bot.memory['tell_lock'])
+
+
+@commands('tell')
+@example('.tell Embolalia you broke something again.')
+def f_remind(bot, trigger):
+	"""Give someone a message the next time they're seen"""
+	teller = trigger.nick
+
+	if not trigger.group(3):
+		bot.reply("Tell whom?")
+		return
+
+	tellee = trigger.group(3).rstrip('.,:;')
+	msg = trigger.group(2).lstrip(tellee).lstrip()
+
+	if not msg:
+		bot.reply("Tell %s what?" % tellee)
+		return
+
+	tellee = Identifier(tellee)
+
+	if not os.path.exists(bot.tell_filename):
+		return
+
+	if len(tellee) > 20:
+		return bot.reply('That nickname is too long.')
+	if tellee == bot.nick:
+		return bot.reply("I'm here now, you can tell me whatever you want!")
+
+	if not tellee in (Identifier(teller), bot.nick, 'me'):
+		tz = get_timezone(bot.db, bot.config, None, tellee)
+		timenow = format_time(bot.db, bot.config, tz, tellee)
+		bot.memory['tell_lock'].acquire()
+		try:
+			if not tellee in bot.memory['reminders']:
+				bot.memory['reminders'][tellee] = [(teller, timenow, msg)]
+			else:
+				bot.memory['reminders'][tellee].append((teller, timenow, msg))
+		finally:
+			bot.memory['tell_lock'].release()
+
+		response = "I'll pass that on when %s is around." % tellee
+
+		bot.reply(response)
+	elif Identifier(teller) == tellee:
+		bot.say('You can tell yourself that.')
+	else:
+		bot.say("Hey, I'm not as stupid as Monty you know!")
+
+	dumpReminders(bot.tell_filename, bot.memory['reminders'], bot.memory['tell_lock'])  # @@ tell
+
+
+def getReminders(bot, channel, key, tellee):
+	lines = []
+	template = "%s: \x0310%s\x03 (\x0308%s\x03) %s [\x0312%s\x03]"
+
+	bot.memory['tell_lock'].acquire()
+	try:
+		for (teller, telldate, msg) in bot.memory['reminders'][key]:
+			lines.append(template % (tellee, msg, teller, telldate, relativeTime(bot, tellee, telldate)))
+
+		try:
+			del bot.memory['reminders'][key]
+		except KeyError:
+			bot.msg(channel, 'Er...')
+	finally:
+		bot.memory['tell_lock'].release()
+	return lines
+
+
+@rule('(.*)')
+@priority('low')
+def message(bot, trigger):
+
+	tellee = trigger.nick
+	channel = trigger.sender
+
+	if not os.path.exists(bot.tell_filename):
+		return
+
+	reminders = []
+	remkeys = list(reversed(sorted(bot.memory['reminders'].keys())))
+
+	for remkey in remkeys:
+		if not remkey.endswith('*') or remkey.endswith(':'):
+			if tellee == remkey:
+				reminders.extend(getReminders(bot, channel, remkey, tellee))
+		elif tellee.startswith(remkey.rstrip('*:')):
+			reminders.extend(getReminders(bot, channel, remkey, tellee))
+
+	for line in reminders[:maximum]:
+		bot.say(line)
+
+	if reminders[maximum:]:
+		bot.say('Further messages sent privately')
+		for line in reminders[maximum:]:
+			bot.msg(tellee, line)
+
+	if len(bot.memory['reminders'].keys()) != remkeys:
+		dumpReminders(bot.tell_filename, bot.memory['reminders'], bot.memory['tell_lock'])  # @@ tell

modules/tld.py

@@ -0,0 +1,69 @@
+# coding=utf-8
+"""
+tld.py - Sopel TLD Module
+Copyright 2009-10, Michael Yanovich, yanovich.net
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+from module import commands, example
+import re
+import sys
+import requests
+if sys.version_info.major >= 3:
+    unicode = str
+
+uri = 'https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains'
+r_tag = re.compile(r'<(?!!)[^>]+>')
+
+
+@commands('tld')
+@example('.tld ru')
+def gettld(bot, trigger):
+    """Show information about the given Top Level Domain."""
+    page = requests.get(uri).text
+    tld = trigger.group(2)
+    if tld[0] == '.':
+        tld = tld[1:]
+    search = r'(?i)<td><a href="\S+" title="\S+">\.{0}</a></td>\n(<td><a href=".*</a></td>\n)?<td>([A-Za-z0-9].*?)</td>\n<td>(.*)</td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n'
+    search = search.format(tld)
+    re_country = re.compile(search)
+    matches = re_country.findall(page)
+    if not matches:
+        search = r'(?i)<td><a href="\S+" title="(\S+)">\.{0}</a></td>\n<td><a href=".*">(.*)</a></td>\n<td>([A-Za-z0-9].*?)</td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n'
+        search = search.format(tld)
+        re_country = re.compile(search)
+        matches = re_country.findall(page)
+    if matches:
+        matches = list(matches[0])
+        i = 0
+        while i < len(matches):
+            matches[i] = r_tag.sub("", matches[i])
+            i += 1
+        desc = matches[2]
+        if len(desc) > 400:
+            desc = desc[:400] + "..."
+        reply = "%s -- %s. IDN: %s, DNSSEC: %s" % (matches[1], desc,
+                matches[3], matches[4])
+        bot.reply(reply)
+    else:
+        search = r'<td><a href="\S+" title="\S+">.{0}</a></td>\n<td><span class="flagicon"><img.*?\">(.*?)</a></td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n<td[^>]*>(.*?)</td>\n'
+        search = search.format(unicode(tld))
+        re_country = re.compile(search)
+        matches = re_country.findall(page)
+        if matches:
+            matches = matches[0]
+            dict_val = dict()
+            dict_val["country"], dict_val["expl"], dict_val["notes"], dict_val["idn"], dict_val["dnssec"], dict_val["sld"] = matches
+            for key in dict_val:
+                if dict_val[key] == "&#160;":
+                    dict_val[key] = "N/A"
+                dict_val[key] = r_tag.sub('', dict_val[key])
+            if len(dict_val["notes"]) > 400:
+                dict_val["notes"] = dict_val["notes"][:400] + "..."
+            reply = "%s (%s, %s). IDN: %s, DNSSEC: %s, SLD: %s" % (dict_val["country"], dict_val["expl"], dict_val["notes"], dict_val["idn"], dict_val["dnssec"], dict_val["sld"])
+        else:
+            reply = "No matches found for TLD: {0}".format(unicode(tld))
+        bot.reply(reply)

modules/translate.py

@@ -0,0 +1,208 @@
+# coding=utf-8
+"""
+translate.py - Sopel Translation Module
+Copyright 2008, Sean B. Palmer, inamidst.com
+Copyright © 2013-2014, Elad Alfassa <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+import json
+import random
+import sys
+import requests
+
+from module import rule, commands, priority, example
+
+mangle_lines = {}
+if sys.version_info.major >= 3:
+    unicode = str
+
+
+def translate(text, in_lang='auto', out_lang='en', verify_ssl=True):
+    raw = False
+    if unicode(out_lang).endswith('-raw'):
+        out_lang = out_lang[:-4]
+        raw = True
+
+    headers = {
+        'User-Agent': 'Mozilla/5.0' +
+        '(X11; U; Linux i686)' +
+        'Gecko/20071127 Firefox/2.0.0.11'
+    }
+
+    query = {
+        "client": "gtx",
+        "sl": in_lang,
+        "tl": out_lang,
+        "dt": "t",
+        "q": text,
+    }
+    url = "http://translate.googleapis.com/translate_a/single"
+    result = requests.get(url, params=query, timeout=40, headers=headers,
+                          verify=verify_ssl).text
+
+    if result == '[,,""]':
+        return None, in_lang
+
+    while ',,' in result:
+        result = result.replace(',,', ',null,')
+        result = result.replace('[,', '[null,')
+
+    data = json.loads(result)
+
+    if raw:
+        return str(data), 'en-raw'
+
+    try:
+        language = data[2]  # -2][0][0]
+    except:
+        language = '?'
+
+    return ''.join(x[0] for x in data[0]), language
+
+
+@rule(u'$nickname[,:]\s+(?:([a-z]{2}) +)?(?:([a-z]{2}|en-raw) +)?["“](.+?)["”]\? *$')
+@example('$nickname: "mon chien"? or $nickname: fr "mon chien"?')
+@priority('low')
+def tr(bot, trigger):
+    """Translates a phrase, with an optional language hint."""
+    in_lang, out_lang, phrase = trigger.groups()
+
+    if (len(phrase) > 350) and (not trigger.admin):
+        return bot.reply('Phrase must be under 350 characters.')
+
+    if phrase.strip() == '':
+        return bot.reply('You need to specify a string for me to translate!')
+
+    in_lang = in_lang or 'auto'
+    out_lang = out_lang or 'en'
+
+    if in_lang != out_lang:
+        msg, in_lang = translate(phrase, in_lang, out_lang,
+                                 verify_ssl=bot.config.core.verify_ssl)
+        if sys.version_info.major < 3 and isinstance(msg, str):
+            msg = msg.decode('utf-8')
+        if msg:
+            msg = web.decode(msg)  # msg.replace('&#39;', "'")
+            msg = '"%s" (%s to %s, translate.google.com)' % (msg, in_lang, out_lang)
+        else:
+            msg = 'The %s to %s translation failed, are you sure you specified valid language abbreviations?' % (in_lang, out_lang)
+
+        bot.reply(msg)
+    else:
+        bot.reply('Language guessing failed, so try suggesting one!')
+
+
+@commands('translate', 'tr')
+@example('.tr :en :fr my dog', '"mon chien" (en to fr, translate.google.com)')
+@example('.tr היי', '"Hey" (iw to en, translate.google.com)')
+@example('.tr mon chien', '"my dog" (fr to en, translate.google.com)')
+def tr2(bot, trigger):
+    """Translates a phrase, with an optional language hint."""
+    command = trigger.group(2)
+
+    if not command:
+        return bot.reply('You did not give me anything to translate')
+
+    def langcode(p):
+        return p.startswith(':') and (2 < len(p) < 10) and p[1:].isalpha()
+
+    args = ['auto', 'en']
+
+    for i in range(2):
+        if ' ' not in command:
+            break
+        prefix, cmd = command.split(' ', 1)
+        if langcode(prefix):
+            args[i] = prefix[1:]
+            command = cmd
+    phrase = command
+
+    if (len(phrase) > 350) and (not trigger.admin):
+        return bot.reply('Phrase must be under 350 characters.')
+
+    if phrase.strip() == '':
+        return bot.reply('You need to specify a string for me to translate!')
+
+    src, dest = args
+    if src != dest:
+        msg, src = translate(phrase, src, dest,
+                             verify_ssl=bot.config.core.verify_ssl)
+        if sys.version_info.major < 3 and isinstance(msg, str):
+            msg = msg.decode('utf-8')
+        if msg:
+            msg = web.decode(msg)  # msg.replace('&#39;', "'")
+            msg = '"%s" (%s to %s, translate.google.com)' % (msg, src, dest)
+        else:
+            msg = 'The %s to %s translation failed, are you sure you specified valid language abbreviations?' % (src, dest)
+
+        bot.reply(msg)
+    else:
+        bot.reply('Language guessing failed, so try suggesting one!')
+
+
+def get_random_lang(long_list, short_list):
+    random_index = random.randint(0, len(long_list) - 1)
+    random_lang = long_list[random_index]
+    if random_lang not in short_list:
+        short_list.append(random_lang)
+    else:
+        return get_random_lang(long_list, short_list)
+    return short_list
+
+
+@commands('mangle', 'mangle2')
+def mangle(bot, trigger):
+    """Repeatedly translate the input until it makes absolutely no sense."""
+    verify_ssl = bot.config.core.verify_ssl
+    global mangle_lines
+    long_lang_list = ['fr', 'de', 'es', 'it', 'no', 'he', 'la', 'ja', 'cy', 'ar', 'yi', 'zh', 'nl', 'ru', 'fi', 'hi', 'af', 'jw', 'mr', 'ceb', 'cs', 'ga', 'sv', 'eo', 'el', 'ms', 'lv']
+    lang_list = []
+    for __ in range(0, 8):
+        lang_list = get_random_lang(long_lang_list, lang_list)
+    random.shuffle(lang_list)
+    if trigger.group(2) is None:
+        try:
+            phrase = (mangle_lines[trigger.sender.lower()], '')
+        except:
+            bot.reply("What do you want me to mangle?")
+            return
+    else:
+        phrase = (trigger.group(2).strip(), '')
+    if phrase[0] == '':
+        bot.reply("What do you want me to mangle?")
+        return
+    for lang in lang_list:
+        backup = phrase
+        try:
+            phrase = translate(phrase[0], 'en', lang,
+                               verify_ssl=verify_ssl)
+        except:
+            phrase = False
+        if not phrase:
+            phrase = backup
+            break
+
+        try:
+            phrase = translate(phrase[0], lang, 'en', verify_ssl=verify_ssl)
+        except:
+            phrase = backup
+            continue
+
+        if not phrase:
+            phrase = backup
+            break
+    bot.reply(phrase[0])
+
+
+@rule('(.*)')
+@priority('low')
+def collect_mangle_lines(bot, trigger):
+    global mangle_lines
+    mangle_lines[trigger.sender.lower()] = "%s said '%s'" % (trigger.nick, (trigger.group(0).strip()))
+
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/unicode_info.py

@@ -0,0 +1,51 @@
+# coding=utf-8
+"""Codepoints Module"""
+# Copyright 2013, Elsie Powell, embolalia.com
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Licensed under the Eiffel Forum License 2.
+import unicodedata
+import sys
+from module import commands, example, NOLIMIT
+
+if sys.version_info.major >= 3:
+    unichr = chr
+
+
+@commands('u')
+@example('.u ‽', 'U+203D INTERROBANG (‽)')
+@example('.u 203D', 'U+203D INTERROBANG (‽)')
+def codepoint(bot, trigger):
+    arg = trigger.group(2)
+    if not arg:
+        bot.reply('What code point do you want me to look up?')
+        return NOLIMIT
+    stripped = arg.strip()
+    if len(stripped) > 0:
+        arg = stripped
+    if len(arg) > 1:
+        if arg.startswith('U+'):
+            arg = arg[2:]
+        try:
+            arg = unichr(int(arg, 16))
+        except:
+            bot.reply("That's not a valid code point.")
+            return NOLIMIT
+
+    # Get the hex value for the code point, and drop the 0x from the front
+    point = str(hex(ord(u'' + arg)))[2:]
+    # Make the hex 4 characters long with preceding 0s, and all upper case
+    point = point.rjust(4, str('0')).upper()
+    try:
+        name = unicodedata.name(arg)
+    except ValueError:
+        return 'U+%s (No name found)' % point
+
+    if not unicodedata.combining(arg):
+        template = 'U+%s %s (%s)'
+    else:
+        template = 'U+%s %s (\xe2\x97\x8c%s)'
+    bot.say(template % (point, name, arg))
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/units.py

@@ -0,0 +1,186 @@
+# coding=utf-8
+"""
+units.py - Unit conversion module for Sopel
+Copyright © 2013, Elad Alfassa, <elad@fedoraproject.org>
+Copyright © 2013, Dimitri Molenaars, <tyrope@tyrope.nl>
+Licensed under the Eiffel Forum License 2.
+
+"""
+import re
+
+from module import commands, example, NOLIMIT
+
+find_temp = re.compile('(-?[0-9]*\.?[0-9]*)[ °]*(K|C|F)', re.IGNORECASE)
+find_length = re.compile('([0-9]*\.?[0-9]*)[ ]*(mile[s]?|mi|inch|in|foot|feet|ft|yard[s]?|yd|(?:milli|centi|kilo|)meter[s]?|[mkc]?m|ly|light-year[s]?|au|astronomical unit[s]?|parsec[s]?|pc)', re.IGNORECASE)
+find_mass = re.compile('([0-9]*\.?[0-9]*)[ ]*(lb|lbm|pound[s]?|ounce|oz|(?:kilo|)gram(?:me|)[s]?|[k]?g)', re.IGNORECASE)
+
+
+def f_to_c(temp):
+    return (float(temp) - 32) * 5 / 9
+
+
+def c_to_k(temp):
+    return temp + 273.15
+
+
+def c_to_f(temp):
+    return (9.0 / 5.0 * temp + 32)
+
+
+def k_to_c(temp):
+    return temp - 273.15
+
+
+@commands('temp')
+@example('.temp 100F', '37.78°C = 100.00°F = 310.93K')
+@example('.temp 100C', '100.00°C = 212.00°F = 373.15K')
+@example('.temp 100K', '-173.15°C = -279.67°F = 100.00K')
+def temperature(bot, trigger):
+    """
+    Convert temperatures
+    """
+    try:
+        source = find_temp.match(trigger.group(2)).groups()
+    except (AttributeError, TypeError):
+        bot.reply("That's not a valid temperature.")
+        return NOLIMIT
+    unit = source[1].upper()
+    numeric = float(source[0])
+    celsius = 0
+    if unit == 'C':
+        celsius = numeric
+    elif unit == 'F':
+        celsius = f_to_c(numeric)
+    elif unit == 'K':
+        celsius = k_to_c(numeric)
+
+    kelvin = c_to_k(celsius)
+    fahrenheit = c_to_f(celsius)
+    bot.reply("{:.2f}°C = {:.2f}°F = {:.2f}K".format(celsius, fahrenheit, kelvin))
+
+
+@commands('length', 'distance')
+@example('.distance 3m', '3.00m = 9 feet, 10.11 inches')
+@example('.distance 3km', '3.00km = 1.86 miles')
+@example('.distance 3 miles', '4.83km = 3.00 miles')
+@example('.distance 3 inch', '7.62cm = 3.00 inches')
+@example('.distance 3 feet', '91.44cm = 3 feet, 0.00 inches')
+@example('.distance 3 yards', '2.74m = 9 feet, 0.00 inches')
+@example('.distance 155cm', '1.55m = 5 feet, 1.02 inches')
+@example('.length 3 ly', '28382191417742.40km = 17635876112814.77 miles')
+@example('.length 3 au', '448793612.10km = 278867421.71 miles')
+@example('.length 3 parsec', '92570329129020.20km = 57520535754731.61 miles')
+def distance(bot, trigger):
+    """
+    Convert distances
+    """
+    try:
+        source = find_length.match(trigger.group(2)).groups()
+    except (AttributeError, TypeError):
+        bot.reply("That's not a valid length unit.")
+        return NOLIMIT
+    unit = source[1].lower()
+    numeric = float(source[0])
+    meter = 0
+    if unit in ("meters", "meter", "m"):
+        meter = numeric
+    elif unit in ("millimeters", "millimeter", "mm"):
+        meter = numeric / 1000
+    elif unit in ("kilometers", "kilometer", "km"):
+        meter = numeric * 1000
+    elif unit in ("miles", "mile", "mi"):
+        meter = numeric / 0.00062137
+    elif unit in ("inch", "in"):
+        meter = numeric / 39.370
+    elif unit in ("centimeters", "centimeter", "cm"):
+        meter = numeric / 100
+    elif unit in ("feet", "foot", "ft"):
+        meter = numeric / 3.2808
+    elif unit in ("yards", "yard", "yd"):
+        meter = numeric / (3.2808 / 3)
+    elif unit in ("light-year", "light-years", "ly"):
+        meter = numeric * 9460730472580800
+    elif unit in ("astronomical unit", "astronomical units", "au"):
+        meter = numeric * 149597870700
+    elif unit in ("parsec", "parsecs", "pc"):
+        meter = numeric * 30856776376340068
+
+    if meter >= 1000:
+        metric_part = '{:.2f}km'.format(meter / 1000)
+    elif meter < 0.01:
+        metric_part = '{:.2f}mm'.format(meter * 1000)
+    elif meter < 1:
+        metric_part = '{:.2f}cm'.format(meter * 100)
+    else:
+        metric_part = '{:.2f}m'.format(meter)
+
+    # Shit like this makes me hate being an American.
+    inch = meter * 39.37
+    foot = int(inch) // 12
+    inch = inch - (foot * 12)
+    yard = foot // 3
+    mile = meter * 0.000621371192
+
+    if yard > 500:
+        stupid_part = '{:.2f} miles'.format(mile)
+    else:
+        parts = []
+        if yard >= 100:
+            parts.append('{} yards'.format(yard))
+            foot -= (yard * 3)
+
+        if foot == 1:
+            parts.append('1 foot')
+        elif foot != 0:
+            parts.append('{:.0f} feet'.format(foot))
+
+        parts.append('{:.2f} inches'.format(inch))
+
+        stupid_part = ', '.join(parts)
+
+    bot.reply('{} = {}'.format(metric_part, stupid_part))
+
+
+@commands('weight', 'mass')
+def mass(bot, trigger):
+    """
+    Convert mass
+    """
+    try:
+        source = find_mass.match(trigger.group(2)).groups()
+    except (AttributeError, TypeError):
+        bot.reply("That's not a valid mass unit.")
+        return NOLIMIT
+    unit = source[1].lower()
+    numeric = float(source[0])
+    metric = 0
+    if unit in ("gram", "grams", "gramme", "grammes", "g"):
+        metric = numeric
+    elif unit in ("kilogram", "kilograms", "kilogramme", "kilogrammes", "kg"):
+        metric = numeric * 1000
+    elif unit in ("lb", "lbm", "pound", "pounds"):
+        metric = numeric * 453.59237
+    elif unit in ("oz", "ounce"):
+        metric = numeric * 28.35
+
+    if metric >= 1000:
+        metric_part = '{:.2f}kg'.format(metric / 1000)
+    else:
+        metric_part = '{:.2f}g'.format(metric)
+
+    ounce = metric * .035274
+    pound = int(ounce) // 16
+    ounce = ounce - (pound * 16)
+
+    if pound > 1:
+        stupid_part = '{} pounds'.format(pound)
+        if ounce > 0.01:
+            stupid_part += ' {:.2f} ounces'.format(ounce)
+    else:
+        stupid_part = '{:.2f} oz'.format(ounce)
+
+    bot.reply('{} = {}'.format(metric_part, stupid_part))
+
+if __name__ == "__main__":
+    from test_tools import run_example_tests
+    run_example_tests(__file__)

modules/uptime.py

@@ -0,0 +1,26 @@
+# coding=utf-8
+"""
+uptime.py - Uptime module
+Copyright 2014, Fabian Neundorf
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+import datetime
+
+from module import commands
+
+
+def setup(bot):
+    if "uptime" not in bot.memory:
+        bot.memory["uptime"] = datetime.datetime.utcnow()
+
+
+@commands('uptime')
+def uptime(bot, trigger):
+    """.uptime - Returns the uptime of Sopel."""
+    delta = datetime.timedelta(seconds=round((datetime.datetime.utcnow() -
+                                              bot.memory["uptime"])
+                                             .total_seconds()))
+    bot.say("I've been sitting here for {} and I keep "
+            "going!".format(delta))

modules/url.py

@@ -0,0 +1,68 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+URL parsing.
+"""
+import re
+from module import rule
+from tools import web
+from config.types import ValidatedAttribute, ListAttribute, StaticSection
+import requests
+from urllib.parse import urlparse
+from html.parser import HTMLParser
+
+headers = {"User-Agent": "bix nood gimme the title", "Range": "bytes=0-4096"}
+
+class UrlSection(StaticSection):
+	# TODO some validation rules maybe?
+	exclude = ListAttribute('exclude')
+	exclusion_char = ValidatedAttribute('exclusion_char', default='!')
+
+
+def configure(config):
+	config.define_section('url', UrlSection)
+	config.url.configure_setting(
+		'exclude',
+		'Enter regular expressions for each URL you would like to exclude.'
+	)
+	config.url.configure_setting(
+		'exclusion_char',
+		'Enter a character which can be prefixed to suppress URL titling'
+	)
+
+
+@rule('(?u).*(https?://\S+).*')
+def title_auto(bot, trigger):
+	"""
+	Automatically show titles for URLs. For shortened URLs/redirects, find
+	where the URL redirects to and show the title for that.
+	"""
+	url_finder = re.compile(r'(?u)(%s?(?:http|https|ftp)(?:://\S+))' %
+							(bot.config.url.exclusion_char), re.IGNORECASE)
+	if re.match(bot.config.core.prefix + 'title', trigger):
+		return
+
+	urls = re.findall(url_finder, trigger)
+	if len(urls) == 0:
+		return
+
+	for url in urls:
+		# Avoid fetching known malicious links
+		if not web.secCheck(bot, url):
+			continue
+		try:
+			res = requests.get(url, headers=headers, verify=True)
+		except requests.exceptions.ConnectionError:
+			continue
+		if res.status_code == 404:
+			continue
+		res.raise_for_status()
+		if not res.headers["Content-Type"].startswith("text/html"):
+			continue
+		if res.text.find("<title>") == -1:
+			continue
+		title = res.text[res.text.find("<title>")+7:res.text.find("</title>")]
+		title = HTMLParser().unescape(title)
+		title = title.replace("\n","").strip()
+		hostname = urlparse(url).hostname
+		bot.say('[ \x0310%s \x03] - \x0304%s' % (title, hostname))

modules/version.py

@@ -0,0 +1,81 @@
+# coding=utf-8
+"""
+version.py - Sopel Version Module
+Copyright 2009, Silas Baronda
+Copyright 2014, Dimitri Molenaars <tyrope@tyrope.nl>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from datetime import datetime
+import re
+from os import path
+
+import module
+
+
+log_line = re.compile('\S+ (\S+) (.*? <.*?>) (\d+) (\S+)\tcommit[^:]*: (.+)')
+
+
+def git_info():
+    repo = path.join(path.dirname(path.dirname(path.dirname(__file__))), '.git')
+    head = path.join(repo, 'HEAD')
+    if path.isfile(head):
+        with open(head) as h:
+            head_loc = h.readline()[5:-1]  # strip ref: and \n
+        head_file = path.join(repo, head_loc)
+        if path.isfile(head_file):
+            with open(head_file) as h:
+                sha = h.readline()
+                if sha:
+                    return sha
+
+
+@module.commands('version')
+def version(bot, trigger):
+    """Display the latest commit version, if Sopel is running in a git repo."""
+    release = sopel.__version__
+    sha = git_info()
+    if not sha:
+        msg = 'Sopel v. ' + release
+        if release[-4:] == '-git':
+            msg += ' at unknown commit.'
+        bot.reply(msg)
+        return
+
+    bot.reply("Sopel v. {} at commit: {}".format(sopel.__version__, sha))
+
+
+@module.intent('VERSION')
+@module.rate(20)
+@module.rule('.*')
+def ctcp_version(bot, trigger):
+    print('wat')
+    bot.write(('NOTICE', trigger.nick),
+              '\x01VERSION Sopel IRC Bot version %s\x01' % sopel.__version__)
+
+
+@module.rule('\x01SOURCE\x01')
+@module.rate(20)
+def ctcp_source(bot, trigger):
+    bot.write(('NOTICE', trigger.nick),
+              '\x01SOURCE https://github.com/sopel-irc/sopel/\x01')
+
+
+@module.rule('\x01PING\s(.*)\x01')
+@module.rate(10)
+def ctcp_ping(bot, trigger):
+    text = trigger.group()
+    text = text.replace("PING ", "")
+    text = text.replace("\x01", "")
+    bot.write(('NOTICE', trigger.nick),
+              '\x01PING {0}\x01'.format(text))
+
+
+@module.rule('\x01TIME\x01')
+@module.rate(20)
+def ctcp_time(bot, trigger):
+    dt = datetime.now()
+    current_time = dt.strftime("%A, %d. %B %Y %I:%M%p")
+    bot.write(('NOTICE', trigger.nick),
+              '\x01TIME {0}\x01'.format(current_time))

modules/weather.py

@@ -0,0 +1,181 @@
+# coding=utf-8
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Copyright 2012, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+from module import commands, example, NOLIMIT
+
+import xmltodict, requests
+
+
+def woeid_search(query):
+    """
+    Find the first Where On Earth ID for the given query. Result is the etree
+    node for the result, so that location data can still be retrieved. Returns
+    None if there is no result, or the woeid field is empty.
+    """
+    query = 'q=select * from geo.places where text="%s"' % query
+    body = requests.get('http://query.yahooapis.com/v1/public/yql?' + query).content
+    parsed = xmltodict.parse(body).get('query')
+    results = parsed.get('results')
+    if results is None or results.get('place') is None:
+        return None
+    if type(results.get('place')) is list:
+        return results.get('place')[0]
+    return results.get('place')
+
+
+def get_cover(parsed):
+    try:
+        condition = parsed['channel']['item']['yweather:condition']
+    except KeyError:
+        return 'unknown'
+    text = condition['@text']
+    # code = int(condition['code'])
+    # TODO parse code to get those little icon thingies.
+    return text
+
+
+def get_temp(parsed):
+    try:
+        condition = parsed['channel']['item']['yweather:condition']
+        temp = int(condition['@temp'])
+    except (KeyError, ValueError):
+        return 'unknown'
+    f = round((temp * 1.8) + 32, 2)
+    return (u'%d\u00B0C (%d\u00B0F)' % (temp, f))
+
+
+def get_humidity(parsed):
+    try:
+        humidity = parsed['channel']['yweather:atmosphere']['@humidity']
+    except (KeyError, ValueError):
+        return 'unknown'
+    return "Humidity: %s%%" % humidity
+
+
+def get_wind(parsed):
+    try:
+        wind_data = parsed['channel']['yweather:wind']
+        kph = float(wind_data['@speed'])
+        m_s = float(round(kph / 3.6, 1))
+        speed = int(round(kph / 1.852, 0))
+        degrees = int(wind_data['@direction'])
+    except (KeyError, ValueError):
+        return 'unknown'
+
+    if speed < 1:
+        description = 'Calm'
+    elif speed < 4:
+        description = 'Light air'
+    elif speed < 7:
+        description = 'Light breeze'
+    elif speed < 11:
+        description = 'Gentle breeze'
+    elif speed < 16:
+        description = 'Moderate breeze'
+    elif speed < 22:
+        description = 'Fresh breeze'
+    elif speed < 28:
+        description = 'Strong breeze'
+    elif speed < 34:
+        description = 'Near gale'
+    elif speed < 41:
+        description = 'Gale'
+    elif speed < 48:
+        description = 'Strong gale'
+    elif speed < 56:
+        description = 'Storm'
+    elif speed < 64:
+        description = 'Violent storm'
+    else:
+        description = 'Hurricane'
+
+    if (degrees <= 22.5) or (degrees > 337.5):
+        degrees = u'\u2193'
+    elif (degrees > 22.5) and (degrees <= 67.5):
+        degrees = u'\u2199'
+    elif (degrees > 67.5) and (degrees <= 112.5):
+        degrees = u'\u2190'
+    elif (degrees > 112.5) and (degrees <= 157.5):
+        degrees = u'\u2196'
+    elif (degrees > 157.5) and (degrees <= 202.5):
+        degrees = u'\u2191'
+    elif (degrees > 202.5) and (degrees <= 247.5):
+        degrees = u'\u2197'
+    elif (degrees > 247.5) and (degrees <= 292.5):
+        degrees = u'\u2192'
+    elif (degrees > 292.5) and (degrees <= 337.5):
+        degrees = u'\u2198'
+
+    return description + ' ' + str(m_s) + 'm/s (' + degrees + ')'
+
+
+@commands('weather', 'wea')
+@example('.weather London')
+def weather(bot, trigger):
+    """.weather location - Show the weather at the given location."""
+
+    location = trigger.group(2)
+    woeid = ''
+    if not location:
+        woeid = bot.db.get_nick_value(trigger.nick, 'woeid')
+        if not woeid:
+            return bot.msg(trigger.sender, "I don't know where you live. " +
+                           'Give me a location, like .weather London, or tell me where you live by saying .setlocation London, for example.')
+    else:
+        location = location.strip()
+        woeid = bot.db.get_nick_value(location, 'woeid')
+        if woeid is None:
+            first_result = woeid_search(location)
+            if first_result is not None:
+                woeid = first_result.get('woeid')
+
+    if not woeid:
+        return bot.reply("I don't know where that is.")
+
+    query = 'q=select * from weather.forecast where woeid="%s" and u=\'c\'' % woeid
+    body = requests.get('http://query.yahooapis.com/v1/public/yql?' + query).content
+    parsed = xmltodict.parse(body).get('query')
+    results = parsed.get('results')
+    if results is None:
+        return bot.reply("No forecast available. Try a more specific location.")
+    location = results.get('channel').get('title')
+    cover = get_cover(results)
+    temp = get_temp(results)
+    humidity = get_humidity(results)
+    wind = get_wind(results)
+    bot.say(u'%s: %s, %s, %s, %s' % (location, cover, temp, humidity, wind))
+
+
+@commands('setlocation', 'setwoeid')
+@example('.setlocation Columbus, OH')
+def update_woeid(bot, trigger):
+    """Set your default weather location."""
+    if not trigger.group(2):
+        bot.reply('Give me a location, like "Washington, DC" or "London".')
+        return NOLIMIT
+
+    first_result = woeid_search(trigger.group(2))
+    if first_result is None:
+        return bot.reply("I don't know where that is.")
+
+    woeid = first_result.get('woeid')
+
+    bot.db.set_nick_value(trigger.nick, 'woeid', woeid)
+
+    neighborhood = first_result.get('locality2') or ''
+    if neighborhood:
+        neighborhood = neighborhood.get('#text') + ', '
+    city = first_result.get('locality1') or ''
+    # This is to catch cases like 'Bawlf, Alberta' where the location is
+    # thought to be a "LocalAdmin" rather than a "Town"
+    if city:
+        city = city.get('#text')
+    else:
+        city = first_result.get('name')
+    state = first_result.get('admin1').get('#text') or ''
+    country = first_result.get('country').get('#text') or ''
+    bot.reply('I now have you at WOEID %s (%s%s, %s, %s)' %
+              (woeid, neighborhood, city, state, country))

modules/wikipedia.py

@@ -0,0 +1,134 @@
+# coding=utf-8
+# Copyright 2013 Elsie Powell - embolalia.com
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+import tools
+from config.types import StaticSection, ValidatedAttribute
+from module import NOLIMIT, commands, example, rule
+import json
+import re
+import requests
+
+import sys
+if sys.version_info.major < 3:
+    from urlparse import unquote as _unquote
+    unquote = lambda s: _unquote(s.encode('utf-8')).decode('utf-8')
+else:
+    from urllib.parse import unquote
+
+REDIRECT = re.compile(r'^REDIRECT (.*)')
+
+
+class WikipediaSection(StaticSection):
+    default_lang = ValidatedAttribute('default_lang', default='en')
+    """The default language to find articles from."""
+    lang_per_channel = ValidatedAttribute('lang_per_channel')
+
+
+def setup(bot):
+    bot.config.define_section('wikipedia', WikipediaSection)
+
+    regex = re.compile('([a-z]+).(wikipedia.org/wiki/)([^ ]+)')
+    if not bot.memory.contains('url_callbacks'):
+        bot.memory['url_callbacks'] = tools.SopelMemory()
+    bot.memory['url_callbacks'][regex] = mw_info
+
+
+def configure(config):
+    config.define_section('wikipedia', WikipediaSection)
+    config.wikipedia.configure_setting(
+        'default_lang',
+        "Enter the default language to find articles from."
+    )
+
+
+def mw_search(server, query, num):
+    """
+    Searches the specified MediaWiki server for the given query, and returns
+    the specified number of results.
+    """
+    search_url = ('http://%s/w/api.php?format=json&action=query'
+                  '&list=search&srlimit=%d&srprop=timestamp&srwhat=text'
+                  '&srsearch=') % (server, num)
+    search_url += query
+    query = json.loads(requests.get(search_url).text)
+    if 'query' in query:
+        query = query['query']['search']
+        return [r['title'] for r in query]
+    else:
+        return None
+
+
+def say_snippet(bot, server, query, show_url=True):
+    page_name = query.replace('_', ' ')
+    query = query.replace(' ', '_')
+    snippet = mw_snippet(server, query)
+    msg = '[WIKIPEDIA] {} | "{}"'.format(page_name, snippet)
+    if show_url:
+        msg = msg + ' | https://{}/wiki/{}'.format(server, query)
+    bot.say(msg)
+
+
+def mw_snippet(server, query):
+    """
+    Retrives a snippet of the specified length from the given page on the given
+    server.
+    """
+    snippet_url = ('https://' + server + '/w/api.php?format=json'
+                   '&action=query&prop=extracts&exintro&explaintext'
+                   '&exchars=300&redirects&titles=')
+    snippet_url += query
+    snippet = json.loads(requests.get(snippet_url).text)
+    snippet = snippet['query']['pages']
+
+    # For some reason, the API gives the page *number* as the key, so we just
+    # grab the first page number in the results.
+    snippet = snippet[list(snippet.keys())[0]]
+
+    return snippet['extract']
+
+
+@rule('.*/([a-z]+\.wikipedia.org)/wiki/([^ ]+).*')
+def mw_info(bot, trigger, found_match=None):
+    """
+    Retrives a snippet of the specified length from the given page on the given
+    server.
+    """
+    match = found_match or trigger
+    say_snippet(bot, match.group(1), unquote(match.group(2)), show_url=False)
+
+
+@commands('w', 'wiki', 'wik')
+@example('.w San Francisco')
+def wikipedia(bot, trigger):
+    lang = bot.config.wikipedia.default_lang
+
+    #change lang if channel has custom language set
+    if (trigger.sender and not trigger.sender.is_nick() and
+            bot.config.wikipedia.lang_per_channel):
+        customlang = re.search('(' + trigger.sender + '):(\w+)',
+                               bot.config.wikipedia.lang_per_channel)
+        if customlang is not None:
+            lang = customlang.group(2)
+
+    if trigger.group(2) is None:
+        bot.reply("What do you want me to look up?")
+        return NOLIMIT
+
+    query = trigger.group(2)
+    args = re.search(r'^-([a-z]{2,12})\s(.*)', query)
+    if args is not None:
+        lang = args.group(1)
+        query = args.group(2)
+
+    if not query:
+        bot.reply('What do you want me to look up?')
+        return NOLIMIT
+    server = lang + '.wikipedia.org'
+    query = mw_search(server, query, 1)
+    if not query:
+        bot.reply("I can't find any results for that.")
+        return NOLIMIT
+    else:
+        query = query[0]
+    say_snippet(bot, server, query)

modules/wiktionary.py

@@ -0,0 +1,101 @@
+# coding=utf-8
+"""
+wiktionary.py - Sopel Wiktionary Module
+Copyright 2009, Sean B. Palmer, inamidst.com
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+
+import re
+import requests
+
+from module import commands, example
+
+uri = 'http://en.wiktionary.org/w/index.php?title={}&printable=yes'
+r_tag = re.compile(r'<[^>]+>')
+r_ul = re.compile(r'(?ims)<ul>.*?</ul>')
+
+
+def text(html):
+    text = r_tag.sub('', html).strip()
+    text = text.replace('\n', ' ')
+    text = text.replace('\r', '')
+    text = text.replace('(intransitive', '(intr.')
+    text = text.replace('(transitive', '(trans.')
+    return text
+
+
+def wikt(word):
+    bytes = requests.get(uri.format(word))
+    bytes = r_ul.sub('', bytes)
+
+    mode = None
+    etymology = None
+    definitions = {}
+    for line in bytes.splitlines():
+        if 'id="Etymology"' in line:
+            mode = 'etymology'
+        elif 'id="Noun"' in line:
+            mode = 'noun'
+        elif 'id="Verb"' in line:
+            mode = 'verb'
+        elif 'id="Adjective"' in line:
+            mode = 'adjective'
+        elif 'id="Adverb"' in line:
+            mode = 'adverb'
+        elif 'id="Interjection"' in line:
+            mode = 'interjection'
+        elif 'id="Particle"' in line:
+            mode = 'particle'
+        elif 'id="Preposition"' in line:
+            mode = 'preposition'
+        elif 'id="' in line:
+            mode = None
+
+        elif (mode == 'etmyology') and ('<p>' in line):
+            etymology = text(line)
+        elif (mode is not None) and ('<li>' in line):
+            definitions.setdefault(mode, []).append(text(line))
+
+        if '<hr' in line:
+            break
+    return etymology, definitions
+
+parts = ('preposition', 'particle', 'noun', 'verb',
+    'adjective', 'adverb', 'interjection')
+
+
+def format(result, definitions, number=2):
+    for part in parts:
+        if part in definitions:
+            defs = definitions[part][:number]
+            result += u' — {}: '.format(part)
+            n = ['%s. %s' % (i + 1, e.strip(' .')) for i, e in enumerate(defs)]
+            result += ', '.join(n)
+    return result.strip(' .,')
+
+
+@commands('wt', 'define', 'dict')
+@example('.wt bailiwick')
+def wiktionary(bot, trigger):
+    """Look up a word on Wiktionary."""
+    word = trigger.group(2)
+    if word is None:
+        bot.reply('You must tell me what to look up!')
+        return
+
+    _etymology, definitions = wikt(word)
+    if not definitions:
+        bot.say("Couldn't get any definitions for %s." % word)
+        return
+
+    result = format(word, definitions)
+    if len(result) < 150:
+        result = format(word, definitions, 3)
+    if len(result) < 150:
+        result = format(word, definitions, 5)
+
+    if len(result) > 300:
+        result = result[:295] + '[...]'
+    bot.say(result)

modules/willilike.py

@@ -0,0 +1,19 @@
+#! /usr/bin/env python3
+#-*- coding:utf-8 -*-
+"""
+Will I like this?
+"""
+import module
+
+@module.commands('willilike')
+@module.example('.willilike Banished Quest')
+def echo(bot, trigger):
+	"""An advanced AI that will determine if you like something."""
+	if trigger.group(2):
+		bot.reply("No.")
+
+@module.commands('upvote')
+@module.example('.willilike Banished Quest')
+def upvote(bot, trigger):
+	"""An advanced AI that will determine if you like something."""
+	bot.say(trigger.nick + " upvoted this post!")

modules/wolfram.py

@@ -0,0 +1,78 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Wolfram|Alpha module for Sopel IRC bot framework
+Forked from code by Max Gurela (@maxpowa):
+https://github.com/maxpowa/inumuta-modules/blob/e0b195c4f1e1b788fa77ec2144d39c4748886a6a/wolfram.py
+Updated and packaged for PyPI by dgw (@dgw)
+"""
+
+from config.types import StaticSection, ChoiceAttribute, ValidatedAttribute
+from module import commands, example
+import wolframalpha
+
+
+@commands('wa', 'wolfram')
+@example('.wa 2+2', '[W|A] 2+2 = 4')
+@example('.wa python language release date', '[W|A] Python | date introduced = 1991')
+def wa_command(bot, trigger):
+	msg = None
+	if not trigger.group(2):
+		msg = 'You must provide a query.'
+	if not bot.config.wolfram.app_id:
+		msg = 'Wolfram|Alpha API app ID not configured.'
+
+	lines = (msg or wa_query(bot.config.wolfram.app_id, trigger.group(2), bot.config.wolfram.units)).splitlines()
+
+
+	for line in lines:
+		bot.say('[\x0304Wolfram\x03] {}'.format(line))
+
+
+def wa_query(app_id, query, units='nonmetric'):
+	if not app_id:
+		return 'Wolfram|Alpha API app ID not provided.'
+	client = wolframalpha.Client(app_id)
+	query = query.encode('utf-8').strip()
+	params = (
+		('format', 'plaintext'),
+		('units', units),
+	)
+
+	try:
+		result = client.query(input=query, params=params)
+	except AssertionError:
+		return 'Temporary API issue. Try again in a moment.'
+	except Exception as e:
+		return 'Query failed: {} ({})'.format(type(e).__name__, e.message or 'Unknown error, try again!')
+
+	num_results = 0
+	try:
+		num_results = int(result['@numpods'])
+	finally:
+		if num_results == 0:
+			return 'No results found.'
+
+	texts = []
+	try:
+		for pod in result.pods:
+			try:
+				texts.append(pod.text)
+			except AttributeError:
+				pass  # pod with no text; skip it
+			except Exception:
+				raise  # raise unexpected exceptions to outer try for bug reports
+			if len(texts) >= 2:
+				break  # len() is O(1); this cheaply avoids copying more strings than needed
+	except Exception as e:
+		return 'Unhandled {}; please report this query ("{}") at https://dgw.me/wabug'.format(type(e).__name__, query)
+
+	try:
+		input, output = texts[0], texts[1]
+	except IndexError:
+		return 'No text-representable result found; see http://wolframalpha.com/input/?i={}'.format(query)
+
+	output = output.replace('\n', ' | ')
+	if not output:
+		return input
+	return '\x0310{} \x03= \x0312{}'.format(input, output)

modules/xkcd.py

@@ -0,0 +1,124 @@
+# coding=utf-8
+# Copyright 2010, Michael Yanovich (yanovich.net), and Morgan Goose
+# Copyright 2012, Lior Ramati
+# Copyright 2013, Elsie Powell (embolalia.com)
+# Licensed under the Eiffel Forum License 2.
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import random
+import re
+import requests
+from modules.search import google_search
+from module import commands, url
+
+ignored_sites = [
+    # For google searching
+    'almamater.xkcd.com',
+    'blog.xkcd.com',
+    'blag.xkcd.com',
+    'forums.xkcd.com',
+    'fora.xkcd.com',
+    'forums3.xkcd.com',
+    'store.xkcd.com',
+    'wiki.xkcd.com',
+    'what-if.xkcd.com',
+]
+sites_query = ' site:xkcd.com -site:' + ' -site:'.join(ignored_sites)
+
+
+def get_info(number=None, verify_ssl=True):
+    if number:
+        url = 'https://xkcd.com/{}/info.0.json'.format(number)
+    else:
+        url = 'https://xkcd.com/info.0.json'
+    data = requests.get(url, verify=verify_ssl).json()
+    data['url'] = 'https://xkcd.com/' + str(data['num'])
+    return data
+
+
+def google(query):
+    url = google_search(query + sites_query)
+    if not url:
+        return None
+    match = re.match('(?:https?://)?xkcd.com/(\d+)/?', url)
+    if match:
+        return match.group(1)
+
+
+@commands('xkcd')
+def xkcd(bot, trigger):
+    """
+    .xkcd - Finds an xkcd comic strip. Takes one of 3 inputs:
+    If no input is provided it will return a random comic
+    If numeric input is provided it will return that comic, or the nth-latest
+    comic if the number is non-positive
+    If non-numeric input is provided it will return the first google result for those keywords on the xkcd.com site
+    """
+    verify_ssl = bot.config.core.verify_ssl
+    # get latest comic for rand function and numeric input
+    latest = get_info(verify_ssl=verify_ssl)
+    max_int = latest['num']
+
+    # if no input is given (pre - lior's edits code)
+    if not trigger.group(2):  # get rand comic
+        random.seed()
+        requested = get_info(random.randint(1, max_int + 1),
+                             verify_ssl=verify_ssl)
+    else:
+        query = trigger.group(2).strip()
+
+        numbered = re.match(r"^(#|\+|-)?(\d+)$", query)
+        if numbered:
+            query = int(numbered.group(2))
+            if numbered.group(1) == "-":
+                query = -query
+            return numbered_result(bot, query, latest)
+        else:
+            # Non-number: google.
+            if (query.lower() == "latest" or query.lower() == "newest"):
+                requested = latest
+            else:
+                number = google(query)
+                if not number:
+                    bot.say('Could not find any comics for that query.')
+                    return
+                requested = get_info(number, verify_ssl=verify_ssl)
+
+    say_result(bot, requested)
+
+
+def numbered_result(bot, query, latest, verify_ssl=True):
+    max_int = latest['num']
+    if query > max_int:
+        bot.say(("Sorry, comic #{} hasn't been posted yet. "
+                    "The last comic was #{}").format(query, max_int))
+        return
+    elif query <= -max_int:
+        bot.say(("Sorry, but there were only {} comics "
+                    "released yet so far").format(max_int))
+        return
+    elif abs(query) == 0:
+        requested = latest
+    elif query == 404 or max_int + query == 404:
+        bot.say("404 - Not Found")  # don't error on that one
+        return
+    elif query > 0:
+        requested = get_info(query, verify_ssl=verify_ssl)
+    else:
+        # Negative: go back that many from current
+        requested = get_info(max_int + query, verify_ssl=verify_ssl)
+
+    say_result(bot, requested)
+
+
+def say_result(bot, result):
+    message = '{} | {} | Alt-text: {}'.format(result['url'], result['title'],
+                                              result['alt'])
+    bot.say(message)
+
+
+@url('xkcd.com/(\d+)')
+def get_url(bot, trigger, match):
+    verify_ssl = bot.config.core.verify_ssl
+    latest = get_info(verify_ssl=verify_ssl)
+    numbered_result(bot, int(match.group(1)), latest)

run_script.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python2.7
+# coding=utf-8
+"""
+Sopel - An IRC Bot
+Copyright 2008, Sean B. Palmer, inamidst.com
+Copyright © 2012-2014, Elad Alfassa <elad@fedoraproject.org>
+Licensed under the Eiffel Forum License 2.
+
+http://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import sys
+from tools import stderr
+
+if sys.version_info < (2, 7):
+    stderr('Error: Requires Python 2.7 or later. Try python2.7 sopel')
+    sys.exit(1)
+if sys.version_info.major == 3 and sys.version_info.minor < 3:
+    stderr('Error: When running on Python 3, Python 3.3 is required.')
+    sys.exit(1)
+
+import os
+import argparse
+import signal
+
+from __init__ import run, __version__
+from config import Config, _create_config, ConfigurationError, _wizard
+import tools as tools
+
+homedir = os.path.join(os.path.expanduser('~'), '.sopel')
+
+
+def enumerate_configs(extension='.cfg'):
+    configfiles = []
+    if os.path.isdir(homedir):
+        sopel_dotdirfiles = os.listdir(homedir)  # Preferred
+        for item in sopel_dotdirfiles:
+            if item.endswith(extension):
+                configfiles.append(item)
+
+    return configfiles
+
+
+def find_config(name, extension='.cfg'):
+    if os.path.isfile(name):
+        return name
+    configs = enumerate_configs(extension)
+    if name in configs or name + extension in configs:
+        if name + extension in configs:
+            name = name + extension
+
+    return os.path.join(homedir, name)
+
+
+def main(argv=None):
+    global homedir
+    # Step One: Parse The Command Line
+    try:
+        parser = argparse.ArgumentParser(description='Sopel IRC Bot',
+                                         usage='%(prog)s [options]')
+        parser.add_argument('-c', '--config', metavar='filename',
+                            help='use a specific configuration file')
+        parser.add_argument("-d", '--fork', action="store_true",
+                            dest="daemonize", help="Daemonize sopel")
+        parser.add_argument("-q", '--quit', action="store_true", dest="quit",
+                            help="Gracefully quit Sopel")
+        parser.add_argument("-k", '--kill', action="store_true", dest="kill",
+                            help="Kill Sopel")
+        parser.add_argument("-l", '--list', action="store_true",
+                            dest="list_configs",
+                            help="List all config files found")
+        parser.add_argument("-m", '--migrate', action="store_true",
+                            dest="migrate_configs",
+                            help="Migrate config files to the new format")
+        parser.add_argument('--quiet', action="store_true", dest="quiet",
+                            help="Supress all output")
+        parser.add_argument('-w', '--configure-all', action='store_true',
+                            dest='wizard', help='Run the configuration wizard.')
+        parser.add_argument('--configure-modules', action='store_true',
+                            dest='mod_wizard', help=(
+                                'Run the configuration wizard, but only for the '
+                                'module configuration options.'))
+        parser.add_argument('-v', '--version', action="store_true",
+                            dest="version", help="Show version number and exit")
+        if argv:
+            opts = parser.parse_args(argv)
+        else:
+            opts = parser.parse_args()
+
+        # Step Two: "Do not run as root" checks.
+        try:
+            # Linux/Mac
+            if os.getuid() == 0 or os.geteuid() == 0:
+                stderr('Error: Do not run Sopel with root privileges.')
+                sys.exit(1)
+        except AttributeError:
+            # Windows
+            if os.environ.get("USERNAME") == "Administrator":
+                stderr('Error: Do not run Sopel as Administrator.')
+                sys.exit(1)
+
+        if opts.version:
+            py_ver = '%s.%s.%s' % (sys.version_info.major,
+                                   sys.version_info.minor,
+                                   sys.version_info.micro)
+            print('Sopel %s (running on python %s)' % (__version__, py_ver))
+            print('http://sopel.chat/')
+            return
+        elif opts.wizard:
+            _wizard('all', opts.config)
+            return
+        elif opts.mod_wizard:
+            _wizard('mod', opts.config)
+            return
+
+        if opts.list_configs:
+            configs = enumerate_configs()
+            print('Config files in ~/.sopel:')
+            if len(configs) is 0:
+                print('\tNone found')
+            else:
+                for config in configs:
+                    print('\t%s' % config)
+            print('-------------------------')
+            return
+
+        config_name = opts.config or 'default'
+
+        configpath = find_config(config_name)
+        if not os.path.isfile(configpath):
+            print("Welcome to Sopel!\nI can't seem to find the configuration file, so let's generate it!\n")
+            if not configpath.endswith('.cfg'):
+                configpath = configpath + '.cfg'
+            _create_config(configpath)
+            configpath = find_config(config_name)
+        try:
+            config_module = Config(configpath)
+        except ConfigurationError as e:
+            stderr(e)
+            sys.exit(2)
+
+        if config_module.core.not_configured:
+            stderr('Bot is not configured, can\'t start')
+            # exit with code 2 to prevent auto restart on fail by systemd
+            sys.exit(2)
+
+        logfile = os.path.os.path.join(config_module.core.logdir, 'stdio.log')
+
+        config_module._is_daemonized = opts.daemonize
+
+        sys.stderr = tools.OutputRedirect(logfile, True, opts.quiet)
+        sys.stdout = tools.OutputRedirect(logfile, False, opts.quiet)
+
+        # Handle --quit, --kill and saving the PID to file
+        pid_dir = config_module.core.pid_dir
+        if opts.config is None:
+            pid_file_path = os.path.join(pid_dir, 'sopel.pid')
+        else:
+            basename = os.path.basename(opts.config)
+            if basename.endswith('.cfg'):
+                basename = basename[:-4]
+            pid_file_path = os.path.join(pid_dir, 'sopel-%s.pid' % basename)
+        if os.path.isfile(pid_file_path):
+            with open(pid_file_path, 'r') as pid_file:
+                try:
+                    old_pid = int(pid_file.read())
+                except ValueError:
+                    old_pid = None
+            if old_pid is not None and tools.check_pid(old_pid):
+                if not opts.quit and not opts.kill:
+                    stderr('There\'s already a Sopel instance running with this config file')
+                    stderr('Try using the --quit or the --kill options')
+                    sys.exit(1)
+                elif opts.kill:
+                    stderr('Killing the sopel')
+                    os.kill(old_pid, signal.SIGKILL)
+                    sys.exit(0)
+                elif opts.quit:
+                    stderr('Signaling Sopel to stop gracefully')
+                    if hasattr(signal, 'SIGUSR1'):
+                        os.kill(old_pid, signal.SIGUSR1)
+                    else:
+                        os.kill(old_pid, signal.SIGTERM)
+                    sys.exit(0)
+            elif opts.kill or opts.quit:
+                stderr('Sopel is not running!')
+                sys.exit(1)
+        elif opts.quit or opts.kill:
+            stderr('Sopel is not running!')
+            sys.exit(1)
+        if opts.daemonize:
+            child_pid = os.fork()
+            if child_pid is not 0:
+                sys.exit()
+        with open(pid_file_path, 'w') as pid_file:
+            pid_file.write(str(os.getpid()))
+
+        # Step Five: Initialise And Run sopel
+        run(config_module, pid_file_path)
+    except KeyboardInterrupt:
+        print("\n\nInterrupted")
+        os._exit(1)
+if __name__ == '__main__':
+    main()

sopel

@@ -0,0 +1,11 @@
+#!/usr/bin/python3
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from run_script import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

test/test_config.py

@@ -0,0 +1,36 @@
+# coding=utf-8
+from __future__ import unicode_literals, division, print_function, absolute_import
+
+import os
+import tempfile
+import unittest
+from sopel import config
+from sopel.config import types
+
+
+class FakeConfigSection(types.StaticSection):
+    attr = types.ValidatedAttribute('attr')
+
+
+class ConfigFunctionalTest(unittest.TestCase):
+    def read_config(self):
+        configo = config.Config(self.filename)
+        configo.define_section('fake', FakeConfigSection)
+        return configo
+
+    def setUp(self):
+        self.filename = tempfile.mkstemp()[1]
+        with open(self.filename, 'w') as fileo:
+            fileo.write(
+                "[core]\n"
+                "owner=embolalia"
+            )
+
+        self.config = self.read_config()
+
+    def tearDown(self):
+        os.remove(self.filename)
+
+    def test_validated_string_when_none(self):
+        self.config.fake.attr = None
+        self.assertEquals(self.config.fake.attr, None)

test/test_db.py

@@ -0,0 +1,257 @@
+# coding=utf-8
+"""Tests for the new database functionality.
+
+TODO: Most of these tests assume functionality tested in other tests. This is
+enough to get everything working (and is better than nothing), but best
+practice would probably be not to do that."""
+from __future__ import unicode_literals
+from __future__ import absolute_import
+
+import json
+import os
+import sqlite3
+import sys
+import tempfile
+
+import pytest
+
+from sopel.db import SopelDB
+from sopel.test_tools import MockConfig
+from sopel.tools import Identifier
+
+db_filename = tempfile.mkstemp()[1]
+if sys.version_info.major >= 3:
+    unicode = str
+    basestring = str
+    iteritems = dict.items
+    itervalues = dict.values
+    iterkeys = dict.keys
+else:
+    iteritems = dict.iteritems
+    itervalues = dict.itervalues
+    iterkeys = dict.iterkeys
+
+
+@pytest.fixture
+def db():
+    config = MockConfig()
+    config.core.db_filename = db_filename
+    db = SopelDB(config)
+    # TODO add tests to ensure db creation works properly, too.
+    return db
+
+
+def teardown_function(function):
+    os.remove(db_filename)
+
+
+def test_get_nick_id(db):
+    conn = sqlite3.connect(db_filename)
+    tests = [
+        [None, 'embolalia', Identifier('Embolalia')],
+        # Ensures case conversion is handled properly
+        [None, '[][]', Identifier('[]{}')],
+        # Unicode, just in case
+        [None, 'embölaliå', Identifier('EmbölaliÅ')],
+    ]
+
+    for test in tests:
+        test[0] = db.get_nick_id(test[2])
+        nick_id, slug, nick = test
+        with conn:
+            cursor = conn.cursor()
+            registered = cursor.execute(
+                'SELECT nick_id, slug, canonical FROM nicknames WHERE canonical IS ?', [nick]
+            ).fetchall()
+            assert len(registered) == 1
+            assert registered[0][1] == slug and registered[0][2] == nick
+
+    # Check that each nick ended up with a different id
+    assert len(set(test[0] for test in tests)) == len(tests)
+
+    # Check that the retrieval actually is idempotent
+    for test in tests:
+        nick_id = test[0]
+        new_id = db.get_nick_id(test[2])
+        assert nick_id == new_id
+
+    # Even if the case is different
+    for test in tests:
+        nick_id = test[0]
+        new_id = db.get_nick_id(Identifier(test[2].upper()))
+        assert nick_id == new_id
+
+
+def test_alias_nick(db):
+    nick = 'Embolalia'
+    aliases = ['EmbölaliÅ', 'Embo`work', 'Embo']
+
+    nick_id = db.get_nick_id(nick)
+    for alias in aliases:
+        db.alias_nick(nick, alias)
+
+    for alias in aliases:
+        assert db.get_nick_id(alias) == nick_id
+
+    db.alias_nick('both', 'arenew')  # Shouldn't fail.
+
+    with pytest.raises(ValueError):
+        db.alias_nick('Eve', nick)
+
+    with pytest.raises(ValueError):
+        db.alias_nick(nick, nick)
+
+
+def test_set_nick_value(db):
+    conn = sqlite3.connect(db_filename)
+    cursor = conn.cursor()
+    nick = 'Embolalia'
+    nick_id = db.get_nick_id(nick)
+    data = {
+        'key': 'value',
+        'number_key': 1234,
+        'unicode': 'EmbölaliÅ',
+    }
+
+    def check():
+        for key, value in iteritems(data):
+            db.set_nick_value(nick, key, value)
+
+        for key, value in iteritems(data):
+            found_value = cursor.execute(
+                'SELECT value FROM nick_values WHERE nick_id = ? AND key = ?',
+                [nick_id, key]
+            ).fetchone()[0]
+            assert json.loads(unicode(found_value)) == value
+    check()
+
+    # Test updates
+    data['number_key'] = 'not a number anymore!'
+    data['unicode'] = 'This is different toö!'
+    check()
+
+
+def test_get_nick_value(db):
+    conn = sqlite3.connect(db_filename)
+    cursor = conn.cursor()
+    nick = 'Embolalia'
+    nick_id = db.get_nick_id(nick)
+    data = {
+        'key': 'value',
+        'number_key': 1234,
+        'unicode': 'EmbölaliÅ',
+    }
+
+    for key, value in iteritems(data):
+        cursor.execute('INSERT INTO nick_values VALUES (?, ?, ?)',
+                       [nick_id, key, json.dumps(value, ensure_ascii=False)])
+    conn.commit()
+
+    for key, value in iteritems(data):
+        found_value = db.get_nick_value(nick, key)
+        assert found_value == value
+
+
+def test_unalias_nick(db):
+    conn = sqlite3.connect(db_filename)
+    nick = 'Embolalia'
+    nick_id = 42
+    conn.execute('INSERT INTO nicknames VALUES (?, ?, ?)',
+                 [nick_id, Identifier(nick).lower(), nick])
+    aliases = ['EmbölaliÅ', 'Embo`work', 'Embo']
+    for alias in aliases:
+        conn.execute('INSERT INTO nicknames VALUES (?, ?, ?)',
+                     [nick_id, Identifier(alias).lower(), alias])
+    conn.commit()
+
+    for alias in aliases:
+        db.unalias_nick(alias)
+
+    for alias in aliases:
+        found = conn.execute(
+            'SELECT * FROM nicknames WHERE nick_id = ?',
+            [nick_id]).fetchall()
+        assert len(found) == 1
+
+
+def test_delete_nick_group(db):
+    conn = sqlite3.connect(db_filename)
+    aliases = ['Embolalia', 'Embo']
+    nick_id = 42
+    for alias in aliases:
+        conn.execute('INSERT INTO nicknames VALUES (?, ?, ?)',
+                     [nick_id, Identifier(alias).lower(), alias])
+    conn.commit()
+
+    db.set_nick_value(aliases[0], 'foo', 'bar')
+    db.set_nick_value(aliases[1], 'spam', 'eggs')
+
+    db.delete_nick_group(aliases[0])
+
+    # Nothing else has created values, so we know the tables are empty
+    nicks = conn.execute('SELECT * FROM nicknames').fetchall()
+    assert len(nicks) == 0
+    data = conn.execute('SELECT * FROM nick_values').fetchone()
+    assert data is None
+
+
+def test_merge_nick_groups(db):
+    conn = sqlite3.connect(db_filename)
+    aliases = ['Embolalia', 'Embo']
+    for nick_id, alias in enumerate(aliases):
+        conn.execute('INSERT INTO nicknames VALUES (?, ?, ?)',
+                     [nick_id, Identifier(alias).lower(), alias])
+    conn.commit()
+
+    finals = (('foo', 'bar'), ('bar', 'blue'), ('spam', 'eggs'))
+
+    db.set_nick_value(aliases[0], finals[0][0], finals[0][1])
+    db.set_nick_value(aliases[0], finals[1][0], finals[1][1])
+    db.set_nick_value(aliases[1], 'foo', 'baz')
+    db.set_nick_value(aliases[1], finals[2][0], finals[2][1])
+
+    db.merge_nick_groups(aliases[0], aliases[1])
+
+    nick_ids = conn.execute('SELECT nick_id FROM nicknames')
+    nick_id = nick_ids.fetchone()[0]
+    alias_id = nick_ids.fetchone()[0]
+    assert nick_id == alias_id
+
+    for key, value in finals:
+        found = conn.execute(
+            'SELECT value FROM nick_values WHERE nick_id = ? AND key = ?',
+            [nick_id, key]).fetchone()[0]
+        assert json.loads(unicode(found)) == value
+
+
+def test_set_channel_value(db):
+    conn = sqlite3.connect(db_filename)
+    db.set_channel_value('#asdf', 'qwer', 'zxcv')
+    result = conn.execute(
+        'SELECT value FROM channel_values WHERE channel = ? and key = ?',
+        ['#asdf', 'qwer']).fetchone()[0]
+    assert result == '"zxcv"'
+
+
+def test_get_channel_value(db):
+    conn = sqlite3.connect(db_filename)
+    conn.execute("INSERT INTO channel_values VALUES ('#asdf', 'qwer', '\"zxcv\"')")
+    conn.commit()
+    result = db.get_channel_value('#asdf', 'qwer')
+    assert result == 'zxcv'
+
+
+def test_get_nick_or_channel_value(db):
+    db.set_nick_value('asdf', 'qwer', 'poiu')
+    db.set_channel_value('#asdf', 'qwer', '/.,m')
+    assert db.get_nick_or_channel_value('asdf', 'qwer') == 'poiu'
+    assert db.get_nick_or_channel_value('#asdf', 'qwer') == '/.,m'
+
+
+def test_get_preferred_value(db):
+    db.set_nick_value('asdf', 'qwer', 'poiu')
+    db.set_channel_value('#asdf', 'qwer', '/.,m')
+    db.set_channel_value('#asdf', 'lkjh', '1234')
+    names = ['asdf', '#asdf']
+    assert db.get_preferred_value(names, 'qwer') == 'poiu'
+    assert db.get_preferred_value(names, 'lkjh') == '1234'

test/test_formatting.py

@@ -0,0 +1,26 @@
+# coding=utf-8
+"""Tests for message formatting"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import pytest
+
+from sopel.formatting import colors, color, bold, underline
+
+
+def test_color():
+    text = 'Hello World'
+    assert color(text) == text
+    assert color(text, colors.PINK) == '\x0313' + text + '\x03'
+    assert color(text, colors.PINK, colors.TEAL) == '\x0313,10' + text + '\x03'
+    pytest.raises(ValueError, color, text, 100)
+    pytest.raises(ValueError, color, text, 'INVALID')
+
+
+def test_bold():
+    text = 'Hello World'
+    assert bold(text) == '\x02' + text + '\x02'
+
+
+def test_underline():
+    text = 'Hello World'
+    assert underline(text) == '\x1f' + text + '\x1f'

test/test_irc.py

@@ -0,0 +1,147 @@
+# coding=utf8
+"""Tests for message formatting"""
+from __future__ import unicode_literals
+
+import pytest
+
+import asynchat
+import os
+import shutil
+import socket
+import select
+import tempfile
+import threading
+import time
+import asyncore
+
+from sopel import irc
+from sopel.tools import stderr, Identifier
+import sopel.config as conf
+
+
+HOST = '127.0.0.1'
+SERVER_QUIT = 'QUIT'
+
+
+class BasicServer(asyncore.dispatcher):
+    def __init__(self, address, handler):
+        asyncore.dispatcher.__init__(self)
+        self.response_handler = handler
+        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.bind(address)
+        self.address = self.socket.getsockname()
+        self.listen(1)
+        return
+
+    def handle_accept(self):
+        # Called when a client connects to our socket
+        client_info = self.accept()
+        BasicHandler(sock=client_info[0], handler=self.response_handler)
+        self.handle_close()
+        return
+
+    def handle_close(self):
+        self.close()
+
+class BasicHandler(asynchat.async_chat):
+    ac_in_buffer_size = 512
+    ac_out_buffer_size = 512
+
+    def __init__(self, sock, handler):
+        self.received_data = []
+        asynchat.async_chat.__init__(self, sock)
+        self.handler_function = handler
+        self.set_terminator(b'\n')
+        return
+
+    def collect_incoming_data(self, data):
+        self.received_data.append(data.decode('utf-8'))
+
+    def found_terminator(self):
+        self._process_command()
+
+    def _process_command(self):
+        command = ''.join(self.received_data)
+        response = self.handler_function(self, command)
+        self.push(':fake.server {}\n'.format(response).encode())
+        self.received_data = []
+
+
+def start_server(rpl_function=None):
+    def rpl_func(msg):
+        print(msg)
+        return msg
+
+    if rpl_function is None:
+        rpl_function = rpl_func
+
+    address = ('localhost', 0) # let the kernel give us a port
+    server = BasicServer(address, rpl_function)
+    return server
+
+
+@pytest.fixture
+def bot(request):
+    cfg_dir = tempfile.mkdtemp()
+    print(cfg_dir)
+    filename = tempfile.mkstemp(dir=cfg_dir)[1]
+    os.mkdir(os.path.join(cfg_dir, 'modules'))
+    def fin():
+        print('teardown config file')
+        shutil.rmtree(cfg_dir)
+    request.addfinalizer(fin)
+
+    def gen(data):
+        with open(filename, 'w') as fileo:
+            fileo.write(data)
+        cfg = conf.Config(filename)
+        irc_bot = irc.Bot(cfg)
+        irc_bot.config = cfg
+        return irc_bot
+
+    return gen
+
+
+def test_bot_init(bot):
+    test_bot = bot(
+        '[core]\n'
+        'owner=Baz\n'
+        'nick=Foo\n'
+        'user=Bar\n'
+        'name=Sopel\n'
+    )
+    assert test_bot.nick == Identifier('Foo')
+    assert test_bot.user == 'Bar'
+    assert test_bot.name == 'Sopel'
+
+
+def basic_irc_replies(server, msg):
+    if msg.startswith('NICK'):
+        return '001 Foo :Hello'
+    elif msg.startswith('USER'):
+        # Quit here because good enough
+        server.close()
+    elif msg.startswith('PING'):
+        return 'PONG{}'.format(msg.replace('PING','',1))
+    elif msg.startswith('CAP'):
+        return 'CAP * :'
+    elif msg.startswith('QUIT'):
+        server.close()
+    else:
+        return '421 {} :Unknown command'.format(msg)
+
+
+def test_bot_connect(bot):
+    test_bot = bot(
+        '[core]\n'
+        'owner=Baz\n'
+        'nick=Foo\n'
+        'user=Bar\n'
+        'name=Sopel\n'
+        'host=127.0.0.1\n'
+        'timeout=10\n'
+    )
+    s = start_server(basic_irc_replies)
+
+    # Do main run
+    test_bot.run(HOST, s.address[1])

test/test_module.py

@@ -0,0 +1,210 @@
+# coding=utf-8
+"""Tests for message formatting"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import pytest
+
+from sopel.trigger import PreTrigger, Trigger
+from sopel.test_tools import MockSopel, MockSopelWrapper
+from sopel.tools import Identifier
+from sopel import module
+
+
+@pytest.fixture
+def sopel():
+    bot = MockSopel('Sopel')
+    bot.config.core.owner = 'Bar'
+    return bot
+
+
+@pytest.fixture
+def bot(sopel, pretrigger):
+    bot = MockSopelWrapper(sopel, pretrigger)
+    bot.privileges = dict()
+    bot.privileges[Identifier('#Sopel')] = dict()
+    bot.privileges[Identifier('#Sopel')][Identifier('Foo')] = module.VOICE
+    return bot
+
+
+@pytest.fixture
+def pretrigger():
+    line = ':Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    return PreTrigger(Identifier('Foo'), line)
+
+
+@pytest.fixture
+def pretrigger_pm():
+    line = ':Foo!foo@example.com PRIVMSG Sopel :Hello, world'
+    return PreTrigger(Identifier('Foo'), line)
+
+
+@pytest.fixture
+def trigger_owner(bot):
+    line = ':Bar!bar@example.com PRIVMSG #Sopel :Hello, world'
+    return Trigger(bot.config, PreTrigger(Identifier('Bar'), line), None)
+
+
+@pytest.fixture
+def trigger(bot, pretrigger):
+    return Trigger(bot.config, pretrigger, None)
+
+
+@pytest.fixture
+def trigger_pm(bot, pretrigger_pm):
+    return Trigger(bot.config, pretrigger_pm, None)
+
+
+def test_unblockable():
+    @module.unblockable
+    def mock(bot, trigger, match):
+        return True
+    assert mock.unblockable is True
+
+
+def test_interval():
+    @module.interval(5)
+    def mock(bot, trigger, match):
+        return True
+    assert mock.interval == [5]
+
+
+def test_rule():
+    @module.rule('.*')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.rule == ['.*']
+
+
+def test_thread():
+    @module.thread(True)
+    def mock(bot, trigger, match):
+        return True
+    assert mock.thread is True
+
+
+def test_commands():
+    @module.commands('sopel')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.commands == ['sopel']
+
+
+def test_nick_commands():
+    @module.nickname_commands('sopel')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.rule == ["""
+        ^
+        $nickname[:,]? # Nickname.
+        \s+(sopel) # Command as group 1.
+        (?:\s+         # Whitespace to end command.
+        (              # Rest of the line as group 2.
+        (?:(\S+))?     # Parameters 1-4 as groups 3-6.
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        .*             # Accept anything after the parameters. Leave it up to
+                       # the module to parse the line.
+        ))?            # Group 1 must be None, if there are no parameters.
+        $              # EoL, so there are no partial matches.
+        """]
+
+
+def test_priority():
+    @module.priority('high')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.priority == 'high'
+
+
+def test_event():
+    @module.event('301')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.event == ['301']
+
+
+def test_intent():
+    @module.intent('ACTION')
+    def mock(bot, trigger, match):
+        return True
+    assert mock.intents == ['ACTION']
+
+
+def test_rate():
+    @module.rate(5)
+    def mock(bot, trigger, match):
+        return True
+    assert mock.rate == 5
+
+
+def test_require_privmsg(bot, trigger, trigger_pm):
+    @module.require_privmsg('Try again in a PM')
+    def mock(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is not True
+    assert mock(bot, trigger_pm) is True
+
+    @module.require_privmsg
+    def mock_(bot, trigger, match=None):
+        return True
+    assert mock_(bot, trigger) is not True
+    assert mock_(bot, trigger_pm) is True
+
+
+def test_require_chanmsg(bot, trigger, trigger_pm):
+    @module.require_chanmsg('Try again in a channel')
+    def mock(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is True
+    assert mock(bot, trigger_pm) is not True
+
+    @module.require_chanmsg
+    def mock_(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is True
+    assert mock(bot, trigger_pm) is not True
+
+
+def test_require_privilege(bot, trigger):
+    @module.require_privilege(module.VOICE)
+    def mock_v(bot, trigger, match=None):
+        return True
+    assert mock_v(bot, trigger) is True
+
+    @module.require_privilege(module.OP, 'You must be at least opped!')
+    def mock_o(bot, trigger, match=None):
+        return True
+    assert mock_o(bot, trigger) is not True
+
+
+def test_require_admin(bot, trigger, trigger_owner):
+    @module.require_admin('You must be an admin')
+    def mock(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is not True
+
+    @module.require_admin
+    def mock_(bot, trigger, match=None):
+        return True
+    assert mock_(bot, trigger_owner) is True
+
+
+def test_require_owner(bot, trigger, trigger_owner):
+    @module.require_owner('You must be an owner')
+    def mock(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is not True
+
+    @module.require_owner
+    def mock_(bot, trigger, match=None):
+        return True
+    assert mock_(bot, trigger_owner) is True
+
+
+def test_example(bot, trigger):
+    @module.commands('mock')
+    @module.example('.mock', 'True')
+    def mock(bot, trigger, match=None):
+        return True
+    assert mock(bot, trigger) is True

test/test_trigger.py

@@ -0,0 +1,245 @@
+# coding=utf-8
+"""Tests for message parsing"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+import pytest
+import datetime
+
+from sopel.test_tools import MockConfig
+from sopel.trigger import PreTrigger, Trigger
+from sopel.tools import Identifier
+
+
+@pytest.fixture
+def nick():
+    return Identifier('Sopel')
+
+
+def test_basic_pretrigger(nick):
+    line = ':Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['#Sopel', 'Hello, world']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == '#Sopel'
+
+
+def test_pm_pretrigger(nick):
+    line = ':Foo!foo@example.com PRIVMSG Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['Sopel', 'Hello, world']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == Identifier('Foo')
+
+
+def test_quit_pretrigger(nick):
+    line = ':Foo!foo@example.com QUIT :quit message text'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['quit message text']
+    assert pretrigger.event == 'QUIT'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender is None
+
+
+def test_join_pretrigger(nick):
+    line = ':Foo!foo@example.com JOIN #Sopel'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['#Sopel']
+    assert pretrigger.event == 'JOIN'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == Identifier('#Sopel')
+
+
+def test_tags_pretrigger(nick):
+    line = '@foo=bar;baz;sopel.chat/special=value :Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {'baz': None,
+                               'foo': 'bar',
+                               'sopel.chat/special': 'value'}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['#Sopel', 'Hello, world']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == '#Sopel'
+
+
+def test_intents_pretrigger(nick):
+    line = '@intent=ACTION :Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {'intent': 'ACTION'}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['#Sopel', 'Hello, world']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == '#Sopel'
+
+
+def test_unusual_pretrigger(nick):
+    line = 'PING'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {}
+    assert pretrigger.hostmask is None
+    assert pretrigger.line == line
+    assert pretrigger.args == []
+    assert pretrigger.event == 'PING'
+
+
+def test_ctcp_intent_pretrigger(nick):
+    line = ':Foo!foo@example.com PRIVMSG Sopel :\x01VERSION\x01'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {'intent': 'VERSION'}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['Sopel', '']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == Identifier('Foo')
+
+
+def test_ctcp_data_pretrigger(nick):
+    line = ':Foo!foo@example.com PRIVMSG Sopel :\x01PING 1123321\x01'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {'intent': 'PING'}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['Sopel', '1123321']
+    assert pretrigger.event == 'PRIVMSG'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == Identifier('Foo')
+
+
+def test_ircv3_extended_join_pretrigger(nick):
+    line = ':Foo!foo@example.com JOIN #Sopel bar :Real Name'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.tags == {'account': 'bar'}
+    assert pretrigger.hostmask == 'Foo!foo@example.com'
+    assert pretrigger.line == line
+    assert pretrigger.args == ['#Sopel', 'bar', 'Real Name']
+    assert pretrigger.event == 'JOIN'
+    assert pretrigger.nick == Identifier('Foo')
+    assert pretrigger.user == 'foo'
+    assert pretrigger.host == 'example.com'
+    assert pretrigger.sender == Identifier('#Sopel')
+
+
+def test_ircv3_extended_join_trigger(nick):
+    line = ':Foo!foo@example.com JOIN #Sopel bar :Real Name'
+    pretrigger = PreTrigger(nick, line)
+
+    config = MockConfig()
+    config.core.owner_account = 'bar'
+
+    fakematch = re.match('.*', line)
+
+    trigger = Trigger(config, pretrigger, fakematch)
+    assert trigger.sender == '#Sopel'
+    assert trigger.raw == line
+    assert trigger.is_privmsg is False
+    assert trigger.hostmask == 'Foo!foo@example.com'
+    assert trigger.user == 'foo'
+    assert trigger.nick == Identifier('Foo')
+    assert trigger.host == 'example.com'
+    assert trigger.event == 'JOIN'
+    assert trigger.match == fakematch
+    assert trigger.group == fakematch.group
+    assert trigger.groups == fakematch.groups
+    assert trigger.args == ['#Sopel', 'bar', 'Real Name']
+    assert trigger.account == 'bar'
+    assert trigger.tags == {'account': 'bar'}
+    assert trigger.owner is True
+    assert trigger.admin is True
+
+
+def test_ircv3_intents_trigger(nick):
+    line = '@intent=ACTION :Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+
+    config = MockConfig()
+    config.core.owner = 'Foo'
+    config.core.admins = ['Bar']
+
+    fakematch = re.match('.*', line)
+
+    trigger = Trigger(config, pretrigger, fakematch)
+    assert trigger.sender == '#Sopel'
+    assert trigger.raw == line
+    assert trigger.is_privmsg is False
+    assert trigger.hostmask == 'Foo!foo@example.com'
+    assert trigger.user == 'foo'
+    assert trigger.nick == Identifier('Foo')
+    assert trigger.host == 'example.com'
+    assert trigger.event == 'PRIVMSG'
+    assert trigger.match == fakematch
+    assert trigger.group == fakematch.group
+    assert trigger.groups == fakematch.groups
+    assert trigger.groupdict == fakematch.groupdict
+    assert trigger.args == ['#Sopel', 'Hello, world']
+    assert trigger.tags == {'intent': 'ACTION'}
+    assert trigger.admin is True
+    assert trigger.owner is True
+
+
+def test_ircv3_account_tag_trigger(nick):
+    line = '@account=Foo :Nick_Is_Not_Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+
+    config = MockConfig()
+    config.core.owner_account = 'Foo'
+    config.core.admins = ['Bar']
+
+    fakematch = re.match('.*', line)
+
+    trigger = Trigger(config, pretrigger, fakematch)
+    assert trigger.admin is True
+    assert trigger.owner is True
+
+
+def test_ircv3_server_time_trigger(nick):
+    line = '@time=2016-01-09T03:15:42.000Z :Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+
+    config = MockConfig()
+    config.core.owner = 'Foo'
+    config.core.admins = ['Bar']
+
+    fakematch = re.match('.*', line)
+
+    trigger = Trigger(config, pretrigger, fakematch)
+    assert trigger.time == datetime.datetime(2016, 1, 9, 3, 15, 42, 0)
+
+    # Spec-breaking string
+    line = '@time=2016-01-09T04:20 :Foo!foo@example.com PRIVMSG #Sopel :Hello, world'
+    pretrigger = PreTrigger(nick, line)
+    assert pretrigger.time is not None

test_tools.py

@@ -0,0 +1,183 @@
+# coding=utf-8
+"""This module has classes and functions that can help in writing tests.
+
+test_tools.py - Sopel misc tools
+Copyright 2013, Ari Koivula, <ari@koivu.la>
+Licensed under the Eiffel Forum License 2.
+
+https://sopel.chat
+"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import os
+import re
+import sys
+import tempfile
+
+try:
+    import ConfigParser
+except ImportError:
+    import configparser as ConfigParser
+
+import config
+import config.core_section
+import tools
+import trigger
+
+
+class MockConfig(config.Config):
+    def __init__(self):
+        self.filename = tempfile.mkstemp()[1]
+        #self._homedir = tempfile.mkdtemp()
+        #self.filename = os.path.join(self._homedir, 'test.cfg')
+        self.parser = ConfigParser.RawConfigParser(allow_no_value=True)
+        self.parser.add_section('core')
+        self.parser.set('core', 'owner', 'Embolalia')
+        self.define_section('core', sopel.config.core_section.CoreSection)
+        self.get = self.parser.get
+
+    def define_section(self, name, cls_):
+        if not self.parser.has_section(name):
+            self.parser.add_section(name)
+        setattr(self, name, cls_(self, name))
+
+
+class MockSopel(object):
+    def __init__(self, nick, admin=False, owner=False):
+        self.nick = nick
+        self.user = "sopel"
+
+        self.channels = ["#channel"]
+
+        self.memory = sopel.tools.SopelMemory()
+
+        self.ops = {}
+        self.halfplus = {}
+        self.voices = {}
+
+        self.config = MockConfig()
+        self._init_config()
+
+        if admin:
+            self.config.core.admins = [self.nick]
+        if owner:
+            self.config.core.owner = self.nick
+
+    def _init_config(self):
+        cfg = self.config
+        cfg.parser.set('core', 'admins', '')
+        cfg.parser.set('core', 'owner', '')
+        home_dir = os.path.join(os.path.expanduser('~'), '.sopel')
+        if not os.path.exists(home_dir):
+            os.mkdir(home_dir)
+        cfg.parser.set('core', 'homedir', home_dir)
+
+
+class MockSopelWrapper(object):
+    def __init__(self, bot, pretrigger):
+        self.bot = bot
+        self.pretrigger = pretrigger
+        self.output = []
+
+    def _store(self, string, recipent=None):
+        self.output.append(string.strip())
+
+    say = reply = action = _store
+
+    def __getattr__(self, attr):
+        return getattr(self.bot, attr)
+
+
+def get_example_test(tested_func, msg, results, privmsg, admin,
+                     owner, repeat, use_regexp, ignore=[]):
+    """Get a function that calls tested_func with fake wrapper and trigger.
+
+    Args:
+        tested_func - A sopel callable that accepts SopelWrapper and Trigger.
+        msg - Message that is supposed to trigger the command.
+        results - Expected output from the callable.
+        privmsg - If true, make the message appear to have sent in a private
+            message to the bot. If false, make it appear to have come from a
+            channel.
+        admin - If true, make the message appear to have come from an admin.
+        owner - If true, make the message appear to have come from an owner.
+        repeat - How many times to repeat the test. Usefull for tests that
+            return random stuff.
+        use_regexp = Bool. If true, results is in regexp format.
+        ignore - List of strings to ignore.
+
+    """
+    def test():
+        bot = MockSopel("NickName", admin=admin, owner=owner)
+
+        match = None
+        if hasattr(tested_func, "commands"):
+            for command in tested_func.commands:
+                regexp = sopel.tools.get_command_regexp(".", command)
+                match = regexp.match(msg)
+                if match:
+                    break
+        assert match, "Example did not match any command."
+
+        sender = bot.nick if privmsg else "#channel"
+        hostmask = "%s!%s@%s " % (bot.nick, "UserName", "example.com")
+        # TODO enable message tags
+        full_message = ':{} PRIVMSG {} :{}'.format(hostmask, sender, msg)
+
+        pretrigger = sopel.trigger.PreTrigger(bot.nick, full_message)
+        trigger = sopel.trigger.Trigger(bot.config, pretrigger, match)
+
+        module = sys.modules[tested_func.__module__]
+        if hasattr(module, 'setup'):
+            module.setup(bot)
+
+        def isnt_ignored(value):
+            """Return True if value doesn't match any re in ignore list."""
+            for ignored_line in ignore:
+                if re.match(ignored_line, value):
+                    return False
+            return True
+
+        for _i in range(repeat):
+            wrapper = MockSopelWrapper(bot, trigger)
+            tested_func(wrapper, trigger)
+            wrapper.output = list(filter(isnt_ignored, wrapper.output))
+            assert len(wrapper.output) == len(results)
+            for result, output in zip(results, wrapper.output):
+                if type(output) is bytes:
+                    output = output.decode('utf-8')
+                if use_regexp:
+                    if not re.match(result, output):
+                        assert result == output
+                else:
+                    assert result == output
+
+    return test
+
+
+def insert_into_module(func, module_name, base_name, prefix):
+    """Add a function into a module."""
+    func.__module__ = module_name
+    module = sys.modules[module_name]
+    # Make sure the func method does not overwrite anything.
+    for i in range(1000):
+        func.__name__ = str("%s_%s_%s" % (prefix, base_name, i))
+        if not hasattr(module, func.__name__):
+            break
+    setattr(module, func.__name__, func)
+
+
+def run_example_tests(filename, tb='native', multithread=False, verbose=False):
+    # These are only required when running tests, so import them here rather
+    # than at the module level.
+    import pytest
+    from multiprocessing import cpu_count
+
+    args = [filename, "-s"]
+    args.extend(['--tb', tb])
+    if verbose:
+        args.extend(['-v'])
+    if multithread and cpu_count() > 1:
+        args.extend(["-n", str(cpu_count())])
+
+    pytest.main(args)

tools/__init__.py

@@ -0,0 +1,352 @@
+# coding=utf-8
+"""Useful miscellaneous tools and shortcuts for Sopel modules
+
+*Availability: 3+*
+"""
+
+# tools.py - Sopel misc tools
+# Copyright 2008, Sean B. Palmer, inamidst.com
+# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
+# Copyright 2012, Elsie Powell, embolalia.com
+# Licensed under the Eiffel Forum License 2.
+
+# https://sopel.chat
+
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import sys
+import os
+import re
+import threading
+import codecs
+import traceback
+from collections import defaultdict
+
+from tools._events import events  # NOQA
+
+if sys.version_info.major >= 3:
+    raw_input = input
+    unicode = str
+    iteritems = dict.items
+    itervalues = dict.values
+    iterkeys = dict.keys
+else:
+    iteritems = dict.iteritems
+    itervalues = dict.itervalues
+    iterkeys = dict.iterkeys
+
+_channel_prefixes = ('#', '&', '+', '!')
+
+
+def get_input(prompt):
+    """Get decoded input from the terminal (equivalent to python 3's ``input``).
+    """
+    if sys.version_info.major >= 3:
+        return input(prompt)
+    else:
+        return raw_input(prompt).decode('utf8')
+
+
+def get_raising_file_and_line(tb=None):
+    """Return the file and line number of the statement that raised the tb.
+
+    Returns: (filename, lineno) tuple
+
+    """
+    if not tb:
+        tb = sys.exc_info()[2]
+
+    filename, lineno, _context, _line = traceback.extract_tb(tb)[-1]
+
+    return filename, lineno
+
+
+def get_command_regexp(prefix, command):
+    """Return a compiled regexp object that implements the command."""
+    # Escape all whitespace with a single backslash. This ensures that regexp
+    # in the prefix is treated as it was before the actual regexp was changed
+    # to use the verbose syntax.
+    prefix = re.sub(r"(\s)", r"\\\1", prefix)
+
+    # This regexp match equivalently and produce the same
+    # groups 1 and 2 as the old regexp: r'^%s(%s)(?: +(.*))?$'
+    # The only differences should be handling all whitespace
+    # like spaces and the addition of groups 3-6.
+    pattern = r"""
+        (?:{prefix})({command}) # Command as group 1.
+        (?:\s+              # Whitespace to end command.
+        (                   # Rest of the line as group 2.
+        (?:(\S+))?          # Parameters 1-4 as groups 3-6.
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        (?:\s+(\S+))?
+        .*                  # Accept anything after the parameters.
+                            # Leave it up to the module to parse
+                            # the line.
+        ))?                 # Group 2 must be None, if there are no
+                            # parameters.
+        $                   # EoL, so there are no partial matches.
+        """.format(prefix=prefix, command=command)
+    return re.compile(pattern, re.IGNORECASE | re.VERBOSE)
+
+
+def deprecated(old):
+    def new(*args, **kwargs):
+        print('Function %s is deprecated.' % old.__name__, file=sys.stderr)
+        trace = traceback.extract_stack()
+        for line in traceback.format_list(trace[:-1]):
+            stderr(line[:-1])
+        return old(*args, **kwargs)
+    new.__doc__ = old.__doc__
+    new.__name__ = old.__name__
+    return new
+
+
+# from
+# http://parand.com/say/index.php/2007/07/13/simple-multi-dimensional-dictionaries-in-python/
+# A simple class to make mutli dimensional dict easy to use
+class Ddict(dict):
+
+    """Class for multi-dimensional ``dict``.
+
+    A simple helper class to ease the creation of multi-dimensional ``dict``\s.
+
+    """
+
+    def __init__(self, default=None):
+        self.default = default
+
+    def __getitem__(self, key):
+        if key not in self:
+            self[key] = self.default()
+        return dict.__getitem__(self, key)
+
+
+class Identifier(unicode):
+    """A `unicode` subclass which acts appropriately for IRC identifiers.
+
+    When used as normal `unicode` objects, case will be preserved.
+    However, when comparing two Identifier objects, or comparing a Identifier
+    object with a `unicode` object, the comparison will be case insensitive.
+    This case insensitivity includes the case convention conventions regarding
+    ``[]``, ``{}``, ``|``, ``\\``, ``^`` and ``~`` described in RFC 2812.
+    """
+
+    def __new__(cls, identifier):
+        # According to RFC2812, identifiers have to be in the ASCII range.
+        # However, I think it's best to let the IRCd determine that, and we'll
+        # just assume unicode. It won't hurt anything, and is more internally
+        # consistent. And who knows, maybe there's another use case for this
+        # weird case convention.
+        s = unicode.__new__(cls, identifier)
+        s._lowered = Identifier._lower(identifier)
+        return s
+
+    def lower(self):
+        """Return the identifier converted to lower-case per RFC 2812."""
+        return self._lowered
+
+    @staticmethod
+    def _lower(identifier):
+        """Returns `identifier` in lower case per RFC 2812."""
+        # The tilde replacement isn't needed for identifiers, but is for
+        # channels, which may be useful at some point in the future.
+        low = identifier.lower().replace('{', '[').replace('}', ']')
+        low = low.replace('|', '\\').replace('^', '~')
+        return low
+
+    def __repr__(self):
+        return "%s(%r)" % (
+            self.__class__.__name__,
+            self.__str__()
+        )
+
+    def __hash__(self):
+        return self._lowered.__hash__()
+
+    def __lt__(self, other):
+        if isinstance(other, Identifier):
+            return self._lowered < other._lowered
+        return self._lowered < Identifier._lower(other)
+
+    def __le__(self, other):
+        if isinstance(other, Identifier):
+            return self._lowered <= other._lowered
+        return self._lowered <= Identifier._lower(other)
+
+    def __gt__(self, other):
+        if isinstance(other, Identifier):
+            return self._lowered > other._lowered
+        return self._lowered > Identifier._lower(other)
+
+    def __ge__(self, other):
+        if isinstance(other, Identifier):
+            return self._lowered >= other._lowered
+        return self._lowered >= Identifier._lower(other)
+
+    def __eq__(self, other):
+        if isinstance(other, Identifier):
+            return self._lowered == other._lowered
+        return self._lowered == Identifier._lower(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def is_nick(self):
+        """Returns True if the Identifier is a nickname (as opposed to channel)
+        """
+        return self and not self.startswith(_channel_prefixes)
+
+
+class OutputRedirect(object):
+
+    """Redirect te output to the terminal and a log file.
+
+    A simplified object used to write to both the terminal and a log file.
+
+    """
+
+    def __init__(self, logpath, stderr=False, quiet=False):
+        """Create an object which will to to a file and the terminal.
+
+        Create an object which will log to the file at ``logpath`` as well as
+        the terminal.
+        If ``stderr`` is given and true, it will write to stderr rather than
+        stdout.
+        If ``quiet`` is given and True, data will be written to the log file
+        only, but not the terminal.
+
+        """
+        self.logpath = logpath
+        self.stderr = stderr
+        self.quiet = quiet
+
+    def write(self, string):
+        """Write the given ``string`` to the logfile and terminal."""
+        if not self.quiet:
+            try:
+                if self.stderr:
+                    sys.__stderr__.write(string)
+                else:
+                    sys.__stdout__.write(string)
+            except:
+                pass
+
+        with codecs.open(self.logpath, 'ab', encoding="utf8",
+                         errors='xmlcharrefreplace') as logfile:
+            try:
+                logfile.write(string)
+            except UnicodeDecodeError:
+                # we got an invalid string, safely encode it to utf-8
+                logfile.write(unicode(string, 'utf8', errors="replace"))
+
+    def flush(self):
+        if self.stderr:
+            sys.__stderr__.flush()
+        else:
+            sys.__stdout__.flush()
+
+
+# These seems to trace back to when we thought we needed a try/except on prints,
+# because it looked like that was why we were having problems. We'll drop it in
+# 4.0^H^H^H5.0^H^H^H6.0^H^H^Hsome version when someone can be bothered.
+@deprecated
+def stdout(string):
+    print(string)
+
+
+def stderr(string):
+    """Print the given ``string`` to stderr.
+
+    This is equivalent to ``print >> sys.stderr, string``
+
+    """
+    print(string, file=sys.stderr)
+
+
+def check_pid(pid):
+    """Check if a process is running with the given ``PID``.
+
+    *Availability: Only on POSIX systems*
+
+    Return ``True`` if there is a process running with the given ``PID``.
+
+    """
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    else:
+        return True
+
+
+def get_hostmask_regex(mask):
+    """Return a compiled `re.RegexObject` for an IRC hostmask"""
+    mask = re.escape(mask)
+    mask = mask.replace(r'\*', '.*')
+    return re.compile(mask + '$', re.I)
+
+
+class SopelMemory(dict):
+
+    """A simple thread-safe dict implementation.
+
+    *Availability: 4.0; available as ``Sopel.SopelMemory`` in 3.1.0 - 3.2.0*
+
+    In order to prevent exceptions when iterating over the values and changing
+    them at the same time from different threads, we use a blocking lock on
+    ``__setitem__`` and ``contains``.
+
+    """
+    def __init__(self, *args):
+        dict.__init__(self, *args)
+        self.lock = threading.Lock()
+
+    def __setitem__(self, key, value):
+        self.lock.acquire()
+        result = dict.__setitem__(self, key, value)
+        self.lock.release()
+        return result
+
+    def __contains__(self, key):
+        """Check if a key is in the dict.
+
+        It locks it for writes when doing so.
+
+        """
+        self.lock.acquire()
+        result = dict.__contains__(self, key)
+        self.lock.release()
+        return result
+
+    def contains(self, key):
+        """Backwards compatability with 3.x, use `in` operator instead."""
+        return self.__contains__(key)
+
+
+class SopelMemoryWithDefault(defaultdict):
+    """Same as SopelMemory, but subclasses from collections.defaultdict."""
+    def __init__(self, *args):
+        defaultdict.__init__(self, *args)
+        self.lock = threading.Lock()
+
+    def __setitem__(self, key, value):
+        self.lock.acquire()
+        result = defaultdict.__setitem__(self, key, value)
+        self.lock.release()
+        return result
+
+    def __contains__(self, key):
+        """Check if a key is in the dict.
+
+        It locks it for writes when doing so.
+
+        """
+        self.lock.acquire()
+        result = defaultdict.__contains__(self, key)
+        self.lock.release()
+        return result
+
+    def contains(self, key):
+        """Backwards compatability with 3.x, use `in` operator instead."""
+        return self.__contains__(key)

tools/_events.py

@@ -0,0 +1,203 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+
+class events(object):
+    """An enumeration of all the standardized and notable IRC numeric events
+
+    This allows you to do, for example, @module.event(events.RPL_WELCOME)
+    rather than @module.event('001')
+    """
+    # ###################################################### Non-RFC / Non-IRCv3
+    # Only add things here if they're actually in common use across multiple
+    # ircds.
+    RPL_ISUPPORT = '005'
+    RPL_WHOSPCRPL = '354'
+
+    # ################################################################### IRC v3
+    # ## 3.1
+    # CAP
+    ERR_INVALIDCAPCMD = '410'
+    # SASL
+    RPL_LOGGEDIN = '900'
+    RPL_LOGGEDOUT = '901'
+    ERR_NICKLOCKED = '902'
+    RPL_SASLSUCCESS = '903'
+    ERR_SASLFAIL = '904'
+    ERR_SASLTOOLONG = '905'
+    ERR_SASLABORTED = '906'
+    ERR_SASLALREADY = '907'
+    RPL_SASLMECHS = '908'
+    # TLS
+    RPL_STARTTLS = '670'
+    ERR_STARTTLS = '691'
+    # ## 3.2
+    # Metadata
+    RPL_WHOISKEYVALUE = '760'
+    RPL_KEYVALUE = '761'
+    RPL_METADATAEND = '762'
+    ERR_METADATALIMIT = '764'
+    ERR_TARGETINVALID = '765'
+    ERR_NOMATCHINGKEY = '766'
+    ERR_KEYINVALID = '767'
+    ERR_KEYNOTSET = '768'
+    ERR_KEYNOPERMISSION = '769'
+    # Monitor
+    RPL_MONONLINE = '730'
+    RPL_MONOFFLINE = '731'
+    RPL_MONLIST = '732'
+    RPL_ENDOFMONLIST = '733'
+    ERR_MONLISTFULL = '734'
+
+    # ################################################################# RFC 1459
+    # ## 6.1 Error Replies.
+    ERR_NOSUCHNICK = '401'
+    ERR_NOSUCHSERVER = '402'
+    ERR_NOSUCHCHANNEL = '403'
+    ERR_CANNOTSENDTOCHAN = '404'
+    ERR_TOOMANYCHANNELS = '405'
+    ERR_WASNOSUCHNICK = '406'
+    ERR_TOOMANYTARGETS = '407'
+    ERR_NOORIGIN = '409'
+    ERR_NORECIPIENT = '411'
+    ERR_NOTEXTTOSEND = '412'
+    ERR_NOTOPLEVEL = '413'
+    ERR_WILDTOPLEVEL = '414'
+    ERR_UNKNOWNCOMMAND = '421'
+    ERR_NOMOTD = '422'
+    ERR_NOADMININFO = '423'
+    ERR_FILEERROR = '424'
+    ERR_NONICKNAMEGIVEN = '431'
+    ERR_ERRONEUSNICKNAME = '432'
+    ERR_NICKNAMEINUSE = '433'
+    ERR_NICKCOLLISION = '436'
+    ERR_USERNOTINCHANNEL = '441'
+    ERR_NOTONCHANNEL = '442'
+    ERR_USERONCHANNEL = '443'
+    ERR_NOLOGIN = '444'
+    ERR_SUMMONDISABLED = '445'
+    ERR_USERSDISABLED = '446'
+    ERR_NOTREGISTERED = '451'
+    ERR_NEEDMOREPARAMS = '461'
+    ERR_ALREADYREGISTRED = '462'
+    ERR_NOPERMFORHOST = '463'
+    ERR_PASSWDMISMATCH = '464'
+    ERR_YOUREBANNEDCREEP = '465'
+    ERR_KEYSET = '467'
+    ERR_CHANNELISFULL = '471'
+    ERR_UNKNOWNMODE = '472'
+    ERR_INVITEONLYCHAN = '473'
+    ERR_BANNEDFROMCHAN = '474'
+    ERR_BADCHANNELKEY = '475'
+    ERR_NOPRIVILEGES = '481'
+    ERR_CHANOPRIVSNEEDED = '482'
+    ERR_CANTKILLSERVER = '483'
+    ERR_NOOPERHOST = '491'
+    ERR_UMODEUNKNOWNFLAG = '501'
+    ERR_USERSDONTMATCH = '502'
+    # ## 6.2 Command responses.
+    RPL_NONE = '300'
+    RPL_USERHOST = '302'
+    RPL_ISON = '303'
+    RPL_AWAY = '301'
+    RPL_UNAWAY = '305'
+    RPL_NOWAWAY = '306'
+    RPL_WHOISUSER = '311'
+    RPL_WHOISSERVER = '312'
+    RPL_WHOISOPERATOR = '313'
+    RPL_WHOISIDLE = '317'
+    RPL_ENDOFWHOIS = '318'
+    RPL_WHOISCHANNELS = '319'
+    RPL_WHOWASUSER = '314'
+    RPL_ENDOFWHOWAS = '369'
+    RPL_LISTSTART = '321'
+    RPL_LIST = '322'
+    RPL_LISTEND = '323'
+    RPL_CHANNELMODEIS = '324'
+    RPL_NOTOPIC = '331'
+    RPL_TOPIC = '332'
+    RPL_INVITING = '341'
+    RPL_SUMMONING = '342'
+    RPL_VERSION = '351'
+    RPL_WHOREPLY = '352'
+    RPL_ENDOFWHO = '315'
+    RPL_NAMREPLY = '353'
+    RPL_ENDOFNAMES = '366'
+    RPL_LINKS = '364'
+    RPL_ENDOFLINKS = '365'
+    RPL_BANLIST = '367'
+    RPL_ENDOFBANLIST = '368'
+    RPL_INFO = '371'
+    RPL_ENDOFINFO = '374'
+    RPL_MOTDSTART = '375'
+    RPL_MOTD = '372'
+    RPL_ENDOFMOTD = '376'
+    RPL_YOUREOPER = '381'
+    RPL_REHASHING = '382'
+    RPL_TIME = '391'
+    RPL_USERSSTART = '392'
+    RPL_USERS = '393'
+    RPL_ENDOFUSERS = '394'
+    RPL_NOUSERS = '395'
+    RPL_TRACELINK = '200'
+    RPL_TRACECONNECTING = '201'
+    RPL_TRACEHANDSHAKE = '202'
+    RPL_TRACEUNKNOWN = '203'
+    RPL_TRACEOPERATOR = '204'
+    RPL_TRACEUSER = '205'
+    RPL_TRACESERVER = '206'
+    RPL_TRACENEWTYPE = '208'
+    RPL_TRACELOG = '261'
+    RPL_STATSLINKINFO = '211'
+    RPL_STATSCOMMANDS = '212'
+    RPL_STATSCLINE = '213'
+    RPL_STATSNLINE = '214'
+    RPL_STATSILINE = '215'
+    RPL_STATSKLINE = '216'
+    RPL_STATSYLINE = '218'
+    RPL_ENDOFSTATS = '219'
+    RPL_STATSLLINE = '241'
+    RPL_STATSUPTIME = '242'
+    RPL_STATSOLINE = '243'
+    RPL_STATSHLINE = '244'
+    RPL_UMODEIS = '221'
+    RPL_LUSERCLIENT = '251'
+    RPL_LUSEROP = '252'
+    RPL_LUSERUNKNOWN = '253'
+    RPL_LUSERCHANNELS = '254'
+    RPL_LUSERME = '255'
+    RPL_ADMINME = '256'
+    RPL_ADMINLOC1 = '257'
+    RPL_ADMINLOC2 = '258'
+    RPL_ADMINEMAIL = '259'
+
+    # ################################################################# RFC 2812
+    # ## 5.1 Command responses
+    RPL_WELCOME = '001'
+    RPL_YOURHOST = '002'
+    RPL_CREATED = '003'
+    RPL_MYINFO = '004'
+    RPL_BOUNCE = '005'
+    RPL_UNIQOPIS = '325'
+    RPL_INVITELIST = '346'
+    RPL_ENDOFINVITELIST = '347'
+    RPL_EXCEPTLIST = '348'
+    RPL_ENDOFEXCEPTLIST = '349'
+    RPL_YOURESERVICE = '383'
+    RPL_TRACESERVICE = '207'
+    RPL_TRACECLASS = '209'
+    RPL_TRACERECONNECT = '210'
+    RPL_TRACEEND = '262'
+    RPL_SERVLIST = '234'
+    RPL_SERVLISTEND = '235'
+    RPL_TRYAGAIN = '263'
+    # ## 5.2 Error Replies
+    ERR_NOSUCHSERVICE = '408'
+    ERR_BADMASK = '415'
+    ERR_UNAVAILRESOURCE = '437'
+    ERR_YOUWILLBEBANNED = '466'
+    ERR_BADCHANMASK = '476'
+    ERR_NOCHANMODES = '477'
+    ERR_BANLISTFULL = '478'
+    ERR_RESTRICTED = '484'
+    ERR_UNIQOPPRIVSNEEDED = '485'

tools/calculation.py

@@ -0,0 +1,195 @@
+# coding=utf-8
+"""Tools to help safely do calculations from user input"""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import time
+import numbers
+import operator
+import ast
+
+__all__ = ['eval_equation']
+
+
+class ExpressionEvaluator:
+    """A generic class for evaluating limited forms of Python expressions.
+
+    Instances can overwrite binary_ops and unary_ops attributes with dicts of
+    the form {ast.Node, function}. When the ast.Node being used as key is
+    found, it will be evaluated using the given function.
+
+    """
+
+    class Error(Exception):
+        pass
+
+    def __init__(self, bin_ops=None, unary_ops=None):
+        self.binary_ops = bin_ops or {}
+        self.unary_ops = unary_ops or {}
+
+    def __call__(self, expression_str, timeout=5.0):
+        """Evaluate a python expression and return the result.
+
+        Raises:
+            SyntaxError: If the given expression_str is not a valid python
+                statement.
+            ExpressionEvaluator.Error: If the instance of ExpressionEvaluator
+                does not have a handler for the ast.Node.
+
+        """
+        ast_expression = ast.parse(expression_str, mode='eval')
+        return self._eval_node(ast_expression.body, time.time() + timeout)
+
+    def _eval_node(self, node, timeout):
+        """Recursively evaluate the given ast.Node.
+
+        Uses self.binary_ops and self.unary_ops for the implementation.
+
+        A subclass could overwrite this to handle more nodes, calling it only
+        for nodes it does not implement it self.
+
+        Raises:
+            ExpressionEvaluator.Error: If it can't handle the ast.Node.
+
+        """
+        if isinstance(node, ast.Num):
+            return node.n
+
+        elif (isinstance(node, ast.BinOp) and
+                type(node.op) in self.binary_ops):
+            left = self._eval_node(node.left, timeout)
+            right = self._eval_node(node.right, timeout)
+            if time.time() > timeout:
+                raise ExpressionEvaluator.Error(
+                    "Time for evaluating expression ran out.")
+            return self.binary_ops[type(node.op)](left, right)
+
+        elif (isinstance(node, ast.UnaryOp) and
+                type(node.op) in self.unary_ops):
+            operand = self._eval_node(node.operand, timeout)
+            if time.time() > timeout:
+                raise ExpressionEvaluator.Error(
+                    "Time for evaluating expression ran out.")
+            return self.unary_ops[type(node.op)](operand)
+
+        raise ExpressionEvaluator.Error(
+            "Ast.Node '%s' not implemented." % (type(node).__name__,))
+
+
+def guarded_mul(left, right):
+    """Decorate a function to raise an error for values > limit."""
+    # Only handle ints because floats will overflow anyway.
+    if not isinstance(left, numbers.Integral):
+        pass
+    elif not isinstance(right, numbers.Integral):
+        pass
+    elif left in (0, 1) or right in (0, 1):
+        # Ignore trivial cases.
+        pass
+    elif left.bit_length() + right.bit_length() > 664386:
+        # 664386 is the number of bits (10**100000)**2 has, which is instant on
+        # my laptop, while (10**1000000)**2 has a noticeable delay. It could
+        # certainly be improved.
+        raise ValueError(
+            "Value is too large to be handled in limited time and memory.")
+
+    return operator.mul(left, right)
+
+
+def pow_complexity(num, exp):
+    """Estimate the worst case time pow(num, exp) takes to calculate.
+
+    This function is based on experimetal data from the time it takes to
+    calculate "num**exp" on laptop with i7-2670QM processor on a 32 bit
+    CPython 2.7.6 interpreter on Windows.
+
+    It tries to implement this surface: x=exp, y=num
+           1e5    2e5    3e5    4e5    5e5    6e5    7e5    8e5    9e5
+    e1    0.03   0.09   0.16   0.25   0.35   0.46   0.60   0.73   0.88
+    e2    0.08   0.24   0.46   0.73   1.03   1.40   1.80   2.21   2.63
+    e3    0.15   0.46   0.87   1.39   1.99   2.63   3.35   4.18   5.15
+    e4    0.24   0.73   1.39   2.20   3.11   4.18   5.39   6.59   7.88
+    e5    0.34   1.03   2.00   3.12   4.48   5.97   7.56   9.37  11.34
+    e6    0.46   1.39   2.62   4.16   5.97   7.86  10.09  12.56  15.39
+    e7    0.60   1.79   3.34   5.39   7.60  10.16  13.00  16.23  19.44
+    e8    0.73   2.20   4.18   6.60   9.37  12.60  16.26  19.83  23.70
+    e9    0.87   2.62   5.15   7.93  11.34  15.44  19.40  23.66  28.58
+
+    For powers of 2 it tries to implement this surface:
+          1e7    2e7    3e7    4e7    5e7    6e7    7e7    8e7    9e7
+    1    0.00   0.00   0.00   0.00   0.00   0.00   0.00   0.00   0.00
+    2    0.21   0.44   0.71   0.92   1.20   1.49   1.66   1.95   2.23
+    4    0.43   0.91   1.49   1.96   2.50   3.13   3.54   4.10   4.77
+    8    0.70   1.50   2.24   3.16   3.83   4.66   5.58   6.56   7.67
+
+    The function number were selected by starting with the theoretical
+    complexity of exp * log2(num)**2 and fiddling with the exponents
+    untill it more or less matched with the table.
+
+    Because this function is based on a limited set of data it might
+    not give accurate results outside these boundaries. The results
+    derived from large num and exp were quite accurate for small num
+    and very large exp though, except when num was a power of 2.
+    """
+    if num in (0, 1) or exp in (0, 1):
+        return 0
+    elif (num & (num - 1)) == 0:
+        # For powers of 2 the scaling is a bit different.
+        return exp ** 1.092 * num.bit_length() ** 1.65 / 623212911.121
+    else:
+        return exp ** 1.590 * num.bit_length() ** 1.73 / 36864057619.3
+
+
+def guarded_pow(left, right):
+    # Only handle ints because floats will overflow anyway.
+    if not isinstance(left, numbers.Integral):
+        pass
+    elif not isinstance(right, numbers.Integral):
+        pass
+    elif pow_complexity(left, right) < 0.5:
+        # Value 0.5 is arbitary and based on a estimated runtime of 0.5s
+        # on a fairly decent laptop processor.
+        pass
+    else:
+        raise ValueError("Pow expression too complex to calculate.")
+
+    return operator.pow(left, right)
+
+
+class EquationEvaluator(ExpressionEvaluator):
+    __bin_ops = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: guarded_mul,
+        ast.Div: operator.truediv,
+        ast.Pow: guarded_pow,
+        ast.Mod: operator.mod,
+        ast.FloorDiv: operator.floordiv,
+        ast.BitXor: guarded_pow
+    }
+    __unary_ops = {
+        ast.USub: operator.neg,
+        ast.UAdd: operator.pos,
+    }
+
+    def __init__(self):
+        ExpressionEvaluator.__init__(
+            self,
+            bin_ops=self.__bin_ops,
+            unary_ops=self.__unary_ops
+        )
+
+    def __call__(self, expression_str):
+        result = ExpressionEvaluator.__call__(self, expression_str)
+
+        # This wrapper is here so additional sanity checks could be done
+        # on the result of the eval, but currently none are done.
+
+        return result
+
+
+eval_equation = EquationEvaluator()
+"""Evaluates a Python equation expression and returns the result.
+
+Supports addition (+), subtraction (-), multiplication (*), division (/),
+power (**) and modulo (%).
+"""

tools/jobs.py

@@ -0,0 +1,233 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import copy
+import datetime
+import sys
+import threading
+import time
+
+if sys.version_info.major >= 3:
+    unicode = str
+    basestring = str
+    py3 = True
+else:
+    py3 = False
+
+try:
+    import Queue
+except ImportError:
+    import queue as Queue
+
+
+class released(object):
+    """A context manager that releases a lock temporarily."""
+    def __init__(self, lock):
+        self.lock = lock
+
+    def __enter__(self):
+        self.lock.release()
+
+    def __exit__(self, _type, _value, _traceback):
+        self.lock.acquire()
+
+
+class PriorityQueue(Queue.PriorityQueue):
+    """A priority queue with a peek method."""
+    def peek(self):
+        """Return a copy of the first element without removing it."""
+        self.not_empty.acquire()
+        try:
+            while not self._qsize():
+                self.not_empty.wait()
+            # Return a copy to avoid corrupting the heap. This is important
+            # for thread safety if the object is mutable.
+            return copy.deepcopy(self.queue[0])
+        finally:
+            self.not_empty.release()
+
+
+class JobScheduler(threading.Thread):
+
+    """Calls jobs assigned to it in steady intervals.
+
+    JobScheduler is a thread that keeps track of Jobs and calls them every
+    X seconds, where X is a property of the Job. It maintains jobs in a
+    priority queue, where the next job to be called is always the first
+    item.
+    Thread safety is maintained with a mutex that is released during long
+    operations, so methods add_job and clear_jobs can be safely called from
+    the main thread.
+
+    """
+
+    min_reaction_time = 30.0  # seconds
+    """How often should scheduler checks for changes in the job list."""
+
+    def __init__(self, bot):
+        """Requires bot as argument for logging."""
+        threading.Thread.__init__(self)
+        self.bot = bot
+        self._jobs = PriorityQueue()
+        # While PriorityQueue it self is thread safe, this mutex is needed
+        # to stop old jobs being put into new queue after clearing the
+        # queue.
+        self._mutex = threading.Lock()
+        # self.cleared is used for more fine grained locking.
+        self._cleared = False
+
+    def add_job(self, job):
+        """Add a Job to the current job queue."""
+        self._jobs.put(job)
+
+    def clear_jobs(self):
+        """Clear current Job queue and start fresh."""
+        if self._jobs.empty():
+            # Guards against getting stuck waiting for self._mutex when
+            # thread is waiting for self._jobs to not be empty.
+            return
+        with self._mutex:
+            self._cleared = True
+            self._jobs = PriorityQueue()
+
+    def run(self):
+        """Run forever."""
+        while True:
+            try:
+                self._do_next_job()
+            except Exception:
+                # Modules exceptions are caught earlier, so this is a bit
+                # more serious. Options are to either stop the main thread
+                # or continue this thread and hope that it won't happen
+                # again.
+                self.bot.error()
+                # Sleep a bit to guard against busy-looping and filling
+                # the log with useless error messages.
+                time.sleep(10.0)  # seconds
+
+    def _do_next_job(self):
+        """Wait until there is a job and do it."""
+        with self._mutex:
+            # Wait until the next job should be executed.
+            # This has to be a loop, because signals stop time.sleep().
+            while True:
+                job = self._jobs.peek()
+                difference = job.next_time - time.time()
+                duration = min(difference, self.min_reaction_time)
+                if duration <= 0:
+                    break
+                with released(self._mutex):
+                    time.sleep(duration)
+
+            self._cleared = False
+            job = self._jobs.get()
+            with released(self._mutex):
+                if job.func.thread:
+                    t = threading.Thread(
+                        target=self._call, args=(job.func,)
+                    )
+                    t.start()
+                else:
+                    self._call(job.func)
+                job.next()
+            # If jobs were cleared during the call, don't put an old job
+            # into the new job queue.
+            if not self._cleared:
+                self._jobs.put(job)
+
+    def _call(self, func):
+        """Wrapper for collecting errors from modules."""
+        # Sopel.bot.call is way too specialized to be used instead.
+        try:
+            func(self.bot)
+        except Exception:
+            self.bot.error()
+
+
+class Job(object):
+
+    """Hold information about when a function should be called next.
+
+    Job is a simple structure that hold information about when a function
+    should be called next.
+    They can be put in a priority queue, in which case the Job that should
+    be executed next is returned.
+
+    Calling the method next modifies the Job object for the next time it
+    should be executed. Current time is used to decide when the job should
+    be executed next so it should only be called right after the function
+    was called.
+
+    """
+
+    max_catchup = 5
+    """
+    This governs how much the scheduling of jobs is allowed
+    to get behind before they are simply thrown out to avoid
+    calling the same function too many times at once.
+    """
+
+    def __init__(self, interval, func):
+        """Initialize Job.
+
+        Args:
+            interval: number of seconds between calls to func
+            func: function to be called
+
+        """
+        self.next_time = time.time() + interval
+        self.interval = interval
+        self.func = func
+
+    def next(self):
+        """Update self.next_time with the assumption func was just called.
+
+        Returns: A modified job object.
+
+        """
+        last_time = self.next_time
+        current_time = time.time()
+        delta = last_time + self.interval - current_time
+
+        if last_time > current_time + self.interval:
+            # Clock appears to have moved backwards. Reset
+            # the timer to avoid waiting for the clock to
+            # catch up to whatever time it was previously.
+            self.next_time = current_time + self.interval
+        elif delta < 0 and abs(delta) > self.interval * self.max_catchup:
+            # Execution of jobs is too far behind. Give up on
+            # trying to catch up and reset the time, so that
+            # will only be repeated a maximum of
+            # self.max_catchup times.
+            self.next_time = current_time - \
+                self.interval * self.max_catchup
+        else:
+            self.next_time = last_time + self.interval
+
+        return self
+
+    def __cmp__(self, other):
+        """Compare Job objects according to attribute next_time."""
+        return self.next_time - other.next_time
+
+    if py3:
+        def __lt__(self, other):
+            return self.next_time < other.next_time
+
+        def __gt__(self, other):
+            return self.next_time > other.next_time
+
+    def __str__(self):
+        """Return a string representation of the Job object.
+
+        Example result:
+            <Job(2013-06-14 11:01:36.884000, 20s, <function upper at 0x02386BF0>)>
+
+        """
+        iso_time = str(datetime.fromtimestamp(self.next_time))
+        return "<Job(%s, %ss, %s)>" % \
+            (iso_time, self.interval, self.func)
+
+    def __iter__(self):
+        """This is an iterator. Never stops though."""
+        return self

tools/target.py

@@ -0,0 +1,90 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import functools
+from tools import Identifier
+
+
+@functools.total_ordering
+class User(object):
+    """A representation of a user Sopel is aware of."""
+    def __init__(self, nick, user, host):
+        assert isinstance(nick, Identifier)
+        self.nick = nick
+        """The user's nickname."""
+        self.user = user
+        """The user's local username."""
+        self.host = host
+        """The user's hostname."""
+        self.channels = {}
+        """The channels the user is in.
+
+        This maps channel name ``Identifier``\s to ``Channel`` objects."""
+        self.account = None
+        """The IRC services account of the user.
+
+        This relies on IRCv3 account tracking being enabled."""
+        self.away = None
+        """Whether the user is marked as away."""
+
+    hostmask = property(lambda self: '{}!{}@{}'.format(self.nick, self.user,
+                                                       self.host))
+    """The user's full hostmask."""
+
+    def __eq__(self, other):
+        if not isinstance(other, User):
+            return NotImplemented
+        return self.nick == other.nick
+
+    def __lt__(self, other):
+        if not isinstance(other, User):
+            return NotImplemented
+        return self.nick < other.nick
+
+
+@functools.total_ordering
+class Channel(object):
+    """A representation of a channel Sopel is in."""
+    def __init__(self, name):
+        assert isinstance(name, Identifier)
+        self.name = name
+        """The name of the channel."""
+        self.users = {}
+        """The users in the channel.
+
+        This maps username ``Identifier``\s to channel objects."""
+        self.privileges = {}
+        """The permissions of the users in the channel.
+
+        This maps username ``Identifier``s to bitwise integer values. This can
+        be compared to appropriate constants from ``sopel.module``."""
+        self.topic = ''
+        """The topic of the channel."""
+
+    def clear_user(self, nick):
+        user = self.users.pop(nick, None)
+        self.privileges.pop(nick, None)
+        if user != None:
+            user.channels.pop(self.name, None)
+
+    def add_user(self, user):
+        assert isinstance(user, User)
+        self.users[user.nick] = user
+        self.privileges[user.nick] = 0
+        user.channels[self.name] = self
+
+    def rename_user(self, old, new):
+        if old in self.users:
+            self.users[new] = self.users.pop(old)
+        if old in self.privileges:
+            self.privileges[new] = self.privileges.pop(old)
+
+    def __eq__(self, other):
+        if not isinstance(other, Channel):
+            return NotImplemented
+        return self.name == other.name
+
+    def __lt__(self, other):
+        if not isinstance(other, Channel):
+            return NotImplemented
+        return self.name < other.name

tools/time.py

@@ -0,0 +1,190 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tools for getting and displaying the time."""
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import datetime
+try:
+    import pytz
+except:
+    pytz = False
+
+
+def validate_timezone(zone):
+    """Return an IETF timezone from the given IETF zone or common abbreviation.
+
+    If the length of the zone is 4 or less, it will be upper-cased before being
+    looked up; otherwise it will be title-cased. This is the expected
+    case-insensitivity behavior in the majority of cases. For example, ``'edt'``
+    and ``'america/new_york'`` will both return ``'America/New_York'``.
+
+    If the zone is not valid, ``ValueError`` will be raised. If ``pytz`` is not
+    available, and the given zone is anything other than ``'UTC'``,
+    ``ValueError`` will be raised.
+    """
+    if zone is None:
+        return None
+    if not pytz:
+        if zone.upper() != 'UTC':
+            raise ValueError('Only UTC available, since pytz is not installed.')
+        else:
+            return zone
+
+    zone = '/'.join(reversed(zone.split(', '))).replace(' ', '_')
+    if len(zone) <= 4:
+        zone = zone.upper()
+    else:
+        zone = zone.title()
+    if zone in pytz.all_timezones:
+        return zone
+    else:
+        raise ValueError("Invalid time zone.")
+
+
+def validate_format(tformat):
+    """Returns the format, if valid, else None"""
+    try:
+        time = datetime.datetime.utcnow()
+        time.strftime(tformat)
+    except:
+        raise ValueError('Invalid time format')
+    return tformat
+
+
+def get_timezone(db=None, config=None, zone=None, nick=None, channel=None):
+    """Find, and return, the approriate timezone
+
+    Time zone is pulled in the following priority:
+    1. `zone`, if it is valid
+    2. The timezone for the channel or nick `zone` in `db` if one is set and
+    valid.
+    3. The timezone for the nick `nick` in `db`, if one is set and valid.
+    4. The timezone for the channel  `channel` in `db`, if one is set and valid.
+    5. The default timezone in `config`, if one is set and valid.
+
+    If `db` is not given, or given but not set up, steps 2 and 3 will be
+    skipped. If `config` is not given, step 4 will be skipped. If no step
+    yeilds a valid timezone, `None` is returned.
+
+    Valid timezones are those present in the IANA Time Zone Database. Prior to
+    checking timezones, two translations are made to make the zone names more
+    human-friendly. First, the string is split on `', '`, the pieces reversed,
+    and then joined with `'/'`. Next, remaining spaces are replaced with `'_'`.
+    Finally, strings longer than 4 characters are made title-case, and those 4
+    characters and shorter are made upper-case. This means "new york, america"
+    becomes "America/New_York", and "utc" becomes "UTC".
+
+    This function relies on `pytz` being available. If it is not available,
+    `None` will always be returned.
+    """
+    def _check(zone):
+        try:
+            return validate_timezone(zone)
+        except ValueError:
+            return None
+
+    if not pytz:
+        return None
+    tz = None
+
+    if zone:
+        tz = _check(zone)
+        if not tz:
+            tz = _check(
+                db.get_nick_or_channel_value(zone, 'timezone'))
+    if not tz and nick:
+        tz = _check(db.get_nick_value(nick, 'timezone'))
+    if not tz and channel:
+        tz = _check(db.get_channel_value(channel, 'timezone'))
+    if not tz and config and config.core.default_timezone:
+        tz = _check(config.core.default_timezone)
+    return tz
+
+
+def format_time(db=None, config=None, zone=None, nick=None, channel=None,
+                time=None):
+    """Return a formatted string of the given time in the given zone.
+
+    `time`, if given, should be a naive `datetime.datetime` object and will be
+    treated as being in the UTC timezone. If it is not given, the current time
+    will be used. If `zone` is given and `pytz` is available, `zone` must be
+    present in the IANA Time Zone Database; `get_timezone` can be helpful for
+    this. If `zone` is not given or `pytz` is not available, UTC will be
+    assumed.
+
+    The format for the string is chosen in the following order:
+
+    1. The format for the nick `nick` in `db`, if one is set and valid.
+    2. The format for the channel `channel` in `db`, if one is set and valid.
+    3. The default format in `config`, if one is set and valid.
+    4. ISO-8601
+
+    If `db` is not given or is not set up, steps 1 and 2 are skipped. If config
+    is not given, step 3 will be skipped."""
+    tformat = None
+    if db:
+        if nick:
+            tformat = db.get_nick_value(nick, 'time_format')
+        if not tformat and channel:
+            tformat = db.get_channel_value(channel, 'time_format')
+    if not tformat and config and config.core.default_time_format:
+        tformat = config.core.default_time_format
+    if not tformat:
+        tformat = '%Y-%m-%d - %T%Z'
+
+    if not time:
+        time = datetime.datetime.utcnow()
+
+    if not pytz or not zone:
+        return time.strftime(tformat)
+    else:
+        if not time.tzinfo:
+            utc = pytz.timezone('UTC')
+            time = utc.localize(time)
+        zone = pytz.timezone(zone)
+        return time.astimezone(zone).strftime(tformat)
+
+
+def relativeTime(bot, nick, telldate):
+	"""
+	Takes a datetime object and returns a string containing the relative time
+	difference between that datetime-string and now.
+	It takes a string. Not a datetime object. Fix that sometime.
+	"""
+	try:
+		telldatetime = datetime.datetime.strptime(telldate, bot.config.core.default_time_format)
+	except ValueError:
+		return("Unable to parse relative time.")
+	tz = get_timezone(bot.db, bot.config, None, nick)
+	timenow = format_time(bot.db, bot.config, tz, nick)
+	try:
+		nowdatetime = datetime.datetime.strptime(timenow, bot.config.core.default_time_format)
+	except ValueError:
+		return("Unable to parse relative time.")
+	
+	timediff = nowdatetime - telldatetime
+	reltime = []
+	if timediff.days:
+		if timediff.days // 365:
+			reltime.append( str(timediff.days // 365) + " year" )
+		if timediff.days % 365 // 31:
+			reltime.append( str(timediff.days % 365 // 31) + " month")
+		if timediff.days % 365 % 31:
+			reltime.append( str(timediff.days % 365 % 31) + " day")
+
+	else:
+		if timediff.seconds // 3600:
+			reltime.append( str(timediff.seconds // 3600) + " hour" )
+		if timediff.seconds % 3600 // 60:
+			reltime.append( str(timediff.seconds % 3600 // 60) + " minute" )
+
+	for item in reltime:
+		if item.split(' ')[0] != '1':
+			reltime[reltime.index(item)] += 's'
+
+	if timediff.days == 0 and timediff.seconds < 60:
+		reltime = ["less than a minute"]
+
+	if not reltime:
+		return("Unable to parse relative time.")
+	return ', '.join(reltime) + ' ago'

tools/web.py

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Some functions for making web interactions easier.
+"""
+import requests, os
+from urllib.parse import urlparse
+
+def secCheck(bot, url):
+	""" Checks to see if the given link is malicious or not. """
+	if not urlparse(url).scheme:
+		hostname = urlparse("//"+url).hostname
+	else:
+		hostname = urlparse(url).hostname
+
+	# Since bot.memory['safety_cache'] apparently doesn't work.
+	with open(os.path.join(bot.config.homedir, 'malwaredomains.txt'), 'r') as file:
+		if hostname in file.read().split():
+			return None
+
+	return url

trigger.py

@@ -0,0 +1,187 @@
+# coding=utf-8
+from __future__ import unicode_literals, absolute_import, print_function, division
+
+import re
+import sys
+import datetime
+
+import tools
+
+if sys.version_info.major >= 3:
+	unicode = str
+	basestring = str
+
+
+class PreTrigger(object):
+	"""A parsed message from the server, which has not been matched against
+	any rules."""
+	component_regex = re.compile(r'([^!]*)!?([^@]*)@?(.*)')
+	intent_regex = re.compile('\x01(\\S+) ?(.*)\x01')
+
+	def __init__(self, own_nick, line):
+		"""own_nick is the bot's nick, needed to correctly parse sender.
+		line is the full line from the server."""
+		line = line.strip('\r')
+		self.line = line
+
+		# Break off IRCv3 message tags, if present
+		self.tags = {}
+		if line.startswith('@'):
+			tagstring, line = line.split(' ', 1)
+			for tag in tagstring[1:].split(';'):
+				tag = tag.split('=', 1)
+				if len(tag) > 1:
+					self.tags[tag[0]] = tag[1]
+				else:
+					self.tags[tag[0]] = None
+
+		self.time = datetime.datetime.utcnow()
+		if 'time' in self.tags:
+			try:
+				self.time = datetime.datetime.strptime(self.tags['time'], '%Y-%m-%dT%H:%M:%S.%fZ')
+			except ValueError:
+				pass  # Server isn't conforming to spec, ignore the server-time
+
+		# TODO note what this is doing and why
+		if line.startswith(':'):
+			self.hostmask, line = line[1:].split(' ', 1)
+		else:
+			self.hostmask = None
+
+		# TODO note what this is doing and why
+		if ' :' in line:
+			argstr, text = line.split(' :', 1)
+			self.args = argstr.split(' ')
+			self.args.append(text)
+		else:
+			self.args = line.split(' ')
+			self.text = self.args[-1]
+
+		self.event = self.args[0]
+		self.args = self.args[1:]
+		components = PreTrigger.component_regex.match(self.hostmask or '').groups()
+		self.nick, self.user, self.host = components
+		self.nick = tools.Identifier(self.nick)
+
+		# If we have arguments, the first one is the sender
+		# Unless it's a QUIT event
+		if self.args and self.event != 'QUIT':
+			target = tools.Identifier(self.args[0])
+		else:
+			target = None
+
+		# Unless we're messaging the bot directly, in which case that second
+		# arg will be our bot's name.
+		if target and target.lower() == own_nick.lower():
+			target = self.nick
+		self.sender = target
+
+		# Parse CTCP into a form consistent with IRCv3 intents
+		if self.event == 'PRIVMSG' or self.event == 'NOTICE':
+			intent_match = PreTrigger.intent_regex.match(self.args[-1])
+			if intent_match:
+				intent, message = intent_match.groups()
+				self.tags['intent'] = intent
+				self.args[-1] = message or ''
+
+		# Populate account from extended-join messages
+		if self.event == 'JOIN' and len(self.args) == 3:
+			# Account is the second arg `...JOIN #Sopel account :realname`
+			self.tags['account'] = self.args[1]
+
+
+class Trigger(unicode):
+	"""A line from the server, which has matched a callable's rules.
+
+	Note that CTCP messages (`PRIVMSG`es and `NOTICE`es which start and end
+	with `'\\x01'`) will have the `'\\x01'` bytes stripped, and the command
+	(e.g. `ACTION`) placed mapped to the `'intent'` key in `Trigger.tags`.
+	"""
+	sender = property(lambda self: self._pretrigger.sender)
+	"""The channel from which the message was sent.
+
+	In a private message, this is the nick that sent the message."""
+	time = property(lambda self: self._pretrigger.time)
+	"""A datetime object at which the message was received by the IRC server.
+
+	If the server does not support server-time, then `time` will be the time
+	that the message was received by Sopel"""
+	raw = property(lambda self: self._pretrigger.line)
+	"""The entire message, as sent from the server. This includes the CTCP
+	\\x01 bytes and command, if they were included."""
+	is_privmsg = property(lambda self: self._is_privmsg)
+	"""True if the trigger is from a user, False if it's from a channel."""
+	hostmask = property(lambda self: self._pretrigger.hostmask)
+	"""Hostmask of the person who sent the message as <nick>!<user>@<host>"""
+	user = property(lambda self: self._pretrigger.user)
+	"""Local username of the person who sent the message"""
+	nick = property(lambda self: self._pretrigger.nick)
+	"""The :class:`sopel.tools.Identifier` of the person who sent the message.
+	"""
+	host = property(lambda self: self._pretrigger.host)
+	"""The hostname of the person who sent the message"""
+	event = property(lambda self: self._pretrigger.event)
+	"""The IRC event (e.g. ``PRIVMSG`` or ``MODE``) which triggered the
+	message."""
+	match = property(lambda self: self._match)
+	"""The regular expression :class:`re.MatchObject` for the triggering line.
+	"""
+	group = property(lambda self: self._match.group)
+	"""The ``group`` function of the ``match`` attribute.
+
+	See Python :mod:`re` documentation for details."""
+	groups = property(lambda self: self._match.groups)
+	"""The ``groups`` function of the ``match`` attribute.
+
+	See Python :mod:`re` documentation for details."""
+	groupdict = property(lambda self: self._match.groupdict)
+	"""The ``groupdict`` function of the ``match`` attribute.
+
+	See Python :mod:`re` documentation for details."""
+	args = property(lambda self: self._pretrigger.args)
+	"""
+	A tuple containing each of the arguments to an event. These are the
+	strings passed between the event name and the colon. For example,
+	setting ``mode -m`` on the channel ``#example``, args would be
+	``('#example', '-m')``
+	"""
+	tags = property(lambda self: self._pretrigger.tags)
+	"""A map of the IRCv3 message tags on the message."""
+	admin = property(lambda self: self._admin)
+	"""True if the nick which triggered the command is one of the bot's admins.
+	"""
+	owner = property(lambda self: self._owner)
+	"""True if the nick which triggered the command is the bot's owner."""
+	account = property(lambda self: self.tags.get('account') or self._account)
+	"""The account name of the user sending the message.
+
+	This is only available if either the account-tag or the account-notify and
+	extended-join capabilites are available. If this isn't the case, or the user
+	sending the message isn't logged in, this will be None.
+	"""
+
+	def __new__(cls, config, message, match, account=None):
+		self = unicode.__new__(cls, message.args[-1] if message.args else '')
+		self._account = account
+		self._pretrigger = message
+		self._match = match
+		self._is_privmsg = message.sender and message.sender.is_nick()
+
+		def match_host_or_nick(pattern):
+			pattern = tools.get_hostmask_regex(pattern)
+			return bool(
+				pattern.match(self.nick) or
+				pattern.match('@'.join((self.nick, self.host)))
+			)
+
+		if config.core.owner_account:
+			self._owner = config.core.owner_account == self.account
+		else:
+			self._owner = match_host_or_nick(config.core.owner)
+		self._admin = (
+			self._owner or
+			self.account in config.core.admin_accounts or
+			any(match_host_or_nick(item) for item in config.core.admins)
+		)
+
+		return self