cslbot.helpers package

Submodules

cslbot.helpers.admin module

cslbot.helpers.admin.set_admin(msg, handler)

Handle admin verification responses from NickServ.

If NickServ tells us that the nick is authed, mark it as verified.

cslbot.helpers.arguments module

class cslbot.helpers.arguments.ArgParser(config=None, **kwargs)

Bases: argparse.ArgumentParser

error(message)

exit(status=0, message=None)

parse_args(msg)

parse_known_args(msg, namespace=None)

exception cslbot.helpers.arguments.ArgumentException

Bases: Exception

class cslbot.helpers.arguments.ChanParser(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Bases: argparse.Action

class cslbot.helpers.arguments.DateParser(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Bases: argparse.Action

class cslbot.helpers.arguments.NickParser(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Bases: argparse.Action

class cslbot.helpers.arguments.TumblrParser(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Bases: argparse.Action

cslbot.helpers.babble module

cslbot.helpers.babble.build_markov(cursor, cmdchar, ctrlchan, speaker=None, initial_run=False, debug=False)

Builds a markov dictionary.

cslbot.helpers.babble.build_rows(cursor, length, markov, initial_run)

cslbot.helpers.babble.clean_msg(msg)

cslbot.helpers.babble.delete_tables(cursor)

cslbot.helpers.babble.generate_markov(cursor, length, messages, initial_run)

cslbot.helpers.babble.get_markov(cursor, length, node, initial_run)

cslbot.helpers.babble.get_messages(cursor, cmdchar, ctrlchan, speaker, newer_than_id)

cslbot.helpers.babble.postgres_hack(cursor, length, data)

cslbot.helpers.babble.update_count(cursor, rows, length, source, target)

cslbot.helpers.babble.update_markov(cursor, config)

cslbot.helpers.backtrace module

cslbot.helpers.backtrace.handle_traceback(ex, c, target, config, source='the bot')

cslbot.helpers.backtrace.output_traceback(ex)

Returns a tuple of a prettyprinted error message and string representation of the error

cslbot.helpers.command module

class cslbot.helpers.command.Command(names, args=[], limit=0, admin=False)

Bases: object

get_doc()

is_limited()

requires_admin()

run(send, msg, args, command, nick, target, handler)

class cslbot.helpers.command.CommandData

Bases: object

disable_command(command)

Adds a command to the disabled commands list.

enable_command(command)

Removes a command from the disabled commands list.

get_command(command_name)

get_disabled_commands()

get_enabled_commands()

get_known_commands()

is_disabled(command)

is_registered(command_name)

register(name, command)

scan_for_commands()

Scans for commands

Return type:list Returns:A list of modules that failed to reload

cslbot.helpers.command.check_command(cursor, nick, msg, target)

cslbot.helpers.command.record_command(cursor, nick, command, channel)

cslbot.helpers.config module

cslbot.helpers.config.check_admins(admins, nickregex)

cslbot.helpers.config.do_config(config)

cslbot.helpers.config.do_setup(configfile)

cslbot.helpers.config.load_config(config_file, send)

cslbot.helpers.config.migrate_config(config_file, config_obj, send)

cslbot.helpers.control module

cslbot.helpers.control.get_accept_msg(handler, pending, type)

cslbot.helpers.control.get_reject_msg(pending, type)

cslbot.helpers.control.handle_accept(args)

cslbot.helpers.control.handle_chanserv(args)

cslbot.helpers.control.handle_ctrlchan(handler, msg, send)

Handle the control channel.

cslbot.helpers.control.handle_disable(args)

cslbot.helpers.control.handle_enable(args)

cslbot.helpers.control.handle_guard(args)

cslbot.helpers.control.handle_help(args)

cslbot.helpers.control.handle_quote(args)

cslbot.helpers.control.handle_reject(args)

cslbot.helpers.control.handle_show(args)

cslbot.helpers.control.handle_show_pending(args)

cslbot.helpers.control.handle_unguard(args)

cslbot.helpers.control.init_parser(send, handler, db)

cslbot.helpers.control.show_pending(db, admins, send, ping=False)

cslbot.helpers.control.show_pending_items(type, items, send)

cslbot.helpers.control.toggle_logging(level)

cslbot.helpers.control.toggle_module(type, name, enable=True)

cslbot.helpers.core module

class cslbot.helpers.core.IrcBot(confdir)

Bases: irc.bot.SingleServerIRCBot

do_cap(_)

static get_target(e)

get_version()

Get the version.

handle_event(c, e)

handle_msg(c, e)

Handles all messages.

If a exception is thrown, catch it and display a nice traceback instead of crashing.

Do the appropriate processing for each event type.

handle_quit(_, e)

is_reload(e)

reload_handler(c, e)

This handles reloads.

shutdown(*_)

shutdown_mp(clean=True)

Shutdown all the multiprocessing.

Parameters:clean (bool) – Whether to shutdown things cleanly, or force a quick and dirty shutdown.

cslbot.helpers.core.init(confdir='/etc/cslbot')

The bot’s main entry point.

Initialize the bot and start processing messages.

cslbot.helpers.exception module

exception cslbot.helpers.exception.CommandFailedException

Bases: Exception

cslbot.helpers.geoip module

cslbot.helpers.geoip.get_zipcode(db, ip)

cslbot.helpers.handler module

class cslbot.helpers.handler.BotHandler(config, connection, channels, confdir)

Bases: object

abusecheck(send, nick, target, limit, cmd)

Rate-limits commands.

If a nick uses commands with the limit attr set, record the time

at which they were used.

If the command is used more than limit times in a

minute, ignore the nick.

check_mode(mode)

do_args(modargs, send, nick, target, source, name, msgtype)

Handle the various args that modules need.

do_join(cmdargs, nick, msgtype, send, c)

Join a channel.

Checks if bot is already joined to channel.

do_kick(send, target, nick, msg, slogan=True)

Kick users.

If kick is disabled, don’t do anything.

If the bot is not a op, rage at a op.

Kick the user.

do_log(target, nick, msg, msgtype)

Handles logging.

Logs to a sql db.

do_mode(target, msg, nick, send)

reop and handle guard violations

do_part(cmdargs, nick, target, msgtype, send, c)

Leaves a channel.

Prevent user from leaving the primary channel.

do_rejoin(c, e)

do_welcome()

Do setup when connected to server.

Join the primary channel.

Join the control channel.

get_admins()

Check verification for all admins.

get_cmd(msg)

get_data()

Saves the handler’s data for bot.IrcBot.do_reload()

get_filtered_send(cmdargs, send, target)

Parse out any filters.

static get_max_length(target, msgtype)

handle_account(e)

handle_authenticate(e)

handle_cap(e)

handle_event(msg, send, c, e)

handle_hooks(send, nick, target, e, msg)

handle_join(c, e, target, send)

handle_kick(c, e, target, send)

handle_msg(c, e)

The Heart and Soul of IrcBot.

handle_nick(send, e)

handle_welcome()

handle_who(e)

is_admin(send, nick)

Checks if a nick is a admin.

If the nick is not in self.admins then it’s not a admin.

If NickServ hasn’t responded yet, then the admin is unverified,

so assume they aren’t a admin.

is_ignored(nick)

rate_limited_send(mtype, target, msg)

run_cmd(send, nick, target, cmd_name, cmdargs, e)

send(target, nick, msg, msgtype, ignore_length=False, filters=None)

Send a message.

Records the message in the log.

set_data(data)

Called from bot.IrcBot.do_reload() to restore the handler’s data.

update_authstatus(nick)

cslbot.helpers.hook module

class cslbot.helpers.hook.Hook(name, types, args=[])

Bases: object

run(send, msg, msgtype, handler, target, args)

class cslbot.helpers.hook.HookData

Bases: object

disable_hook(hook)

Adds a hook to the disabled hooks list.

enable_hook(hook)

Removes a command from the disabled hooks list.

get_disabled_hooks()

get_enabled_hooks()

get_hook_objects()

get_known_hooks()

is_disabled(hook)

register(hook)

scan_for_hooks()

Scans for hooks

Return type:list Returns:A list of modules that failed to reload

cslbot.helpers.identity module

cslbot.helpers.identity.do_kick(session, nick)

cslbot.helpers.identity.get_chain(session, nick, limit=0)

cslbot.helpers.identity.handle_nick(handler, e)

cslbot.helpers.misc module

cslbot.helpers.misc.do_nuke(c, nick, target, channel)

cslbot.helpers.misc.do_pull(srcdir=None, repo=None)

cslbot.helpers.misc.get_channels(chanlist, nick)

cslbot.helpers.misc.get_cmdchar(config, connection, msg, msgtype)

cslbot.helpers.misc.get_fortune(msg, name='fortune')

cslbot.helpers.misc.get_users(args)

cslbot.helpers.misc.get_version(srcdir)

cslbot.helpers.misc.ignore(session, nick)

cslbot.helpers.misc.list_fortunes(offensive=False)

cslbot.helpers.misc.parse_header(header, msg)

cslbot.helpers.misc.parse_time(time)

cslbot.helpers.misc.ping(ping_map, c, e, pongtime)

cslbot.helpers.misc.random() → x in the interval [0, 1).

cslbot.helpers.misc.split_msg(msgs, max_len)

Splits as close to the end as possible.

cslbot.helpers.misc.truncate_msg(msg, max_len)

cslbot.helpers.modutils module

cslbot.helpers.modutils.add_to_groups(config, groups, mod_type)

cslbot.helpers.modutils.get_disabled(mod_type)

cslbot.helpers.modutils.get_enabled(mod_type, package='CslBot')

cslbot.helpers.modutils.get_modules(mod_type)

cslbot.helpers.modutils.group_disabled(mod_type, name)

cslbot.helpers.modutils.group_enabled(mod_type, name)

cslbot.helpers.modutils.init_aux(config)

cslbot.helpers.modutils.init_groups(groups, confdir)

cslbot.helpers.modutils.load_groups(confdir)

cslbot.helpers.modutils.loaded(mod_type, name)

cslbot.helpers.modutils.parse_group(cfg)

cslbot.helpers.modutils.safe_load(modname)

Load a module, logging errors instead of dying if it fails to load

Returns:None when import was successful. String is the first line of the error message

cslbot.helpers.modutils.safe_reload(modname)

Catch and log any errors that arise from reimporting a module, but do not die.

Returns:None when import was successful. String is the first line of the error message

cslbot.helpers.modutils.scan_and_reimport(mod_type)

Scans folder for modules.

cslbot.helpers.orm module

class cslbot.helpers.orm.Babble(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

freq

id

key

source

target

word

class cslbot.helpers.orm.Babble2(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

freq

id

key

source

target

word

class cslbot.helpers.orm.Babble_count(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

count

id

key

length

type

class cslbot.helpers.orm.Babble_last(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

last

class cslbot.helpers.orm.Commands(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

channel

command

id

nick

class cslbot.helpers.orm.Ignore(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

expire

id

nick

class cslbot.helpers.orm.Issues(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

accepted

description

id

source

title

class cslbot.helpers.orm.Log(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

flags

id

msg

source

target

time

type

class cslbot.helpers.orm.Notes(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

nick

note

pending

submitter

time

class cslbot.helpers.orm.Poll_responses(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

pid

response

voter

class cslbot.helpers.orm.Polls(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

accepted

active

deleted

id

question

submitter

class cslbot.helpers.orm.Quotes(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

accepted

id

nick

quote

submitter

class cslbot.helpers.orm.Scores(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

nick

score

class cslbot.helpers.orm.Stopwatches(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

active

elapsed

id

time

class cslbot.helpers.orm.Tumblrs(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

accepted

blogname

id

post

submitter

class cslbot.helpers.orm.UrbanBlacklist(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

word

class cslbot.helpers.orm.Urls(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

nick

time

title

url

class cslbot.helpers.orm.Weather_prefs(**kwargs)

Bases: sqlalchemy.ext.declarative.api.Base

id

location

nick

cslbot.helpers.orm.setup_db(session, botconfig, confdir)

Sets up the database.

cslbot.helpers.reddit module

cslbot.helpers.reddit.check_exists(subreddit)

Make sure that a subreddit actually exists

cslbot.helpers.reddit.random_post(subreddit, apikey)

Gets a random post from a subreddit and returns a title and shortlink to it

cslbot.helpers.reloader module

cslbot.helpers.reloader.do_log(c, target, msg)

cslbot.helpers.reloader.do_reload(bot, target, cmdargs, server_send=None)

The reloading magic.

First, reload handler.py.

Then make copies of all the handler data we want to keep.

Create a new handler and restore all the data.

cslbot.helpers.reloader.load_modules(cfg, confdir, send=<function error>)

cslbot.helpers.server module

class cslbot.helpers.server.BotNetHandler(request, client_address, server)

Bases: socketserver.BaseRequestHandler

get_data()

handle()

handle_cmd(cmd, bot, send)

class cslbot.helpers.server.BotNetServer(server_address, RequestHandlerClass, bind_and_activate=True)

Bases: socketserver.ThreadingMixIn, socketserver.TCPServer

allow_reuse_address = True

cslbot.helpers.server.init_server(bot)

cslbot.helpers.sql module

class cslbot.helpers.sql.Sql(config, confdir)

Bases: object

log(source, target, flags, msg, mtype)

Logs a message to the database

source: The source of the message.

target: The target of the message.

flags: Is the user a operator or voiced?

msg: The text of the message.

msg: The type of message.

time: The current time (Unix Epoch).

session_scope()

Provide a transactional scope around a series of operations.

cslbot.helpers.sql.get_session(config)

cslbot.helpers.textutils module

cslbot.helpers.textutils.append_filters(filters)

cslbot.helpers.textutils.char_to_bin(c)

cslbot.helpers.textutils.gen_binary(text)

cslbot.helpers.textutils.gen_creffett(msg)

cslbot.helpers.textutils.gen_fwilson(x, mode=None)

cslbot.helpers.textutils.gen_gizoogle(msg)

cslbot.helpers.textutils.gen_hashtag(msg)

cslbot.helpers.textutils.gen_insult(user)

cslbot.helpers.textutils.gen_lenny(msg)

cslbot.helpers.textutils.gen_morse(msg)

cslbot.helpers.textutils.gen_praise(msg)

cslbot.helpers.textutils.gen_randfilter(msg)

cslbot.helpers.textutils.gen_random_translate(msg)

cslbot.helpers.textutils.gen_removevowels(msg)

cslbot.helpers.textutils.gen_shakespeare(msg)

cslbot.helpers.textutils.gen_shibe(msg)

cslbot.helpers.textutils.gen_slogan(msg)

cslbot.helpers.textutils.gen_translate(msg, outputlang='en')

cslbot.helpers.textutils.gen_underscore(msg)

cslbot.helpers.textutils.gen_word()

cslbot.helpers.textutils.gen_xkcd_sub(msg, hook=False)

cslbot.helpers.textutils.gen_yoda(msg)

cslbot.helpers.textutils.get_praise()

cslbot.helpers.textutils.random() → x in the interval [0, 1).

cslbot.helpers.textutils.reverse(msg)

cslbot.helpers.textutils.transform_text(msg)

cslbot.helpers.tokens module

class cslbot.helpers.tokens.Token

Bases: object

class cslbot.helpers.tokens.TranslateToken

Bases: cslbot.helpers.tokens.Token

update(config)

cslbot.helpers.tokens.update_all_tokens(config)

cslbot.helpers.urlutils module

cslbot.helpers.urlutils.ensure_prefix(url)

cslbot.helpers.urlutils.get_short(msg, key)

cslbot.helpers.urlutils.get_title(url)

cslbot.helpers.web module

cslbot.helpers.web.create_issue(title, desc, nick, repo, apikey)

cslbot.helpers.web.get_rand_word(session)

cslbot.helpers.web.get_urban(msg, session, key)

cslbot.helpers.web.get_urban_definition(msg, key)

cslbot.helpers.web.post_tumblr(config, blog, body)

cslbot.helpers.workers module

class cslbot.helpers.workers.Event(event, run_on_cancel)

Bases: tuple

event

Alias for field number 0

run_on_cancel

Alias for field number 1

class cslbot.helpers.workers.Workers(handler)

Bases: object

cancel(eventid)

check_active(handler, send)

check_babble(handler, send)

defer(t, run_on_cancel, func, *args)

handle_pending(handler, send)

restart_pool()

run_action(func, args)

run_pool(func, args)

start_thread(func, *args, **kwargs)

stop_workers(clean)

Stop workers and deferred events

update_tokens(handler)

cslbot.helpers.workers.pool_init()

We ignore Ctrl-C in the poll workers, so that we can clean things up properly.

Module contents