def test_without_parameters():
sig = Signature([Parameter('foo'), Parameter('bar'), Parameter('baz')])
expected = Signature([Parameter('bar')])
result = sig.without_parameters(0, 'baz')
assert result == expected
def test_replace():
sig = Signature([Parameter('foo')], return_annotation=int)
expected = Signature(return_annotation=str)
result = sig.replace(parameters=[], return_annotation=str)
assert isinstance(result, Signature)
assert result == expected
def test_get_float_signature():
sig = Signature.from_callable(float)
assert sig.return_annotation is float
assert len(sig.parameters) == 1
assert list(sig.parameters) == ['x']
assert sig.parameters['x'].kind == Parameter.POSITIONAL_ONLY
assert sig.parameters['x'].default in {0, Parameter.missing}
def test_signature_with_optional_parameter():
sig = Signature.from_callable(vars)
assert sig.return_annotation is dict
assert len(sig.parameters) == 1
assert sig.parameters['object'].annotation is typing.Any
assert sig.parameters['object'].default is Parameter.missing
def test_get_missing_parameter_names_with_optionals(func, args, kwargs,
expected):
bound_args = Signature.from_callable(func).bind_partial(*args, **kwargs)
result = bound_args.get_missing_parameter_names(
include_optional_parameters=True)
assert result == expected
def test_get_bool_signature():
sig = Signature.from_callable(bool)
assert sig.return_annotation is bool
assert len(sig.parameters) == 1
assert list(sig.parameters) == ['x']
assert sig.parameters['x'].kind == Parameter.POSITIONAL_ONLY
assert sig.parameters['x'].default is Parameter.missing
def test_num_required_arguments():
sig = Signature([
Parameter('a', Parameter.POSITIONAL_ONLY),
Parameter('b', Parameter.VAR_POSITIONAL),
Parameter('c', Parameter.KEYWORD_ONLY),
Parameter('d', Parameter.VAR_KEYWORD)
])
assert sig.num_required_arguments == 2
def test_get_int_signature():
sig = Signature.from_callable(int)
assert sig.return_annotation is int
assert len(sig.parameters) == 2
assert list(sig.parameters) == ['x', 'base']
assert sig.parameters['x'].kind == Parameter.POSITIONAL_ONLY
assert sig.parameters['x'].default in {0, Parameter.missing}
assert sig.parameters['base'].kind == Parameter.POSITIONAL_ONLY
assert sig.parameters['base'].default in {10, Parameter.missing}
def test_to_varargs_prefer_kwargs(func, args, kwargs, expected_args,
expected_kwargs):
sig = Signature.from_callable(func)
bound_args = sig.bind_partial(*args, **kwargs)
args, kwargs = bound_args.to_varargs(prefer='kwargs')
assert args == expected_args
assert kwargs == expected_kwargs
def test_store_signature():
def foo(a=5) -> str:
return 'bar'
sig = Signature.from_callable(foo)
foo.__signature__ = sig
s = inspect.signature(foo)
assert s is sig
def test_builtin_signatures():
import builtins
for thing in vars(builtins).values():
if not callable(thing):
continue
try:
_ = Signature.from_callable(thing)
except Exception as e:
msg = "Couldn't obtain signature of {!r}: {!r}"
pytest.fail(msg.format(thing, e))
def test_get_signature():
def foo(a, b=3) -> str:
pass
sig = Signature.from_callable(foo)
assert sig.return_annotation is str
assert len(sig.parameters) == 2
assert list(sig.parameters) == ['a', 'b']
assert sig.parameters['a'].kind == Parameter.POSITIONAL_OR_KEYWORD
assert sig.parameters['a'].default == Parameter.empty
assert sig.parameters['b'].kind == Parameter.POSITIONAL_OR_KEYWORD
assert sig.parameters['b'].default == 3
def test_method_signature():
class A:
def method(self, foo: int = 3) -> None:
pass
class B(A):
def method(self, *args, bar: bool = True, **kwargs):
return super().method(*args, **kwargs)
sig = Signature.for_method(B, 'method')
assert list(sig.parameters) == ['self', 'foo', 'bar']
assert sig.return_annotation is None
assert sig.parameters['foo'].annotation is int
assert sig.parameters['foo'].default == 3
assert sig.parameters['foo'].kind is Parameter.POSITIONAL_OR_KEYWORD
assert sig.parameters['bar'].annotation is bool
assert sig.parameters['bar'].default is True
assert sig.parameters['bar'].kind is Parameter.KEYWORD_ONLY
def test_get_signature_undoc_c_function(monkeypatch):
fake_func = make_fake_c_function(None, monkeypatch)
with pytest.raises(ValueError):
Signature.from_callable(fake_func)
def test_get_missing_parameter_names(func, args, kwargs, expected):
bound_args = Signature.from_callable(func).bind_partial(*args, **kwargs)
assert bound_args.get_missing_parameter_names() == expected
def test_setitem():
bound_args = Signature.from_callable(lambda x: x).bind(3)
bound_args['x'] = 17
assert bound_args['x'] == 17
def test_getitem_keyerror():
bound_args = Signature.from_callable(lambda x: x).bind(3)
with pytest.raises(KeyError):
bound_args['y']
def test_len():
bound_args = Signature.from_callable(lambda x, y: x).bind_partial(3)
assert len(bound_args) == 1
def test_bind_partial(func, args, kwargs, expected_result):
sig = Signature.from_callable(func)
assert sig.bind_partial(*args, **kwargs).arguments == expected_result
def test_get_signature_noncallable():
with pytest.raises(TypeError):
Signature.from_callable(3)
def test_to_varargs_invalid_prefer_arg():
bound_args = Signature.from_callable(lambda x: x).bind(3)
with pytest.raises(ValueError):
bound_args.to_varargs(prefer='foobar')
def test_iter():
bound_args = Signature.from_callable(lambda x, y, z: x).bind_partial(3, 4)
assert tuple(bound_args) == ('x', 'y')
'd': 'D'
}, {
'a': ('A', 'B'),
'c': {
'd': 'D'
}
}),
])
def test_bind_partial(func, args, kwargs, expected_result):
sig = Signature.from_callable(func)
assert sig.bind_partial(*args, **kwargs).arguments == expected_result
@pytest.mark.parametrize('signature, expected', [
(Signature([
Parameter('a', Parameter.POSITIONAL_ONLY),
Parameter('b', Parameter.VAR_POSITIONAL)
]), '(a, /, *b)'),
(Signature([
Parameter('a', Parameter.POSITIONAL_ONLY),
Parameter('b', Parameter.POSITIONAL_ONLY)
]), '(a, b, /)'),
(Signature([Parameter('a', default=Parameter.missing)]), '([a])'),
(Signature([
Parameter('a', Parameter.POSITIONAL_ONLY, default=Parameter.missing)
]), '([a], /)'),
(Signature([
Parameter('a', Parameter.POSITIONAL_ONLY, default=Parameter.missing),
Parameter('b', default=Parameter.missing)
]), '([a], /[, b])'),
(Signature([
Parameter('a', Parameter.POSITIONAL_ONLY, default=Parameter.missing),