def write(self):
self.file.write('#compdef mktap\n')
self.file.write('_mktap_subcmds=(\n')
from twisted import plugin as newplugin
from twisted.scripts.mktap import IServiceMaker
plugins = newplugin.getPlugins(IServiceMaker)
for p in plugins:
self.file.write('"%s:%s"\n' % (p.tapname, p.description))
self.file.write(")\n\n")
self.optionsClass.zsh_extras = ['*::subcmd:->subcmd']
gen = ArgumentsGenerator(self.cmd_name, self.optionsClass, self.file)
gen.write()
self.file.write("""if (( CURRENT == 1 )); then
_describe "tap to build" _mktap_subcmds && ret=0
fi
(( ret )) || return 0
service="$words[1]"
case $service in\n""")
plugins = newplugin.getPlugins(IServiceMaker)
for p in plugins:
self.file.write(p.tapname + ")\n")
gen = ArgumentsGenerator(p.tapname, p.options, self.file)
gen.write()
self.file.write(";;\n")
self.file.write("""*) _message "don't know how to complete $service";;\nesac""")
def test_detectFilesChanged(self):
"""
Check that if the content of a plugin change, L{plugin.getPlugins} is
able to detect the new plugins added.
"""
FilePath(__file__).sibling('plugin_extra1.py'
).copyTo(self.package.child('pluginextra.py'))
try:
plgs = list(plugin.getPlugins(ITestPlugin, self.module))
# Sanity check
self.assertEquals(len(plgs), 2)
FilePath(__file__).sibling('plugin_extra2.py'
).copyTo(self.package.child('pluginextra.py'))
# Fake out Python.
self._unimportPythonModule(sys.modules['mypackage.pluginextra'])
# Make sure additions are noticed
plgs = list(plugin.getPlugins(ITestPlugin, self.module))
self.assertEquals(len(plgs), 3)
names = ['TestPlugin', 'FourthTestPlugin', 'FifthTestPlugin']
for p in plgs:
names.remove(p.__name__)
p.test1()
finally:
self._unimportPythonModule(
sys.modules['mypackage.pluginextra'],
True)
def write(self):
"""
Write the completion function to the file given to __init__
@return: C{None}
"""
self.file.write('#compdef %s\n' % (self.cmd_name,))
self.file.write('local _zsh_subcmds_array\n_zsh_subcmds_array=(\n')
from twisted import plugin as newplugin
plugins = newplugin.getPlugins(self.interface)
for p in plugins:
self.file.write('"%s:%s"\n' % (p.tapname, p.description))
self.file.write(")\n\n")
self.options.__class__.zsh_extras = ['*::subcmd:->subcmd']
gen = ArgumentsGenerator(self.cmd_name, self.options, self.file)
gen.write()
self.file.write("""if (( CURRENT == 1 )); then
_describe "%s" _zsh_subcmds_array && ret=0
fi
(( ret )) || return 0
service="$words[1]"
case $service in\n""" % (self.subcmdLabel,))
plugins = newplugin.getPlugins(self.interface)
for p in plugins:
self.file.write(p.tapname + ")\n")
gen = ArgumentsGenerator(p.tapname, p.options(), self.file)
gen.write()
self.file.write(";;\n")
self.file.write("*) _message \"don't know how to" \
" complete $service\";;\nesac")
def fromPlugins(cls, clock):
"""
Create a :obj:`MimicCore` from all :obj:`IAPIMock` and
:obj:`IAPIDomainMock` plugins.
"""
service_catalog_plugins = getPlugins(IAPIMock, plugins)
domain_plugins = getPlugins(IAPIDomainMock, plugins)
return cls(clock, service_catalog_plugins, domain_plugins)
def test_detectFilesRemoved(self):
"""
Check that when a dropin file is removed, L{plugin.getPlugins} doesn't
return it anymore.
"""
FilePath(__file__).sibling("plugin_extra1.py").copyTo(self.package.child("pluginextra.py"))
try:
# Generate a cache with pluginextra in it.
list(plugin.getPlugins(ITestPlugin, self.module))
finally:
self._unimportPythonModule(sys.modules["mypackage.pluginextra"], True)
plgs = list(plugin.getPlugins(ITestPlugin, self.module))
self.assertEqual(1, len(plgs))
def _init_faf_events(self):
"""
Generate classes and initializes listeners for 'system events'.
Please use global registration as last resort.
"""
for klass_name in events_lst + [evname for elst in getPlugins(IEventList, events) for evname in elst]:
self.registerEventFromName(klass_name, Evt)
# Register Listeners
for event_handler in getPlugins(IEventListener, events):
if not isinstance(event_handler.__class__.EVENT, list):
self.addListener(event_handler.__class__.EVENT, event_handler)
else:
for event_name in event_handler.__class__.EVENT:
self.addListener(event_name, event_handler)
def _init_resp_events(self):
full_lst = responding_events + [
evname for elst in getPlugins(IRespondingEventList,
events) for evname in elst
]
for klass_name in full_lst:
self.registerEventFromName(klass_name, RespondingEvt)
for event_handler in getPlugins(IEventResponder):
if not isinstance(event_handler.__class__.RESPEVENT, list):
self.addResponder(event_handler.__class__.RESPEVENT, event_handler.respond)
else:
for event_name in event_handler.__class__.RESPEVENT:
self.addResponder(event_name, event_handler.respond)
def postOptions(self):
BaseOptions.postOptions(self)
if self['running_author-whitelist']:
self['author-whitelist'] = self['running_author-whitelist']
else:
self['author-whitelist'] = [ip_network(self['author-whitelist'], strict=False)]
if self['running_subscriber-whitelist']:
self['subscriber-whitelist'] = self['running_subscriber-whitelist']
else:
self['subscriber-whitelist'] = [ip_network(self['subscriber-whitelist'], strict=False)]
if self['verbosity'] >= 2:
log.LEVEL = log.Levels.DEBUG
elif self['verbosity'] == 1:
log.LEVEL = log.Levels.INFO
else:
log.LEVEL = log.Levels.WARNING
# Now enable plugins if requested.
# We loop over all plugins, checking if the user supplied their name
# on the command line and adding them to our list of handlers if so.
for plugin in getPlugins(IHandler, comet.plugins):
if self[plugin.name]:
if IHasOptions.providedBy(plugin):
for name, _, _ in plugin.get_options():
plugin.set_option(name, self["%s-%s" % (plugin.name, name)])
self['handlers'].append(plugin)
def retrieve_plugins(interface, cached=True, cache={}):
"""
Look up all plugins for a certain interface.
If the plugin cache is enabled, this function will not attempt to reload
plugins from disk or discover new plugins.
:param interface interface: the interface to use
:param bool cached: whether to use the in-memory plugin cache
:returns: a dict of plugins, keyed by name
:raises PluginException: no plugins could be found for the given interface
"""
if cached and interface in cache:
return cache[interface]
print "Discovering %s..." % interface
d = {}
for p in getPlugins(interface, beta.plugins):
print " ~ Plugin: %s" % p.name
d[p.name] = p
cache[interface] = d
return d
def loadAll(self) -> None:
configModulesToLoad = self.bot.config.getWithDefault('modules', ['all'])
moduleNamesToLoad = set()
allModules = [module for module in getPlugins(IModule, desertbot.modules)]
if 'all' in configModulesToLoad:
moduleNamesToLoad.update(set([module.__class__.__name__ for module in allModules]))
for module in configModulesToLoad:
if module == 'all':
continue
elif module.startswith('-'):
moduleNamesToLoad.remove(module[1:])
else:
moduleNamesToLoad.add(module)
modulesToLoad = sorted([module for module in allModules if module.__class__.__name__ in moduleNamesToLoad],
key=lambda module: module.loadingPriority, reverse=True)
for module in modulesToLoad:
try:
self.loadModule(module.__class__.__name__, rebuild_=False)
except Exception as e:
# ^ dirty, but we don't want any modules to kill the bot
self.logger.exception("Exception when loading module {!r}".format(module))
self.bot.reraiseIfDebug(e)
def activate(self):
self.installable = []
self.uninstallable = []
installed = {}
available = {}
for i in self.store.query(InstalledPlugin):
installed[i.path] = i.version
for a in getPlugins(isqueal.ISquealPlugin, plugins):
path = a.__name__ + "." + a.__module__
available[path] = a
for path, plugin in available.items():
if path in installed:
self.uninstallable.append({
'plugin': plugin,
'version': a.version,
'path': path
})
if plugin.version > installed[path]:
log.warning("Plugin %s has been upgraded" % path)
elif plugin.version < installed[path]:
log.warning("Plugin %s has been downgraded" % path)
else:
self.installable.append({
'plugin': plugin,
'version': a.version,
'path': path
})
for path, version in installed.items():
if path not in available:
print "Plugin", path, "has been removed"
def retrieve_plugins(interface, cached=True, cache={}):
"""
Look up all plugins for a certain interface.
If the plugin cache is enabled, this function will not attempt to reload
plugins from disk or discover new plugins.
:param interface interface: the interface to use
:param bool cached: whether to use the in-memory plugin cache
:returns: a dict of plugins, keyed by name
:raises PluginException: no plugins could be found for the given interface
"""
if cached and interface in cache:
return cache[interface]
log.msg("Discovering %s..." % interface)
d = {}
for p in getPlugins(interface, bravo.plugins):
try:
verifyObject(interface, p)
log.msg(" ( ^^) Plugin: %s" % p.name)
d[p.name] = p
except BrokenImplementation, bi:
if hasattr(p, "name"):
log.msg(" ( ~~) Plugin %s is missing attribute %r!" %
(p.name, bi.name))
else:
log.msg(" ( >&) Plugin %s is unnamed and useless!" % p)
except BrokenMethodImplementation, bmi:
log.msg(" ( Oo) Plugin %s has a broken %s()!" % (p.name,
bmi.method))
log.err()
def check(cmd, mg):
from twisted.plugin import getPlugins, IPlugin
from twisted import plugins as twisted_plugins
from mimic import plugins as mimic_plugins
for plugin_package in [twisted_plugins, mimic_plugins]:
import time
list(getPlugins(IPlugin, package=plugin_package))
import os
def plugpath(what):
path_in_zip = what + "/plugins"
path_on_fs = (
os.path.abspath(
os.path.join(
os.path.dirname(
__import__(what + ".plugins",
fromlist=["nonempty"])
.__file__),
"dropin.cache")
))
os.utime(path_on_fs, (time.time() + 86400,) * 2)
return (path_in_zip, [path_on_fs])
data_files = [plugpath("mimic"), plugpath("twisted")]
return dict(loader_files=data_files)
def retrieve_plugins(interface, cached=True, cache={}):
"""
Look up all plugins for a certain interface.
If the plugin cache is enabled, this function will not attempt to reload
plugins from disk or discover new plugins.
:param interface interface: the interface to use
:param bool cached: whether to use the in-memory plugin cache
:returns: a dict of plugins, keyed by name
:raises PluginException: no plugins could be found for the given interface
"""
if cached and interface in cache:
return cache[interface]
log.msg("Discovering %s..." % interface)
d = {}
for p in getPlugins(interface, bravo.plugins):
try:
verify_plugin(interface, p)
d[p.name] = p
except PluginException:
pass
if issubclass(interface, ISortedPlugin):
# Sortable plugins need their edges mirrored.
d = add_plugin_edges(d)
cache[interface] = d
return d
def test_detectNewFiles(self):
"""
Check that L{plugin.getPlugins} is able to detect plugins added at
runtime.
"""
FilePath(__file__).sibling('plugin_extra1.py'
).copyTo(self.package.child('pluginextra.py'))
try:
# Check that the current situation is clean
self.failIfIn('mypackage.pluginextra', sys.modules)
self.failIf(hasattr(sys.modules['mypackage'], 'pluginextra'),
"mypackage still has pluginextra module")
plgs = list(plugin.getPlugins(ITestPlugin, self.module))
# We should find 2 plugins: the one in testplugin, and the one in
# pluginextra
self.assertEquals(len(plgs), 2)
names = ['TestPlugin', 'FourthTestPlugin']
for p in plgs:
names.remove(p.__name__)
p.test1()
finally:
self._unimportPythonModule(
sys.modules['mypackage.pluginextra'],
True)
def iterate():
import tj.plugins
for module in plugin.getPlugins(IBotPlugin, tj.plugins):
if(module.__module__ not in conf.get('active-plugins')):
continue
m = module()
yield m
def subCommands(self):
from twisted import plugin
plugins = plugin.getPlugins(service.IServiceMaker)
self.loadedPlugins = {}
for plug in plugins:
self.loadedPlugins[plug.tapname] = plug
yield (plug.tapname, None, lambda: plug.options(), plug.description)
def _put_plugin_resources(client_resource):
# Plugin resources and plugin info
load_list_css = []
load_list_js = []
mode_table = {}
plugin_resources = Resource()
client_resource.putChild('plugins', plugin_resources)
for resource_def in getPlugins(IClientResourceDef, shinysdr.plugins):
# Add the plugin's resource to static serving
plugin_resources.putChild(resource_def.key, resource_def.resource)
plugin_resource_url = '/client/plugins/' + urllib.quote(resource_def.key, safe='') + '/'
# Tell the client to load the plugins
# TODO constrain path values to be relative (not on a different origin, to not leak urls)
if resource_def.load_css_path is not None:
load_list_css.append(plugin_resource_url + resource_def.load_cs_path)
if resource_def.load_js_path is not None:
# TODO constrain value to be in the directory
load_list_js.append(plugin_resource_url + resource_def.load_js_path)
for mode_def in get_modes():
mode_table[mode_def.mode] = {
u'info_enum_row': mode_def.info.to_json(),
u'can_transmit': mode_def.mod_class is not None
}
# Client gets info about plugins through this resource
client_resource.putChild('plugin-index.json', static.Data(serialize({
u'css': load_list_css,
u'js': load_list_js,
u'modes': mode_table,
}).encode('utf-8'), 'application/json'))
def handlePlugins(self, info):
"""Give control to plugins.
@param info: C{(proxy, equipment)} tuple
"""
proxy, equipment = info
proxy.version = 2 # Switch to version 2. Plugins should
# switch back to version 1 if needed.
# Filter out plugins that do not handle our equipment
plugins = [ plugin for plugin
in getPlugins(ICollector,
wiremaps.collector.equipment)
if plugin.handleEquipment(str(equipment.oid)) ]
if not plugins:
print "No plugin found for OID %s, using generic one" % str(equipment.oid)
plugins = [generic]
print "Using %s to collect data from %s" % ([str(plugin.__class__)
for plugin in plugins],
proxy.ip)
d = defer.succeed(None)
# Run each plugin to complete C{equipment}
for plugin in plugins:
plugin.config = self.config
d.addCallback(lambda x: plugin.collectData(equipment, proxy))
# At the end, write C{equipment} to the database
d.addCallback(lambda _: DatabaseWriter(equipment, self.config).write(self.dbpool))
return d
def _put_plugin_resources(wcommon, client_resource):
"""Plugin-defined resources and client-configuration."""
load_list_css = []
load_list_js = []
mode_table = {}
plugin_resources = Resource()
client_resource.putChild('plugins', plugin_resources)
for resource_def in getPlugins(_IClientResourceDef, shinysdr.plugins):
# Add the plugin's resource to static serving
plugin_resources.putChild(resource_def.key, resource_def.resource)
plugin_resource_url = '/client/plugins/' + urllib.parse.quote(resource_def.key, safe='') + '/'
# Tell the client to load the plugins
# TODO constrain path values to be relative (not on a different origin, to not leak urls)
if resource_def.load_css_path is not None:
load_list_css.append(plugin_resource_url + resource_def.load_cs_path)
if resource_def.load_js_path is not None:
# TODO constrain value to be in the directory
load_list_js.append(plugin_resource_url + resource_def.load_js_path)
for mode_def in get_modes():
mode_table[mode_def.mode] = {
u'info_enum_row': mode_def.info.to_json(),
u'can_transmit': mode_def.mod_class is not None
}
plugin_index = {
'css': load_list_css,
'js': load_list_js,
'modes': mode_table,
}
client_resource.putChild('client-configuration', ClientConfigurationResource(wcommon, plugin_index))
def _getProviders(self):
from dad import plugins
providers = {}
for provider in plugin.getPlugins(idad.IPlayerProvider, plugins):
providers[provider.name] = provider
return providers
def _scan_sites(env):
"""
Search for available site configuration objects.
Register any found objects with the internal structures.
"""
global host_tree, debug_site_scan
import modu.sites
reload(modu.sites)
plugins = plugin.getPlugins(ISite, modu.sites)
for site_plugin in plugins:
if(debug_site_scan):
env['wsgi.errors'].write('Found %r\n' % (site_plugin,))
site = site_plugin()
app = Application(site)
root = app.tree.get_data_at('/')
webroot = os.path.join(app.approot, app.webroot)
app.tree.register('/', (static.FileResource, (webroot, root), {}), clobber=True)
domain = app.base_domain
if(domain.find(':') == -1):
domain += ':' + env['SERVER_PORT']
host_node = host_tree.setdefault(domain, url.URLNode())
base_path = app.base_path
if not(base_path):
base_path = '/'
if(debug_site_scan):
env['wsgi.errors'].write('Loaded %r for %r\n' % (site_plugin, domain))
host_node.register(base_path, app, clobber=True)
def __init__(self, config):
self.channels = config['channels']
self.nickname = config['nickname']
self.history = {}
self.loader = PluginLoader()
self.loader.config = config
if 'db' in config:
print('Loading db from config: ' + config['db'])
db_engine = sqlalchemy.create_engine(config['db'])
else:
print('Using in-memory db')
db_engine = sqlalchemy.create_engine('sqlite:///:memory:')
DBSession = orm.sessionmaker(db_engine)
session = DBSession()
self.loader.db = DB(db_engine, session)
# Load all plugins mentioned in the configuration. Allow globbing.
config_matches = set()
for plugin in getPlugins(BaseInterface, package=plugins):
for pattern in config['plugins']:
if fnmatch(plugin.name, pattern):
self.loader.registerPlugin(plugin)
config_matches.add(pattern)
break
for pattern in config['plugins']:
if pattern not in config_matches:
log.warning('No plugin matched pattern "%s"', pattern)
def __init__(self, config):
self.loader = PluginLoader()
self.loader.config = config
self.history = {}
if 'db' in config:
print('Loading db from config: ' + config['db'])
db_engine = sqlalchemy.create_engine(config['db'])
else:
print('Using in-memory db')
db_engine = sqlalchemy.create_engine('sqlite:///:memory:')
DBSession = orm.sessionmaker(db_engine)
session = DBSession()
self.loader.db = DB(db_engine, session)
# Load all plugins mentioned in the configuration. Allow globbing.
print "Loading plugins", config["plugins"]
plugins = getPlugins(BaseInterface, package=hamper.plugins)
for plugin in plugins:
for pattern in config["plugins"]:
if fnmatch(plugin.name, pattern):
self.loader.registerPlugin(plugin)
def _testPlugins(self):
plugins = list(plugin.getPlugins(plugin.ITestPlugin2))
self.assertEquals(len(plugins), 2)
names = ['AnotherTestPlugin', 'ThirdTestPlugin']
for p in plugins:
names.remove(p.__name__)
p.test()
def loadApps():
"""
Read the IResource plugins
"""
import goonsite.plugins
plugins = getPlugins(IAppFactory, goonsite.plugins)
return dict([(p.name, p) for p in plugins])
def loadModule(self, name):
for module in getPlugins(IBotModule, heufybot.modules):
if module.name and module.name.lower() == name.lower():
rebuild(importlib.import_module(module.__module__))
self._loadModuleData(module)
return module.name
raise ModuleLoaderError(name, "The module could not be found.", ModuleLoadType.LOAD)
def test_findCheckerFactories(self):
"""
Test that findCheckerFactories returns all available plugins.
"""
availablePlugins = list(strcred.findCheckerFactories())
for plg in plugin.getPlugins(strcred.ICheckerFactory):
self.assertIn(plg, availablePlugins)
def __init__(self, config):
self.channels = config['channels']
self.nickname = config['nickname']
self.config = config
self.history = {}
self.plugins = {
'base_plugin': [],
'presence': [],
'chat': [],
'population': [],
}
if 'db' in config:
print('Loading db from config: ' + config['db'])
self.db_engine = sqlalchemy.create_engine(config['db'])
else:
print('Using in-memory db')
self.db_engine = sqlalchemy.create_engine('sqlite:///:memory:')
DBSession = orm.sessionmaker(self.db_engine)
self.db = DBSession()
# Load all plugins mentioned in the configuration. Allow globbing.
for plugin in getPlugins(BaseInterface, package=plugins):
self.registerPlugin(plugin)
def loadModule(self, name):
for module in getPlugins(IBotModule, heufybot.modules):
if not module.name:
raise ModuleLoaderError("???", "Module did not provide a name")
if module.name == name:
rebuild(importlib.import_module(module.__module__))
self._loadModuleData(module)
break
"Programming Language :: Python :: Implementation :: PyPy",
"Topic :: Internet",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Communications",
"Topic :: System :: Distributed Computing",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: Software Development :: Object Brokering"],
keywords='autobahn crossbar websocket realtime rfc6455 wamp rpc pubsub twisted asyncio xbr data-markets blockchain ethereum'
)
# regenerate Twisted plugin cache
try:
from twisted.internet import reactor
print("Twisted found (default reactor is {0})".format(reactor.__class__))
except ImportError:
# the user doesn't have Twisted, so skip
pass
else:
# Make Twisted regenerate the dropin.cache, if possible. This is necessary
# because in a site-wide install, dropin.cache cannot be rewritten by
# normal users.
try:
from twisted.plugin import IPlugin, getPlugins
list(getPlugins(IPlugin))
except Exception as e:
print("Failed to update Twisted plugin cache: {0}".format(e))
else:
print("Twisted dropin.cache regenerated.")
def clientFromString(reactor, description):
"""
Construct a client endpoint from a description string.
Client description strings are much like server description strings,
although they take all of their arguments as keywords, aside from host and
port.
You can create a TCP client endpoint with the 'host' and 'port' arguments,
like so::
clientFromString(reactor, "tcp:host=www.example.com:port=80")
or, without specifying host and port keywords::
clientFromString(reactor, "tcp:www.example.com:80")
Or you can specify only one or the other, as in the following 2 examples::
clientFromString(reactor, "tcp:host=www.example.com:80")
clientFromString(reactor, "tcp:www.example.com:port=80")
or an SSL client endpoint with those arguments, plus the arguments used by
the server SSL, for a client certificate::
clientFromString(reactor, "ssl:web.example.com:443:"
"privateKey=foo.pem:certKey=foo.pem")
to specify your certificate trust roots, you can identify a directory with
PEM files in it with the C{caCertsDir} argument::
clientFromString(reactor, "ssl:host=web.example.com:port=443:"
"caCertsDir=/etc/ssl/certs")
You can create a UNIX client endpoint with the 'path' argument and optional
'lockfile' and 'timeout' arguments::
clientFromString(reactor, "unix:path=/var/foo/bar:lockfile=1:timeout=9")
or, with the path as a positional argument with or without optional
arguments as in the following 2 examples::
clientFromString(reactor, "unix:/var/foo/bar")
clientFromString(reactor, "unix:/var/foo/bar:lockfile=1:timeout=9")
This function is also extensible; new endpoint types may be registered as
L{IStreamClientEndpointStringParser} plugins. See that interface for more
information.
@param reactor: The client endpoint will be constructed with this reactor.
@param description: The strports description to parse.
@return: A new endpoint which can be used to connect with the parameters
given by by C{description}.
@rtype: L{IStreamClientEndpoint<twisted.internet.interfaces.IStreamClientEndpoint>}
@since: 10.2
"""
args, kwargs = _parse(description)
aname = args.pop(0)
name = aname.upper()
for plugin in getPlugins(IStreamClientEndpointStringParser):
if plugin.prefix.upper() == name:
return plugin.parseStreamClient(*args, **kwargs)
if name not in _clientParsers:
raise ValueError("Unknown endpoint type: %r" % (aname, ))
kwargs = _clientParsers[name](*args, **kwargs)
return _endpointClientFactories[name](reactor, **kwargs)
def refresh_plugin_cache():
from twisted.plugin import IPlugin, getPlugins
list(getPlugins(IPlugin))
def __init__(self):
self.__all_modes = {d.mode: d
for d in getPlugins(IModeDef, plugins)}
self.__available_modes = {d.mode: d
for d in self.__all_modes.itervalues()
if d.available}
def _zshReporterAction():
return "(%s)" % (" ".join(
[p.longOpt for p in plugin.getPlugins(itrial.IReporter)]), )
from shinysdr.db_import import GeoFilter, IImporter, _IImporterDef
from shinysdr import plugins
def _general_warning_callback(msg):
print >>sys.stderr, msg
def _add_file_wrapper(importer, filename, open_file):
def warning_callback(msg):
print >>sys.stderr, u'%s:%s' % (filename, msg)
importer.add_file(filename, open_file, warning_callback)
_importer_defs = {p.name: p for p in getPlugins(_IImporterDef, plugins) if p.available}
def _importer_list_msg():
out = 'Known importers:\n'
for name, idef in _importer_defs.iteritems():
out += ' %s: %s\n' % (name, idef.description)
return out
def _parse_args(argv):
parser = argparse.ArgumentParser(
prog=argv[0],
epilog=_importer_list_msg(),
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('importer_name', metavar='IMPORTER',
def findCheckerFactories():
"""
Find all objects that implement L{ICheckerFactory}.
"""
return getPlugins(ICheckerFactory)
def fromPlugins(cls, clock):
"""
Create a :obj:`MimicCore` from all :obj:`IAPIMock` plugins.
"""
return cls(clock, list(getPlugins(IAPIMock, plugins)))
def __init__(self):
self.__modes = {p.mode: p for p in getPlugins(_IModeDef, plugins) if p.available}
def getReactorTypes() -> Iterable[IReactorInstaller]:
"""
Return an iterator of L{IReactorInstaller} plugins.
"""
return getPlugins(IReactorInstaller)
def _general_warning_callback(msg):
print >> sys.stderr, msg
def _add_file_wrapper(importer, filename, open_file):
def warning_callback(msg):
print >> sys.stderr, u'%s:%s' % (filename, msg)
importer.add_file(filename, open_file, warning_callback)
_importer_defs = {
p.name: p
for p in getPlugins(_IImporterDef, plugins) if p.available
}
def _importer_list_msg():
out = 'Known importers:\n'
for name, idef in _importer_defs.iteritems():
out += ' %s: %s\n' % (name, idef.description)
return out
def _parse_args(argv):
parser = argparse.ArgumentParser(
prog=argv[0],
epilog=_importer_list_msg(),
formatter_class=argparse.RawDescriptionHelpFormatter)
def _reporterAction():
return usage.CompleteList(
[p.longOpt for p in plugin.getPlugins(itrial.IReporter)])
def execute(self, server, source, command, params, data):
if command == "addalias":
if len(params) < 2:
self.replyPRIVMSG(server, source, "Add which alias?")
return
alias = params[0].lower()
if alias in self.aliases:
self.replyPRIVMSG(
server, source,
"{!r} already exists as an alias.".format(alias))
return
commandsList = []
for module in getPlugins(IBotModule, heufybot.modules):
if isinstance(module, BotCommand):
commandsList += module.triggers()
if alias in commandsList:
self.replyPRIVMSG(
server, source,
"{!r} already exists as a command.".format(alias))
return
if params[1] not in commandsList:
self.replyPRIVMSG(
server, source,
"{!r} is not a valid command or alias.".format(params[1]))
return
replacement = " ".join(params[1:])
self.aliases[alias] = {
"replacement": replacement,
"helptext": None
}
self.commandHelp[alias] = self._getAliasReplacementMessage(alias)
self._syncAliases()
self.replyPRIVMSG(
server, source,
"{!r} has been added as an alias for {!r}.".format(
alias, replacement))
elif command == "delalias":
if len(params) < 1:
self.replyPRIVMSG(server, source, "Remove which alias?")
return
alias = params[0].lower()
if self._checkAliasExists(alias, server, source):
del self.aliases[alias]
if alias in self.commandHelp:
del self.commandHelp[alias]
self._syncAliases()
self.replyPRIVMSG(server, source,
"Alias {!r} has been removed.".format(alias))
elif command == "listaliases":
if len(self.aliases) == 0:
self.replyPRIVMSG(server, source,
"No aliases have been configured.")
else:
self.replyPRIVMSG(
server, source, "Aliases: {}".format(". ".join(
sorted(self.aliases.keys()))))
elif command == "showalias":
if len(params) < 1:
self.replyPRIVMSG(server, source, "Add help for which alias?")
return
alias = params[0].lower()
if self._checkAliasExists(alias, server, source):
self.replyPRIVMSG(server, source,
self._getAliasReplacementMessage(alias))
elif command == "setaliashelp":
if len(params) < 2:
self.replyPRIVMSG(server, source, "Add help to which alias?")
return
alias = params[0].lower()
if self._checkAliasExists(alias, server, source):
helpText = " ".join(params[1:])
self.aliases[alias]["helptext"] = helpText
self.commandHelp[alias] = helpText
self._syncAliases()
self.replyPRIVMSG(
server, source,
"Help text for {!r} has been set to {!r}.".format(
alias, helpText))
else:
src = data["channel"] if "channel" in data else data["user"]
message = self._getAliasedMessage(server, src, data["user"],
command, params)
if message:
if "channel" in data:
self.bot.moduleHandler.runGenericAction(
"message-channel", server, src, data["user"], message)
else:
self.bot.moduleHandler.runGenericAction(
"message-user", server, src, message)
def _collect_storage_plugins(cls, storage_plugin_names):
"""
Get the storage plugins with names matching those given.
"""
return list(plugin for plugin in getPlugins(IFoolscapStoragePlugin)
if plugin.name in storage_plugin_names)
