def extensions(self):
"""Lazy loading of extensions"""
if self._extensions is None:
self._extensions = NamedExtensionManager(namespace='extensions',
names=self.features,
name_order=True)
return self._extensions
def run():
"""Example application using pangadfs"""
logging.basicConfig(level=logging.INFO)
ctx = {
'ga_settings': {
'crossover_method': 'uniform',
'csvpth': Path(__file__).parent / 'appdata' / 'pool.csv',
'elite_divisor': 5,
'elite_method': 'fittest',
'mutation_rate': .05,
'n_generations': 20,
'points_column': 'proj',
'population_size': 30000,
'position_column': 'pos',
'salary_column': 'salary',
'select_method': 'roulette',
'stop_criteria': 10,
'verbose': True
},
'site_settings': {
'flex_positions': ('RB', 'WR', 'TE'),
'lineup_size': 9,
'posfilter': {'QB': 14, 'RB': 8, 'WR': 8, 'TE': 5, 'DST': 4, 'FLEX': 8},
'posmap': {'DST': 1, 'QB': 1, 'TE': 1, 'RB': 2, 'WR': 3, 'FLEX': 7},
'salary_cap': 50000
}
}
# set up driver managers
dmgrs = {}
emgrs = {}
for ns in GeneticAlgorithm.PLUGIN_NAMESPACES:
pns = f'pangadfs.{ns}'
if ns == 'validate':
emgrs['validate'] = NamedExtensionManager(
namespace=pns,
names=['validate_salary', 'validate_duplicates'],
invoke_on_load=True,
name_order=True)
else:
dmgrs[ns] = DriverManager(
namespace=pns,
name=f'{ns}_default',
invoke_on_load=True)
# set up GeneticAlgorithm object
ga = GeneticAlgorithm(ctx=ctx, driver_managers=dmgrs, extension_managers=emgrs)
# run optimizer
results = ga.optimize()
# show best score and lineup at conclusion
# will break after n_generations or when stop_criteria reached
print(results['best_lineup'])
print(f'Lineup score: {results["best_score"]}')
def run_hooks(recipe_parts, hook_type, extensions=[]):
if not extensions:
return recipe_parts
namespace = "recipe.hooks." + hook_type
hook_mgr = NamedExtensionManager(namespace, extensions, name_order=True)
for extension in hook_mgr.extensions:
recipe_parts = extension.plugin(recipe_parts).execute()
return recipe_parts
def _load_kuryr_ctrlr_handlers():
configured_handlers = CONF.kubernetes.enabled_handlers
LOG.info('Configured handlers: %s', configured_handlers)
handlers = NamedExtensionManager(
'kuryr_kubernetes.controller.handlers',
configured_handlers,
invoke_on_load=True,
on_missing_entrypoints_callback=_handler_not_found,
on_load_failure_callback=_handler_not_loaded)
LOG.info('Loaded handlers: %s', handlers.names())
ctrlr_handlers = []
for handler in handlers.extensions:
ctrlr_handlers.append(handler.obj)
return ctrlr_handlers
def _load_plugins(self):
"""Loads default plugins for any namespace that doesn't have a plugin"""
for ns in self.PLUGIN_NAMESPACES:
if ns not in self.driver_managers and ns not in self.extension_managers:
if ns == 'validate':
self.extension_managers[ns] = NamedExtensionManager(
namespace='pangadfs.validate',
names=self.VALIDATE_PLUGINS,
invoke_on_load=True,
name_order=True)
else:
mgr = DriverManager(namespace=f'pangadfs.{ns}',
name=f'{ns}_default',
invoke_on_load=True)
self.driver_managers[ns] = mgr
def load_plugins(plugins, load_args=None, load_kwargs=None):
load_args = load_args or []
load_kwargs = load_kwargs or {}
logger.debug('Enabled plugins: %s', plugins)
plugins = NamedExtensionManager(namespace='wazo_call_logd.plugins',
names=plugins,
name_order=True,
on_load_failure_callback=plugins_load_fail,
propagate_map_exceptions=True,
invoke_on_load=True)
try:
plugins.map(load_plugin, load_args, load_kwargs)
except RuntimeError as e:
logger.error("Could not load enabled plugins")
logger.exception(e)
def _init_extensions(self):
""" Loads and prepares all enabled extensions """
enabled_notification_handlers = \
cfg.CONF['service:sink'].enabled_notification_handlers
self.extensions_manager = NamedExtensionManager(
HANDLER_NAMESPACE, names=enabled_notification_handlers)
def _load_extension(ext):
handler_cls = ext.plugin
return handler_cls()
try:
return self.extensions_manager.map(_load_extension)
except RuntimeError:
# No handlers enabled. No problem.
return []
def load(namespace, names, dependencies):
names = enabled_names(names)
logger.debug('Enabled plugins: %s', names)
if not names:
logger.info('no enabled plugins')
return
manager = NamedExtensionManager(
namespace,
names,
name_order=True,
on_load_failure_callback=on_load_failure,
on_missing_entrypoints_callback=on_missing_entrypoints,
invoke_on_load=True)
manager.map(load_plugin, dependencies)
return manager
def _init_extensions(self):
""" Loads and prepares all enabled extensions """
enabled_notification_handlers = \
cfg.CONF['service:sink'].enabled_notification_handlers
self.extensions_manager = NamedExtensionManager(
HANDLER_NAMESPACE, names=enabled_notification_handlers)
def _load_extension(ext):
handler_cls = ext.plugin
return handler_cls()
try:
return self.extensions_manager.map(_load_extension)
except RuntimeError:
# No handlers enabled. Bail!
raise exceptions.ConfigurationError('No designate-sink handlers '
'enabled')
