[Python-Dev] PEP 362 Third Revision (original) (raw)

Thu Jun 14 04:52:43 CEST 2012

sig = signature(test)
ba = sig.bind(10, b=20)
test(*ba.args, **ba.kwargs)
- If the object is not callable - raise a TypeError

- If the object has a ``__signature__`` attribute and if it
  is not ``None`` - return a deepcopy of it

    - If it is ``None`` and the object is an instance of
      ``BuiltinFunction``, raise a ``ValueError``

- If the object is a an instance of ``FunctionType``:

    - If it has a ``__wrapped__`` attribute, return
      ``signature(object.__wrapped__)``

    - Or else construct a new ``Signature`` object and return it

- If the object is a method or a classmethod, construct and return
  a new ``Signature`` object, with its first parameter (usually
  ``self`` or ``cls``) removed

- If the object is a staticmethod, construct and return
  a new ``Signature`` object

- If the object is an instance of ``functools.partial``, construct
  a new ``Signature`` from its ``partial.func`` attribute, and
  account for already bound ``partial.args`` and ``partial.kwargs``

- If the object is a class or metaclass:

    - If the object's type has a ``__call__`` method defined in
      its MRO, return a Signature for it

    - If the object has a ``__new__`` method defined in its class,
      return a Signature object for it

    - If the object has a ``__init__`` method defined in its class,
      return a Signature object for it

- Return ``signature(object.__call__)``
class FooMeta(type):
    def __new__(mcls, name, bases, dct, *, bar:bool=False):
        return super().__new__(mcls, name, bases, dct)

    def __init__(cls, name, bases, dct, **kwargs):
        return super().__init__(name, bases, dct)


class Foo(metaclass=FooMeta):
    def __init__(self, spam:int=42):
        self.spam = spam

    def __call__(self, a, b, *, c) -> tuple:
        return a, b, c


print('FooMeta >', str(signature(FooMeta)))
print('Foo >', str(signature(Foo)))
print('Foo.__call__ >', str(signature(Foo.__call__)))
print('Foo().__call__ >', str(signature(Foo().__call__)))
print('partial(Foo().__call__, 1, c=3) >',
      str(signature(partial(Foo().__call__, 1, c=3))))
print('partial(partial(Foo().__call__, 1, c=3), 2, c=20) >',
      str(signature(partial(partial(Foo().__call__, 1, c=3), 2, c=20))))
def checktypes(func):
    '''Decorator to verify arguments and return types

    Example:

        >>> @checktypes
        ... def test(a:int, b:str) -> int:
        ...     return int(a * b)

        >>> test(10, '1')
        1111111111

        >>> test(10, 1)
        Traceback (most recent call last):
          ...
        ValueError: foo: wrong type of 'b' argument, 'str' expected, got 'int'
    '''

    sig = inspect.signature(func)

    types = {}
    for param in sig.parameters.values():
        # Iterate through function's parameters and build the list of
        # arguments types
        try:
            type_ = param.annotation
        except AttributeError:
            continue
        else:
            if not inspect.isclass(type_):
                # Not a type, skip it
                continue

            types[param.name] = type_

            # If the argument has a type specified, let's check that its
            # default value (if present) conforms with the type.
            try:
                default = param.default
            except AttributeError:
                continue
            else:
                if not isinstance(default, type_):
                    raise ValueError("{func}: wrong type of a default value for {arg!r}". \
                                     format(func=sig.qualname, arg=param.name))

    def check_type(sig, arg_name, arg_type, arg_value):
        # Internal function that incapsulates arguments type checking
        if not isinstance(arg_value, arg_type):
            raise ValueError("{func}: wrong type of {arg!r} argument, " \
                             "{exp!r} expected, got {got!r}". \
                             format(func=sig.qualname, arg=arg_name,
                                    exp=arg_type.__name__, got=type(arg_value).__name__))

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Let's bind the arguments
        ba = sig.bind(*args, **kwargs)
        for arg_name, arg in ba.arguments.items():
            # And iterate through the bound arguments
            try:
                type_ = types[arg_name]
            except KeyError:
                continue
            else:
                # OK, we have a type for the argument, lets get the corresponding
                # parameter description from the signature object
                param = sig.parameters[arg_name]
                if param.is_args:
                    # If this parameter is a variable-argument parameter,
                    # then we need to check each of its values
                    for value in arg:
                        check_type(sig, arg_name, type_, value)
                elif param.is_kwargs:
                    # If this parameter is a variable-keyword-argument parameter:
                    for subname, value in arg.items():
                        check_type(sig, arg_name + ':' + subname, type_, value)
                else:
                    # And, finally, if this parameter a regular one:
                    check_type(sig, arg_name, type_, arg)

        result = func(*ba.args, **ba.kwargs)
        # The last bit - let's check that the result is correct
        try:
            return_type = sig.return_annotation
        except AttributeError:
            # Looks like we don't have any restriction on the return type
            pass
        else:
            if isinstance(return_type, type) and not isinstance(result, return_type):
                raise ValueError('{func}: wrong return type, {exp} expected, got {got}'. \
                                 format(func=sig.qualname, exp=return_type.__name__,
                                        got=type(result).__name__))
        return result

    return wrapper

[Python-Dev] PEP 362 Third Revision (original) (raw)

Abstract

Signature Object

Parameter Object

BoundArguments Object

Implementation

Design Considerations

No implicit caching of Signature objects

Examples

Visualizing Callable Objects' Signature

Annotation Checker

References

Copyright