mirror of https://github.com/Mikaela/Limnoria.git
833 lines
37 KiB
Python
833 lines
37 KiB
Python
#!/usr/bin/env python3
|
|
|
|
###
|
|
# Copyright (c) 2003-2004, Jeremiah Fincher
|
|
# Copyright (c) 2009, James McCoy
|
|
# Copyright (c) 2010-2021, Valentin Lorentz
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright notice,
|
|
# this list of conditions, and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions, and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
# * Neither the name of the author of this software nor the name of
|
|
# contributors to this software may be used to endorse or promote products
|
|
# derived from this software without specific prior written consent.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
###
|
|
|
|
from __future__ import print_function
|
|
|
|
import os
|
|
import sys
|
|
|
|
def error(s):
|
|
sys.stderr.write(s)
|
|
if not s.endswith(os.linesep):
|
|
sys.stderr.write(os.linesep)
|
|
sys.exit(-1)
|
|
|
|
import supybot
|
|
|
|
import re
|
|
import time
|
|
import pydoc
|
|
import pprint
|
|
import socket
|
|
import logging
|
|
import optparse
|
|
|
|
try:
|
|
import supybot.i18n as i18n
|
|
except ImportError:
|
|
sys.stderr.write("""Error:
|
|
You are running a mix of Limnoria and stock Supybot code. Although you run
|
|
one of Limnoria\'s executables, Python tries to load stock
|
|
Supybot\'s library. To fix this issue, uninstall Supybot
|
|
("%s -m pip uninstall supybot" should do the job)
|
|
and install Limnoria again.
|
|
For your information, Supybot's libraries are installed here:
|
|
%s\n""" %
|
|
(sys.executable, '\n '.join(supybot.__path__)))
|
|
exit(-1)
|
|
|
|
import supybot.ansi as ansi
|
|
import supybot.utils as utils
|
|
import supybot.ircutils as ircutils
|
|
import supybot.registry as registry
|
|
# supybot.plugin, supybot.log, and supybot.conf will be imported later,
|
|
# because we need to set a language before loading the conf
|
|
|
|
import supybot.questions as questions
|
|
from supybot.questions import output, yn, anything, something, expect, getpass
|
|
|
|
def getPlugins(pluginDirs):
|
|
plugins = set([])
|
|
join = os.path.join
|
|
for pluginDir in pluginDirs:
|
|
try:
|
|
for filename in os.listdir(pluginDir):
|
|
fname = join(pluginDir, filename)
|
|
if (filename.endswith('.py') or os.path.isdir(fname)) \
|
|
and filename[0].isupper():
|
|
plugins.add(os.path.splitext(filename)[0])
|
|
except OSError:
|
|
continue
|
|
plugins.discard('Owner')
|
|
plugins = list(plugins)
|
|
plugins.sort()
|
|
return plugins
|
|
|
|
def loadPlugin(name):
|
|
import supybot.plugin as plugin
|
|
try:
|
|
module = plugin.loadPluginModule(name)
|
|
if hasattr(module, 'Class'):
|
|
return module
|
|
else:
|
|
output("""That plugin loaded fine, but didn't seem to be a real
|
|
Supybot plugin; there was no Class variable to tell us what class
|
|
to load when we load the plugin. We'll skip over it for now, but
|
|
you can always add it later.""")
|
|
return None
|
|
except Exception as e:
|
|
output("""We encountered a bit of trouble trying to load plugin %r.
|
|
Python told us %r. We'll skip over it for now, you can always add it
|
|
later.""" % (name, utils.gen.exnToString(e)))
|
|
return None
|
|
|
|
def describePlugin(module, showUsage):
|
|
if module.__doc__:
|
|
output(module.__doc__, unformatted=False)
|
|
elif hasattr(module.Class, '__doc__'):
|
|
output(module.Class.__doc__, unformatted=False)
|
|
else:
|
|
output("""Unfortunately, this plugin doesn't seem to have any
|
|
documentation. Sorry about that.""")
|
|
if showUsage:
|
|
if hasattr(module, 'example'):
|
|
if yn('This plugin has a usage example. '
|
|
'Would you like to see it?', default=False):
|
|
pydoc.pager(module.example)
|
|
else:
|
|
output("""This plugin has no usage example.""")
|
|
|
|
def clearLoadedPlugins(plugins, pluginRegistry):
|
|
for plugin in plugins:
|
|
try:
|
|
pluginKey = pluginRegistry.get(plugin)
|
|
if pluginKey():
|
|
plugins.remove(plugin)
|
|
except registry.NonExistentRegistryEntry:
|
|
continue
|
|
|
|
_windowsVarRe = re.compile(r'%(\w+)%')
|
|
def getDirectoryName(default, basedir=os.curdir, prompt=True):
|
|
done = False
|
|
while not done:
|
|
if prompt:
|
|
dir = something('What directory do you want to use?',
|
|
default=os.path.join(basedir, default))
|
|
else:
|
|
dir = os.path.join(basedir, default)
|
|
orig_dir = dir
|
|
dir = os.path.expanduser(dir)
|
|
dir = _windowsVarRe.sub(r'$\1', dir)
|
|
dir = os.path.expandvars(dir)
|
|
dir = os.path.abspath(dir)
|
|
try:
|
|
os.makedirs(dir)
|
|
done = True
|
|
except OSError as e:
|
|
# 17 is File exists for Linux (and likely other POSIX systems)
|
|
# 183 is the same for Windows
|
|
if e.args[0] == 17 or (os.name == 'nt' and e.args[0] == 183):
|
|
done = True
|
|
else:
|
|
output("""Sorry, I couldn't make that directory for some
|
|
reason. The Operating System told me %s. You're going to
|
|
have to pick someplace else.""" % e)
|
|
prompt = True
|
|
return (dir, os.path.dirname(orig_dir))
|
|
|
|
|
|
def main():
|
|
import supybot.version as version
|
|
parser = optparse.OptionParser(usage='Usage: %prog [options]',
|
|
version='Supybot %s' % version.version)
|
|
parser.add_option('', '--allow-root', action='store_true',
|
|
dest='allowRoot',
|
|
help='Determines whether the wizard will be allowed to '
|
|
'as root. This should not be used except in special '
|
|
'circumstances, such as running inside a containerized '
|
|
'environment.')
|
|
parser.add_option('', '--allow-home', action='store_true',
|
|
dest='allowHome',
|
|
help='Determines whether the wizard will be allowed to '
|
|
'run directly in the HOME directory. '
|
|
'You should not do this unless you want it to '
|
|
'create multiple files in your HOME directory.')
|
|
parser.add_option('', '--allow-bin', action='store_true',
|
|
dest='allowBin',
|
|
help='Determines whether the wizard will be allowed to '
|
|
'run directly in a directory for binaries (eg. '
|
|
'/usr/bin, /usr/local/bin, or ~/.local/bin). '
|
|
'You should not do this unless you want it to '
|
|
'create multiple non-binary files in directory '
|
|
'that should only contain binaries.')
|
|
parser.add_option('', '--no-network', action='store_false',
|
|
dest='network',
|
|
help='Determines whether the wizard will be allowed to '
|
|
'run without a network connection.')
|
|
(options, args) = parser.parse_args()
|
|
if os.name == 'posix':
|
|
if (os.getuid() == 0 or os.geteuid() == 0) and not options.allowRoot:
|
|
error('Running as root is not supported by default (see --allow-root).')
|
|
if os.name == 'posix':
|
|
if (os.getcwd() == os.path.expanduser('~')) and not options.allowHome:
|
|
error('Please, don\'t run this in your HOME directory.')
|
|
if (os.path.split(os.getcwd())[-1] == 'bin') and not options.allowBin:
|
|
error('Please, don\'t run this in a "bin" directory.')
|
|
if os.path.isfile(os.path.join('scripts', 'supybot-wizard')) or \
|
|
os.path.isfile(os.path.join('..', 'scripts', 'supybot-wizard')):
|
|
print('')
|
|
print('+------------------------------------------------------------+')
|
|
print('| +--------------------------------------------------------+ |')
|
|
print('| | Warning: It looks like you are running the wizard from | |')
|
|
print('| | the Supybot source directory. This is not recommended. | |')
|
|
print('| | Please press Ctrl-C and change to another directory. | |')
|
|
print('| +--------------------------------------------------------+ |')
|
|
print('+------------------------------------------------------------+')
|
|
print('')
|
|
|
|
if args:
|
|
parser.error('This program takes no non-option arguments.')
|
|
output("""This is a wizard to help you start running supybot. What it
|
|
will do is create the necessary config files based on the options you
|
|
select here. So hold on tight and be ready to be interrogated :)""")
|
|
|
|
|
|
output("""First of all, we can bold the questions you're asked so you can
|
|
easily distinguish the mostly useless blather (like this) from the
|
|
questions that you actually have to answer.""")
|
|
if yn('Would you like to try this bolding?', default=True):
|
|
questions.useBold = True
|
|
if not yn('Do you see this in bold?'):
|
|
output("""Sorry, it looks like your terminal isn't ANSI compliant.
|
|
Try again some other day, on some other terminal :)""")
|
|
questions.useBold = False
|
|
else:
|
|
output("""Great!""")
|
|
|
|
###
|
|
# Preliminary questions.
|
|
###
|
|
output("""We've got some preliminary things to get out of the way before
|
|
we can really start asking you questions that directly relate to what your
|
|
bot is going to be like.""")
|
|
|
|
# Advanced?
|
|
output("""We want to know if you consider yourself an advanced Supybot
|
|
user because some questions are just utterly boring and useless for new
|
|
users. Others might not make sense unless you've used Supybot for some
|
|
time.""")
|
|
advanced = yn('Are you an advanced Supybot user?', default=False)
|
|
|
|
# Language?
|
|
output("""This version of Supybot (known as Limnoria) includes another
|
|
language. This can be changed at any time. You need to answer with a short
|
|
id for the language, such as 'en', 'fr', 'it' (without the quotes). If
|
|
you want to use English, just press enter.""")
|
|
language = something('What language do you want to use?', default='en')
|
|
|
|
class Empty:
|
|
"""This is a hack to allow the i18n to get the current language, before
|
|
loading the conf module, before the conf module needs i18n to set the
|
|
default strings."""
|
|
def __call__(self):
|
|
return self.value
|
|
fakeConf = Empty()
|
|
fakeConf.supybot = Empty()
|
|
fakeConf.supybot.language = Empty()
|
|
fakeConf.supybot.language.value = language
|
|
i18n.conf = fakeConf
|
|
i18n.currentLocale = language
|
|
i18n.reloadLocales()
|
|
import supybot.conf as conf
|
|
i18n.import_conf() # It imports the real conf module
|
|
|
|
### Directories.
|
|
# We set these variables in cache because otherwise conf and log will
|
|
# create directories for the default values, which might not be what the
|
|
# user wants.
|
|
if advanced:
|
|
output("""Now we've got to ask you some questions about where some of
|
|
your directories are (or, perhaps, will be :)). If you're running this
|
|
wizard from the directory you'll actually be starting your bot from and
|
|
don't mind creating some directories in the current directory, then
|
|
just don't give answers to these questions and we'll create the
|
|
directories we need right here in this directory.""")
|
|
|
|
# conf.supybot.directories.log
|
|
output("""Your bot will need to put its logs somewhere. Do you have
|
|
any specific place you'd like them? If not, just press enter and we'll
|
|
make a directory named "logs" right here.""")
|
|
(logDir, basedir) = getDirectoryName('logs')
|
|
conf.supybot.directories.log.setValue(logDir)
|
|
import supybot.log as log
|
|
log._stdoutHandler.setLevel(100) # *Nothing* gets through this!
|
|
|
|
# conf.supybot.directories.data
|
|
output("""Your bot will need to put various data somewhere. Things
|
|
like databases, downloaded files, etc. Do you have any specific place
|
|
you'd like the bot to put these things? If not, just press enter and
|
|
we'll make a directory named "data" right here.""")
|
|
(dataDir, basedir) = getDirectoryName('data', basedir=basedir)
|
|
conf.supybot.directories.data.setValue(dataDir)
|
|
|
|
# conf.supybot.directories.conf
|
|
output("""Your bot must know where to find its configuration files.
|
|
It'll probably only make one or two, but it's gotta have some place to
|
|
put them. Where should that place be? If you don't care, just press
|
|
enter and we'll make a directory right here named "conf" where it'll
|
|
store its stuff. """)
|
|
(confDir, basedir) = getDirectoryName('conf', basedir=basedir)
|
|
conf.supybot.directories.conf.setValue(confDir)
|
|
|
|
# conf.supybot.directories.backup
|
|
output("""Your bot must know where to place backups of its conf and
|
|
data files. Where should that place be? If you don't care, just press
|
|
enter and we'll make a directory right here named "backup" where it'll
|
|
store its stuff.""")
|
|
(backupDir, basedir) = getDirectoryName('backup', basedir=basedir)
|
|
conf.supybot.directories.backup.setValue(backupDir)
|
|
|
|
# conf.supybot.directories.data.tmp
|
|
output("""Your bot needs a directory to put temporary files (used
|
|
mainly to atomically update its configuration files).""")
|
|
(tmpDir, basedir) = getDirectoryName('tmp', basedir=basedir)
|
|
conf.supybot.directories.data.tmp.setValue(tmpDir)
|
|
|
|
# conf.supybot.directories.data.web
|
|
output("""Your bot needs a directory to put files related to the web
|
|
server (templates, CSS).""")
|
|
(webDir, basedir) = getDirectoryName('web', basedir=basedir)
|
|
conf.supybot.directories.data.web.setValue(webDir)
|
|
|
|
|
|
# imports callbacks, which imports ircdb, which requires
|
|
# directories.conf
|
|
import supybot.plugin as plugin
|
|
|
|
# pluginDirs
|
|
output("""Your bot will also need to know where to find its plugins at.
|
|
Of course, it already knows where the plugins that it came with are,
|
|
but your own personal plugins that you write for will probably be
|
|
somewhere else.""")
|
|
pluginDirs = conf.supybot.directories.plugins()
|
|
output("""Currently, the bot knows about the following directories:""")
|
|
output(format('%L', pluginDirs + [plugin._pluginsDir]))
|
|
while yn('Would you like to add another plugin directory? '
|
|
'Adding a local plugin directory is good style.',
|
|
default=True):
|
|
(pluginDir, _) = getDirectoryName('plugins', basedir=basedir)
|
|
if pluginDir not in pluginDirs:
|
|
pluginDirs.append(pluginDir)
|
|
conf.supybot.directories.plugins.setValue(pluginDirs)
|
|
else:
|
|
output("""Your bot needs to create some directories in order to store
|
|
the various log, config, and data files.""")
|
|
basedir = something("""Where would you like to create these
|
|
directories?""", default=os.curdir)
|
|
|
|
# conf.supybot.directories.log
|
|
(logDir, basedir) = getDirectoryName('logs',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.log.setValue(logDir)
|
|
|
|
# conf.supybot.directories.data
|
|
(dataDir, basedir) = getDirectoryName('data',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.data.setValue(dataDir)
|
|
(tmpDir, basedir) = getDirectoryName('tmp',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.data.tmp.setValue(tmpDir)
|
|
(webDir, basedir) = getDirectoryName('web',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.data.web.setValue(webDir)
|
|
|
|
# conf.supybot.directories.conf
|
|
(confDir, basedir) = getDirectoryName('conf',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.conf.setValue(confDir)
|
|
|
|
# conf.supybot.directories.backup
|
|
(backupDir, basedir) = getDirectoryName('backup',
|
|
basedir=basedir, prompt=False)
|
|
conf.supybot.directories.backup.setValue(backupDir)
|
|
|
|
# pluginDirs
|
|
pluginDirs = conf.supybot.directories.plugins()
|
|
(pluginDir, _) = getDirectoryName('plugins',
|
|
basedir=basedir, prompt=False)
|
|
if pluginDir not in pluginDirs:
|
|
pluginDirs.append(pluginDir)
|
|
conf.supybot.directories.plugins.setValue(pluginDirs)
|
|
|
|
import supybot.log as log
|
|
log._stdoutHandler.setLevel(100) # *Nothing* gets through this!
|
|
import supybot.plugin as plugin
|
|
|
|
output("Good! We're done with the directory stuff.")
|
|
|
|
###
|
|
# Bot stuff
|
|
###
|
|
output("""Now we're going to ask you things that actually relate to the
|
|
bot you'll be running.""")
|
|
|
|
network = None
|
|
while not network:
|
|
output("""First, we need to know the name of the network you'd like to
|
|
connect to. Not the server host, mind you, but the name of the
|
|
network. If you plan to connect to irc.libera.chat, for instance,
|
|
you should answer this question with 'libera' or 'liberachat'
|
|
(without the quotes).
|
|
""")
|
|
network = something('What IRC network will you be connecting to?')
|
|
if '.' in network:
|
|
output("""There shouldn't be a '.' in the network name. Remember,
|
|
this is the network name, not the actual server you plan to connect
|
|
to.""")
|
|
network = None
|
|
elif not registry.isValidRegistryName(network):
|
|
output("""That's not a valid name for one reason or another. Please
|
|
pick a simpler name, one more likely to be valid.""")
|
|
network = None
|
|
|
|
conf.supybot.networks.setValue([network])
|
|
network = conf.registerNetwork(network)
|
|
|
|
defaultServer = None
|
|
server = None
|
|
ip = None
|
|
while not ip:
|
|
serverString = something('What server would you like to connect to?',
|
|
default=defaultServer)
|
|
if options.network:
|
|
try:
|
|
output("""Looking up %s...""" % serverString)
|
|
ip = socket.gethostbyname(serverString)
|
|
except:
|
|
output("""Sorry, I couldn't find that server. Perhaps you
|
|
misspelled it? Also, be sure not to put the port in the
|
|
server's name -- we'll ask you about that later.""")
|
|
else:
|
|
ip = 'no network available'
|
|
|
|
output("""Found %s (%s).""" % (serverString, ip))
|
|
|
|
# conf.supybot.networks.<network>.ssl
|
|
output("""Most networks allow you to use a secure connection via SSL.
|
|
If you are not sure whether this network supports SSL or not, check
|
|
its website.""")
|
|
use_ssl = yn('Do you want to use an SSL connection?', default=True)
|
|
network.ssl.setValue(use_ssl)
|
|
|
|
output("""IRC servers almost always accept connections on port
|
|
6697 (or 6667 when not using SSL). They can, however, accept connections
|
|
anywhere their admins feel like they want to accept connections from.""")
|
|
if yn('Does this server require connection on a non-standard port?',
|
|
default=False):
|
|
port = 0
|
|
while not port:
|
|
port = something('What port is that?')
|
|
try:
|
|
i = int(port)
|
|
if not (0 < i < 65536):
|
|
raise ValueError()
|
|
except ValueError:
|
|
output("""That's not a valid port.""")
|
|
port = 0
|
|
else:
|
|
if network.ssl.value:
|
|
port = 6697
|
|
else:
|
|
port = 6667
|
|
server = ':'.join([serverString, str(port)])
|
|
network.servers.setValue([server])
|
|
|
|
# conf.supybot.nick
|
|
# Force the user into specifying a nick if it didn't have one already
|
|
while True:
|
|
nick = something('What nick would you like your bot to use?',
|
|
default=None)
|
|
try:
|
|
conf.supybot.nick.set(nick)
|
|
break
|
|
except registry.InvalidRegistryValue:
|
|
output("""That's not a valid nick. Go ahead and pick another.""")
|
|
|
|
# conf.supybot.networks.<network>.sasl.{username,password}
|
|
output("""Most networks allow you to create an account, using services
|
|
typically known as NickServ. If you already have one, you can configure
|
|
the bot to use that account by proving your username and password
|
|
(also known as "SASL plain").
|
|
It is usually not a requirement.""")
|
|
if yn('Do you want your bot to use a network account?', default=False):
|
|
while True:
|
|
username = something('What account name should the bot use?')
|
|
password = getpass('What is the password of that account?')
|
|
if not username:
|
|
if yn('Missing username. Do you want to try again?'):
|
|
continue
|
|
if not password:
|
|
if yn('Missing password. Do you want to try again?'):
|
|
continue
|
|
network.sasl.username.set(username)
|
|
network.sasl.password.set(password)
|
|
break
|
|
|
|
# conf.supybot.user
|
|
if advanced:
|
|
output("""If you've ever done a /whois on a person, you know that IRC
|
|
provides a way for users to show the world their full name. What would
|
|
you like your bot's full name to be? If you don't care, just press
|
|
enter and it'll be the same as your bot's nick.""")
|
|
user = ''
|
|
user = something('What would you like your bot\'s full name to be?',
|
|
default=nick)
|
|
conf.supybot.user.set(user)
|
|
# conf.supybot.ident (if advanced)
|
|
defaultIdent = 'limnoria'
|
|
if advanced:
|
|
output("""IRC servers also allow you to set your ident, which they
|
|
might need if they can't find your identd server. What would you like
|
|
your ident to be? If you don't care, press enter and we'll use
|
|
'limnoria'. In fact, we prefer that you do this, because it provides
|
|
free advertising for Supybot when users /whois your bot. But, of
|
|
course, it's your call.""")
|
|
while True:
|
|
ident = something('What would you like your bot\'s ident to be?',
|
|
default=defaultIdent)
|
|
try:
|
|
conf.supybot.ident.set(ident)
|
|
break
|
|
except registry.InvalidRegistryValue:
|
|
output("""That was not a valid ident. Go ahead and pick
|
|
another.""")
|
|
else:
|
|
conf.supybot.ident.set(defaultIdent)
|
|
|
|
# conf.supybot.networks.<network>.password
|
|
output("""Some servers require a password to connect to them. Most
|
|
public servers don't. If you try to connect to a server and for some
|
|
reason it just won't work, it might be that you need to set a
|
|
password.""")
|
|
if yn('Do you want to set such a password?', default=False):
|
|
network.password.set(getpass())
|
|
|
|
# conf.supybot.networks.<network>.channels
|
|
output("""Of course, having an IRC bot isn't the most useful thing in the
|
|
world unless you can make that bot join some channels.""")
|
|
if yn('Do you want your bot to join some channels when it connects?',
|
|
default=True):
|
|
defaultChannels = ' '.join(network.channels())
|
|
output("""Separate channels with spaces. If the channel is locked
|
|
with a key, follow the channel name with the key separated
|
|
by a comma. For example:
|
|
#supybot-bots #mychannel,mykey #otherchannel""");
|
|
while True:
|
|
channels_input = something('What channels?', default=defaultChannels)
|
|
channels = []
|
|
error_ = False
|
|
for channel in channels_input.split():
|
|
L = channel.split(',')
|
|
if len(L) == 0:
|
|
continue
|
|
elif len(L) == 1:
|
|
(channel,) = L
|
|
channels.append(channel)
|
|
elif len(L) == 2:
|
|
(channel, key) = L
|
|
channels.append(channel)
|
|
network.channels.key.get(channel).setValue(key)
|
|
else:
|
|
output("""Too many commas in %s.""" % channel)
|
|
error_ = True
|
|
break
|
|
if error_:
|
|
break
|
|
try:
|
|
network.channels.set(' '.join(channels))
|
|
break
|
|
except registry.InvalidRegistryValue as e:
|
|
output(""""%s" is an invalid IRC channel. Be sure to prefix
|
|
the channel with # (or +, or !, or &, but no one uses those
|
|
channels, really). Be sure the channel key (if you are
|
|
supplying one) does not contain a comma.""" % e.channel)
|
|
else:
|
|
network.channels.setValue([])
|
|
|
|
###
|
|
# Plugins
|
|
###
|
|
def configurePlugin(module, advanced):
|
|
if hasattr(module, 'configure'):
|
|
output("""Beginning configuration for %s...""" %
|
|
module.Class.__name__)
|
|
module.configure(advanced)
|
|
print() # Blank line :)
|
|
output("""Done!""")
|
|
else:
|
|
conf.registerPlugin(module.__name__, currentValue=True)
|
|
|
|
plugins = getPlugins(pluginDirs + [plugin._pluginsDir])
|
|
for s in ('Admin', 'User', 'Channel', 'Misc', 'Config', 'Utilities'):
|
|
m = loadPlugin(s)
|
|
if m is not None:
|
|
configurePlugin(m, advanced)
|
|
else:
|
|
error('There was an error loading one of the core plugins that '
|
|
'under almost all circumstances are loaded. Go ahead and '
|
|
'fix that error and run this script again.')
|
|
clearLoadedPlugins(plugins, conf.supybot.plugins)
|
|
|
|
output("""Now we're going to run you through plugin configuration. There's
|
|
a variety of plugins in supybot by default, but you can create and
|
|
add your own, of course. We'll allow you to take a look at the known
|
|
plugins' descriptions and configure them
|
|
if you like what you see.""")
|
|
|
|
# bulk
|
|
addedBulk = False
|
|
if advanced and yn('Would you like to add plugins en masse first?'):
|
|
addedBulk = True
|
|
output(format("""The available plugins are: %L.""", plugins))
|
|
output("""What plugins would you like to add? If you've changed your
|
|
mind and would rather not add plugins in bulk like this, just press
|
|
enter and we'll move on to the individual plugin configuration.
|
|
We suggest you to add Aka, Ctcp, Later, Network, Plugin, String,
|
|
and Utilities""")
|
|
massPlugins = anything('Separate plugin names by spaces or commas:')
|
|
for name in re.split(r',?\s+', massPlugins):
|
|
module = loadPlugin(name)
|
|
if module is not None:
|
|
configurePlugin(module, advanced)
|
|
clearLoadedPlugins(plugins, conf.supybot.plugins)
|
|
|
|
# individual
|
|
if yn('Would you like to look at plugins individually?'):
|
|
output("""Next comes your opportunity to learn more about the plugins
|
|
that are available and select some (or all!) of them to run in your
|
|
bot. Before you have to make a decision, of course, you'll be able to
|
|
see a short description of the plugin and, if you choose, an example
|
|
session with the plugin. Let's begin.""")
|
|
# until we get example strings again, this will default to false
|
|
#showUsage =yn('Would you like the option of seeing usage examples?')
|
|
showUsage = False
|
|
name = expect('What plugin would you like to look at?',
|
|
plugins, acceptEmpty=True)
|
|
while name:
|
|
module = loadPlugin(name)
|
|
if module is not None:
|
|
describePlugin(module, showUsage)
|
|
if yn('Would you like to load this plugin?', default=True):
|
|
configurePlugin(module, advanced)
|
|
clearLoadedPlugins(plugins, conf.supybot.plugins)
|
|
if not yn('Would you like add another plugin?'):
|
|
break
|
|
name = expect('What plugin would you like to look at?', plugins)
|
|
|
|
###
|
|
# Sundry
|
|
###
|
|
output("""Although supybot offers a supybot-adduser script, with which
|
|
you can add users to your bot's user database, it's *very* important that
|
|
you have an owner user for you bot.""")
|
|
if yn('Would you like to add an owner user for your bot?', default=True):
|
|
import supybot.ircdb as ircdb
|
|
name = something('What should the owner\'s username be?')
|
|
try:
|
|
id = ircdb.users.getUserId(name)
|
|
u = ircdb.users.getUser(id)
|
|
if u._checkCapability('owner'):
|
|
output("""That user already exists, and has owner capabilities
|
|
already. Perhaps you added it before? """)
|
|
if yn('Do you want to remove its owner capability?',
|
|
default=False):
|
|
u.removeCapability('owner')
|
|
ircdb.users.setUser(u)
|
|
else:
|
|
output("""That user already exists, but doesn't have owner
|
|
capabilities.""")
|
|
if yn('Do you want to add to it owner capabilities?',
|
|
default=False):
|
|
u.addCapability('owner')
|
|
ircdb.users.setUser(u)
|
|
except KeyError:
|
|
password = getpass('What should the owner\'s password be?')
|
|
u = ircdb.users.newUser()
|
|
u.name = name
|
|
u.setPassword(password)
|
|
u.addCapability('owner')
|
|
ircdb.users.setUser(u)
|
|
|
|
output("""Of course, when you're in an IRC channel you can address the bot
|
|
by its nick and it will respond, if you give it a valid command (it may or
|
|
may not respond, depending on what your config variable replyWhenNotCommand
|
|
is set to). But your bot can also respond to a short "prefix character,"
|
|
so instead of saying "bot: do this," you can say, "@do this" and achieve
|
|
the same effect. Of course, you don't *have* to have a prefix char, but
|
|
if the bot ends up participating significantly in your channel, it'll ease
|
|
things.""")
|
|
if yn('Would you like to set the prefix char(s) for your bot? ',
|
|
default=True):
|
|
output("""Enter any characters you want here, but be careful: they
|
|
should be rare enough that people don't accidentally address the bot
|
|
(simply because they'll probably be annoyed if they do address the bot
|
|
on accident). You can even have more than one. I (jemfinch) am quite
|
|
partial to @, but that's because I've been using it since my ocamlbot
|
|
days.""")
|
|
import supybot.callbacks as callbacks
|
|
c = ''
|
|
while not c:
|
|
try:
|
|
c = anything('What would you like your bot\'s prefix '
|
|
'character(s) to be?')
|
|
conf.supybot.reply.whenAddressedBy.chars.set(c)
|
|
except registry.InvalidRegistryValue as e:
|
|
output(str(e))
|
|
c = ''
|
|
else:
|
|
conf.supybot.reply.whenAddressedBy.chars.set('')
|
|
|
|
###
|
|
# logging variables.
|
|
###
|
|
|
|
if advanced:
|
|
# conf.supybot.log.stdout
|
|
output("""By default, your bot will log not only to files in the logs
|
|
directory you gave it, but also to stdout. We find this useful for
|
|
debugging, and also just for the pretty output (it's colored!)""")
|
|
stdout = not yn('Would you like to turn off this logging to stdout?',
|
|
default=False)
|
|
conf.supybot.log.stdout.setValue(stdout)
|
|
if conf.supybot.log.stdout():
|
|
# conf.something
|
|
output("""Some terminals may not be able to display the pretty
|
|
colors logged to stderr. By default, though, we turn the colors
|
|
off for Windows machines and leave it on for *nix machines.""")
|
|
if os.name != 'nt':
|
|
conf.supybot.log.stdout.colorized.setValue(
|
|
not yn('Would you like to turn this colorization off?',
|
|
default=False))
|
|
|
|
# conf.supybot.log.level
|
|
output("""Your bot can handle debug messages at several priorities,
|
|
CRITICAL, ERROR, WARNING, INFO, and DEBUG, in decreasing order of
|
|
priority. By default, your bot will log all of these priorities except
|
|
DEBUG. You can, however, specify that it only log messages above a
|
|
certain priority level.""")
|
|
priority = str(conf.supybot.log.level)
|
|
logLevel = something('What would you like the minimum priority to be?'
|
|
' Just press enter to accept the default.',
|
|
default=priority).lower()
|
|
while logLevel not in ['debug','info','warning','error','critical']:
|
|
output("""That's not a valid priority. Valid priorities include
|
|
'DEBUG', 'INFO', 'WARNING', 'ERROR', and 'CRITICAL'""")
|
|
logLevel = something('What would you like the minimum priority to '
|
|
'be? Just press enter to accept the default.',
|
|
default=priority).lower()
|
|
conf.supybot.log.level.set(logLevel)
|
|
|
|
# conf.supybot.databases.plugins.channelSpecific
|
|
|
|
output("""Many plugins in Supybot are channel-specific. Their
|
|
databases, likewise, are specific to each channel the bot is in. Many
|
|
people don't want this, so we have one central location in which to
|
|
say that you would prefer all databases for all channels to be shared.
|
|
This variable, supybot.databases.plugins.channelSpecific, is that
|
|
place.""")
|
|
|
|
conf.supybot.databases.plugins.channelSpecific.setValue(
|
|
not yn('Would you like plugin databases to be shared by all '
|
|
'channels, rather than specific to each channel the '
|
|
'bot is in?'))
|
|
|
|
output("""There are a lot of options we didn't ask you about simply
|
|
because we'd rather you get up and running and have time
|
|
left to play around with your bot. But come back and see
|
|
us! When you've played around with your bot enough to
|
|
know what you like, what you don't like, what you'd like
|
|
to change, then take a look at your configuration file
|
|
when your bot isn't running and read the comments,
|
|
tweaking values to your heart's desire.""")
|
|
|
|
# Let's make sure that src/ plugins are loaded.
|
|
conf.registerPlugin('Admin', True)
|
|
conf.registerPlugin('AutoMode', True)
|
|
conf.registerPlugin('Channel', True)
|
|
conf.registerPlugin('Config', True)
|
|
conf.registerPlugin('Misc', True)
|
|
conf.registerPlugin('Network', True)
|
|
conf.registerPlugin('NickAuth', True)
|
|
conf.registerPlugin('User', True)
|
|
conf.registerPlugin('Utilities', True)
|
|
|
|
###
|
|
# Write the registry
|
|
###
|
|
|
|
# We're going to need to do a darcs predist thing here.
|
|
#conf.supybot.debug.generated.setValue('...')
|
|
|
|
if advanced:
|
|
basedir = '.'
|
|
filename = os.path.join(basedir, '%s.conf')
|
|
|
|
filename = something("""In which file would you like to save
|
|
this config?""", default=filename % nick)
|
|
if not filename.endswith('.conf'):
|
|
filename += '.conf'
|
|
registry.close(conf.supybot, os.path.expanduser(filename))
|
|
|
|
# Done!
|
|
output("""All done! Your new bot configuration is %s. If you're running
|
|
a *nix based OS, you can probably start your bot with the command line
|
|
"supybot %s". If you're not running a *nix or similar machine, you'll
|
|
just have to start it like you start all your other Python scripts.""" % \
|
|
(filename, filename))
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
main()
|
|
except KeyboardInterrupt:
|
|
# We may still be using bold text when exiting during a prompt
|
|
if questions.useBold:
|
|
import supybot.ansi as ansi
|
|
print(ansi.RESET)
|
|
print()
|
|
print()
|
|
output("""Well, it looks like you canceled out of the wizard before
|
|
it was done. Unfortunately, I didn't get to write anything to file.
|
|
Please run the wizard again to completion.""")
|
|
|
|
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
|