+
+

function¶

+

Utils for manipulating functions.

+
+
+exception GlobalNameConflictError[source]¶
+

Bases: Exception

+

Raised on a conflict between the globals used to resolve annotations of a wrapped function and its wrapper.

+
+ +
+
+command_wraps(wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotations__'), updated=('__dict__',), *, ignored_conflict_names=frozenset({}))[source]¶
+

Update the decorated function to look like wrapped, and update globals for discord.py forwardref evaluation.

+

See update_wrapper_globals() for more details on how the globals are updated.

+
+
Parameters:
+
    +

  • wrapped (Callable[[ParamSpec(_P)], TypeVar(_R)]) – The function to wrap with.

    • +

  • assigned (Sequence[str]) – Sequence of attribute names that are directly assigned from wrapped to wrapper.

    • +

  • updated (Sequence[str]) – Sequence of attribute names that are .update``d on ``wrapper from the attributes on wrapped.

    • +

  • ignored_conflict_names (Set[str]) – A set of names to ignore if a conflict between them is found.

    • +
+
+
Return type:
+

Callable[[Callable[[ParamSpec(_P)], TypeVar(_R)]], Callable[[ParamSpec(_P)], TypeVar(_R)]]

+
+
Returns:
+

A decorator that behaves like functools.wraps(), +with the wrapper replaced with the function update_wrapper_globals() returned.

+
+
+
+ +
+
+get_arg_value(name_or_pos, arguments)[source]¶
+

Return a value from arguments based on a name or position.

+
+
Parameters:
+

arguments (OrderedDict[str, Any]) – An ordered mapping of parameter names to argument values.

+
+
Return type:
+

Any

+
+
Returns:
+

Value from arguments based on a name or position.

+
+
Raises:
+
    +

  • TypeError – name_or_pos isn’t a str or int.

    • +

  • ValueError – name_or_pos does not match any argument.

    • +
+
+
+
+ +
+
+get_arg_value_wrapper(decorator_func, name_or_pos, func=None)[source]¶
+

Call decorator_func with the value of the arg at the given name/position.

+
+
Parameters:
+
    +

  • decorator_func (Callable[[Callable[[OrderedDict[str, Any]], Any]], Callable[[Callable], Callable]]) – A function that must accept a callable as a parameter to which it will pass a mapping of +parameter names to argument values of the function it’s decorating.

    • +

  • name_or_pos (int | str) – The name/position of the arg to get the value from.

    • +

  • func (Optional[Callable[[Any], Any]]) – An optional callable which will return a new value given the argument’s value.

    • +
+
+
Return type:
+

Callable[[Callable], Callable]

+
+
Returns:
+

The decorator returned by decorator_func.

+
+
+
+ +
+
+get_bound_args(func, args, kwargs)[source]¶
+

Bind args and kwargs to func and return a mapping of parameter names to argument values.

+

Default parameter values are also set.

+
+
Parameters:
+
    +

  • args (tuple) – The arguments to bind to func

    • +

  • kwargs (dict[str, Any]) – The keyword arguments to bind to func

    • +

  • func (Callable) – The function to bind args and kwargs to

    • +
+
+
Return type:
+

OrderedDict[str, Any]

+
+
Returns:
+

A mapping of parameter names to argument values.

+
+
+
+ +
+
+update_wrapper_globals(wrapper, wrapped, *, ignored_conflict_names=frozenset({}))[source]¶
+

Create a copy of wrapper, the copy’s globals are updated with wrapped's globals.

+

For forwardrefs in command annotations, discord.py uses the __global__ attribute of the function +to resolve their values. This breaks for decorators that replace the function because they have +their own globals.

+
+

Warning

+

This function captures the state of wrapped's module’s globals when it’s called; +changes won’t be reflected in the new function’s globals.

+
+
+
Parameters:
+
    +

  • wrapper (Callable[[ParamSpec(_P)], TypeVar(_R)]) – The function to wrap.

    • +

  • wrapped (Callable[[ParamSpec(_P)], TypeVar(_R)]) – The function to wrap with.

    • +

  • ignored_conflict_names (Set[str]) – A set of names to ignore if a conflict between them is found.

    • +
+
+
Raises:
+

GlobalNameConflictError – If wrapper and wrapped share a global name that’s also used in wrapped's typehints, + and is not in ignored_conflict_names.

+
+
Return type:
+

Callable[[ParamSpec(_P)], TypeVar(_R)]

+
+
+
+ +
+ +