Function Signatures

Function signatures are represented by the Signature class. Function parameters are represented by the Parameter class.

Signatures can be created through the signature function or the Signature class’s various from_X methods - Signature.from_callable, Signature.from_signature.


class Signature

An inspect.Signature subclass that represents a function’s parameter signature and return annotation.

Instances of this class are immutable.

Variables

  • parameters – An OrderedDict of Parameter objects

  • return_annotation – The annotation for the function’s return value

__init__()
Parameters

  • parameters – A list or dict of Parameter objects

  • return_annotation – The annotation for the function’s return value

classmethod from_signature(signature, param_type=<class 'introspection.parameter.Parameter'>)

Creates a new Signature instance from an inspect.Signature instance.

Parameters

  • signature – An inspect.Signature instance

  • param_type – The class to use for the signature’s parameters

Returns

A new Signature instance

classmethod from_callable(callable_, param_type=<class 'introspection.parameter.Parameter'>, follow_wrapped=True)

Returns a matching Signature instance for the given callable_.

Parameters

  • callable (Callable) – A function or any other callable object

  • param_type (Type[Parameter]) – The class to use for the signature’s parameters

  • follow_wrapped (bool) – Whether to unwrap decorated callables

Returns

A corresponding Signature instance

Raises

  • TypeError – If callable_ isn’t a callable object

  • ValueError – If the signature can’t be determined (can happen for functions defined in C extensions)

without_parameters(*params)

Returns a copy of this signature with some parameters removed.

Parameters can be referenced by their name or index.

Example:

>>> sig = Signature([
...     Parameter('foo'),
...     Parameter('bar'),
...     Parameter('baz')
... ])
>>> sig.without_parameters(0, 'baz')
<Signature (bar)>
Parameters

params – Names or indices of the parameters to remove

Returns

A copy of this signature without the given parameters

property param_list

Returns a list of the signature’s parameters.

property has_return_annotation

Returns whether the signature’s return annotation is not Signature.empty.

property num_required_arguments

Returns the number of required arguments, i.e. arguments with a default value.

to_string()

Returns a string representation of this signature.

Example:

>>> Signature([
...    Parameter('nums', Parameter.VAR_POSITIONAL, annotation=int)
... ], return_annotation=int).to_string()
'(*nums: int) -> int'
class Parameter

An inspect.Parameter subclass that represents a function parameter.

Instances of this class are immutable.

This class adds a new special value for the default attribute: Parameter.missing. This value indicates that the parameter is optional, but has no known default value.

Variables

  • name – The parameter’s name

  • kind – The parameter’s kind. See inspect.Parameter.kind for details.

  • default – The parameter’s default value or inspect.Parameter.empty

  • annotation – The parameter’s type annotation

missing = <class 'introspection.parameter._missing'>

A special class-level marker that can be used to specify that the parameter is optional, but doesn’t have a (known) default value.

__init__()
Parameters
classmethod from_parameter(parameter)

Creates a new Parameter instance from an inspect.Parameter instance.

Parameters

parameter – An inspect.Parameter instance

Returns

A new Parameter instance

property has_annotation

Returns whether the parameter’s annotation is not Parameter.empty.

property is_vararg

Returns a boolean indicating whether this parameter accepts a variable number of arguments; i.e. whether the parameter’s kind is inspect.Parameter.VAR_POSITIONAL or inspect.Parameter.VAR_KEYWORD.

property is_optional

Returns a boolean indicating whether this parameter requires an argument.

Returns False if the parameter has a default value or is a vararg.

to_string()

Returns a string representation of this parameter, similar to how parameters are written in function signatures.

Examples:

>>> Parameter('foo', Parameter.VAR_POSITIONAL).to_string()
'*foo'
>>> Parameter('foo', annotation=int, default=3).to_string()
'foo: int = 3'
signature(callable_, param_type=<class 'introspection.parameter.Parameter'>, follow_wrapped=True)

Shorthand for Signature.from_callable.