def test_indexer_backend_yaml_options(self, make_yaml_config): from devpi_web import main from pluggy import HookimplMarker hookimpl = HookimplMarker("devpiweb") class Index(object): def __init__(self, config, settings): self.settings = settings class Plugin: @hookimpl def devpiweb_indexer_backend(self): return dict(indexer=Index, name="foo", description="Foo backend") yaml_path = make_yaml_config( textwrap.dedent("""\ devpi-server: indexer-backend: name: foo bar: ham""")) options = ("-c", yaml_path) config = make_config(("devpi-server", ) + options) assert isinstance(config.args.indexer_backend, dict) plugin = Plugin() main.get_pluginmanager(config).register(plugin) indexer = main.get_indexer_from_config(config) assert isinstance(indexer, Index) assert indexer.settings == {"bar": "ham"}
def setup_proxy(proxy, plugin_manager, mock): mark = HookimplMarker(plugin_manager.project_name) hooks = [] for function_name in dir(plugin_manager.hook): # find the specifications of the hooks in the plugin manager hook = getattr(plugin_manager.hook, function_name, None) if hook is None: continue has_spec = getattr(hook, 'has_spec', None) if has_spec is None or not has_spec(): continue if getattr(mock, function_name, None) is None: # we were passed a mock object which does not implement this hook # skip it continue hooks.append(function_name) # create a function with the right signature which delegates # to the mock object args = [a for a in hook.argnames if a != '__multicall__'] code = 'def {func}({args}):\n return mock.{func}({args})'.format( func=function_name, args=', '.join(args)) ns = dict(mock=mock) exec(code, ns) func = ns[function_name] func = mark(func) setattr(proxy, function_name, func) return hooks
def impls(reauth=None, post_reauth=None, failure=None): impl = HookimplMarker('flaskbb') class Impls: if reauth is not None: @impl def flaskbb_reauth_attempt(self, user, secret): return reauth(user=user, secret=secret) if post_reauth is not None: @impl def flaskbb_post_reauth(self, user): post_reauth(user=user) if failure is not None: @impl def flaskbb_reauth_failed(self, user): failure(user=user) return Impls()
def impls(auth=None, post_auth=None, failure=None): impl = HookimplMarker('flaskbb') class Impls: if auth is not None: @impl def flaskbb_authenticate(self, identifier, secret): return auth(identifier=identifier, secret=secret) if post_auth is not None: @impl def flaskbb_post_authenticate(self, user): post_auth(user=user) if failure is not None: @impl def flaskbb_authentication_failed(self, identifier): failure(identifier=identifier) return Impls()
def test_indexer_backend_options(self): from devpi_web import main from pluggy import HookimplMarker hookimpl = HookimplMarker("devpiweb") class Index(object): def __init__(self, config, settings): self.settings = settings class Plugin: @hookimpl def devpiweb_indexer_backend(self): return dict(indexer=Index, name="foo", description="Foo backend") options = ("--indexer-backend", "foo:bar=ham") config = make_config(("devpi-server", ) + options) assert config.args.indexer_backend == "foo:bar=ham" plugin = Plugin() main.get_pluginmanager(config).register(plugin) indexer = main.get_indexer_from_config(config) assert isinstance(indexer, Index) assert indexer.settings == {"bar": "ham"}
def impls(validator=None, failure=None, post_process=None): impl = HookimplMarker("flaskbb") class Impls: if validator is not None: @impl def flaskbb_gather_registration_validators(self): return [validator] if failure is not None: @impl def flaskbb_registration_failure_handler( self, user_info, failures): failure(user_info, failures) if post_process is not None: @impl def flaskbb_registration_post_processor(self, user): post_process(user) return Impls()
""" Hook specifications for tox. """ from pluggy import HookspecMarker, HookimplMarker hookspec = HookspecMarker("tox") hookimpl = HookimplMarker("tox") @hookspec def tox_addoption(parser): """ add command line options to the argparse-style parser object.""" @hookspec def tox_configure(config): """ called after command line options have been parsed and the ini-file has been read. Please be aware that the config object layout may change as its API was not designed yet wrt to providing stability (it was an internal thing purely before tox-2.0). """ @hookspec(firstresult=True) def tox_get_python_executable(envconfig): """ return a python executable for the given python base name. The first plugin/hook which returns an executable path will determine it. ``envconfig`` is the testenv configuration which contains per-testenv configuration, notably the ``.envname`` and ``.basepython`` setting.
"""TIFF file reader plugin for napari.""" __version__ = '2020.5.7' from typing import List, Optional, Union, Any, Tuple, Dict, Callable import numpy from tifffile import TiffFile, TiffSequence, TIFF from vispy.color import Colormap from pluggy import HookimplMarker LayerData = Union[Tuple[Any], Tuple[Any, Dict], Tuple[Any, Dict, str]] PathLike = Union[str, List[str]] ReaderFunction = Callable[[PathLike], List[LayerData]] napari_hook_implementation = HookimplMarker('napari') @napari_hook_implementation def napari_get_reader(path: PathLike) -> Optional[ReaderFunction]: """Implements napari_get_reader hook specification.""" if isinstance(path, list): path = path[0] path = path.lower() if path.endswith('zip'): return zip_reader for ext in TIFF.FILE_EXTENSIONS: if path.endswith(ext): return reader_function return None
from whoosh import fields from whoosh.analysis import Filter, LowercaseFilter, RegexTokenizer from whoosh.analysis import Token, Tokenizer from whoosh.compat import text_type, u from whoosh.highlight import ContextFragmenter, HtmlFormatter, highlight from whoosh.index import create_in, exists_in, open_dir from whoosh.index import IndexError as WhooshIndexError from whoosh.qparser import QueryParser from whoosh.qparser import plugins from whoosh.searching import ResultsPage from whoosh.util.text import rcompile from whoosh.writing import CLEAR import itertools import shutil hookimpl = HookimplMarker("devpiweb") try: xrange except NameError: xrange = range class ProjectNameTokenizer(Tokenizer): def __init__(self): self.expression = rcompile(r'(\W|_)') def __eq__(self, other): if self.__class__ is other.__class__: if self.expression.pattern == other.expression.pattern: return True
from pluggy import HookimplMarker from pluggy import HookspecMarker hookspec = HookspecMarker("datasette") hookimpl = HookimplMarker("datasette") @hookspec def startup(datasette): """Fires directly after Datasette first starts running""" @hookspec def get_metadata(datasette, key, database, table): """Return metadata to be merged into Datasette's metadata dictionary""" @hookspec def asgi_wrapper(datasette): """Returns an ASGI middleware callable to wrap our ASGI application with""" @hookspec def prepare_connection(conn, database, datasette): """Modify SQLite connection in some way e.g. register custom SQL functions""" @hookspec def prepare_jinja2_environment(env): """Modify Jinja2 template environment e.g. register custom template tags"""
from pluggy import HookimplMarker import logging # DEBUG logging for s3fs so we can track remote calls logging.basicConfig(level=logging.INFO) logging.getLogger('s3fs').setLevel(logging.DEBUG) # for optional type hints only, otherwise you can delete/ignore this stuff from typing import List, Optional, Union, Any, Tuple, Dict, Callable LayerData = Union[Tuple[Any], Tuple[Any, Dict], Tuple[Any, Dict, str]] PathLike = Union[str, List[str]] ReaderFunction = Callable[[PathLike], List[LayerData]] # END type hint stuff. napari_hook_implementation = HookimplMarker("napari") @napari_hook_implementation def napari_get_reader(path: PathLike) -> Optional[ReaderFunction]: """ Returns a reader for supported paths that include IDR ID - URL of the form: https://s3.embassy.ebi.ac.uk/idr/zarr/v0.1/ID.zarr/ """ if isinstance(path, list): path = path[0] if isinstance(path, str): if re.search(r'^.*/(\d+)\.zarr.*', path) is not None: return reader_function
from itertools import chain from pluggy import HookimplMarker from flask_allows import Permission impl = HookimplMarker('flaskpet') @impl(hookwrapper=True, tryfirst=True) def flaskpet_tpl_admin_settings_menu(user): """ Flattens the lists that come back from the hook into a single iterable that can be used to populate the menu """ from flaskpet.utils.requirements import IsAdmin # noqa: circular dependency results = [('management.overview', 'Overview', 'fa fa-tasks'), ('management.unread_reports', 'Reports', 'fa fa-flag'), ('management.users', 'Users', 'fa fa-user')] if Permission(IsAdmin, identity=user): results.extend([('management.groups', 'Groups', 'fa fa-users'), ('management.forums', 'Forums', 'fa fa-comments'), ('management.settings', 'Settings', 'fa fa-cogs'), ('management.plugins', 'Plugins', 'fa fa-puzzle-piece') ]) outcome = yield outcome.force_result(chain(results, *outcome.get_result()))
import logging from datetime import datetime import pathlib import sys import os from pathlib import Path from pluggy import HookspecMarker, HookimplMarker, PluginManager from baangt.base.PathManagement import ManagedPaths hook_spec = HookspecMarker("baangt") hook_impl = HookimplMarker("baangt") plugin_manager = PluginManager("baangt") from baangt.hookSpecs import baangtHookSpec plugin_manager.add_hookspecs(baangtHookSpec) from baangt.base.TestRun.hookImpls import TestRunHookImpl from baangt.base.BrowserHandling.hookImpls import BrowserDriverHookImpl from baangt.base.Timing.hookImpls import TimingHookImpl from baangt.base.ExportResults.hookImpls import \ (ExportResultsHookImpl, ExcelSheetHelperFunctionsHookImpl, ExportTimingHookImpl) plugin_manager.register(plugin=TestRunHookImpl()) plugin_manager.register(plugin=BrowserDriverHookImpl()) plugin_manager.register(plugin=TimingHookImpl()) plugin_manager.register(plugin=ExportResultsHookImpl()) plugin_manager.register(plugin=ExcelSheetHelperFunctionsHookImpl()) plugin_manager.register(plugin=ExportTimingHookImpl()) # fixme: Parameter für Logfile should include stage and browser()
from pluggy import HookspecMarker, HookimplMarker hookspec = HookspecMarker("mpeb") hookimpl = HookimplMarker("mpeb") @hookspec() def mpeb_setup(): """just a place to handle pre confit stuff""" @hookspec() def mpeb_addsubparser(parser): """register subcommands""" @hookspec() def mpeb_addoption(parser): """register arparse-style options""" @hookspec() def mpeb_cmdline_main(config): """the run loop""" @hookspec() def mpeb_prerun_main(config): """wrap things here"""
""" ``PluginManager`` unit and public API testing. """ import pytest import types import sys from pluggy import ( PluginManager, PluginValidationError, HookCallError, HookimplMarker, HookspecMarker, ) hookspec = HookspecMarker("example") hookimpl = HookimplMarker("example") def test_plugin_double_register(pm): """Registering the same plugin more then once isn't allowed""" pm.register(42, name="abc") with pytest.raises(ValueError): pm.register(42, name="abc") with pytest.raises(ValueError): pm.register(42, name="def") def test_pm(pm): """Basic registration with objects""" class A(object): pass
from flask import Blueprint, render_template from pluggy import HookimplMarker hookimpl = HookimplMarker('fp') bp = Blueprint('iunno', __name__) @bp.route('/') def bp_index(): return 'hello' @bp.route('/me') def me(): return 'hello me' @bp.route('/template') def template(): return render_template("host.html") @hookimpl def fp_load_blueprints(): return {'blueprint': bp, 'url_prefix': '/hello'}
from pluggy import HookimplMarker __all__ = ["hookimpl"] hookimpl = HookimplMarker("preacher") """Marker to be imported and used in plugins (and for own implementations)"""
""" DirectShow device""" from subprocess import PIPE from ffmpegio import path import re, logging from pluggy import HookimplMarker from packaging.version import Version hookimpl = HookimplMarker("ffmpegio") def _scan(): logs = path.ffmpeg( [ "-hide_banner", "-f", "dshow", "-list_devices", "true", "-i", "dummy", "-loglevel", "repeat+info", ], stderr=PIPE, universal_newlines=True, ).stderr logging.debug(logs)
# ScanCode is a free software code scanning tool from nexB Inc. and others. # Visit https://github.com/nexB/scancode-toolkit/ for support and download. from __future__ import absolute_import from __future__ import print_function from __future__ import unicode_literals from collections import OrderedDict import sys from pluggy import HookimplMarker from pluggy import HookspecMarker from pluggy import PluginManager scan_output_spec = HookspecMarker('scan_output_writer') scan_output_writer = HookimplMarker('scan_output_writer') # FIXME: simplify the hooskpec @scan_output_spec def write_output(files_count, version, notice, scanned_files, options, input, output_file, _echo): """ Write the `scanned_files` scan results in the format supplied by the --format command line option. Parameters: - `file_count`: the number of files and directories scanned. - `version`: ScanCode version - `notice`: ScanCode notice - `scanned_files`: an iterable of scan results for each file - `options`: a mapping of key by command line option to a flag True
"""Tag plugger.""" from pluggy import HookspecMarker, HookimplMarker, PluginManager hookspec = HookspecMarker('Tag Plug') environment_hooks = PluginManager('Tag Plug') tag_behavior = HookimplMarker("Tag Plug") class BDDHooks: @hookspec def before_all(self, context): ... @hookspec def before_feature(self, context, feature): ... @hookspec def before_scenario(self, context, scenario): ... @hookspec def before_tag(self, context, tag): ... @hookspec def before_step(self, context, step): ... @hookspec def after_all(self, context):
CategoryForm, EditForumForm, EditGroupForm, EditUserForm) from flaskbb.management.models import Setting, SettingsGroup from flaskbb.plugins.models import PluginRegistry, PluginStore from flaskbb.plugins.utils import validate_plugin from flaskbb.user.models import Group, Guest, User from flaskbb.utils.forms import populate_settings_dict, populate_settings_form from flaskbb.utils.helpers import (get_online_users, register_view, render_template, time_diff, time_utcnow, FlashAndRedirect) from flaskbb.utils.requirements import (CanBanUser, CanEditUser, IsAdmin, IsAtleastModerator, IsAtleastSuperModerator) from flaskbb.utils.settings import flaskbb_config impl = HookimplMarker('flaskbb') logger = logging.getLogger(__name__) class ManagementSettings(MethodView): decorators = [ allows.requires( IsAdmin, on_fail=FlashAndRedirect( message=_("You are not allowed to access the management settings"), # noqa level="danger", endpoint="management.overview" ) ) ]
# for any legal advice. # ScanCode is a free software code scanning tool from nexB Inc. and others. # Visit https://github.com/nexB/scancode-toolkit/ for support and download. from __future__ import absolute_import from __future__ import unicode_literals from collections import OrderedDict import sys from pluggy import HookimplMarker from pluggy import HookspecMarker from pluggy import PluginManager post_scan_spec = HookspecMarker('post_scan') post_scan_impl = HookimplMarker('post_scan') @post_scan_spec def post_scan_handler(active_scans, results): """ Process the scanned files and yield the modified results. Parameters: - `active_scans`: a list of scanners names requested in the current run. - `results`: an iterable of scan results for each file or directory. """ pass post_scan_plugins = PluginManager('post_scan') post_scan_plugins.add_hookspecs(sys.modules[__name__])
from devpi_common.types import cached_property from devpi_server.fileutil import dumps, loads from devpi_server.log import threadlog, thread_push_log, thread_pop_log from devpi_server.readonly import ReadonlyView from devpi_server.readonly import ensure_deeply_readonly, get_mutable_deepcopy from functools import partial from pluggy import HookimplMarker from repoze.lru import LRUCache import contextlib import os import pg8000 import py import time devpiserver_hookimpl = HookimplMarker("devpiserver") class Connection: def __init__(self, sqlconn, storage): self._sqlconn = sqlconn self.dirty_files = {} self.changes = {} self.storage = storage self._changelog_cache = storage._changelog_cache def __enter__(self): return self def __exit__(self, cls, val, tb): pass
collections_manage, categories, categories_manage, product_types, product_types_manage, products, product_detail, product_edit, product_create_step1, product_create_step2, variant_manage, ) from .order import orders, order_detail, send_order, draft_order from .discount import vouchers, vouchers_manage, sales, sales_manage impl = HookimplMarker("flaskshop") def index(): def get_today_num(model): target = db.cast(datetime.now(), db.DATE) which = db.cast(model.created_at, db.DATE) return model.query.filter(which == target).count() def get_order_status(status): return { "count": Order.query.filter_by(status=status).count(), "kind": status, } onsale_products_count = Product.query.filter_by(on_sale=True).count()
import _pytest.assertion import _pytest.hookspec # the extension point definitions from .exceptions import PrintHelp from .exceptions import UsageError from .findpaths import determine_setup from .findpaths import exists from _pytest import deprecated from _pytest._code import ExceptionInfo from _pytest._code import filter_traceback from _pytest.compat import lru_cache from _pytest.compat import safe_str from _pytest.outcomes import fail from _pytest.outcomes import Skipped from _pytest.warning_types import PytestConfigWarning hookimpl = HookimplMarker("pytest") hookspec = HookspecMarker("pytest") class ConftestImportFailure(Exception): def __init__(self, path, excinfo): Exception.__init__(self, path, excinfo) self.path = path self.excinfo = excinfo def main(args=None, plugins=None): """ return exit code, after performing an in-process test run. :arg args: list of command line arguments.
# for any legal advice. # ScanCode is a free software code scanning tool from nexB Inc. and others. # Visit https://github.com/nexB/scancode-toolkit/ for support and download. from __future__ import absolute_import from __future__ import unicode_literals from collections import OrderedDict import sys from pluggy import HookimplMarker from pluggy import HookspecMarker from pluggy import PluginManager pre_scan_spec = HookspecMarker('pre_scan') pre_scan_impl = HookimplMarker('pre_scan') @pre_scan_spec class PreScanPlugin(object): """ A pre-scan plugin layout class to be extended by the pre_scan plugins. Docstring of a plugin class will be used as the plugin option's help text """ # attributes to be used while creating the option for this plugin. option_attrs = {} def __init__(self, user_input): self.user_input = user_input
from flaskbb.markup import make_renderer from flaskbb.user.models import User from flaskbb.utils.helpers import (FlashAndRedirect, do_topic_action, format_quote, get_online_users, real, register_view, render_template, time_diff, time_utcnow) from flaskbb.utils.requirements import (CanAccessForum, CanDeletePost, CanDeleteTopic, CanEditPost, CanPostReply, CanPostTopic, Has, IsAtleastModeratorInForum) from flaskbb.utils.settings import flaskbb_config from .locals import current_category, current_forum, current_topic from .utils import force_login_if_needed impl = HookimplMarker("flaskbb") logger = logging.getLogger(__name__) class ForumIndex(MethodView): def get(self): categories = Category.get_all(user=real(current_user)) # Fetch a few stats about the forum user_count = User.query.count() topic_count = Topic.query.count() post_count = Post.query.count() newest_user = User.query.order_by(User.id.desc()).first() # Check if we use redis or not
from devpi_common.url import URL from devpi.use import PersistentCurrent from devpi_common.request import new_requests_session from devpi import __version__ as client_version from pluggy import HookimplMarker from pluggy import PluginManager import json subcommand = lazydecorator() main_description = """ The devpi commands (installed via devpi-client) wrap common Python packaging, uploading, installation and testing activities, using a remote devpi-server managed index. For more information see http://doc.devpi.net """ hookimpl = HookimplMarker("devpiclient") def main(argv=None): if argv is None: argv = list(sys.argv) hub, method = initmain(argv) with closing(hub): return method(hub, hub.args) def initmain(argv): pm = get_pluginmanager() args = parse_args(argv, pm) mod = args.mainloc func = "main"
from pluggy import HookimplMarker from pluggy import HookspecMarker hookspec = HookspecMarker('datasette') hookimpl = HookimplMarker('datasette') @hookspec def prepare_connection(conn): "Modify SQLite connection in some way e.g. register custom SQL functions" @hookspec def prepare_jinja2_environment(env): "Modify Jinja2 template environment e.g. register custom template tags" @hookspec def extra_css_urls(): "Extra CSS URLs added by this plugin" @hookspec def extra_js_urls(): "Extra JavaScript URLs added by this plugin"
from pluggy import HookspecMarker, HookimplMarker hookspec = HookspecMarker("allure") hookimpl = HookimplMarker("allure") class AllureUserHooks(object): @hookspec def decorate_as_title(self, test_title): """ title """ @hookspec def add_title(self, test_title): """ title """ @hookspec def decorate_as_description(self, test_description): """ description """ @hookspec def add_description(self, test_description): """ description """ @hookspec def decorate_as_description_html(self, test_description_html): """ description html""" @hookspec def add_description_html(self, test_description_html): """ description html"""