How to use the pluggy.HookimplMarker function in pluggy

import pytest
from pluggy import PluginValidationError, HookimplMarker, HookspecMarker


hookspec = HookspecMarker("example")
hookimpl = HookimplMarker("example")


def test_happypath(pm):
    class Api(object):
        @hookspec
        def hello(self, arg):
            "api hook 1"

    pm.add_hookspecs(Api)
    hook = pm.hook
    assert hasattr(hook, 'hello')
    assert repr(hook.hello).find("hello") != -1

    class Plugin(object):
        @hookimpl
        def hello(self, arg):

            @HookimplMarker("flaskbb")
            def flaskbb_settings_updated(self, user, settings_update):
                post_processor.post_process_changeset(
                    user=user, settings_update=settings_update
                )

hookspec (pluggy.HookspecMarker): The marker for runner hooks
"""
# pylint: disable=unused-argument,invalid-name
import sys
import pluggy
import psutil
from .exception import (RunnerNoSuchRunner, RunnerMorethanOneRunnerEnabled,
                        RunnerTypeError)

RMNAME = "pyppl_runner"
# save all runners ever registered
RUNNERS = {}
# poll interval to check job status
DEFAULT_POLL_INTERVAL = 1

hookimpl = pluggy.HookimplMarker(RMNAME)
hookspec = pluggy.HookspecMarker(RMNAME)


@hookspec
def runner_init(proc):
    """@API
    RUNNER API
    Initiate runner
    @params:
        proc (Proc): The Proc instance
    """


@hookspec(firstresult=True)
def isrunning(job):
    """@API

from chameleon.config import AUTO_RELOAD
from devpi_common.metadata import get_latest_version
from devpi_web.config import get_pluginmanager
from devpi_web.doczip import remove_docs
from devpi_web.indexing import ProjectIndexingInfo
from devpi_server.log import threadlog
from devpi_server.main import fatal
from pkg_resources import resource_filename
from pluggy import HookimplMarker
from pyramid.renderers import get_renderer
from pyramid_chameleon.renderer import ChameleonRendererLookup
import os
import sys


hookimpl = HookimplMarker("devpiweb")
devpiserver_hookimpl = HookimplMarker("devpiserver")


def theme_static_url(request, path):
    return request.static_url(
        os.path.join(request.registry['theme_path'], 'static', path))


def macros(request):
    # returns macros which may partially be overwritten in a theme
    result = {}
    paths = [
        resource_filename('devpi_web', 'templates/macros.pt'),
        "templates/macros.pt"]
    for path in paths:
        renderer = get_renderer(path)

from .version import __version__

__all__ = (
    "__version__",  # tox version
    "cmdline",  # run tox as part of another program/IDE (same behaviour as called standalone)
    "hookimpl",  # Hook implementation marker to be imported by plugins
    "exception",  # tox specific exceptions
    # EXPERIMENTAL CONSTANTS API
    "PYTHON",
    "INFO",
    "PIP",
    # DEPRECATED - will be removed from API in tox 4
    "hookspec",
)

hookimpl = pluggy.HookimplMarker("tox")

# NOTE: must come last due to circular import
from .session import cmdline  # isort:skip

# -*- coding: utf-8 -*-
"""Top-level package for alfasim-sdk."""
import pluggy

__author__ = """ESSS"""
__email__ = "foss@esss.co"
__version__ = "0.1.0"

hookimpl = pluggy.HookimplMarker("ALFAsim")


def get_alfasim_sdk_api_path():
    """
    Return the directory that contains the alfasim_sdk_api with the header files
    """
    from alfasim_sdk import hook_specs
    from pathlib import Path

    return str(Path(hook_specs.__file__).parents[1])

import attr
import pluggy

__all__ = ['hookimpl', 'USBQPluginDef']

USBQ_EP = 'usbq'

hookspec = pluggy.HookspecMarker('usbq')
hookimpl = pluggy.HookimplMarker('usbq')


@attr.s(frozen=True)
class USBQPluginDef:
    'Define a USBQ plugin.'

    #: Name of the plugin
    name = attr.ib(converter=str)

    #: Description
    desc = attr.ib(converter=str)

    #: Module name
    mod = attr.ib(converter=str)

    #: Class

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

import pluggy

from kube_hunter.plugins import hookspecs

hookimpl = pluggy.HookimplMarker("kube-hunter")


def initialize_plugin_manager():
    """
    Initializes and loads all default and setup implementations for registered plugins

    @return: initialized plugin manager
    """
    pm = pluggy.PluginManager("kube-hunter")
    pm.add_hookspecs(hookspecs)
    pm.load_setuptools_entrypoints("kube_hunter")

    # default registration of builtin implemented plugins
    from kube_hunter.conf import parser
    pm.register(parser)

import pluggy

spec_name = "deltabot"
deltabot_hookspec = pluggy.HookspecMarker(spec_name)
deltabot_hookimpl = pluggy.HookimplMarker(spec_name)


class DeltaBotSpecs:
    """ per DeltaBot instance hook specifications. """

    @deltabot_hookspec
    def deltabot_init_parser(self, parser):
        """ initialize the deltabot main parser with new options and subcommands.

        :param parser: a :class:`deltabot.parser.MyArgumentParser` instance where you can
                        call `add_subcommand(name, func)` to get a sub parser where you
                        can then add arguments.
        """

    @deltabot_hookspec(firstresult=True)
    def deltabot_get_logger(self, args):