def interface(trace, arch, mode):
'''
Arguments:
Trace - Log_file_path
Arch - Architecture
Mode - Execution trace format
'''
parser_pm = pluggy.PluginManager("parser")
decoder_pm = pluggy.PluginManager("decoder")
parser_pm.add_hookspecs(ParserSpec)
decoder_pm.add_hookspecs(DecoderSpec)
parserfile = importlib.import_module("riscv_isac.plugins." + mode)
parserclass = getattr(parserfile, "mode_" + mode)
parser_pm.register(parserclass())
parser = parser_pm.hook
parser.setup(trace=trace, arch=arch)
instructionObjectfile = importlib.import_module(
"riscv_isac.plugins.internalDecoder")
decoderclass = getattr(instructionObjectfile, "disassembler")
decoder_pm.register(decoderclass())
decoder = decoder_pm.hook
decoder.setup(arch=arch)
iterator = iter(parser.__iter__()[0])
for instr, mnemonic, addr, commitvalue in iterator:
if instr is not None:
instrObj = decoder.decode(instr=instr, addr=addr)
def start(config: Settings):
backbones = pluggy.PluginManager("threatbus.backbone")
backbones.add_hookspecs(backbonespecs)
apps = pluggy.PluginManager("threatbus.app")
apps.add_hookspecs(appspecs)
tb_logger = logger.setup(config.logging, "threatbus")
installed_apps = set(list_installed("threatbus.app"))
configured_apps = set(config.plugins.apps.keys())
for app in configured_apps:
apps.load_setuptools_entrypoints("threatbus.app", app)
installed_backbones = set(list_installed("threatbus.backbone"))
configured_backbones = set(config.plugins.backbones.keys())
for backbone in configured_backbones:
backbones.load_setuptools_entrypoints("threatbus.backbone", backbone)
## Notify user about configuration mismatches between installed and
## configured plugins.
for unwanted_app in installed_apps - configured_apps:
tb_logger.info(
f"Ignoring installed, but unconfigured app '{unwanted_app}'")
for unwanted_backbones in installed_backbones - configured_backbones:
tb_logger.info(
f"Ignoring installed, but unconfigured backbones '{unwanted_backbones}'"
)
for unconfigured_app in (configured_apps -
installed_apps).union(configured_backbones -
installed_backbones):
tb_logger.warn(
f"Found configuration for '{unconfigured_app}' but no corresponding plugin is installed."
)
## Validate all plugins that are both installed and configured
for validators in apps.hook.config_validators():
config.validators.register(*validators)
for validators in backbones.hook.config_validators():
config.validators.register(*validators)
try:
config.validators.validate()
except Exception as e:
sys.exit(f"Invalid config: {e}")
bus_thread = ThreatBus(backbones.hook, apps.hook, tb_logger, config)
signal.signal(signal.SIGINT, bus_thread.stop_signal)
bus_thread.start()
return bus_thread
def create_manager(logger=None):
manager = pluggy.PluginManager(PROJECT_NAME)
if logger is not None:
manager.trace.root.setwriter(logger.debug)
manager.enable_tracing()
manager.add_hookspecs(HookSpecs)
# Pluggy will skip loading a plugin if it throws a DistributionNotFound exception.
# However we don't all plugins to have to catch ImportError and re-throw.
# So here we'll filter out any entry points that throw ImportError,
# assuming one or more of their dependencies isn't present.
for entry_point in pkg_resources.iter_entry_points(PROJECT_NAME):
try:
entry_point.load()
except ImportError as e:
if logger is not None:
logger.warning(
"Failed to load %s entry point '%s': %s",
PROJECT_NAME,
entry_point.name,
e,
)
manager.set_blocked(entry_point.name)
# Load the entry points into pluggy, having blocked any failing ones
manager.load_setuptools_entrypoints(PROJECT_NAME)
if logger is not None:
for name, plugin in manager.list_name_plugin():
if plugin is not None:
logger.info("Loaded %s plugin %s from %s", PROJECT_NAME, name,
plugin)
return manager
def get_plugin_manager():
pm = pluggy.PluginManager("eggsample")
pm.add_hookspecs(hookspecs)
count = pm.load_setuptools_entrypoints("eggsample") # 注册插件: 根据 setuptools中的entrypoint名称
print(count)
pm.register(lib)
return pm
def setup_plugin_manager():
plugin_manager = pluggy.PluginManager("derex.runner")
plugin_manager.add_hookspecs(plugin_spec)
plugin_manager.load_setuptools_entrypoints("derex.runner")
plugin_manager.register(config.LocalOpenEdX)
plugin_manager.register(config.BaseServices)
return plugin_manager
def get_plugin_manager():
pm = pluggy.PluginManager(project_name='guttenberg-search')
pm.add_hookspecs(hookspecs)
pm.register(json_output)
pm.load_setuptools_entrypoints('guttenberg-search')
return pm
def create_app(*, plugins=(), template_paths=(), **plugin_kwargs):
api = fastapi.FastAPI()
api.mount("/static",
StaticFiles(directory=ijik_path("static")),
name="static")
pluginmanager = pluggy.PluginManager("ijik")
pluginmanager.add_hookspecs(Hooks)
pluginmanager.add_hookspecs(EntityHooks)
pluginmanager.add_hookspecs(FormHooks)
for p in itertools.chain(core_plugins(**plugin_kwargs), plugins):
pluginmanager.register(p)
@api.exception_handler(Exception)
async def api_error(request, exc):
pluginmanager.hook.ijik_uncaught_exception(exc=exc)
return PlainTextResponse("Internal Server Error", status_code=500)
ijik = Ijik(api=api,
templates=Jinja2Templates(
directory=[*template_paths,
ijik_path("templates")]),
pluginmanager=pluginmanager,
registry=sa_registry(),
sessionmanager=SessionManager(),
entitymanager=EntityManager(pluginmanager),
mixins=Mixins(),
form_renderer=FormRenderer(pluginmanager))
ijik.init()
ijik.setup()
return api
def get_plugin_manager() -> pluggy.PluginManager:
"""Get the plugin manager."""
pm = pluggy.PluginManager("pytask")
pm.add_hookspecs(hookspecs)
pm.load_setuptools_entrypoints("pytask")
return pm
def test_correlate_management_grp_data(self):
parquet_file = "TestingCorrelation.parquet"
xlsx_file = "TestingCorrelation.xlsx"
with change_dir(OPERATIONSPATH):
if os.path.isfile(parquet_file):
os.remove(parquet_file)
subscription = os.environ["SUB"]
management_grp = os.environ["MANGRP"]
credentials = AzureConnections().get_authenticated_client()
df = EvaluatePolicies(credentials).correlate_management_grp_data(
management_grp=management_grp, subscription=subscription)
df = df.drop(columns=['serialize', 'timestamp'])
df.to_excel(xlsx_file)
pm = pluggy.PluginManager("Analysis")
pm.add_hookspecs(DatbasePlugins)
pm.register(SQLServerDatabase())
engine_list = pm.hook.get_db_engine(
driver=self.driver,
server=self.server,
database=self.database,
user=self.user,
password=self.password,
)
engine = engine_list[0]
df.to_sql('test_noncompliant_002',
con=engine,
if_exists='append',
chunksize=1000)
def __init__(self) -> None:
self.actions: List[Action] = []
try:
self.repo = Repo(".", search_parent_directories=True)
except GitError:
logging.fatal("Current version of mk works only within git repos.")
self.repo = None
return
self.root = Path(self.repo.working_dir)
self.pm = pluggy.PluginManager("mk_tools")
self.pm.load_setuptools_entrypoints("mk_tools")
for _, cls_name in self.pm.list_name_plugin():
# for c in Tool:
c = cls_name()
if c.is_present(self.root):
logging.debug("Detected %s !", c)
self.actions.extend(c.actions())
else:
logging.debug("%s not detected !", c)
if self.repo.is_dirty():
logging.warning("Repo is dirty on %s", self.repo.active_branch)
# expos up command
self.actions.append(
Action(
name="up",
description=
"Upload current change by creating or updating a CR/PR.",
tool=GitTool(),
runner=self,
))
def get_plugin_manager() -> pluggy.PluginManager:
from . import hookspecs
pm = pluggy.PluginManager("nixops")
pm.add_hookspecs(hookspecs)
pm.load_setuptools_entrypoints("nixops")
return pm
def test_pandas_dataframe_policy_states_summarize_for_subscription_pluggy(
self):
pm = pluggy.PluginManager("Analysis")
pm.add_hookspecs(DatbasePlugins)
pm.register(SQLServerDatabase())
engine_list = pm.hook.get_db_engine(
driver=self.db_driver,
server=self.server,
database=self.database,
user=self.user,
password=self.password,
)
subscriptionId = self.config["DEFAULT"]["subscription_id"]
df = subscription_policy_compliance(subscriptionId)
self.assertTrue(len(df.index) > 0)
engine = engine_list[0]
df.to_sql('test_policy_compliance_ratios',
index=False,
con=engine,
if_exists='append',
chunksize=1000)
def get_plugin_manager():
"""Fetch pluggy's plugin manager for our library."""
pm = pluggy.PluginManager("bitex")
pm.add_hookspecs(AnnouncePluginHookSpec)
pm.load_setuptools_entrypoints("bitex")
pm.register(AnnouncePluginHookImpl)
return pm
def __init__(self) -> None:
self.manager = pluggy.PluginManager(NAME) # type:pluggy.PluginManager
self.manager.add_hookspecs(spec)
internal_plugins = (
provision,
core_config,
runner,
sdist,
wheel,
dev,
parallel,
sequential,
list_env,
version_flag,
show_config,
)
for plugin in internal_plugins:
self.manager.register(plugin)
self.manager.load_setuptools_entrypoints(NAME)
self.manager.register(builder)
REGISTER.populate(self)
self.manager.check_pending()
def get_plugin_manager():
"""Fetch pluggy's plugin manager for our library."""
pm = pluggy.PluginManager("bitex")
pm.add_hookspecs(specs)
pm.load_setuptools_entrypoints("bitex")
pm.register(base)
return pm
def test_pandas_dataframe_to_sql_pluggy(self):
pm = pluggy.PluginManager("Analysis")
pm.add_hookspecs(DatbasePlugins)
pm.register(SQLServerDatabase())
engine_list = pm.hook.get_db_engine(
driver=self.db_driver,
server=self.server,
database=self.database,
user=self.user,
password=self.password,
)
engine = engine_list[0]
# Create dataframe
data = pd.DataFrame({
'book_id': [uuid.uuid1(), uuid.uuid1(),
uuid.uuid1()],
'title': [
'Python Programming for Freaks', 'Learn Something',
'Data Science for the Masses'
],
'price': [32, 22, 29]
})
data.to_sql('book_details',
con=engine,
if_exists='append',
chunksize=1000)
def __init__(self) -> None:
self.pm: pluggy.PluginManager = pluggy.PluginManager(
"python_plugin_example")
self.pm.add_hookspecs(PluginExampleHookSpec)
self.pm.register(ChuckNorrisPlugin())
self.pm.register(ICanHazDadJokePlugin())
def __init__(self, root_uri, init_opts):
self._root_path = uris.to_fs_path(root_uri)
self._root_uri = root_uri
self._init_opts = init_opts
self._disabled_plugins = []
self._settings = {}
self._plugin_settings = {}
self._config_sources = {
'flake8': Flake8Config(self._root_path),
'pycodestyle': PyCodeStyleConfig(self._root_path)
}
self._pm = pluggy.PluginManager(PYLS)
self._pm.trace.root.setwriter(log.debug)
self._pm.enable_tracing()
self._pm.add_hookspecs(hookspecs)
self._pm.load_setuptools_entrypoints(PYLS)
for name, plugin in self._pm.list_name_plugin():
log.info("Loaded pyls plugin %s from %s", name, plugin)
for plugin_conf in self._pm.hook.pyls_settings(config=self):
self._plugin_settings = _utils.merge_dicts(self._plugin_settings, plugin_conf)
def getNewPluginManager() -> pluggy.PluginManager:
"""
Return a new plugin manager with all of the hookspecs pre-registered.
"""
pm = pluggy.PluginManager("armi")
pm.add_hookspecs(ArmiPlugin)
return pm
def get_plugin_manager() -> pluggy.PluginManager:
from pyfileconf.plugin import hookspecs, default_hooks
plm = pluggy.PluginManager("pyfileconf")
plm.add_hookspecs(hookspecs)
plm.load_setuptools_entrypoints("pyfileconf")
plm.register(default_hooks)
return plm
def get_plugin_manager(self) -> pluggy.PluginManager:
logger.debug('Creating plugin manager')
pm = pluggy.PluginManager('awsume')
pm.add_hookspecs(hookspec)
logger.debug('Loading plugins')
pm.register(default_plugins)
pm.load_setuptools_entrypoints('awsume')
return pm
def get_plugin_manager(plugins=()):
pm = pluggy.PluginManager("pyrandall")
# add default implementations
pm.add_hookspecs(sys.modules[__name__])
pm.register(pyrandall.behaviors)
pm.load_setuptools_entrypoints("pyrandallX")
pm.check_pending()
return pm
def get_plugin_manager():
"""Get dropdata plugin manager. """
plugin_manager = pluggy.PluginManager(core.PROJECT_NAME)
plugin_manager.add_hookspecs(spec)
for module in plugins.ALL:
plugin_manager.register(module)
plugin_manager.load_setuptools_entrypoints(core.PROJECT_NAME)
return plugin_manager
def __init__(self, root_path, init_opts):
self._root_path = root_path
self._init_opts = init_opts
self._pm = pluggy.PluginManager(PYLS)
self._pm.trace.root.setwriter(log.debug)
self._pm.enable_tracing()
self._pm.add_hookspecs(hookspecs)
self._pm.load_setuptools_entrypoints(PYLS)
def load_plugins(self):
pm = pluggy.PluginManager("jupyterhub_configurator")
pm.add_hookspecs(hooks)
pm.load_setuptools_entrypoints("jupyterhub_configurator")
for fields in pm.hook.jupyterhub_configurator_fields():
self.available_fields.update(fields)
return pm
def __init__(self, plugins=None, entry_point_group=None):
"""Initialize resolver with various plugins and entry point group."""
self.pm = pluggy.PluginManager('jsonresolver')
self.pm.add_hookspecs(hookspec)
for plugin in plugins or []:
self.pm.register(importlib.import_module(plugin))
if entry_point_group:
self.pm.load_setuptools_entrypoints(entry_point_group)
self.url_map = None
def get_plugin_manager():
# initialize plugin manager
pm = pluggy.PluginManager("tox")
pm.add_hookspecs(hookspecs)
pm.register(tox.config)
pm.register(tox.interpreters)
pm.load_setuptools_entrypoints("tox")
pm.check_pending()
return pm
def get_plugin_manager(setup_plugins, events, logger=_logger):
logger.info('Loading Plugins')
pm = pluggy.PluginManager('zgres')
pm.add_hookspecs(events)
setup_plugins = list(setup_plugins)
setup_plugins.reverse()
for name, plugin in setup_plugins:
pm.register(plugin, name=name)
return pm
def setup_plugin_manager():
plugin_manager = pluggy.PluginManager("derex.runner")
plugin_manager.add_hookspecs(plugin_spec)
plugin_manager.load_setuptools_entrypoints("derex.runner")
plugin_manager.register(compose_generation.LocalOpenEdX)
plugin_manager.register(compose_generation.BaseServices)
plugin_manager.register(compose_generation.LocalUser)
plugin_manager.register(compose_generation.LocalRunmodeOpenEdX)
return plugin_manager
def _init_plugin_manager() -> pluggy.PluginManager:
pm = pluggy.PluginManager("crib")
pm.add_hookspecs(CribSpec)
pm.load_setuptools_entrypoints("crib")
pm.register(config)
pm.register(properties)
pm.register(user)
pm.register(directions)
pm.register(dirrepo)
return pm
