def _delegate_method_dispatch(fn: Callable, attr: str, prop_name: str, skip: int = 2):
adapter = wrapt.adapter_factory(partial(argspec_factory, fn=fn, skip=skip))
@wrapt.decorator(adapter=adapter)
def delegate(wrapped, instance, args, kwargs):
# first, get the correct method based on the dispatcher (can't use wrapped.dispatch..., since it's a function)
# then, call the actual function
return getattr(instance, attr)(
getattr(instance, prop_name), prop_name, *args, **kwargs
)
return delegate(fn)
def test_adapter_factory(self):
def factory(wrapped):
argspec = inspect.getargspec(wrapped)
argspec.args.insert(0, 'arg0')
return argspec
@wrapt.decorator(adapter=wrapt.adapter_factory(factory))
def _wrapper_1(wrapped, instance, args, kwargs):
return wrapped(*args, **kwargs)
@_wrapper_1
def _function_1(arg1, arg2):
pass
argspec = inspect.getargspec(_function_1)
self.assertEqual(argspec.args, ['arg0', 'arg1', 'arg2'])
def test_adapter_factory(self):
def factory(wrapped):
argspec = inspect.getargspec(wrapped)
argspec.args.insert(0, 'arg0')
return argspec
@wrapt.decorator(adapter=wrapt.adapter_factory(factory))
def _wrapper_1(wrapped, instance, args, kwargs):
return wrapped(*args, **kwargs)
@_wrapper_1
def _function_1(arg1, arg2):
pass
argspec = inspect.getargspec(_function_1)
self.assertEqual(argspec.args, ['arg0', 'arg1', 'arg2'])
def change_signature(
force_annotation: Optional[Dict[str, Type]] = None,
change_annotation: Optional[Dict[str, Type]] = None,
namespace: Optional[Dict[str, Any]] = None,
) -> Callable[[Callable], Callable]:
"""Change function signature.
Parameters
----------
force_annotation : dict, optional
mapping of {argument_name: type_hint}. Will force any arguments named
``argument_name`` to be annotated as ``type_hint``.
change_annotation : dict
mapping of {current_hint: new_hint}. Will force any arguments currently
annotated with a type of ``curent_hint`` to ``new_hint`.
namespace : dict
mapping of {name: object}. Namespaces required for importing any types
declared as type annotations in the other arguments.
Returns
-------
adapter : callable
The returned function may be provided to the `adapter` argument of the
``wrapt.decorator`` function.
"""
force_annotation = force_annotation or dict()
change_annotation = change_annotation or dict()
namespace = namespace or dict()
if not namespace:
for val in chain(change_annotation.values(), force_annotation.values()):
mod = val.__module__.split(".")[0]
namespace[mod] = import_module(mod)
def argspec_factory(wrapped):
sig = inspect.signature(wrapped)
new_params = OrderedDict(sig.parameters.items())
for name, param in new_params.items():
if name in force_annotation:
new_params[name] = param.replace(annotation=force_annotation[name])
new_sig = sig.replace(parameters=list(new_params.values()))
_globals = {}
exec(f"def _func{new_sig}: pass", namespace, _globals)
return _globals["_func"]
return wrapt.adapter_factory(argspec_factory)
def _delegate(
*,
prop_name: Optional[str] = None,
return_type: Optional[Type] = None,
skip: int = 2,
) -> Callable:
@wrapt.decorator()
def pass_through(wrapped, _instance, args, kwargs):
return wrapped(*args, **kwargs)
if prop_name is None:
return pass_through
adapter = wrapt.adapter_factory(
partial(argspec_factory, skip=skip, return_type=return_type))
@wrapt.decorator(adapter=adapter)
def wrapper(wrapped, instance, args, kwargs):
return wrapped(getattr(instance, prop_name), prop_name, *args,
**kwargs)
return wrapper
def _inject_api_method(
clazz: type,
) -> None:
"""
Create a decorator which does nothing except for modifying the function signature in the docstring.
The function to be decorated must be a class method and is allowed only to have positional arguments,
and variable keyword arguments (**kwargs).
The resulting decorated function will containing only the positional arguments (including original type annotations)
and possibly keyword only arguments. In this example signature might def fn(foo, bar, *, baz, quux),
`baz` and `quux` are the keyword only arguments.
Parameters
----------
clazz
The class for which to create the query. Must not be abstract.
Returns
-------
:class:`callable`
The decorator as described above.
"""
def argspec_factory(orig_fn: Callable) -> Callable:
orig_params = inspect.signature(orig_fn).parameters
# maintain the original signature if the subclass has overriden the method
# this will lose the docstring of the original function
parameters = {
k: v
for k, v in orig_params.items()
if k != "cls"
and v.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD)
}
annotations = {
k: v for k, v in clazz._annotations().items() if k not in parameters
}
sig = inspect.signature(lambda _: _)
sig = sig.replace(
parameters=[Parameter("cls", kind=Parameter.POSITIONAL_ONLY)]
+ list(parameters.values())
+ [
Parameter(k, kind=Parameter.KEYWORD_ONLY, annotation=a)
for k, a in sorted(annotations.items())
]
+ [Parameter("kwargs", kind=Parameter.VAR_KEYWORD)]
)
# modify locals() for argspec factory
import omnipath # noqa: F401
NoneType, pandas = type(None), pd
exec(
f"def adapter{sig}: pass".replace(" /,", ""),
globals(),
locals(),
)
return locals()["adapter"]
if not isinstance(clazz, type):
raise TypeError(
f"Expected `clazz` to be a type, found `{type(clazz).__name__}`."
)
if isabstract(clazz):
return
@wrapt.decorator(adapter=wrapt.adapter_factory(argspec_factory))
def wrapper(wrapped, _instance, args, kwargs):
return wrapped(*args, **kwargs)
if hasattr(clazz, "get") and not hasattr(clazz.get, "__wrapped__"):
# overriding in subclass
clazz.get = wrapper(unwrap(clazz.get))
return
clazz.get = wrapper(MethodType(_get_helper, clazz))