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"""
