Exemple #1
0
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?"""))
Exemple #2
0
 def clear_repos(self):
     "Remove all defined repositories."
     plugin_group = conf.supybot.plugins.get('Git')
     try:
         plugin_group.unregister('repos')
     except registry.NonExistentRegistryEntry:
         pass
     conf.registerGroup(plugin_group, 'repos')
     conf.supybot.plugins.Git.repolist.setValue('')
     self.assertNotError('reload Git')
     expected = ['The operation succeeded.',
                 'Git reinitialized with 0 repositories.',
                 'The operation succeeded.'
     ]
     self.assertResponses('reload Git', expected)
Exemple #3
0
 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.""")))
Exemple #4
0
 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.""")))
Exemple #5
0
 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))
Exemple #6
0
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)
Exemple #7
0
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)
Exemple #8
0
 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.""")))
Exemple #9
0
 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.""")))
Exemple #10
0
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)
Exemple #11
0
 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.""")))
Exemple #12
0
 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.""")))
Exemple #13
0
conf.registerChannelValue(Rweb, 'nonSnarfingRegexp',
    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(Rweb, 'checkIgnored',
    registry.Boolean(True, _("""Determines whether the title snarfer checks
    if the author of a message is ignored.""")))

conf.registerGlobalValue(Rweb, '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(Rweb, '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(Rweb, 'fetch')
conf.registerGlobalValue(Rweb.fetch, 'maximum',
    registry.NonNegativeInteger(0, _("""Determines the maximum number of
    bytes the bot will download via the 'fetch' command in this plugin.""")))

conf.registerGlobalValue(Rweb.fetch, 'timeout',
    registry.NonNegativeInteger(5, """Determines the maximum number of
    seconds the bot will wait for the site to respond, when using the 'fetch'
    command in this plugin. If 0, will use socket.defaulttimeout"""))

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #14
0
    # user or not.  You should effect your configuration by manipulating the
    # registry as appropriate.
    from supybot.questions import output, expect, anything, something, yn
    conf.registerPlugin('Unix', True)
    output(
        _("""The "progstats" command can reveal potentially sensitive
              information about your machine. Here's an example of its output:

              %s\n""") % progstats())
    if yn(_('Would you like to disable this command for non-owner users?'),
          default=True):
        conf.supybot.commands.disabled().add('Unix.progstats')


Unix = conf.registerPlugin('Unix')
conf.registerGroup(Unix, 'fortune')
conf.registerGlobalValue(
    Unix.fortune, 'command',
    registry.String(
        utils.findBinaryInPath('fortune') or '',
        _("""Determines
    what command will be called for the fortune command.""")))
conf.registerChannelValue(
    Unix.fortune, 'short',
    registry.Boolean(
        True,
        _("""Determines whether only short fortunes will be
    used if possible.  This sends the -s option to the fortune program.""")))
conf.registerGlobalValue(
    Unix.fortune, 'equal',
    registry.Boolean(
Exemple #15
0
    # without the i18n module
    _ = lambda x: x

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):
Exemple #16
0
        return level


class LogLevel(ValidLogLevel):
    """Invalid log level.  Value must be either DEBUG, INFO, WARNING,
    ERROR, or CRITICAL."""
    handler = _handler


class StdoutLogLevel(ValidLogLevel):
    """Invalid log level.  Value must be either DEBUG, INFO, WARNING,
    ERROR, or CRITICAL."""
    handler = _stdoutHandler


conf.registerGroup(conf.supybot, 'log')
conf.registerGlobalValue(
    conf.supybot.log, 'format',
    registry.String(
        '%(levelname)s %(asctime)s %(name)s %(message)s',
        """Determines what the bot's logging format will be.  The relevant
    documentation on the available formattings is Python's documentation on
    its logging module."""))
conf.registerGlobalValue(
    conf.supybot.log, 'level',
    LogLevel(
        logging.INFO, """Determines what the minimum priority level logged
    to file will be.  Do note that this value does not affect the level logged
    to stdout; for that, you should set the value of supybot.log.stdout.level.
    Valid values are DEBUG, INFO, WARNING, ERROR, and CRITICAL, in order of
    increasing priority."""))
Exemple #17
0
###

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('String', True)


String = conf.registerPlugin('String')
conf.registerGroup(String, 'levenshtein')
conf.registerGlobalValue(String.levenshtein, 'max',
    registry.PositiveInteger(256, """Determines the maximum size of a string
    given to the levenshtein command.  The levenshtein command uses an O(m*n)
    algorithm, which means that with strings of length 256, it can take 1.5
    seconds to finish; with strings of length 384, though, it can take 4
    seconds to finish, and with strings of much larger lengths, it takes more
    and more time.  Using nested commands, strings can get quite large, hence
    this variable, to limit the size of arguments passed to the levenshtein
    command."""))
conf.registerGroup(String, 're')
conf.registerGlobalValue(String.re, 'timeout',
    registry.PositiveFloat(0.1, """Determines the maximum time, in seconds, that
    a regular expression is given to execute before being terminated. Since
    there is a possibility that user input for the re command can cause it to
    eat up large amounts of ram or cpu time, it's a good idea to keep this
    registry.Boolean(
        False, """Determines whether messages addressed to the
    bot are ignored."""))
conf.registerChannelValue(
    ArtificialIntelligence, 'minChainLength',
    registry.PositiveInteger(
        1, """Determines the length of the smallest chain
    which the markov command will generate."""))
conf.registerChannelValue(
    ArtificialIntelligence, 'maxAttempts',
    registry.PositiveInteger(
        1, """Determines the maximum number of times the
    bot will attempt to generate a chain that meets or exceeds the size set in
    minChainLength."""))

conf.registerGroup(ArtificialIntelligence, 'randomSpeaking')
conf.registerChannelValue(
    ArtificialIntelligence.randomSpeaking, 'probability',
    registry.Probability(
        0, """Determines the probability that
    will be checked against to determine whether the bot should randomly say
    something.  If 0, the bot will never say anything on it's own.  If 1, the
    bot will speak every time we make a check."""))
conf.registerChannelValue(
    ArtificialIntelligence.randomSpeaking, 'maxDelay',
    registry.PositiveInteger(
        10, """Determines the upper bound for
    how long the bot will wait before randomly speaking.  The delay is a
    randomly generated number of seconds below the value of this config
    variable."""))
conf.registerChannelValue(
Exemple #19
0
    you have a vhost that isn't set until you're identified, or if you're
    joining +r channels that won't allow you to join unless you identify.""")))
conf.registerNetworkValue(
    Services, 'ghostDelay',
    registry.NonNegativeInteger(
        60,
        _("""Determines how many seconds the bot will
    wait between successive GHOST attempts. Set this to 0 to disable GHOST.""")
    ))
conf.registerNetworkValue(
    Services, 'NickServ',
    ValidNickOrEmptyString(
        'NickServ',
        _("""Determines what nick the 'NickServ' service
    has.""")))
conf.registerGroup(Services.NickServ, 'password')
conf.registerNetworkValue(
    Services, 'ChanServ',
    ValidNickOrEmptyString(
        'ChanServ',
        _("""Determines what nick the 'ChanServ' service
    has.""")))
conf.registerChannelValue(
    Services.ChanServ, 'password',
    registry.String('',
                    _("""Determines what password the bot will use with
    ChanServ."""),
                    private=True))
conf.registerChannelValue(
    Services.ChanServ, 'op',
    registry.Boolean(
Exemple #20
0
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('TriviaTime', True)

TriviaTime = conf.registerPlugin('TriviaTime')

# Config groups
conf.registerGroup(TriviaTime, 'kaos')
conf.registerGroup(TriviaTime, 'admin')
conf.registerGroup(TriviaTime, 'questions')
conf.registerGroup(TriviaTime, 'general')
conf.registerGroup(TriviaTime, 'commands')
conf.registerGroup(TriviaTime, 'voice')
conf.registerGroup(TriviaTime, 'skip')
conf.registerGroup(TriviaTime, 'hints')

# CONFIGURATION
# file locations for database and question
conf.registerChannelValue(TriviaTime.admin, 'sqlitedb', 
        registry.NormalizedString("""plugins/TriviaTime/storage/db/trivia.db""", 
                """Location of sqlite database file""")
        )
Exemple #21
0

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('Guardian', True)


Guardian = conf.registerPlugin('Guardian')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Guardian, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))
conf.registerGroup(Guardian, 'flood', private=True)
conf.registerGlobalValue(
    Guardian.flood, 'interval',
    registry.NonNegativeInteger(
        7, """Indique l'interval de temps de contrôle
        du flood (en sec)."""))
conf.registerGlobalValue(
    Guardian.flood, 'max',
    registry.NonNegativeInteger(
        5, """Indique le nombre de message maximum.
        """))
conf.registerGlobalValue(
    Guardian.flood, 'maxKick',
    registry.NonNegativeInteger(
        5, """Indique le nombre de kick minimum avant
    un bannissement."""))
    about network exceptions like hostnotfound, timeout ....""")))
conf.registerChannelValue(Web, 'snarferShowTargetDomain',
    registry.Boolean(False, _("""Determines whether the domain name displayed
    by the snarfer will be the original one (posted on IRC) or the target one
    (got after following redirects, if any).""")))
conf.registerChannelValue(Web, 'nonSnarfingRegexp',
    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.registerGroup(Web, 'fetch')
conf.registerGlobalValue(Web.fetch, 'maximum',
    registry.NonNegativeInteger(0, _("""Determines the maximum number of
    bytes the bot will download via the 'fetch' command in this plugin.""")))

conf.registerGlobalValue(Web.fetch, 'timeout',
    registry.NonNegativeInteger(5, """Determines the maximum number of
    seconds the bot will wait for the site to respond, when using the 'fetch'
    command in this plugin. If 0, will use socket.defaulttimeout"""))

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #23
0
    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, 'announceFormat',
    registry.String(
        'Announcement from my owner ($owner): $text',
        """Determines the format of messages sent by the 'announce' command.
    $owner may be used for the username of the owner calling this command,
    and $text for the announcement being made."""))
conf.registerGlobalValue(
    Owner, 'quitMsg',
    registry.String(
        'Limnoria $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:
Exemple #24
0
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

import supybot.conf as conf
import supybot.registry as registry
from supybot.i18n import PluginInternationalization, internationalizeDocstring
_ = PluginInternationalization('Alias')

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('Alias', True)

Alias = conf.registerPlugin('Alias')
conf.registerGroup(Alias, 'aliases')

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #25
0
        _ = 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('Trigger', True)


Trigger = conf.registerPlugin('Trigger')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Trigger, 'someConfigVariableName',
#     registry.Boolean(False, _("""Help for someConfigVariableName.""")))
conf.registerGroup(Trigger, 'triggers')

for trigger in 'join part privmsg notice highlight nick quit kick'.split(' '):
    conf.registerChannelValue(Trigger.triggers, trigger,
        registry.String('', _("""Command triggered by %ss""" % trigger),
            private=True))

conf.registerGlobalValue(Trigger.triggers, 'connect',
    registry.String('', _("""Command triggered on connect. This shouldn't be
    a Supybot command, but an IRC command (as given to ircquote)."""),
    private=True))


# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #26
0
    TOPICLEN value sent to it by the server and thus refuse to send TOPICs
    longer than the TOPICLEN.  These topics are likely to be truncated by the
    server anyway, so this defaults to True.""")))
conf.registerChannelValue(
    Topic, 'default',
    registry.String(
        '',
        _("""Determines what the default topic for the channel
    is.  This is used by the default command to set this topic.""")))
conf.registerChannelValue(
    Topic, 'alwaysSetOnJoin',
    registry.Boolean(
        False,
        _("""Determines whether the bot will set the topic
    every time it joins, or only if the topic is empty.""")))
conf.registerGroup(Topic, 'undo')
conf.registerChannelValue(
    Topic.undo, 'max',
    registry.NonNegativeInteger(
        10,
        _("""Determines the number of previous
    topics to keep around in case the undo command is called.""")))
conf.registerChannelValue(
    Topic, 'requireManageCapability',
    registry.String(
        'channel,op; channel,halfop',
        _("""Determines the
    capabilities required (if any) to make any topic changes,
    (everything except for read-only operations). Use 'channel,capab' for
    channel-level capabilities.
    Note that absence of an explicit anticapability means user has
Exemple #27
0
def configure(advanced):
    # This will be called by setup.py 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('Later', True)

Later = conf.registerPlugin('Later')
conf.registerGlobalValue(Later, 'maximum',
    registry.NonNegativeInteger(0, _("""Determines the maximum number of
    messages to be queued for a user.  If this value is 0, there is no maximum.
    """)))
conf.registerGlobalValue(Later, 'private',
    registry.Boolean(False, _("""Determines whether users will be notified in
    the first place in which they're seen, or in private.""")))
conf.registerGlobalValue(Later, 'tellOnJoin',
    registry.Boolean(False, _("""Determines whether users will be notified upon
    joining any channel the bot is in, or only upon sending a message.""")))
conf.registerGlobalValue(Later, 'messageExpiry',
    registry.NonNegativeInteger(30, _("""Determines the maximum number of
    days that a message will remain queued for a user. After this time elapses,
    the message will be deleted. If this value is 0, there is no maximum.""")))

conf.registerGroup(Later, 'format')
conf.registerGlobalValue(Later.format, 'senderHostname',
    registry.Boolean(False, _("""Determines whether senders' hostname will be
    shown in messages (instead of just the nick).""")))

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #28
0
conf.registerChannelValue(RelayNext, 'color',
    registry.Boolean(True, _("""Determines whether the bot will color relayed
    PRIVMSGs so as to make the messages easier to read.""")))
conf.registerChannelValue(RelayNext, 'hostmasks',
    registry.Boolean(True, _("""Determines whether the bot will relay the
    hostmask of the person joining or parting the channel when he or she joins
    or parts.""")))
conf.registerChannelValue(RelayNext, 'noHighlight',
    registry.Boolean(False, _("""Determines whether the bot should prefix nicks
    with a hyphen (-) to prevent excess highlights (in PRIVMSGs and actions).""")))
conf.registerChannelValue(RelayNext, 'showPrefixes',
    registry.Boolean(False, _("""Determines whether the bot should status prefixes
    (@, %, +) when relaying.""")))

conf.registerGroup(RelayNext, 'antiflood')
conf.registerChannelValue(RelayNext.antiflood, 'enable',
    registry.Boolean(False, _("""Determines whether flood prevention should be enabled
    for the given channel.""")))
conf.registerChannelValue(RelayNext.antiflood, 'seconds',
    registry.PositiveInteger(20, _("""Determines how many seconds messages should be queued
        for flood protection.""")))
conf.registerChannelValue(RelayNext.antiflood, 'maximum',
    registry.PositiveInteger(15, _("""Determines the maximum amount of incoming messages
        the bot will allow from a relay channel before flood protection is triggered.""")))
conf.registerChannelValue(RelayNext.antiflood.maximum, 'nonPrivmsgs',
    registry.PositiveInteger(10, _("""Determines the maximum amount of incoming non-PRIVMSG events
        the bot will allow from a relay channel before flood protection is triggered.""")))
conf.registerChannelValue(RelayNext.antiflood, 'timeout',
    registry.PositiveInteger(60, _("""Determines the amount of time in seconds the bot should
        block messages if flood protection is triggered.""")))
Exemple #29
0
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('TriviaTime', True)


TriviaTime = conf.registerPlugin('TriviaTime')

conf.registerGroup(TriviaTime, 'kaos')
conf.registerGroup(TriviaTime, 'admin')
conf.registerGroup(TriviaTime, 'questions')
conf.registerGroup(TriviaTime, 'general')
conf.registerGroup(TriviaTime, 'commands')
conf.registerGroup(TriviaTime, 'voice')
conf.registerGroup(TriviaTime, 'skip')
# CONFIGURATION
# file locations for database and question
conf.registerChannelValue(
    TriviaTime.admin, 'sqlitedb',
    registry.NormalizedString("""plugins/TriviaTime/storage/db/trivia.db""",
                              """Location of sqlite database file"""))

conf.registerChannelValue(
    TriviaTime.admin, 'quizfile',
    registry.Regexp(
        None,
        """Determines what URLs are to be snarfed and stored
    in the database in the channel; URLs matching the regexp given 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,
    "ignoreNicks",
    registry.String(
        " ",
        """Determines the nicks who shall be ignored (because 
    they are bots or other URL Snarfing bots.""",
    ),
)

conf.registerGroup(Web, "fetch")
conf.registerGlobalValue(
    Web.fetch,
    "maximum",
    registry.NonNegativeInteger(
        0,
        """Determines the maximum number of
    bytes the bot will download via the 'fetch' command in this plugin.""",
    ),
)

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #31
0
conf.registerGlobalValue(Services, 'disabledNetworks',
    Networks(_('QuakeNet').split(), _("""Determines what networks this plugin
    will be disabled on.""")))

conf.registerGlobalValue(Services, 'noJoinsUntilIdentified',
    registry.Boolean(False, _("""Determines whether the bot will not join any
    channels until it is identified.  This may be useful, for instances, if
    you have a vhost that isn't set until you're identified, or if you're
    joining +r channels that won't allow you to join unless you identify.""")))
conf.registerGlobalValue(Services, 'ghostDelay',
    registry.PositiveInteger(60, _("""Determines how many seconds the bot will
    wait between successive GHOST attempts.""")))
conf.registerGlobalValue(Services, 'NickServ',
    ValidNickOrEmptyString('', _("""Determines what nick the 'NickServ' service
    has.""")))
conf.registerGroup(Services.NickServ, 'password')
conf.registerGlobalValue(Services, 'ChanServ',
    ValidNickOrEmptyString('', _("""Determines what nick the 'ChanServ' service
    has.""")))
conf.registerChannelValue(Services.ChanServ, 'password',
    registry.String('', _("""Determines what password the bot will use with
    ChanServ."""), private=True))
conf.registerChannelValue(Services.ChanServ, 'op',
    registry.Boolean(False, _("""Determines whether the bot will request to get
    opped by the ChanServ when it joins the channel.""")))
conf.registerChannelValue(Services.ChanServ, 'halfop',
    registry.Boolean(False, _("""Determines whether the bot will request to get
    half-opped by the ChanServ when it joins the channel.""")))
conf.registerChannelValue(Services.ChanServ, 'voice',
    registry.Boolean(False, _("""Determines whether the bot will request to get
    voiced by the ChanServ when it joins the channel.""")))
Exemple #32
0
    # 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',
Exemple #33
0
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

import supybot.conf as conf
import supybot.registry as registry
from supybot.i18n import PluginInternationalization, internationalizeDocstring
_ = PluginInternationalization('Filter')

Filter = conf.registerPlugin('Filter')
conf.registerGroup(Filter, 'spellit')
conf.registerGlobalValue(
    Filter.spellit, 'replaceLetters',
    registry.Boolean(
        True,
        _("""Determines whether or not to
    replace letters in the output of spellit.""")))
conf.registerGlobalValue(
    Filter.spellit, 'replacePunctuation',
    registry.Boolean(
        True,
        _("""Determines whether or not
    to replace punctuation in the output of spellit.""")))
conf.registerGlobalValue(
    Filter.spellit, 'replaceNumbers',
    registry.Boolean(
Exemple #34
0
    # 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('Gogs', True)


Gogs = conf.registerPlugin('Gogs')

# Settings
conf.registerChannelValue(Gogs, 'projects',
    registry.Json({}, _("""List of projects""")))

# Format
conf.registerGroup(Gogs, 'format')

conf.registerChannelValue(Gogs, 'use-notices',
    registry.Boolean(False, _("""Determines whether the bot should announce using NOTICE instead of PRIVMSG.""")))
conf.registerChannelValue(Gogs.format, 'push',
    registry.String(_("""\x02[{repository[name]}]\x02 {pusher[username]} pushed \x02{total_commits_count} commit(s)\x02 to \x02{repository[name]} {ref}\x02:"""),
                    _("""Format for push events.""")))
conf.registerChannelValue(Gogs.format, 'commit',
    registry.String(_("""\x02[{repository[name]}]\x02 {short_id} \x02{short_message}\x02 by {author[name]}"""),
                    _("""Format for commits.""")))

conf.registerChannelValue(Gogs.format, 'create',
    registry.String(_("""\x02[{repository[name]}]\x02 {sender[username]} created a new {ref_type} : {ref}"""),
                    _("""Format for tag push events.""")))

# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #35
0
    Misc, 'listUnloadedPlugins',
    registry.Boolean(
        False,
        _("""Determines whether the bot will list unloaded
    plugins with the list command if given the --unloaded switch.  If this is
    disabled, non-owner users should be unable to see what unloaded plugins
    are available.""")))
conf.registerGlobalValue(
    Misc, 'timestampFormat',
    registry.String(
        '[%H:%M:%S]',
        _("""Determines the format string for
    timestamps in the Misc.last command.  Refer to the Python documentation
    for the time module to see what formats are accepted. If you set this
    variable to the empty string, the timestamp will not be shown.""")))
conf.registerGroup(Misc, 'last')
conf.registerGroup(Misc.last, 'nested')
conf.registerChannelValue(
    Misc.last.nested, 'includeTimestamp',
    registry.Boolean(
        False,
        _("""Determines whether or not
    the timestamp will be included in the output of last when it is part of a
    nested command""")))
conf.registerChannelValue(
    Misc.last.nested, 'includeNick',
    registry.Boolean(
        False,
        _("""Determines whether or not the
    nick will be included in the output of last when it is part of a nested
    command""")))
Exemple #36
0
    # 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('Gitlab', True)


Gitlab = conf.registerPlugin('Gitlab')

# Settings
conf.registerChannelValue(Gitlab, 'projects',
    registry.Json({}, _("""List of projects""")))

# Format
conf.registerGroup(Gitlab, 'format')

conf.registerChannelValue(Gitlab, 'use-notices',
    registry.Boolean(False, _("""Determines whether the bot should announce using NOTICE instead of PRIVMSG.""")))
conf.registerChannelValue(Gitlab.format, 'push',
    registry.String(_("""\x02[{project[name]}]\x02 {user_name} pushed \x02{total_commits_count} commit(s)\x02 to \x02{ref}\x02:"""),
                    _("""Format for push events.""")))
conf.registerChannelValue(Gitlab.format, 'commit',
    registry.String(_("""\x02[{project[name]}]\x02 {short_id} \x02{short_message}\x02 by {author[name]}"""),
                    _("""Format for commits.""")))

conf.registerChannelValue(Gitlab.format, 'tag',
    registry.String(_("""\x02[{project[name]}]\x02 {user_name} created a new tag {ref}"""),
                    _("""Format for tag push events.""")))

conf.registerChannelValue(Gitlab.format, 'issue-open',
Exemple #37
0
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("Pacman", True)


Pacman = conf.registerPlugin("Pacman")
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Pacman, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))

conf.registerGroup(Pacman, "pkg")
conf.registerGlobalValue(
    Pacman.pkg,
    "max",
    registry.NonNegativeInteger(
        2,
        """Indique le maximum de paquets
		à afficher (commande 'pkg' et 'aur').""",
    ),
)

conf.registerGroup(Pacman, "pkgfile")
conf.registerGlobalValue(
    Pacman.pkgfile,
    "max",
    registry.NonNegativeInteger(
Exemple #38
0
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

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('Alias', True)


Alias = conf.registerPlugin('Alias')
conf.registerGroup(Alias, 'aliases')

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #39
0
###


import supybot.conf as conf
import supybot.registry as registry
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 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('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:
Exemple #40
0
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('MegaHAL', True)


MegaHAL = conf.registerPlugin('MegaHAL')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(MegaHAL, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))

conf.registerGroup(MegaHAL, 'learn')
conf.registerGlobalValue(
    MegaHAL.learn, 'commands',
    registry.Boolean(
        False,
        _("""Determines whether the bot answers to messages
    beginning by a non-alphanumeric char.""")))
conf.registerGroup(MegaHAL, 'answer')
conf.registerChannelValue(
    MegaHAL.answer, 'commands',
    registry.Boolean(
        False,
        _("""Determines whether messages beginning by a
    non-alphanumeric char are learned.""")))
conf.registerChannelValue(
    MegaHAL.answer, 'probability',
Exemple #41
0
        _("""Indicates how many headlines an rss feed
    will output when it is first added to announce for a channel.""")))
conf.registerChannelValue(
    RSS, 'keywordWhitelist',
    registry.SpaceSeparatedSetOfStrings([],
                                        _("""Space separated list of 
    strings, lets you filter headlines to those containing one or more items
    in this whitelist.""")))
conf.registerChannelValue(
    RSS, 'keywordBlacklist',
    registry.SpaceSeparatedSetOfStrings([],
                                        _("""Space separated list of 
    strings, lets you filter headlines to those not containing any items
    in this blacklist.""")))

conf.registerGroup(RSS, 'announce')
conf.registerChannelValue(
    RSS.announce, 'showLinks',
    registry.Boolean(
        True,
        _("""Determines whether the bot will list the link
    along with the title of the feed when a feed is automatically
    announced.""")))

conf.registerChannelValue(
    RSS.announce, 'showPubDate',
    registry.Boolean(
        False, """Determines whether the bot will list the 
    publication datetime stamp along with the title of the feed when a feed
    is automatically announced."""))
conf.registerGlobalValue(
Exemple #42
0
from supybot.i18n import PluginInternationalization, internationalizeDocstring

_ = PluginInternationalization('Note')


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('Note', True)


Note = conf.registerPlugin('Note')
conf.registerGroup(Note, 'notify')
conf.registerGlobalValue(
    Note.notify, 'onJoin',
    registry.Boolean(
        False, """Determines whether the bot will notify people of
    their new messages when they join the channel.  Normally it will notify
    them when they send a message to the channel, since oftentimes joins are
    the result of netsplits and not the actual presence of the user."""))
conf.registerGlobalValue(
    Note.notify.onJoin, 'repeatedly',
    registry.Boolean(
        False, """Determines whether the bot will repeatedly
    notify people of their new messages when they join the channel.  That means
    when they join the channel, the bot will tell them they have unread
    messages, even if it's told them before."""))
conf.registerGlobalValue(
Exemple #43
0
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

import supybot.conf as conf
import supybot.registry as registry
from supybot.i18n import PluginInternationalization, internationalizeDocstring
_ = PluginInternationalization('Filter')

Filter = conf.registerPlugin('Filter')
conf.registerGroup(Filter, 'spellit')
conf.registerGlobalValue(Filter.spellit,
    'replaceLetters', registry.Boolean(True, _("""Determines whether or not to
    replace letters in the output of spellit.""")))
conf.registerGlobalValue(Filter.spellit,
    'replacePunctuation', registry.Boolean(True, _("""Determines whether or not
    to replace punctuation in the output of spellit.""")))
conf.registerGlobalValue(Filter.spellit,
    'replaceNumbers', registry.Boolean(True, _("""Determines whether or not to
    replace numbers in the output of spellit.""")))
conf.registerGroup(Filter, 'shrink')
conf.registerChannelValue(Filter.shrink, 'minimum',
    registry.PositiveInteger(4, _("""Determines the minimum number of a letters
    in a word before it will be shrunken by the shrink command/filter.""")))

def configure(advanced):
Exemple #44
0
        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, ''))


Lookup = conf.registerPlugin('Lookup')
conf.registerGroup(Lookup, 'lookups')

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #45
0
# 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',
        registry.StringWithSpaceOnRight(':', _("""This text is appended to each service's
        name.""")))
conf.registerGroup(MCStatus, 'status')
conf.registerChannelValue(MCStatus.status, 'online',
        registry.NormalizedString('\x0309ONLINE\x03', _("""This text is displayed when a
        service is online (green).""")))
conf.registerChannelValue(MCStatus.status, 'offline',
        registry.NormalizedString('\x0304OFFLINE\x03', _("""This text is displayed when a
        service is offline (red).""")))

# vim: set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #46
0
    registry.Boolean(
        True, _("""Ignores URLs that appear in an action such as /me""")))

conf.registerChannelValue(
    SpiffyTitles, 'requireCapability',
    registry.String(
        "",
        _("""If defined, SpiffyTitles will only acknowledge links from users with this capability. Useful for hostile environments."""
          )))

conf.registerChannelValue(
    SpiffyTitles, 'ignoredTitlePattern',
    registry.Regexp("",
                    _("""Titles matching this pattern will be ignored.""")))

conf.registerGroup(SpiffyTitles, 'wikipedia')

conf.registerChannelValue(
    SpiffyTitles.wikipedia, 'enabled',
    registry.Boolean(
        True, _("""Whether to fetch extracts for Wikipedia articles.""")))

conf.registerChannelValue(
    SpiffyTitles.wikipedia, 'apiParams',
    registry.SpaceSeparatedListOfStrings(
        [],
        _("""Add or override API query parameters with a space-separated list of key=value pairs."""
          )))

conf.registerChannelValue(
    SpiffyTitles.wikipedia, 'titleParam',
Exemple #47
0
###
# Copyright (c) 2013, Nils Brinkmann
# All rights reserved.
#
#
###

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('Subversion', True)


Subversion = conf.registerPlugin('Subversion')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Subversion, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))
conf.registerGroup(Subversion, 'notifiers')


# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #48
0
import supybot.conf as conf
import supybot.registry as registry
from supybot.i18n import PluginInternationalization, internationalizeDocstring
_ = PluginInternationalization('User')

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('User', True)


User = conf.registerPlugin('User')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(User, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))

conf.registerGroup(User, 'gpg')

conf.registerGlobalValue(User.gpg, 'enable',
    registry.Boolean(True, """Determines whether or not users are
    allowed to use GPG for authentication."""))
conf.registerGlobalValue(User.gpg, 'TokenTimeout',
    registry.PositiveInteger(60*10, """Determines the lifetime of a GPG
    authentication token (in seconds)."""))

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #49
0
###

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('Ottdcoop', True)


Ottdcoop = conf.registerPlugin('Ottdcoop')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Ottdcoop, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))
conf.registerChannelValue(Ottdcoop, 'PlayerWarner',
     registry.Boolean(False, """Determines whether the bot will auto warn clients joining as 'Player'"""))
conf.registerChannelValue(Ottdcoop, 'PlayerReply',
     registry.String('Player, please change your in game nick', """What the bot will say if it sees '*** Player joined the game'"""))
conf.registerChannelValue(Ottdcoop, 'MultiWarner',
     registry.Boolean(False, """Determines whether the bot will auto warn clients multiple joining as 'nick #number'"""))
conf.registerChannelValue(Ottdcoop, 'MultiReply',
     registry.String('$name, it appears that you have joined twice, please ask someone to join you, rather than double joining. If this is due to a time-out, you may disregard this.', """What the bot will say if it sees '*** nick #number joined the game'"""))
conf.registerGroup(Ottdcoop, 'abbr')

# 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 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('Tea', True)


Tea = conf.registerPlugin('Tea')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(Tea, 'someConfigVariableName',
#     registry.Boolean(False, _("""Help for someConfigVariableName.""")))

conf.registerGroup(Tea, 'mariagefreres')

conf.registerGlobalValue(Tea.mariagefreres, 'homepage',
    registry.String(
            'http://www.mariagefreres.com/FR/accueil.html',
            _("""The home page of the Mariage Frères website.""")
    ))

conf.registerGlobalValue(Tea.mariagefreres, 'no_results_url',
    registry.String(
        'http://www.mariagefreres.com/FR/plus_de_thes.html',
        _("""The URL Mariage Frères redirects to if a search leads to no results.
        We have to store that because the HTTP status code is always 200.""")
    ))

conf.registerGlobalValue(Tea.mariagefreres, 'result_urls',
Exemple #51
0
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('GPG', True)


GPG = conf.registerPlugin('GPG')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(GPG, 'someConfigVariableName',
#     registry.Boolean(False, _("""Help for someConfigVariableName.""")))

conf.registerGroup(GPG, 'auth')
conf.registerGroup(GPG.auth, 'sign')

conf.registerGlobalValue(
    GPG.auth.sign, 'enable',
    registry.Boolean(
        True, """Determines whether or not users are
    allowed to use GPG signing for authentication."""))
conf.registerGlobalValue(
    GPG.auth.sign, 'TokenTimeout',
    registry.PositiveInteger(
        60 * 10, """Determines the lifetime of a GPG
    signature authentication token (in seconds)."""))

# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #52
0
class ValidNonPrivmsgsHandling(registry.OnlySomeStrings):
    validStrings = ('privmsg', 'notice', 'nothing')
conf.registerChannelValue(LinkRelay, 'nonPrivmsgs',
    ValidNonPrivmsgsHandling('privmsg', _("""Determines whether the
    bot will use PRIVMSGs (privmsg), NOTICEs (notice), for non-PRIVMSG Relay
    messages (i.e., joins, parts, nicks, quits, modes, etc.), or whether it
    won't relay such messages (nothing)""")))

conf.registerGlobalValue(LinkRelay, 'relays',
    registry.String('', _("""You shouldn't edit this configuration variable
    yourself unless you know what you do. Use @LinkRelay {add|remove} instead.""")))

conf.registerGlobalValue(LinkRelay, 'substitutes',
    registry.String('', _("""You shouldn't edit this configuration variable
    yourself unless you know what you do. Use @LinkRelay (no)substitute instead.""")))

conf.registerGroup(LinkRelay, 'colors')
for name, color in {'info': '02',
                    'truncated': '14',
                    'mode': '14',
                    'join': '14',
                    'part': '14',
                    'kick': '14',
                    'nick': '14',
                    'quit': '14'}.items():
    conf.registerChannelValue(LinkRelay.colors, name,
        ColorNumber(color, _("""Color used for relaying %s.""") % color))


# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
Exemple #53
0
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('IMDb', True)


IMDb = conf.registerPlugin('IMDb')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(IMDb, 'someConfigVariableName',
#     registry.Boolean(False, """Help for someConfigVariableName."""))

conf.registerGroup(IMDb, 'formats')

conf.registerChannelValue(IMDb, 'outputorder',
        registry.String('url;title;description;creator,director,stars;genres,plot_keys;runtime,language', 
            'Order that parts will be output. ; is line separator and , is field separator'))

conf.registerChannelValue(IMDb.formats, 'url',
        registry.String('\x02\x031,8IMDb\x03 %(url)s', 'Format for the output of imdb command'))

conf.registerChannelValue(IMDb.formats, 'title',
        registry.String('\x02\x0304\x1F%(name)s\x1F\x0311\x02 (%(year)s) %(rating)s/10', 'Format for the output of imdb command'))

conf.registerChannelValue(IMDb.formats, 'description',
        registry.String('\x0305Description\03 /\x0311 %(description)s', 'Format for the output of imdb command'))

conf.registerChannelValue(IMDb.formats, 'creator',
Exemple #54
0
    or parts.""")))
conf.registerChannelValue(
    RelayNext, 'noHighlight',
    registry.Boolean(
        False,
        _("""Determines whether the bot should prefix nicks
    with a hyphen (-) to prevent excess highlights (in PRIVMSGs and actions)."""
          )))
conf.registerChannelValue(
    RelayNext, 'showPrefixes',
    registry.Boolean(
        False,
        _("""Determines whether the bot should status prefixes
    (@, %, +) when relaying.""")))

conf.registerGroup(RelayNext, 'antiflood')
conf.registerChannelValue(
    RelayNext.antiflood, 'enable',
    registry.Boolean(
        False,
        _("""Determines whether flood prevention should be enabled
    for the given channel.""")))
conf.registerChannelValue(
    RelayNext.antiflood, 'seconds',
    registry.PositiveInteger(
        20,
        _("""Determines how many seconds messages should be queued
        for flood protection.""")))
conf.registerChannelValue(
    RelayNext.antiflood, 'maximum',
    registry.PositiveInteger(
Exemple #55
0
_ = PluginInternationalization('UndernetX')


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('UndernetX', True)


UndernetX = conf.registerPlugin('UndernetX')
# This is where your configuration variables (if any) should go.  For example:
# conf.registerGlobalValue(UndernetX, 'someConfigVariableName',
#     registry.Boolean(False, _("""Help for someConfigVariableName.""")))
conf.registerGlobalValue(UndernetX, 'modeXonID',
                         registry.Boolean(True, _("""Whether or not to mode +x on ID""")))
conf.registerGroup(UndernetX, 'auth')
# /msg [email protected] login username password
conf.registerGlobalValue(UndernetX.auth, 'username',
                         registry.String("", _("""Username for X""")))
conf.registerGlobalValue(UndernetX.auth, 'password',
                         registry.String("", _("""Password for X""")))
conf.registerGlobalValue(UndernetX.auth, 'xservice',
                         registry.String("*****@*****.**", _("""XService hostmask""")))
conf.registerGlobalValue(UndernetX.auth, 'noJoinsUntilAuthed',
                         registry.Boolean(True, _("""Don't join until we're authed.""")))

# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
Exemple #56
0
import supybot.conf as conf
import supybot.registry as registry

def configure(advanced):
    from supybot.questions import expect, anything, something, yn
    WhatCD = conf.registerPlugin('WhatCD', True)
    if yn("""This plugin also offers a snarfer that will try to fetch the
             title of URLs that it sees in the channel.  Would like you this
             snarfer to be enabled?""", default=False):
        WhatCD.titleSnarfer.setValue(True)


WhatCD = conf.registerPlugin('WhatCD')

conf.registerGlobalValue(WhatCD, 'username', registry.String('', '''the what.cd username to use'''))
conf.registerGlobalValue(WhatCD, 'password', registry.String('', '''the what.cd password to use'''))
conf.registerGlobalValue(WhatCD, 'max_results', registry.String('3', '''the number of results to display from what.cd torrent searches'''))

conf.registerGroup(WhatCD, 'fetch')

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79: