cslbot.commands package

Submodules

cslbot.commands.8ball module

cslbot.commands.8ball.cmd(send, msg, args)

Asks the Magic 8-Ball a question. Syntax: {command} <question>

cslbot.commands.about module

cslbot.commands.about.cmd(send, _, args)

Returns info about the bot. Syntax: {command}

cslbot.commands.abuse module

cslbot.commands.abuse.cmd(send, msg, args)

Shows or clears the abuse list Syntax: {command} <–clear|–show>

cslbot.commands.acronym module

cslbot.commands.acronym.cmd(send, msg, _)

Generates a meaning for the specified acronym. Syntax: {command} <acronym>

cslbot.commands.acronym.get_list()

cslbot.commands.active module

cslbot.commands.active.cmd(send, _, args)

Returns stats on the active users. Syntax: {command}

cslbot.commands.admins module

cslbot.commands.admins.cmd(send, _, args)

Returns a list of admins. V = Verified (authed to NickServ), U = Unverified. Syntax: {command}

cslbot.commands.babble module

cslbot.commands.babble.build_msg(cursor, speaker, length, start)

cslbot.commands.babble.cmd(send, msg, args)

Babbles like a user Syntax: {command} [nick] [–length <1|2>] [–start <word>]

cslbot.commands.babble.weighted_next(data)

cslbot.commands.bard module

cslbot.commands.bard.cmd(send, msg, _)

Translates something into Shakespearese. Syntax: {command} <something>

cslbot.commands.bc module

cslbot.commands.bc.cmd(send, msg, args)

Evaluates mathmatical expressions. Syntax: {command} <expression>

cslbot.commands.bc.get_scores(cursor)

cslbot.commands.bike module

cslbot.commands.bike.cmd(send, *_)

I’ve got a bike, you can ride it if you like. It’s got a basket, a bell that rings and things to make it look good. I’d give it to you if I could but I borrowed it. Syntax: {command}

cslbot.commands.blame module

cslbot.commands.blame.cmd(send, msg, args)

Blames a random user for something. Syntax: {command} [reason]

cslbot.commands.botsnack module

cslbot.commands.botsnack.cmd(send, msg, args)

Causes the bot to snack on something. Syntax: {command} [object]

cslbot.commands.botspam module

cslbot.commands.botspam.cmd(send, _, args)

Abuses the bot. Syntax: {command}

cslbot.commands.botspam.gen_fortune(send)

cslbot.commands.botspam.gen_urban(send, session, key)

cslbot.commands.cadmin module

cslbot.commands.cadmin.cmd(send, msg, args)

Clears the verified admin list Syntax: {command}

cslbot.commands.cancel module

cslbot.commands.cancel.cmd(send, msg, args)

Cancels a deferred action with the given id. Syntax: {command} <id>

cslbot.commands.channels module

cslbot.commands.channels.cmd(send, _, args)

Returns a listing of the current channels. Syntax: {command}

cslbot.commands.choose module

cslbot.commands.choose.cmd(send, msg, args)

Chooses between multiple choices. Syntax: {command} <object> or <object> (or <object>...)

cslbot.commands.cidr module

cslbot.commands.cidr.cmd(send, msg, args)

Gets a CIDR range. Syntax: {command} <range>

cslbot.commands.coin module

cslbot.commands.coin.cmd(send, msg, _)

Flips a coin a number of times. Syntax: {command} [number]

cslbot.commands.cve module

cslbot.commands.cve.cmd(send, msg, args)

Gets info on a CVE id from MITRE’s CVE database Syntax: {command} <cveid>

cslbot.commands.ddate module

cslbot.commands.ddate.cmd(send, *_)

Returns the Discordian date. Syntax: {command}

cslbot.commands.defersay module

cslbot.commands.defersay.cmd(send, msg, args)

Says something at a later time. Syntax: {command} <delay> <msg>

cslbot.commands.define module

cslbot.commands.define.cmd(send, msg, args)

Gets the definition of a word. Syntax: {command} [–entry <num>] <word>

cslbot.commands.define.get_def(entry, word, key)

cslbot.commands.define.strip_colon(msg)

cslbot.commands.demorse module

cslbot.commands.demorse.cmd(send, msg, _)

Converts morse to ascii. Syntax: {command} <text>

cslbot.commands.distro module

cslbot.commands.distro.cmd(send, *_)

Gets a random distro. Syntax: {command}

cslbot.commands.dvorak module

cslbot.commands.dvorak.cmd(send, msg, args)

Converts a message to/from dvorak. Syntax: {command} <–nick <nick>|msg>

cslbot.commands.dvorak.get_log(conn, user, target)

cslbot.commands.dvorak.translate(msg, encode=True)

cslbot.commands.ebay module

cslbot.commands.ebay.cmd(send, _, args)

Implements xkcd 576. Syntax: {command}

cslbot.commands.ebay.get_categories(apikey)

cslbot.commands.ebay.get_item(category, apikey)

cslbot.commands.eix module

cslbot.commands.eix.cmd(send, msg, args)

Runs eix with the given arguments. Syntax: {command} <package>

cslbot.commands.errno module

cslbot.commands.errno.cmd(send, msg, _)

Return either a random value or the specified one from errno.h. Syntax: {command} <errorcode|list>

cslbot.commands.filter module

cslbot.commands.filter.cmd(send, msg, args)

Changes the output filter. Syntax: {command} [–channel channel] <filter|–show|–list|–reset|–chain filter,[filter2,...]>

cslbot.commands.filter.get_filters(handler, target)

cslbot.commands.fml module

cslbot.commands.fml.cmd(send, msg, args)

Gets a random FML post. Syntax: {command}

cslbot.commands.fortune module

cslbot.commands.fortune.cmd(send, msg, args)

Returns a fortune. Syntax: {command} <list|[-a|-o] [module]>

cslbot.commands.fweather module

cslbot.commands.fweather.cmd(send, msg, _)

Gets the F***ING weather! Syntax: {command} <location>

cslbot.commands.gcc module

cslbot.commands.gcc.cmd(send, msg, args)

Compiles stuff. Syntax: {command} <code>

cslbot.commands.gizoogle module

cslbot.commands.gizoogle.cmd(send, msg, args)

Translates something into gangsta. Syntax: {command} <something>

cslbot.commands.google module

cslbot.commands.google.cmd(send, msg, args)

Googles something. Syntax: {command} <term>

cslbot.commands.grep module

cslbot.commands.grep.cmd(send, msg, args)

Greps the log for a string. Syntax: {command} [–nick <nick>] [–ignore-case/-i] <string>

cslbot.commands.guarded module

cslbot.commands.guarded.cmd(send, _, args)

Shows the currently guarded nicks. Syntax: {command}

cslbot.commands.help module

cslbot.commands.help.cmd(send, msg, args)

Gives help. Syntax: {command} [command]

cslbot.commands.highlight module

cslbot.commands.highlight.cmd(send, msg, args)

When a nick was last pinged. Syntax: {command} [–channel #channel] [nick]

cslbot.commands.hooks module

cslbot.commands.hooks.cmd(send, *_)

Lists loaded hooks Syntax: {command}

cslbot.commands.ignore module

cslbot.commands.ignore.cmd(send, msg, args)

Handles ignoring/unignoring people Syntax: {command} <–clear|–show/–list|–delete|nick>

cslbot.commands.imdb module

cslbot.commands.imdb.cmd(send, msg, args)

Gets a random movie. Syntax: {command}

cslbot.commands.inspect module

cslbot.commands.inspect.cmd(send, msg, args)

‘Inspects a bot attribute. Syntax: {command} <attr>

cslbot.commands.insult module

cslbot.commands.insult.cmd(send, msg, args)

Insults a user. Syntax: {command} [nick]

cslbot.commands.ipa module

cslbot.commands.ipa.cmd(send, msg, args)

Converts text into NATO form. Syntax: {command} <text>

cslbot.commands.ipa.gen_nato(msg)

cslbot.commands.issue module

cslbot.commands.issue.cmd(send, msg, args)

Files a github issue or gets a open one. Syntax: {command} <title [–desc description]|–get <number>>

cslbot.commands.isup module

cslbot.commands.isup.cmd(send, msg, args)

Checks if a website is up. Syntax: {command} <website>

cslbot.commands.jargon module

cslbot.commands.jargon.cmd(send, *_)

Causes the bot to generate some jargon. Syntax: {command}

cslbot.commands.join module

cslbot.commands.join.cmd(send, msg, args)

Orders the bot to join a channel Syntax: {command} <channel> [channel] ...

cslbot.commands.kill module

cslbot.commands.kill.cmd(send, msg, args)

Kills somebody. Syntax: {command} <victim>

cslbot.commands.line module

cslbot.commands.line.cmd(send, msg, args)

Returns a random line from $nick. Syntax: {command} (–channel <channel>) (nick)

cslbot.commands.lmgtfy module

cslbot.commands.lmgtfy.cmd(send, msg, args)

Explain things. Syntax: {command} <text>

cslbot.commands.man module

cslbot.commands.man.cmd(send, msg, args)

Gets a man page. Syntax: {command} [section] <command>

cslbot.commands.metar module

cslbot.commands.metar.cmd(send, msg, args)

Gets the weather. Syntax: {command} <station> [station2...]

cslbot.commands.microwave module

cslbot.commands.microwave.cmd(send, msg, args)

Microwaves something. Syntax: {command} <level> <target>

cslbot.commands.mission module

cslbot.commands.mission.cmd(send, *_)

Announces the mission. Syntax: {command}

cslbot.commands.mode module

cslbot.commands.mode.cmd(send, msg, args)

Sets a mode. Syntax: {command} [–chan <chan>] <mode>

cslbot.commands.morse module

cslbot.commands.morse.cmd(send, msg, args)

Converts text to morse code. Syntax: {command} [text]

cslbot.commands.msg module

cslbot.commands.msg.cmd(send, msg, args)

Sends a message to a channel Syntax: {command} <channel> <message>

cslbot.commands.nicks module

cslbot.commands.nicks.cmd(send, msg, args)

Gets previous nicks. Syntax: {command} <nick>

cslbot.commands.note module

cslbot.commands.note.cmd(send, msg, args)

Leaves a note for a user or users. Syntax: {command} <nick>[,nick2,...] <note>

cslbot.commands.nuke module

cslbot.commands.nuke.cmd(send, msg, args)

Nukes somebody. Syntax: {command} <target>

cslbot.commands.part module

cslbot.commands.part.cmd(send, msg, args)

Orders the bot to leave a channel Syntax: {command} <channel>

cslbot.commands.pester module

cslbot.commands.pester.cmd(send, msg, args)

Pesters somebody. Syntax: {command} <nick> <message>

cslbot.commands.ping module

cslbot.commands.ping.cmd(send, msg, args)

Ping something. Syntax: {command} <target>

cslbot.commands.praise module

cslbot.commands.praise.cmd(send, msg, _)

Praises something. Syntax: {command} <something>

cslbot.commands.pull module

cslbot.commands.pull.cmd(send, _, args)

Pull changes. Syntax: {command} <branch>

cslbot.commands.quit module

cslbot.commands.quit.cmd(send, msg, args)

Makes the bot disconnect and shut off Syntax: {command}

cslbot.commands.quote module

cslbot.commands.quote.cmd(send, msg, args)

Handles quotes. Syntax: {command} <number|nick>, !quote –add <quote> –nick <nick> (–approve), !quote –list, !quote –delete <number>, !quote –edit <number> <quote> –nick <nick> !quote –search (–offset <num>) <number>

cslbot.commands.quote.do_add_quote(nick, quote, session, isadmin, approve, send, args)

cslbot.commands.quote.do_delete_quote(args, session, qid)

cslbot.commands.quote.do_get_quote(session, qid=None)

cslbot.commands.quote.do_list_quotes(session, quote_url)

cslbot.commands.quote.do_update_quote(session, qid, nick, quote)

cslbot.commands.quote.get_quotes_nick(session, nick)

cslbot.commands.quote.search_quote(session, offset, search)

cslbot.commands.random module

cslbot.commands.random.cmd(send, msg, args)

For when you don’t have enough randomness in your life. Syntax: {command} [–int] [len]

cslbot.commands.random.getrandbits(k) → x. Generates an int with k random bits.

cslbot.commands.randtranslate module

cslbot.commands.randtranslate.cmd(send, msg, args)

Translate something into a random language Syntax: {command} <text>

cslbot.commands.reddit module

cslbot.commands.reddit.cmd(send, msg, args)

Gets a random Reddit post. Syntax: {command} [subreddit]

cslbot.commands.roman module

cslbot.commands.roman.cmd(send, msg, _)

Convert a number to the roman numeral equivalent. Syntax: {command} [number]

cslbot.commands.roman.gen_roman(num)

cslbot.commands.s module

cslbot.commands.s.cmd(send, msg, args)

Corrects a previous message. Syntax: {command}/<msg>/<replacement>/<ig|nick>

cslbot.commands.s.do_replace(log, config, char, regex, replacement)

cslbot.commands.s.get_log(conn, target, user)

cslbot.commands.s.get_modifiers(msg, nick, nickregex)

cslbot.commands.score module

cslbot.commands.score.cmd(send, msg, args)

Gets scores. Syntax: {command} <–high|–low|nick>

cslbot.commands.seen module

cslbot.commands.seen.cmd(send, msg, args)

When a nick was last seen. Syntax: {command} <nick>

cslbot.commands.seen.get_last(cursor, cmdchar, ctrlchan, nick)

cslbot.commands.sha512 module

cslbot.commands.sha512.cmd(send, msg, _)

SHA512 hashes something. Syntax: {command} <msg>

cslbot.commands.shibe module

cslbot.commands.shibe.cmd(send, msg, _)

Generates a shibe reaction. Syntax: {command} [topic1]...[topicn]

cslbot.commands.signal module

cslbot.commands.signal.cmd(send, msg, _)

Return either a random value or the specified one from signal.h. Syntax: {command} <signal|list>

cslbot.commands.slap module

cslbot.commands.slap.cmd(send, msg, args)

Slap somebody. Syntax: {command} <nick> [for <reason>]

cslbot.commands.slogan module

cslbot.commands.slogan.cmd(send, msg, _)

Gets a slogan. Syntax: {command} [text]

cslbot.commands.stats module

cslbot.commands.stats.cmd(send, msg, args)

Gets stats. Syntax: {command} <–high|–low|–userhigh|–nick <nick>|command>

cslbot.commands.stats.get_command(session, command, totals)

cslbot.commands.stats.get_command_totals(session)

cslbot.commands.stats.get_nick(session, nick)

cslbot.commands.stats.get_nick_totals(session, command=None)

cslbot.commands.stock module

cslbot.commands.stock.cmd(send, msg, args)

Gets a stock quote. Syntax: {command} [symbol] Powered by markit on demand (http://dev.markitondemand.com)

cslbot.commands.stock.gen_stock(msg)

cslbot.commands.stock.random_stock()

cslbot.commands.stopwatch module

cslbot.commands.stopwatch.cmd(send, msg, args)

Start/stops/resume/get stopwatch Syntax: {command} <start|stop|resume|delete|get|list>

cslbot.commands.stopwatch.create_stopwatch(args)

cslbot.commands.stopwatch.delete_stopwatch(args)

cslbot.commands.stopwatch.get_elapsed(session, sw)

cslbot.commands.stopwatch.get_stopwatch(args)

cslbot.commands.stopwatch.list_stopwatch(args)

cslbot.commands.stopwatch.resume_stopwatch(args)

cslbot.commands.stopwatch.stop_stopwatch(args)

cslbot.commands.summon module

cslbot.commands.summon.cmd(send, msg, args)

Summons a user Syntax: {command} <nick>

cslbot.commands.threads module

cslbot.commands.threads.cmd(send, *_)

Enumerate threads. Syntax: {command}

cslbot.commands.throw module

cslbot.commands.throw.cmd(send, msg, args)

Throw something. Syntax: {command} <object> [at <target>]

cslbot.commands.time module

cslbot.commands.time.cmd(send, msg, _)

Tells the time. Syntax: {command}

cslbot.commands.timeout module

cslbot.commands.timeout.cmd(send, msg, args)

Quiets a user, then unquiets them after the specified period of time. Syntax: {command} <timespec> <nickname> timespec is in the format: <number><unit>, where unit is s, m, h, or d.

cslbot.commands.timeuntil module

cslbot.commands.timeuntil.cmd(send, msg, args)

Reports the difference between now and some specified time. Syntax: {command} <time>

cslbot.commands.tjbash module

cslbot.commands.tjbash.cmd(send, msg, _)

Finds a random quote from tjbash.org given search criteria. Syntax: {command} [searchstring]

cslbot.commands.translate module

cslbot.commands.translate.cmd(send, msg, args)

Translate something. Syntax: {command} [–lang <language code>] <text> See https://msdn.microsoft.com/en-us/library/hh456380.aspx for a list of valid language codes

cslbot.commands.tumblr module

cslbot.commands.tumblr.cmd(send, msg, args)

Searches tumblr Syntax: {command} <blogname> <–submit content|–random>

cslbot.commands.uptime module

cslbot.commands.uptime.cmd(send, _, args)

Shows the bot’s uptime. Syntax: {command}

cslbot.commands.urban module

cslbot.commands.urban.blacklist_word(session, msg)

cslbot.commands.urban.cmd(send, msg, args)

Gets a definition from urban dictionary. Syntax: {command} <[#<num>] <term>|–blacklist (word)|–unblacklist (word)>

cslbot.commands.urban.unblacklist_word(session, msg)

cslbot.commands.version module

cslbot.commands.version.cmd(send, msg, args)

Check the git revison. Syntax: {command} [check|master]

cslbot.commands.vote module

cslbot.commands.vote.cmd(send, msg, args)

Handles voting. Syntax: {command} <start|end|list|tally|edit|delete|retract|reopen|(num) vote>

cslbot.commands.vote.delete_poll(args)

Deletes a poll

cslbot.commands.vote.edit_poll(args)

Edits a poll

cslbot.commands.vote.end_poll(args)

Ends a poll

cslbot.commands.vote.get_open_poll(session, pid)

cslbot.commands.vote.get_response(session, pid, nick)

cslbot.commands.vote.list_polls(args)

cslbot.commands.vote.reopen(args)

reopens a closed poll.

cslbot.commands.vote.retract(args)

Deletes a vote for a poll

cslbot.commands.vote.start_poll(args)

Starts a poll

cslbot.commands.vote.tally_poll(args)

Shows the results of poll

cslbot.commands.vote.vote(session, nick, pid, response)

Votes on a poll

cslbot.commands.wai module

cslbot.commands.wai.cmd(send, *_)

Gives a reason for something. Syntax: {command}

cslbot.commands.weather module

cslbot.commands.weather.cmd(send, msg, args)

Gets the weather. Syntax: {command} <[–date (date)] [–hour (hour)] (location)|–set (default)> Powered by Weather Underground, www.wunderground.com

cslbot.commands.weather.get_default(nick, session, send, config, source)

cslbot.commands.weather.get_forecast(cmdargs, send, apikey)

cslbot.commands.weather.get_hourly(cmdargs, send, apikey)

cslbot.commands.weather.get_weather(cmdargs, send, apikey)

cslbot.commands.weather.set_default(nick, location, session, send, apikey)

Sets nick’s default location to location.

cslbot.commands.weather.valid_location(location, apikey)

cslbot.commands.wiki module

cslbot.commands.wiki.cmd(send, msg, args)

Returns the first wikipedia result for the argument. Syntax: {command} [term]

cslbot.commands.wiki.get_rand(url)

cslbot.commands.wikipath module

cslbot.commands.wikipath.check_article(name)

cslbot.commands.wikipath.cmd(send, msg, args)

Find a path between two wikipedia articles. Syntax: {command} [article] [article]

cslbot.commands.wikipath.gen_path(cmdargs)

cslbot.commands.wikipath.get_article()

cslbot.commands.wolf module

cslbot.commands.wolf.cmd(send, msg, args)

Queries WolframAlpha. Syntax: {command} <expression>

cslbot.commands.word module

cslbot.commands.word.cmd(send, *_)

Gets a random word. Syntax: {command}

cslbot.commands.wtf module

cslbot.commands.wtf.cmd(send, msg, _)

Tells you what acronyms mean. Syntax: {command} <term>

cslbot.commands.xkcd module

cslbot.commands.xkcd.cmd(send, msg, args)

Gets a xkcd comic. Syntax: {command} [num|latest|term]

cslbot.commands.xkcd.do_search(msg, key, searchid)

cslbot.commands.xkcd.get_latest()

cslbot.commands.yoda module

cslbot.commands.yoda.cmd(send, msg, _)

Convert a message to Yoda-speak. Syntax: {command} <msg>

Module contents