napari_plugin_engine/hooks.py
def _check_call_kwargs(self, kwargs):
        """Warn if any keys in the hookspec are not present in this call.

        It's possible to add arguments to hook specifications (as they evolve).
        Here we just emit a warning if there are arguments in the hookspec that
        were not specified in this call, which may mean the call could be
        updated.
        """
        # "historic" hooks can be called with ``call_historic()`` *before*
        # having been registered.  However they must be called with
        # self.call_historic().
        # https://pluggy.readthedocs.io/en/latest/index.html#historic-hooks
        assert (
            not self.is_historic()
        ), 'Historic hooks must be called with `call_historic()`'

        if self.spec and self.spec.argnames:
            notincall = set(self.spec.argnames) - set(kwargs.keys())
            if notincall:
                warnings.warn(
                    "Argument(s) {} which are declared in the hookspec "
                    "can not be found in this hook call".format(
                        tuple(notincall)
                    ),
                    stacklevel=2,
                )
Warn if any keys in the hookspec are not present in this call.

        It's possible to add arguments to hook specifications (as they evolve).
        Here we just emit a warning if there are arguments in the hookspec that
        were not specified in this call, which may mean the call could be
        updated.
        
Warn if any keys in the hookspec are not present in this call.
It's possible to add arguments to hook specifications (as they evolve).
Here we just emit a warning if there are arguments in the hookspec that
were not specified in this call, which may mean the call could be
updated.
Warn if any keys in the hookspec are not present in this call . It ' s possible to add arguments to hook specifications ( as they evolve ) . Here we just emit a warning if there are arguments in the hookspec that were not specified in this call which may mean the call could be updated .
def _check_call_kwargs(self, kwargs):
        assert (
            not self.is_historic()
        ), 'Historic hooks must be called with `call_historic()`'
        if self.spec and self.spec.argnames:
            notincall = set(self.spec.argnames) - set(kwargs.keys())
            if notincall:
                warnings.warn(
                    "Argument(s) {} which are declared in the hookspec "
                    "can not be found in this hook call".format(
                        tuple(notincall)
                    ),
                    stacklevel=2,
                )
def _check_call_kwargs ( self , kwargs ) : assert ( not self . is_historic ( ) ) , 'Historic hooks must be called with `call_historic()`' if self . spec and self . spec . argnames : notincall = set ( self . spec . argnames ) - set ( kwargs . keys ( ) ) if notincall : warnings . warn ( "Argument(s) {} which are declared in the hookspec " "can not be found in this hook call" . format ( tuple ( notincall ) ) , stacklevel = 2 , )
Warn if any keys in the hookspec are not present in this call.
Warn if any keys in the hookspec are not present in this call .
"""Warn if any keys in the hookspec are not present in this call.

        It's possible to add arguments to hook specifications (as they evolve).
        Here we just emit a warning if there are arguments in the hookspec that
        were not specified in this call, which may mean the call could be
        updated.
        """ # "historic" hooks can be called with ``call_historic()`` *before* # having been registered.  However they must be called with # self.call_historic(). # https://pluggy.readthedocs.io/en/latest/index.html#historic-hooks
self
kwargs