.. attribute:: Signature.parameters
- An ordered mapping of parameters' names to the corresponding
- :class:`Parameter` objects. Parameters appear in strict definition
- order, including keyword-only parameters.
+ An dictionary of :class:`Parameter` objects. Parameters appear in strict
+ definition order, including keyword-only parameters.
.. versionchanged:: 3.7
Python only explicitly guaranteed that it preserved the declaration
order of keyword-only parameters as of version 3.7, although in practice
this order had always been preserved in Python 3.
+ .. versionchanged:: 3.9
+ :attr:`parameters` is now of type :class:`dict`. Formerly, it was of
+ type :class:`collections.OrderedDict`.
+
.. attribute:: Signature.return_annotation
The "return" annotation for the callable. If the callable has no "return"
.. attribute:: BoundArguments.arguments
- An ordered, mutable mapping (:class:`collections.OrderedDict`) of
- parameters' names to arguments' values. Contains only explicitly bound
- arguments. Changes in :attr:`arguments` will reflect in :attr:`args` and
- :attr:`kwargs`.
+ An ordered, mutable mapping of parameters' names to arguments' values.
+ Contains only explicitly bound arguments. Changes in :attr:`arguments`
+ will reflect in :attr:`args` and :attr:`kwargs`.
Should be used in conjunction with :attr:`Signature.parameters` for any
argument processing purposes.
However, if needed, use :meth:`BoundArguments.apply_defaults` to add
them.
+ .. versionchanged:: 3.9
+ :attr:`arguments` is now of type :class:`dict`. Formerly, it was of
+ type :class:`collections.OrderedDict`.
+
.. attribute:: BoundArguments.args
A tuple of positional arguments values. Dynamically computed from the
>>> ba = inspect.signature(foo).bind('spam')
>>> ba.apply_defaults()
>>> ba.arguments
- OrderedDict([('a', 'spam'), ('b', 'ham'), ('args', ())])
+ {'a': 'spam', 'b': 'ham', 'args': ()}
.. versionadded:: 3.5
import functools
import builtins
from operator import attrgetter
-from collections import namedtuple, OrderedDict
+from collections import namedtuple
# Create constants for the compiler flags in Include/code.h
# We try to get them from dis to avoid duplication
"""
old_params = wrapped_sig.parameters
- new_params = OrderedDict(old_params.items())
+ new_params = {}
partial_args = partial.args or ()
partial_keywords = partial.keywords or {}
transform_to_kwonly = False
+ kwonly_params = {} # Keyword only parameters are moved to end.
for param_name, param in old_params.items():
try:
arg_value = ba.arguments[param_name]
if param.kind is _POSITIONAL_ONLY:
# If positional-only parameter is bound by partial,
# it effectively disappears from the signature
- new_params.pop(param_name)
continue
if param.kind is _POSITIONAL_OR_KEYWORD:
# multiple values.
transform_to_kwonly = True
# Set the new default value
- new_params[param_name] = param.replace(default=arg_value)
+ param = param.replace(default=arg_value)
else:
# was passed as a positional argument
- new_params.pop(param.name)
continue
if param.kind is _KEYWORD_ONLY:
# Set the new default value
- new_params[param_name] = param.replace(default=arg_value)
+ param = param.replace(default=arg_value)
if transform_to_kwonly:
assert param.kind is not _POSITIONAL_ONLY
if param.kind is _POSITIONAL_OR_KEYWORD:
- new_param = new_params[param_name].replace(kind=_KEYWORD_ONLY)
- new_params[param_name] = new_param
- new_params.move_to_end(param_name)
+ kwonly_params[param_name] = param.replace(kind=_KEYWORD_ONLY)
elif param.kind in (_KEYWORD_ONLY, _VAR_KEYWORD):
- new_params.move_to_end(param_name)
- elif param.kind is _VAR_POSITIONAL:
- new_params.pop(param.name)
+ kwonly_params[param_name] = param
+ else:
+ new_params[param_name] = param
+ new_params.update(kwonly_params)
return wrapped_sig.replace(parameters=new_params.values())
Has the following public attributes:
- * arguments : OrderedDict
+ * arguments : dict
An ordered mutable mapping of parameters' names to arguments' values.
Does not contain arguments' default values.
* signature : Signature
# Signature.bind_partial().
continue
new_arguments.append((name, val))
- self.arguments = OrderedDict(new_arguments)
+ self.arguments = dict(new_arguments)
def __eq__(self, other):
if self is other:
A Signature object has the following public attributes and methods:
- * parameters : OrderedDict
+ * parameters : dict
An ordered mapping of parameters' names to the corresponding
Parameter objects (keyword-only arguments are in the same order
as listed in `code.co_varnames`).
"""
if parameters is None:
- params = OrderedDict()
+ params = {}
else:
if __validate_parameters__:
- params = OrderedDict()
+ params = {}
top_kind = _POSITIONAL_ONLY
kind_defaults = False
- for idx, param in enumerate(parameters):
+ for param in parameters:
kind = param.kind
name = param.name
params[name] = param
else:
- params = OrderedDict(((param.name, param)
- for param in parameters))
+ params = {param.name: param for param in parameters}
self._parameters = types.MappingProxyType(params)
self._return_annotation = return_annotation
def _bind(self, args, kwargs, *, partial=False):
"""Private method. Don't use directly."""
- arguments = OrderedDict()
+ arguments = {}
parameters = iter(self.parameters.values())
parameters_ex = ()
projects / thirdparty / Python / cpython.git / commitdiff
