def addAlias(self, irc, name, alias, lock=False): if self._invalidCharsRe.search(name): raise AliasError, 'Names cannot contain spaces or square brackets.' if '|' in name: raise AliasError, 'Names cannot contain pipes.' realName = callbacks.canonicalName(name) if name != realName: s = format('That name isn\'t valid. Try %q instead.', realName) raise AliasError, s name = realName if self.isCommandMethod(name): if realName not in self.aliases: s = 'You can\'t overwrite commands in this plugin.' raise AliasError, s if name in self.aliases: (currentAlias, locked, _) = self.aliases[name] if locked and currentAlias != alias: raise AliasError, format('Alias %q is locked.', name) try: f = makeNewAlias(name, alias) f = new.instancemethod(f, self, Alias) except RecursiveAlias: raise AliasError, 'You can\'t define a recursive alias.' aliasGroup = self.registryValue('aliases', value=False) if name in self.aliases: # We gotta remove it so its value gets updated. aliasGroup.unregister(name) conf.registerGlobalValue(aliasGroup, name, registry.String(alias, '')) conf.registerGlobalValue(aliasGroup.get(name), 'locked', registry.Boolean(lock, '')) self.aliases[name] = [alias, lock, f]
def addAlias(self, irc, name, alias, lock=False): if not self.isValidName(name): raise AliasError('Invalid alias name.') realName = callbacks.canonicalName(name) if name != realName: s = format(_('That name isn\'t valid. Try %q instead.'), realName) raise AliasError(s) name = realName if self.isCommandMethod(name): if realName not in self.aliases: s = 'You can\'t overwrite commands in this plugin.' raise AliasError(s) if name in self.aliases: (currentAlias, locked, _) = self.aliases[name] if locked and currentAlias != alias: raise AliasError(format('Alias %q is locked.', name)) f = makeNewAlias(name, alias) f = types.MethodType(f, self) if name in self.aliases: # We gotta remove it so its value gets updated. self.aliasRegistryRemove(name) aliasGroup = self.aliasRegistryGroup(name) if needsEscaping(name): confname = escapeAlias(name) else: confname = name conf.registerGlobalValue(aliasGroup, confname, registry.String(alias, '')) conf.registerGlobalValue(aliasGroup.get(confname), 'locked', registry.Boolean(lock, '')) self.aliases[name] = [alias, lock, f]
def __init__(self, irc): self.__parent = super(Alias, self) self.__parent.__init__(irc) # Schema: {alias: [command, locked, commandMethod]} self.aliases = {} # XXX This should go. aliases should be a space separate list, etc. group = conf.supybot.plugins.Alias.aliases for (name, alias) in registry._cache.iteritems(): name = name.lower() if name.startswith('supybot.plugins.alias.aliases.'): name = name[len('supybot.plugins.alias.aliases.'):] if '.' in name: continue conf.registerGlobalValue(group, name, registry.String('', '')) conf.registerGlobalValue(group.get(name), 'locked', registry.Boolean(False, '')) for (name, value) in group.getValues(fullNames=False): name = name.lower() # Just in case. command = value() locked = value.locked() self.aliases[name] = [command, locked, None] for (alias, (command, locked, _)) in self.aliases.items(): try: self.addAlias(irc, alias, command, locked) except Exception, e: self.log.exception('Exception when trying to add alias %s. ' 'Removing from the Alias database.', alias) del self.aliases[alias]
def __init__(self, irc): self.__parent = super(Ottdcoop, self) self.__parent.__init__(irc) # Schema: {alias: [command, locked, commandMethod]} self.abbr = {} # XXX This should go. aliases should be a space separate list, etc. group = conf.supybot.plugins.Ottdcoop.abbr for (name, text) in registry._cache.iteritems(): name = name.lower() if name.startswith('supybot.plugins.ottdcoop.abbr.'): name = name[len('supybot.plugins.ottdcoop.abbr.'):] if '.' in name: continue self.log.debug ('Name: %s, Value: %s', name, text) conf.registerGlobalValue(group, name, registry.String('', '')) conf.registerGlobalValue(group.get(name), 'url', registry.String('', '')) for (name, value) in group.getValues(fullNames=False): name = name.lower() # Just in case. text = value() url = value.url() self.log.debug ('Name: %s, Text: %s, URL: %s', name, text, url) self.abbr[name] = [text, url, None] for (name, (text, url, _)) in self.abbr.items(): try: f = self.makeAbbrCommand(name) self.abbr[name] = [text, url, f] except Exception, e: self.log.exception('Exception when trying to add abbreviation %s. ' 'Removing from the database.', name) del self.abbr[name]
def addAlias(self, irc, name, alias, lock=False): if not self._validNameRe.search(name): raise AliasError('Names can only contain alphanumerical ' 'characters, dots, pipes, and ' 'exclamation/interrogatin marks ' '(and the first character cannot be a number).') realName = callbacks.canonicalName(name) if name != realName: s = format(_('That name isn\'t valid. Try %q instead.'), realName) raise AliasError(s) name = realName if self.isCommandMethod(name): if realName not in self.aliases: s = 'You can\'t overwrite commands in this plugin.' raise AliasError(s) if name in self.aliases: (currentAlias, locked, _) = self.aliases[name] if locked and currentAlias != alias: raise AliasError(format('Alias %q is locked.', name)) f = makeNewAlias(name, alias) f = types.MethodType(f, self) if '.' in name or '|' in name: aliasGroup = self.registryValue('escapedaliases', value=False) confname = escapeAlias(name) else: aliasGroup = self.registryValue('aliases', value=False) confname = name if name in self.aliases: # We gotta remove it so its value gets updated. aliasGroup.unregister(confname) conf.registerGlobalValue(aliasGroup, confname, registry.String(alias, '')) conf.registerGlobalValue(aliasGroup.get(confname), 'locked', registry.Boolean(lock, '')) self.aliases[name] = [alias, lock, f]
def registerBugzilla(name, url=''): if (not re.match('\w+$', name)): s = utils.str.normalizeWhitespace(BugzillaName.__doc__) raise registry.InvalidRegistryValue("%s (%s)" % (s, name)) install = conf.registerGroup(conf.supybot.plugins.Bugzilla.bugzillas, name.lower()) conf.registerGlobalValue(install, 'url', registry.String(url, """Determines the URL to this Bugzilla installation. This must be identical to the urlbase (or sslbase) parameter used by the installation. (The url that shows up in emails.) It must end with a forward slash.""")) conf.registerChannelValue(install, 'queryTerms', registry.String('', """Additional search terms in QuickSearch format, that will be added to every search done with "query" against this installation.""")) # conf.registerGlobalValue(install, 'aliases', # BugzillaNames([], """Alternate names for this Bugzilla # installation. These must be globally unique.""")) conf.registerGroup(install, 'watchedItems', orderAlphabetically=True) conf.registerChannelValue(install.watchedItems, 'product', registry.CommaSeparatedListOfStrings([], """What products should be reported to this channel?""")) conf.registerChannelValue(install.watchedItems, 'component', registry.CommaSeparatedListOfStrings([], """What components should be reported to this channel?""")) conf.registerChannelValue(install.watchedItems, 'changer', registry.SpaceSeparatedListOfStrings([], """Whose changes should be reported to this channel?""")) conf.registerChannelValue(install.watchedItems, 'all', registry.Boolean(False, """Should *all* changes be reported to this channel?""")) conf.registerChannelValue(install, 'reportedChanges', registry.CommaSeparatedListOfStrings(['newBug', 'newAttach', 'Flags', 'Attachment Flags', 'Resolution', 'Product', 'Component'], """The names of fields, as they appear in bugmail, that should be reported to this channel.""")) conf.registerGroup(install, 'traces') conf.registerChannelValue(install.traces, 'report', registry.Boolean(False, """Some Bugzilla installations have gdb stack traces in comments. If you turn this on, the bot will report some basic details of any trace that shows up in the comments of a new bug.""")) conf.registerChannelValue(install.traces, 'ignoreFunctions', registry.SpaceSeparatedListOfStrings(['__kernel_vsyscall', 'raise', 'abort', '??'], """Some functions are useless to report, from a stack trace. This contains a list of function names to skip over when reporting traces to the channel.""")) #conf.registerChannelValue(install.traces, 'crashStarts', # registry.CommaSeparatedListOfStrings([], # """These are function names that indicate where a crash starts # in a stack trace.""")) conf.registerChannelValue(install.traces, 'frameLimit', registry.PositiveInteger(5, """How many stack frames should be reported from the crash?"""))
def register_feed_config(self, name, url=''): self.registryValue('feeds').add(name) group = self.registryValue('feeds', value=False) conf.registerGlobalValue(group, name, registry.String(url, '')) feed_group = conf.registerGroup(group, name) conf.registerChannelValue(feed_group, 'format', registry.String('', _("""Feed-specific format. Defaults to supybot.plugins.RSS.format if empty."""))) conf.registerChannelValue(feed_group, 'announceFormat', registry.String('', _("""Feed-specific announce format. Defaults to supybot.plugins.RSS.announceFormat if empty.""")))
def watch_option(watchname, option): ''' Return a watch-specific option, registering on the fly. ''' watches = global_option('watches') try: watch = watches.get(watchname) except registry.NonExistentRegistryEntry: watch = conf.registerGroup(watches, watchname) try: return watch.get(option) except registry.NonExistentRegistryEntry: conf.registerGlobalValue(watch, option, _WATCH_OPTIONS[option]()) return watch.get(option)
def repo_option(reponame, option): ''' Return a repo-specific option, registering on the fly. ''' repos = global_option('repos') try: repo = repos.get(reponame) except registry.NonExistentRegistryEntry: repo = conf.registerGroup(repos, reponame) try: return repo.get(option) except registry.NonExistentRegistryEntry: conf.registerGlobalValue(repo, option, _REPO_OPTIONS[option]()) return repo.get(option)
def registerRename(plugin, command=None, newName=None): g = conf.registerGlobalValue(conf.supybot.commands.renames, plugin, registry.SpaceSeparatedSetOfStrings([], """Determines what commands in this plugin are to be renamed.""")) if command is not None: g().add(command) v = conf.registerGlobalValue(g, command, registry.String('', '')) if newName is not None: v.setValue(newName) # In case it was already registered. return v else: return g
def __init__(self, irc): self.__parent = super(SMBugs, self) self.__parent.__init__(irc) try: self.registryValue("refreshTime") except registry.NonExistentRegistryEntry: plugin = conf.registerPlugin('SMBugs') conf.registerGlobalValue(plugin, "refreshTime", registry.PositiveInteger(60 * 2, "Time in seconds to refresh bugs list.")) self.BugCheck(irc, time.localtime()) self.MercurialCheck(irc, time.localtime())
def register_feed_config(self, name, url=''): self.registryValue('feeds').add(name) group = self.registryValue('feeds', value=False) conf.registerGlobalValue(group, name, registry.String(url, '')) feed_group = conf.registerGroup(group, name) conf.registerChannelValue(feed_group, 'format', registry.String('', _("""Feed-specific format. Defaults to supybot.plugins.RSS.format if empty."""))) conf.registerChannelValue(feed_group, 'announceFormat', registry.String('', _("""Feed-specific announce format. Defaults to supybot.plugins.RSS.announceFormat if empty."""))) conf.registerGlobalValue(feed_group, 'waitPeriod', registry.NonNegativeInteger(0, _("""If set to a non-zero value, overrides supybot.plugins.RSS.waitPeriod for this particular feed.""")))
def registerBugtracker(name, url='', description='', trackertype=''): conf.supybot.plugins.Bugtracker.bugtrackers().add(name) group = conf.registerGroup(conf.supybot.plugins.Bugtracker.bugtrackers, name) URL = conf.registerGlobalValue(group, 'url', registry.String(url, '')) DESC = conf.registerGlobalValue(group, 'description', registry.String(description, '')) TRACKERTYPE = conf.registerGlobalValue(group, 'trackertype', registry.String(trackertype, '')) if url: URL.setValue(url) if description: DESC.setValue(description) if trackertype: if defined_bugtrackers.has_key(trackertype.lower()): TRACKERTYPE.setValue(trackertype.lower()) else: raise BugtrackerError("Unknown trackertype: %s" % trackertype)
def registerNick(nick, password=''): p = conf.supybot.plugins.Services.Nickserv.get('password') h = _('Determines what password the bot will use with NickServ when ' \ 'identifying as %s.') % nick v = conf.registerGlobalValue(p, nick, registry.String(password, h, private=True)) if password: v.setValue(password)
def registerObserver(name, regexpString='', commandString='', probability=1.0): g = conf.registerGlobalValue(conf.supybot.plugins.Observer.observers, name, registry.Regexp(regexpString, """Determines what regexp must match for this observer to be executed.""")) if regexpString: g.set(regexpString) # This is in case it's been registered. conf.registerGlobalValue(g, 'command', registry.String('', """Determines what command will be run when this observer is executed.""")) if commandString: g.command.setValue(commandString) conf.registerGlobalValue(g, 'probability', Probability(probability, """ Determines what the probability of executing this observer is if it matches.""")) g.probability.setValue(probability) conf.supybot.plugins.Observer.observers().add(name) return g
def update(self): """update the geo files""" now=int(time.time()) try: lastupdate=self.registryValue('datalastupdated') self.log.info('Last update: %s seconds ago.' % lastupdate) except registry.NonExistentRegistryEntry: self.log.info('supybot.plugins.%s.datalastupdate not set. Creating...' % self.name) conf.registerGlobalValue(conf.supybot.plugins.get(self.name), 'datalastupdated', registry.PositiveInteger(1, """An integer representing the time since epoch the .dat file was last updated.""")) self.log.info('...success!') lastupdate=1 self.log.info('Last update: Unknown/Never') #if (now-lastupdate)>604800: # updated weekly if 1==1: self.setRegistryValue('datalastupdated', now) self.log.info("Starting update of Geo data files...") self.getfile() return
def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import output, expect, anything, something, yn Lookup = conf.registerPlugin('Lookup', True) lookups = Lookup.lookups output("""This module allows you to define commands that do a simple key lookup and return some simple value. It has a command "add" that takes a command name and a file from the data dir and adds a command with that name that responds with the mapping from that file. The file itself should be composed of lines of the form key:value.""") while yn('Would you like to add a file?'): filename = something('What\'s the filename?') try: fd = file(filename) except EnvironmentError, e: output('I couldn\'t open that file: %s' % e) continue counter = 1 try: try: for line in fd: line = line.rstrip('\r\n') if not line or line.startswith('#'): continue (key, value) = line.split(':', 1) counter += 1 except ValueError: output('That\'s not a valid file; ' 'line #%s is malformed.' % counter) continue finally: fd.close() command = something('What would you like the command to be?') conf.registerGlobalValue(lookups,command, registry.String(filename,'')) nokeyVal = yn('Would you like the key to be shown for random ' 'responses?') conf.registerGlobalValue(lookups.get(command), 'nokey', registry.Boolean(nokeyVal, ''))
def register_feed_config(self, name, url=''): self.registryValue('feeds').add(name) group = self.registryValue('feeds', value=False) conf.registerGlobalValue(group, name, registry.String(url, """The URL for the feed %s. Note that because announced lines are cached, you may need to reload this plugin after changing this option.""" % name)) feed_group = conf.registerGroup(group, name) conf.registerChannelValue(feed_group, 'format', registry.String('', _("""Feed-specific format. Defaults to supybot.plugins.RSS.format if empty."""))) conf.registerChannelValue(feed_group, 'announceFormat', registry.String('', _("""Feed-specific announce format. Defaults to supybot.plugins.RSS.announceFormat if empty."""))) conf.registerGlobalValue(feed_group, 'waitPeriod', registry.NonNegativeInteger(0, _("""If set to a non-zero value, overrides supybot.plugins.RSS.waitPeriod for this particular feed.""")))
def register_jira_install(self, handle): group = conf.registerGroup(conf.supybot.plugins.JIRA.installs, handle) conf.registerGlobalValue(group, "url", registry.String("", "URL of the JIRA install, e.g. " \ "http://issues.foresightlinux.org/jira")) conf.registerGlobalValue(group, "username", registry.String("", "Username to login the JIRA install", private=True)) conf.registerGlobalValue(group, "password", registry.String("", "Password to login the JIRA install", private=True))
# # ### import supybot.conf as conf import supybot.registry as registry try: from supybot.i18n import PluginInternationalization _ = PluginInternationalization('MUD') except: # Placeholder that allows to run the plugin on a bot # without the i18n module _ = lambda x: x def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('MUD', True) MUD = conf.registerPlugin('MUD') conf.registerGlobalValue(MUD, 'server', registry.String('', _("""Server Address"""))) conf.registerGlobalValue(MUD, 'port', registry.Integer('', _("""Port""")))
# 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. ### import supybot.conf as conf import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Flight', True) Flight = conf.registerPlugin('Flight') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Flight, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue( Flight, 'flightapi_url', registry.String('http://localhost:5000/api', 'flightapi url', private=True)) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
' || ', """Determines what string is used to separate headlines in new feeds.""")) conf.registerChannelValue( RSS, 'announcementPrefix', registry.StringWithSpaceOnRight( 'New news from ', """Determines what prefix is prepended (if any) to the new news item announcements made in the channel.""")) conf.registerChannelValue( RSS, 'announce', registry.SpaceSeparatedSetOfStrings([], """Determines which RSS feeds should be announced in the channel; valid input is a list of strings (either registered RSS feeds or RSS feed URLs) separated by spaces.""")) conf.registerGlobalValue( RSS, 'waitPeriod', registry.PositiveInteger( 1800, """Indicates how many seconds the bot will wait between retrieving RSS feeds; requests made within this period will return cached results.""")) conf.registerGlobalValue( RSS, 'feeds', FeedNames([], """Determines what feeds should be accessible as commands.""")) conf.registerChannelValue( RSS, 'showLinks', registry.Boolean( False, """Determines whether the bot will list the link along with the title of the feed when the rss command is called. supybot.plugins.RSS.announce.showLinks affects whether links will be listed when a feed is automatically announced.""")) conf.registerGlobalValue( RSS, 'defaultNumberOfHeadlines',
conf.registerGlobalValue( TimeBomb, 'colors', registry.SpaceSeparatedListOfStrings([ 'AliceBlue', 'AntiqueWhite', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque', 'Black', 'BlanchedAlmond', 'Blue', 'BlueViolet', 'Brown', 'BurlyWood', 'CadetBlue', 'Chartreuse', 'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan', 'DarkBlue', 'DarkCyan', 'DarkGoldenRod', 'DarkGray', 'DarkGreen', 'DarkKhaki', 'DarkMagenta', 'DarkOliveGreen', 'DarkOrange', 'DarkOrchid', 'DarkRed', 'DarkSalmon', 'DarkSeaGreen', 'DarkSlateBlue', 'DarkSlateGray', 'DarkTurquoise', 'DarkViolet', 'DeepPink', 'DeepSkyBlue', 'DimGray', 'DodgerBlue', 'FireBrick', 'FloralWhite', 'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod', 'Gray', 'Green', 'GreenYellow', 'HoneyDew', 'HotPink', 'IndianRed', 'Indigo', 'Ivory', 'Khaki', 'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue', 'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGrey', 'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue', 'LightSlateGray', 'LightSteelBlue', 'LightYellow', 'Lime', 'LimeGreen', 'Linen', 'Magenta', 'Maroon', 'MediumAquaMarine', 'MediumBlue', 'MediumOrchid', 'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen', 'MediumTurquoise', 'MediumVioletRed', 'MidnightBlue', 'MintCream', 'MistyRose', 'Moccasin', 'NavajoWhite', 'Navy', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed', 'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed', 'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple', 'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Salmon', 'SandyBrown', 'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue', 'SlateGray', 'Snow', 'SpringGreen', 'SteelBlue', 'Tan', 'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White', 'WhiteSmoke', 'Yellow', 'YellowGreen' ], """The set of possible timebomb wire colors"""))
def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('IMDB', True) IMDB = conf.registerPlugin('IMDB') conf.registerGlobalValue( IMDB, 'template', registry.String( "$title ($year, $country, [$rated], $genre, $runtime) | IMDB: $imdbRating MC: $metascore% | $plot | Director: $director | Writer: $writer | Actors: $actors | http://imdb.com/title/$imdbID", _("""Template for the output of a search query."""))) # alternative template: # $title ($year - $director) :: [i:$imdbRating r:$tomatoMeter m:$metascore] $plot :: http://imdb.com/title/$imdbID conf.registerGlobalValue( IMDB, 'noResultsMessage', registry.String("No results for that query.", _("""This message is sent when there are no results"""))) conf.registerGlobalValue(IMDB, 'omdbAPI', registry.String('', _("""OMDB API Key"""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
_ = PluginInternationalization('WolframAlpha') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('WolframAlpha', True) WolframAlpha = conf.registerPlugin('WolframAlpha') conf.registerGlobalValue( WolframAlpha, 'apiKey', registry.String('', ("""Your Wolfram Alpha API key."""), private=True)) conf.registerGlobalValue( WolframAlpha, 'maxOutput', registry.Integer(4, ("""How many lines by default to output."""))) conf.registerGlobalValue( WolframAlpha, 'useImperial', registry.Boolean(True, ("""Use imperial units? Defaults to yes."""))) conf.registerGlobalValue( WolframAlpha, 'reinterpretInput', registry.Boolean(False, ( """Reinterpret input string if WA API cannot understand. Best to leave false.""" ))) conf.registerGlobalValue( WolframAlpha, 'disableANSI', registry.Boolean(False,
from supybot.questions import expect, anything, something, yn conf.registerPlugin('Jira', True) user = something('What is your api username?') password = something('What is your password for that username?') api_url = something('What is your api url (eg. https://jira.com/api/v2)?') url = something('What is your domain (eg. https://jira.com)?') conf.supybot.plugins.Jira.apiUser.setValue(user) conf.supybot.plugins.Jira.apiPass.setValue(password) conf.supybot.plugins.Jira.apiUrl.setValue(api_url) conf.supybot.plugins.Jira.domain.setValue(url) Jira = conf.registerPlugin('Jira') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Jira, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue(Jira, 'apiUser', registry.String('', """Defines the username used to access the API.""")) conf.registerGlobalValue(Jira, 'apiPass', registry.String('', """Defines the password used to access the API.""")) conf.registerGlobalValue(Jira, 'apiUrl', registry.String('', """Defines the full base api url to access the API. (eg. https://<instance>.Jira.com/api/v2)""")) conf.registerGlobalValue(Jira, 'domain', registry.String('', """Defines the url to access. (eg. https://jira.com)""")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
should be revealed with each hint"""))) conf.registerChannelValue(Trivia, 'flexibility', registry.PositiveInteger(8, _("""The flexibility of the trivia answer checker. One typo will be allowed for every __ characters."""))) conf.registerChannelValue(Trivia, 'color', registry.PositiveInteger(10, _("""The mIRC color to use for trivia questions"""))) conf.registerChannelValue(Trivia, 'inactiveShutoff', registry.Integer(6, _("""The number of questions that can go unanswered before the trivia stops automatically."""))) conf.registerGlobalValue(Trivia, 'scoreFile', registry.String('scores.txt', _("""The path to the scores file. If it doesn't exist, it will be created."""))) conf.registerGlobalValue(Trivia, 'questionFile', registry.String('questions.txt', _("""The path to the questions file. If it doesn't exist, it will be created."""))) conf.registerChannelValue(Trivia, 'defaultRoundLength', registry.PositiveInteger(10, _("""The default number of questions to be asked in a round of trivia."""))) conf.registerGlobalValue(Trivia, 'questionFileSeparator', registry.String('*', _("""The separator used between the questions and answers in your trivia file."""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('MCStatus', True) MCStatus = conf.registerPlugin('MCStatus') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(MCStatus, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGlobalValue(MCStatus, 'statusURL', registry.String('http://status.mojang.com/check', _("""This is the URL that is queried for JSON data. You shouldn't change this unless you know what you are doing."""))) conf.registerChannelValue(MCStatus, 'prefix', registry.String('', _("""This text is prepended to the mcstatus command's output."""))) conf.registerChannelValue(MCStatus, 'suffix', registry.String('', _("""This text is appended to the mcstatus command's output."""))) conf.registerChannelValue(MCStatus, 'separator', registry.StringSurroundedBySpaces('|', _("""This text is inserted between service-status pairs."""))) conf.registerGroup(MCStatus, 'service') conf.registerChannelValue(MCStatus.service, 'prefix', registry.String('', _("""This text is prepended to each service's name."""))) conf.registerChannelValue(MCStatus.service, 'suffix',
import supybot.registry as registry from supybot.i18n import PluginInternationalization, internationalizeDocstring _ = PluginInternationalization('Weather') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Weather', True) Weather = conf.registerPlugin('Weather') conf.registerGlobalValue(Weather,'apiKey', registry.String('', ("""Your wunderground.com API key."""), private=True)) conf.registerChannelValue(Weather,'useImperial', registry.Boolean(True, ("""Use imperial units? Defaults to yes."""))) conf.registerChannelValue(Weather,'disableColoredTemp', registry.Boolean(False, """If True, this will disable coloring temperatures based on values.""")) # conf.registerChannelValue(Weather,'useWeatherSymbols', registry.Boolean(False, """Use unicode symbols with weather conditions and for wind direction.""")) conf.registerGlobalValue(Weather,'forecast', registry.Boolean(True, ("""Display forecast in output by default?"""))) conf.registerGlobalValue(Weather,'alerts', registry.Boolean(False, ("""Display alerts by default?"""))) conf.registerGlobalValue(Weather,'almanac', registry.Boolean(False, ("""Display almanac by default?"""))) conf.registerGlobalValue(Weather,'astronomy', registry.Boolean(False, ("""Display astronomy by default?"""))) conf.registerGlobalValue(Weather,'showPressure', registry.Boolean(False, ("""Show pressure in output?"""))) conf.registerGlobalValue(Weather,'showWind', registry.Boolean(False, ("""Show wind in output?"""))) conf.registerGlobalValue(Weather,'showUpdated', registry.Boolean(False, ("""Show updated in output?"""))) conf.registerChannelValue(Weather,'showImperialAndMetric', registry.Boolean(True, ("""In channel, display output with Imperial and Metric?"""))) conf.registerGlobalValue(Weather,'lang', registry.String('EN', ("""language to use. See docs for available codes."""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=250:
# POSSIBILITY OF SUCH DAMAGE. ### import supybot.conf as conf import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Bitbucket', True) Bitbucket = conf.registerPlugin('Bitbucket') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Bitbucket, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue(Bitbucket, 'accountname', registry.String('', """Bitbucket account name.""")) conf.registerGlobalValue(Bitbucket, 'repo_slug', registry.String('', """Bitbucket repository name.""")) conf.registerGlobalValue(Bitbucket, 'snarferTimeout', registry.PositiveInteger(300, """Time out for snarfer in seconds.""")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
from supybot.i18n import internationalizeDocstring _ = PluginInternationalization('GUI') except: # This are useless functions that's allow to run the plugin on a bot # without the i18n plugin _ = lambda x: x internationalizeDocstring = lambda x: x def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('GUI', True) GUI = conf.registerPlugin('GUI') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(GUI, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGlobalValue( GUI, 'host', registry.String('127.0.0.1', _("""The host the server will bind."""))) conf.registerGlobalValue( GUI, 'port', registry.Integer(14789, _("""The port the server will bind."""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
# This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Factoids', True) class FactoidFormat(registry.TemplatedString): """Value must include $value, otherwise the factoid's value would be left out.""" requiredTemplates = ['value'] Factoids = conf.registerPlugin('Factoids') conf.registerGroup(Factoids, 'web') conf.registerGlobalValue(Factoids.web, 'enable', registry.Boolean(False, _("""Determines whether the Factoids plugins will be browsable on the HTTP server."""))) conf.registerChannelValue(Factoids.web, 'channel', registry.Boolean(False, _("""Determines whether factoids can be displayed via the web server."""))) conf.registerChannelValue(Factoids, 'requireVoice', registry.Boolean(False, _("""Only allows a user with voice or above on a channel to use the 'learn' and 'forget' commands."""))) conf.registerChannelValue(Factoids, 'learnSeparator', registry.String('is', _("""Determines what separator must be used in the learn command. Defaults to 'is' -- learn <key> is <value>. Users might want to change this to something else, so it's configurable."""))) conf.registerChannelValue(Factoids, 'showFactoidIfOnlyOneMatch', registry.Boolean(True, _("""Determines whether the bot will reply with the
import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Mailbox', True) Mailbox = conf.registerPlugin('Mailbox') conf.registerGlobalValue( Mailbox, 'server', registry.String( '', """Determines what POP3 server to connect to in order to check for email.""")) conf.registerGlobalValue( Mailbox, 'user', registry.String( '', """Determines what username to give to the POP3 server when connecting.""")) conf.registerGlobalValue( Mailbox, 'password', registry.String('', """Determines what password to give to the POP3 server when connecting.""", private=True)) conf.registerGlobalValue( Mailbox, 'period',
# 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. ### import supybot.conf as conf import supybot.registry as registry from supybot.i18n import PluginInternationalization, internationalizeDocstring import os _ = PluginInternationalization('SeattleIncidentResponse') def configure(advanced): from supybot.questions import expect, anything, something, yn conf.registerPlugin('Seattle911') SeattleIncidentResponse = conf.registerPlugin('SeattleIncidentResponse') conf.registerGlobalValue(SeattleIncidentResponse, 'checkinterval', registry.NonNegativeInteger(1, """How often, in minutes, to check for new incidents""")) conf.registerGlobalValue(SeattleIncidentResponse, 'postformat', registry.String("[911] [{incident_number}][{incident_type}] {address}", """How often, in minutes, to check for new incidents""")) conf.registerChannelValue(SeattleIncidentResponse, 'enabled', registry.Boolean(False, """Determines whether the bot will announce 911 calls in this channel"""))
except: # Placeholder that allows to run the plugin on a bot # without the i18n module _ = lambda x: x def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('DomainChecker', True) DomainChecker = conf.registerPlugin('DomainChecker') # This is where your configuration variables (if any) should go. For example: conf.registerGlobalValue(DomainChecker, 'sandbox', registry.Boolean(False, _("""Should we use the Namecheap sandbox?"""))) conf.registerGlobalValue(DomainChecker, 'ApiUser', registry.String("", "Namecheap API username")) conf.registerGlobalValue(DomainChecker, 'ApiKey', registry.String("", "Namecheap API key")) conf.registerGlobalValue(DomainChecker, 'affiliate_id', registry.String("80599", "Namecheap affiliate ID")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
import supybot.conf as conf import supybot.registry as registry from supybot.i18n import PluginInternationalization, internationalizeDocstring _ = PluginInternationalization('RottenTomatoes') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('RottenTomatoes', True) RottenTomatoes = conf.registerPlugin('RottenTomatoes') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(RottenTomatoes, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGlobalValue( RottenTomatoes, 'apikey', registry.String('Not set', """API key to use Rotten Tomatoes REST API. A key can be requested at http://developer.rottentomatoes.com/.""", private=True)) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
# Placeholder that allows to run the plugin on a bot # without the i18n module _ = lambda x: x def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('AQI', True) AQI = conf.registerPlugin('AQI') conf.registerGlobalValue( AQI, 'apikey', registry.String( '', """Sets the API key for aqicn.org, see https://aqicn.org/api""", private=True)) conf.registerChannelValue( AQI, 'geocodeBackend', registry.String( 'native', """Sets the default geocode backend. If set to 'native', this uses aqicn's built-in (but limited) city search. Otherwise, you can use any value supported by NuWeather: https://github.com/jlu5/SupyPlugins/tree/master/NuWeather""" )) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
username = something("""What iRacing user name (email address) should be used to query for users? This account must watch or friend any user to be known to this bot.""") password = something("""What is the password for that iRacing account?""") Racebot.iRacingUsername.setValue(username) Racebot.iRacingPassword.setValue(password) Racebot = conf.registerPlugin('Racebot') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Racebot, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue(Racebot, 'iRacingUsername', registry.String('', """iRacing account (email) that will have all relevat users watched or friended.""")) conf.registerGlobalValue(Racebot, 'iRacingPassword', registry.String('', """Password for the iRacing account. Hopefully we get OAuth some day :-/""", private=True)) conf.registerChannelValue(Racebot, 'raceRegistrationAlerts', registry.Boolean(True, """Determines whether the bot will broadcast in this channel whenever a user joins a race""")) conf.registerChannelValue(Racebot, 'nonRaceRegistrationAlerts', registry.Boolean(False, """Determines whether the bot will broadcast in this channel whenever a user joins a session other than a race (practice, qual, etc.)""")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
except: _ = lambda x: x def configure(advanced): from supybot.questions import expect, anything, something, yn conf.registerPlugin('BotLibre', True) if advanced: output('The BotLibre Plugin allows you to interact with Bot Libre') BotLibre = conf.registerPlugin('BotLibre') conf.registerChannelValue( BotLibre, 'invalidCommand', registry.Boolean(False, _("""Should I be invoked on Invalid Commands?"""))) conf.registerGlobalValue( BotLibre, 'application', registry.String('', _("""The BotLibre API Application String (required)"""), private=True)) conf.registerGlobalValue( BotLibre, 'instance', registry.String('', _("""The BotLibre API Instance String (required)"""), private=True)) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
import supybot.conf as conf import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('TraktTV', True) TraktTV = conf.registerPlugin('TraktTV') conf.registerGlobalValue( TraktTV, 'apikey', registry.String('', """Determines what apikey to use with TraktTV""")) conf.registerGlobalValue( TraktTV, 'maxSearchResults', registry.PositiveInteger( 3, """Limits the number of results that will be displayed in the channel.""" )) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
_ = lambda x: x def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('TubeSleuth', True) TubeSleuth = conf.registerPlugin('TubeSleuth') conf.registerGlobalValue( TubeSleuth, 'developerKey', registry.String("", _("""Google API key. Required."""))) conf.registerGlobalValue( TubeSleuth, 'sortOrder', registry.String( "relevance", _("""The order parameter specifies the method that will be used to order resources in the API response.""" ))) conf.registerGlobalValue( TubeSleuth, 'template', registry.String("$yt_logo $link :: $title", _("""Template used for search result replies"""))) conf.registerGlobalValue(TubeSleuth, 'useBold',
# a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('GitHub', True) GitHub = conf.registerPlugin('GitHub') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(GitHub, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGroup(GitHub, 'api') conf.registerGlobalValue( GitHub.api, 'url', registry.String( 'https://api.github.com', _("""The URL of the GitHub API to use. You probably don't need to edit it, but I let it there, just in case."""))) conf.registerGlobalValue( GitHub, 'announces', registry.String( '', _("""You shouldn't edit this configuration variable yourself, unless you know what you do. Use '@Github announce add' or '@Github announce remove' instead."""))) conf.registerGlobalValue( GitHub.announces, 'secret', registry.SpaceSeparatedSetOfStrings(set(), _("""Set of space-separated secret payloads used to authenticate GitHub."""),
# 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. ### import supybot.conf as conf import supybot.registry as registry from supybot.i18n import PluginInternationalization, internationalizeDocstring _ = PluginInternationalization('Random') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Random', True) Random = conf.registerPlugin('Random') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Random, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGlobalValue(Random, 'maxCoins', registry.PositiveInteger(50000, _("""The maximum amount of coins that can be flipped"""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
from supybot.i18n import PluginInternationalization, internationalizeDocstring _ = PluginInternationalization('Owner') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Owner', True) Owner = conf.registerPlugin('Owner', True) conf.registerGlobalValue( Owner, 'public', registry.Boolean( True, """Determines whether this plugin is publicly visible.""")) conf.registerGlobalValue( Owner, 'quitMsg', registry.String( '', """Determines what quit message will be used by default. If the quit command is called without a quit message, this will be used. If this value is empty, the nick of the person giving the quit command will be used.""")) conf.registerGroup(conf.supybot.commands, 'renames', orderAlphabetically=True) # vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
# 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. ### import supybot.conf as conf import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Hanzi', True) Hanzi = conf.registerPlugin('Hanzi') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Hanzi, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue(Hanzi, 'encoding', registry.String('utf-8',"""The charest used in the channels""")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Jira', True) Jira = conf.registerPlugin('Jira') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Jira, 'someConfigVariableName', # registry.Boolean(False, """Help for someConfigVariableName.""")) conf.registerGlobalValue( Jira, 'server', registry.String( "", """URL for the jira rpc server, such as https://issues.jboss.org/rpc/xmlrpc""" )) conf.registerGlobalValue( Jira, 'user', registry.String("", """Username used to access jira server""")) conf.registerGlobalValue( Jira, 'password', registry.String("", """Password used to access jira server""")) conf.registerGlobalValue( Jira, 'browseurl', registry.String( "", """URL for browsing the issues by key, such as https://issues.jboss.org/browse/; the key is appended to the url""" )) conf.registerGlobalValue(
# a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('TwitterLite', True) consumer_key = something("consumer_key") consumer_secret = something("consumer_secret") access_token_key = something("access_token_key") access_token_secret = something("access_token_secret") conf.supybot.plugins.TwitterLite.consumer_key.set(consumer_key) conf.supybot.plugins.TwitterLite.consumer_secret.set(consumer_secret) conf.supybot.plugins.TwitterLite.access_token_key.set(access_token_key) conf.supybot.plugins.TwitterLite.access_token_secret.set( access_token_secret) TwitterLite = conf.registerPlugin('TwitterLite') conf.registerGlobalValue(TwitterLite, 'consumer_key', registry.String('', """Consumer key.""")) conf.registerGlobalValue(TwitterLite, 'consumer_secret', registry.String('', """Consumer secret.""")) conf.registerGlobalValue(TwitterLite, 'access_token_key', registry.String('', """Access token key.""")) conf.registerGlobalValue(TwitterLite, 'access_token_secret', registry.String('', """Access token secret.""")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
class FeedNames(registry.SpaceSeparatedListOfStrings): List = callbacks.CanonicalNameSet class FeedItemSortOrder(registry.OnlySomeStrings): """Valid values include 'asInFeed', 'oldestFirst', 'newestFirst'.""" validStrings = ('asInFeed', 'oldestFirst', 'newestFirst', 'outdatedFirst', 'updatedFirst') RSS = conf.registerPlugin('RSS') conf.registerGlobalValue( RSS, 'feeds', FeedNames([], _("""Determines what feeds should be accessible as commands."""))) ######## # Format conf.registerChannelValue( RSS, 'headlineSeparator', registry.StringSurroundedBySpaces( '|', _("""Determines what string is used to separate headlines in new feeds."""))) conf.registerChannelValue( RSS, 'format', registry.String(
# 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. ### import supybot.conf as conf import supybot.registry as registry from supybot.i18n import PluginInternationalization, internationalizeDocstring _ = PluginInternationalization('Rebrandly') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Rebrandly', True) Rebrandly = conf.registerPlugin('Rebrandly') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Rebrandly, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGlobalValue(Rebrandly, 'api_url', registry.String("", _("""Rebrandly API url"""))) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
# This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('ChannelLogger', True) ChannelLogger = conf.registerPlugin('ChannelLogger') conf.registerChannelValue( ChannelLogger, 'enable', registry.Boolean(True, _("""Determines whether logging is enabled."""))) conf.registerGlobalValue( ChannelLogger, 'flushImmediately', registry.Boolean( False, _("""Determines whether channel logfiles will be flushed anytime they're written to, rather than being buffered by the operating system."""))) conf.registerChannelValue( ChannelLogger, 'stripFormatting', registry.Boolean( True, _("""Determines whether formatting characters (such as bolding, color, etc.) are removed when writing the logs to disk."""))) conf.registerChannelValue( ChannelLogger, 'timestamp', registry.Boolean( True, _("""Determines whether the logs for this channel are timestamped with the timestamp in supybot.log.timestampFormat.""")))
def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('AutoMode', True) AutoMode = conf.registerPlugin('AutoMode') conf.registerChannelValue(AutoMode, 'enable', registry.Boolean(True, _("""Determines whether this plugin is enabled. """))) conf.registerGlobalValue(AutoMode, 'owner', registry.Boolean(True, _("""Determines whether this plugin will automode owners even if they don't have op/halfop/voice/whatever capability."""))) conf.registerChannelValue(AutoMode, 'alternativeCapabilities', registry.Boolean(False, _("""Determines whether the bot will check for 'alternative capabilities' (ie. autoop, autohalfop, autovoice) in addition to/instead of classic ones."""))) conf.registerChannelValue(AutoMode, 'fallthrough', registry.Boolean(False, _("""Determines whether the bot will "fall through" to halfop/voicing when auto-opping is turned off but auto-halfopping/voicing are turned on."""))) conf.registerChannelValue(AutoMode, 'op', registry.Boolean(True, _("""Determines whether the bot will automatically op people with the <channel>,op capability when they join the channel. """))) conf.registerChannelValue(AutoMode, 'halfop', registry.Boolean(True, _("""Determines whether the bot will automatically
from supybot.questions import expect, anything, something, yn conf.registerPlugin('Twitter', True) Twitter = conf.registerPlugin('Twitter') # This is where your configuration variables (if any) should go. For example: # conf.registerGlobalValue(Twitter, 'someConfigVariableName', # registry.Boolean(False, _("""Help for someConfigVariableName."""))) conf.registerGroup(Twitter, 'accounts') helpGetToken = _('running get_access_token.py is a way to get it') conf.registerGroup(Twitter.accounts, 'bot') conf.registerGlobalValue( Twitter.accounts.bot, 'key', registry.String( '', _("""The Twitter Access Token key for the bot's account (%s)""") % helpGetToken)) conf.registerGlobalValue( Twitter.accounts.bot, 'secret', registry.String('', _("""The Twitter Access Token secret for the bot's account (%s)""") % helpGetToken, private=True)) conf.registerGroup(Twitter.accounts, 'channel') conf.registerChannelValue( Twitter.accounts.channel, 'key', registry.String( '', _("""The Twitter Access Token key for this
from .local import accountsdb def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('NuWeather', True) NuWeather = conf.registerPlugin('NuWeather') conf.registerGroup(NuWeather, 'apikeys') conf.registerGroup(NuWeather, 'units') conf.registerGlobalValue(NuWeather, accountsdb.CONFIG_OPTION_NAME, accountsdb.CONFIG_OPTION) class NuWeatherTemperatureDisplayMode(registry.OnlySomeStrings): validStrings = ('F/C', 'C/F', 'F', 'C') conf.registerChannelValue(NuWeather.units, 'temperature', NuWeatherTemperatureDisplayMode('F/C', _("""Determines how temperatures will be displayed. F/C means show "50F/10C", C means display only Celsius, and so on."""))) BACKENDS = ('darksky', 'apixu') GEOCODE_BACKENDS = ('nominatim', 'googlemaps', 'opencage') class NuWeatherBackend(registry.OnlySomeStrings): validStrings = BACKENDS class NuWeatherGeocode(registry.OnlySomeStrings): validStrings = GEOCODE_BACKENDS
registry.Regexp( None, _("""Determines what URLs matching the given regexp will not be snarfed. Give the empty string if you have no URLs that you'd like to exclude from being snarfed."""))) conf.registerChannelValue( Web, 'checkIgnored', registry.Boolean( True, _("""Determines whether the title snarfer checks if the author of a message is ignored."""))) conf.registerGlobalValue( Web, 'urlWhitelist', registry.SpaceSeparatedListOfStrings([], """If set, bot will only fetch data from urls in the whitelist, i.e. starting with http://domain/optionalpath/. This will apply to all commands that retrieve data from user-supplied URLs, including fetch, headers, title, doctype.""")) conf.registerGlobalValue( Web, 'timeout', registry.NonNegativeInteger( 5, """Determines the maximum number of seconds the bot will wait for the site to respond, when using a command in this plugin other than 'fetch'. If 0, will use socket.defaulttimeout""") ) conf.registerGroup(Web, 'fetch') conf.registerGlobalValue( Web.fetch, 'maximum',
def registerDefaultPlugin(command, plugin): command = callbacks.canonicalName(command) conf.registerGlobalValue(conf.supybot.commands.defaultPlugins, command, registry.String(plugin, '')) # This must be set, or the quotes won't be removed. conf.supybot.commands.defaultPlugins.get(command).set(plugin)
_ = PluginInternationalization('Owner') def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified themself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('Owner', True) Owner = conf.registerPlugin('Owner', True) conf.registerGlobalValue( Owner, 'public', registry.Boolean( True, """Determines whether this plugin is publicly visible.""")) conf.registerGlobalValue( Owner, 'quitMsg', registry.String( '$version', """Determines what quit message will be used by default. If the quit command is called without a quit message, this will be used. If this value is empty, the nick of the person giving the quit command will be used. The standard substitutions ($version, $nick, etc.) are all handled appropriately.""")) conf.registerGroup(conf.supybot.commands, 'renames', orderAlphabetically=True) # vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
# 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. ### import supybot.conf as conf import supybot.registry as registry def configure(advanced): # This will be called by supybot to configure this module. advanced is # a bool that specifies whether the user identified himself as an advanced # user or not. You should effect your configuration by manipulating the # registry as appropriate. from supybot.questions import expect, anything, something, yn conf.registerPlugin('TelegramBridge', True) TelegramBridge = conf.registerPlugin('TelegramBridge') conf.registerGlobalValue(TelegramBridge, 'tgToken', registry.String("TelegramUser", "ID of the telegram bot" "(as shown by BotFather during creation)")) conf.registerGlobalValue(TelegramBridge, 'tgChatId', registry.Integer("666", "ID of the telegram chat")) conf.registerGlobalValue(TelegramBridge, 'tgTimeout', registry.Integer("120", "API timeout for waiting for " "updates")) # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
cur.close() con.close() Encyclopedia = conf.registerPlugin('Encyclopedia') conf.registerChannelValue(Encyclopedia, 'enabled', registry.Boolean(True, "Enable Encyclopedia")) conf.registerChannelValue(Encyclopedia, 'database', registry.String('ubuntu', 'Name of database to use')) conf.registerChannelValue(Encyclopedia, 'relaychannel', registry.String('#ubuntu-ops', 'Relay channel for unauthorized edits')) conf.registerGlobalValue(Encyclopedia, 'editchannel', registry.SpaceSeparatedListOfStrings(['#ubuntu-ops'], 'Channels where unauthorised edits are allowed.')) conf.registerGlobalValue(Encyclopedia, 'notfoundmsg', registry.String('Factoid %s not found', 'Reply when factoid isn\'t found')) conf.registerChannelValue(Encyclopedia,'prefixchar', registry.String('!','Prefix character for factoid display/editing')) conf.registerGlobalValue(Encyclopedia, 'datadir', conf.Directory(conf.supybot.directories.data(), 'Path to dir containing factoid databases', private=True)) conf.registerChannelValue(Encyclopedia, 'alert', registry.SpaceSeparatedListOfStrings(['ops', 'op', 'kops', 'calltheops'], 'factoid name(s) used for alerts', private=True)) conf.registerChannelValue(Encyclopedia, 'remotedb',
def set(self, v): if not v.strip(): self.setValue(set()) else: super().set(v) def setValue(self, v): self.lastModified = time.time() registry.CommaSeparatedListOfStrings.setValue(self, v) BadWords = conf.registerPlugin('BadWords') conf.registerGlobalValue( BadWords, 'words', LastModifiedSpaceSeparatedSetOfStrings([], _("""Determines what words are considered to be 'bad' so the bot won't say them."""))) conf.registerChannelValue( BadWords, 'requireWordBoundaries', registry.Boolean( False, _("""Determines whether the bot will require bad words to be independent words, or whether it will censor them within other words. For instance, if 'darn' is a bad word, then if this is true, 'darn' will be censored, but 'darnit' will not. You probably want this to be false. After changing this setting, the BadWords regexp needs to be regenerated by adding/removing a word to the list, or reloading the plugin."""))) conf.registerGlobalValue( BadWords, 'phrases',