def _test(self, outer, inner, args, kwargs, expected, expected_get,
exp_src, exp_src_get):
outer_f = support.f(outer, name='outer')
inner_f = support.f(inner, name='inner')
forw = specifiers.forwards_to_function(inner_f, *args,
**kwargs)(outer_f)
sig = specifiers.signature(forw)
self.assertSigsEqual(sig, support.s(expected))
self.assertSourcesEqual(
sig.sources, {
'outer': exp_src[0],
'inner': exp_src[1],
'+depths': ['outer', 'inner']
})
sig_get = specifiers.signature(_util.safe_get(forw, object(), object))
self.assertSigsEqual(sig_get, support.s(expected_get))
self.assertSourcesEqual(
sig_get.sources, {
'outer': exp_src_get[0],
'inner': exp_src_get[1],
'+depths': ['outer', 'inner']
})
def test_success(self):
self.assertSigsEqual(s('a, b:1'),
signature(modifiers.annotate(b=1)(f('a, b'))))
self.assertSigsEqual(
s('a:1, b:2'), signature(modifiers.annotate(a=1, b=2)(f('a, b'))))
self.assertSigsEqual(s('a:1, b', 2),
signature(modifiers.annotate(2, a=1)(f('a, b'))))
def test_call(self):
outer = support.f('*args, **kwargs')
inner = support.f('a, *, b')
forw = specifiers.forwards_to_function(inner)(outer)
instance = object()
forw_get_prox = _util.safe_get(forw, instance, object)
self.assertEqual(
forw_get_prox(1, b=2),
{'args': (instance, 1), 'kwargs': {'b': 2}})
class ExtraParamsTests(object):
_func = support.f('')
_func2 = support.f('')
alt_cmd = ('', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', 'a', '-b', '--third'), ['test --alt', 'a', '-b',
'--third'], {}, _func)
alt_cmd2 = ('', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', '--alpha', '-b'), ['test --alt', '--alpha', '-b'], {}, _func)
flb_cmd_start = ('', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', '-a', 'b', '--third'), ['test --alt', '-a', 'b',
'--third'], {}, _func)
flb_cmd_valid = ('*a', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('a', '--alt', 'b', '-c', '--fourth'), ['test --alt'], {}, _func)
flb_cmd_invalid = ('', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('a', '--alt', 'a', '-b'), ['test --alt'], {}, _func)
flb_cmd_invalid_valid = ('a: int, b', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('xyz', 'abc', '--alt', 'def', '-g', '--hij'), ['test --alt'], {},
_func)
flb_after_alt = ('a: int, b', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt']),
parser.FallbackCommandParameter(func=_func2, aliases=['--flb']),
], ('--invalid', '--alt', '--flb'), ['test --flb'], {}, _func2)
def test_alt_middle(self):
_func = support.f('')
args = [
'*a',
[parser.AlternateCommandParameter(func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
self.assertRaises(errors.ArgsBeforeAlternateCommand, self._test_func,
*args)
try:
self._test_func(*args)
except errors.ArgsBeforeAlternateCommand as e:
self.assertEqual(
'Error: Arguments found before alternate '
'action parameter --alt', str(e))
def test_param_extras(self):
extra_params = [
parser.FlagParameter(value=True,
conv=parser.is_true,
aliases=['-' + name],
argument_name=name) for name in 'abc'
]
param = parser.PositionalParameter(display_name='one',
argument_name='one')
param.extras = extra_params
csig = parser.CliSignature([param])
self.assertEqual('[-a] [-b] [-c] one', str(csig))
def forwards_tests(self, outer, inner, args, kwargs, expected, expected_get):
outer_f = support.f(outer)
inner_f = support.f(inner)
forw = specifiers.forwards_to_function(inner_f, *args, **kwargs)(outer_f)
self.assertSigsEqual(specifiers.signature(forw), support.s(expected))
self.assertSigsEqual(
specifiers.signature(_util.safe_get(forw, object(), object)),
support.s(expected_get))
def test_use_twice(self):
annotator = modifiers.annotate(a=1)
self.assertSigsEqual(
s('a:1, b'),
signature(annotator(f('a, b')))
)
self.assertSigsEqual(
s('a:1'),
signature(annotator(f('a')))
)
def test_specifiers_sig_after(self):
inner = f('a, b', name='inner')
outer = f('x, y, z, *args, **kwargs', name='outer')
pt = modifiers.kwoargs('z')(outer)
pt = specifiers.forwards_to_function(inner)(pt)
sig = specifiers.signature(pt)
self.assertSigsEqual(sig, s('x, y, a, b, *, z'))
self.assertSourcesEqual(
sig.sources, {'inner': 'ab', 'outer': 'xyz',
'+depths': ['outer', 'inner']})
self.assertEqual(sig.sources['x'], [pt])
def test_call(self):
outer = support.f('*args, **kwargs')
inner = support.f('a, *, b')
forw = specifiers.forwards_to_function(inner)(outer)
instance = object()
forw_get_prox = _util.safe_get(forw, instance, object)
self.assertEqual(forw_get_prox(1, b=2), {
'args': (instance, 1),
'kwargs': {
'b': 2
}
})
def _test_func(self, sig, wrapper_sigs, doc, wrapper_docs, help_str):
ifunc = f(sig, pre="from clize import Parameter")
ifunc.__doc__ = doc
func = ifunc
for sig, doc in zip(wrapper_sigs, wrapper_docs):
wfunc = f('func, ' + sig, pre="from clize import Parameter")
wfunc.__doc__ = doc
func = wrapper_decorator(wfunc)(func)
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
h.prepare()
p_help_str = str(h.show('func'))
self.assertEqual(help_str.split(), p_help_str.split())
def _test_func(self, sig, wrapper_sigs, doc, wrapper_docs, help_str):
ifunc = f(sig, pre="from clize import Parameter")
ifunc.__doc__ = doc
func = ifunc
for sig, doc in zip(wrapper_sigs, wrapper_docs):
wfunc = f('func, ' + sig, pre="from clize import Parameter")
wfunc.__doc__ = doc
func = wrapper_decorator(wfunc)(func)
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
h.prepare()
p_help_str = str(h.show('func'))
self.assertEqual(help_str.split(), p_help_str.split())
def test_success(self):
self.assertSigsEqual(
s('a, b:1'),
signature(modifiers.annotate(b=1)(f('a, b')))
)
self.assertSigsEqual(
s('a:1, b:2'),
signature(modifiers.annotate(a=1, b=2)(f('a, b')))
)
self.assertSigsEqual(
s('a:1, b', 2),
signature(modifiers.annotate(2, a=1)(f('a, b')))
)
def test_specifiers_sig_after(self):
inner = f('a, b', name='inner')
outer = f('x, y, z, *args, **kwargs', name='outer')
pt = modifiers.kwoargs('z')(outer)
pt = specifiers.forwards_to_function(inner)(pt)
sig = specifiers.signature(pt)
self.assertSigsEqual(sig, s('x, y, a, b, *, z'))
self.assertSourcesEqual(sig.sources, {
'inner': 'ab',
'outer': 'xyz',
'+depths': ['outer', 'inner']
})
self.assertEqual(sig.sources['x'], [pt])
def test_custom_param_help(self):
class CustParam(parser.OptionParameter):
def show_help(self, desc, after, f, cols):
cols.append('I am', 'a custom parameter!')
f.append("There is stuff after me.")
f.append(desc)
f.extend(after)
func = f(
"*, param: a",
locals={'a': parser.use_class(named=CustParam)})
func.__doc__ = """
param: Param desc
After param
_:_
"""
r = runner.Clize(func)
self._do_test(r, ['func --param=STR', USAGE_HELP], """
Usage: func [OPTIONS]
Options:
I am a custom parameter!
There is stuff after me.
Param desc
After param
Other actions:
-h, --help Show the help
""")
def test_custom_param_help(self):
class CustParam(parser.OptionParameter):
def show_help(self, desc, after, f, cols):
cols.append('I am', 'a custom parameter!')
f.append("There is stuff after me.")
f.append(desc)
f.extend(after)
func = f("*, param: a",
locals={'a': parser.use_class(named=CustParam)})
func.__doc__ = """
param: Param desc
After param
_:_
"""
r = runner.Clize(func)
self._do_test(
r, ['func --param=STR', USAGE_HELP], """
Usage: func [OPTIONS]
Options:
I am a custom parameter!
There is stuff after me.
Param desc
After param
Other actions:
-h, --help Show the help
""")
class PartialSigTests(Fixtures):
def _test(self, obj, exp_sig, exp_src=None):
sig = signature(obj)
self.assertSigsEqual(sig, s(exp_sig))
if exp_src is None:
exp_src = dict((p, [obj.func]) for p in sig.parameters)
exp_src['+depths'] = {obj: 0, obj.func: 1}
self.assertEqual(sig.sources, exp_src)
_func1 = f('a, b, c, *args, d, e, **kwargs')
pos = partial(_func1, 1), 'b, c, *args, d, e, **kwargs'
kwkw = partial(_func1, d=1), 'a, b, c, *args, e, d=1, **kwargs'
kwposlast_1 = partial(_func1, c=1), 'a, b, *, d, e, c=1, **kwargs'
kwposlast_2 = partial(_func1, b=1), 'a, *, d, e, c, b=1, **kwargs'
def _kw_create(_func1):
par = partial(_func1, f=1)
src = dict(
(p, [_func1]) for p in ['a', 'b', 'c', 'args', 'd', 'e', 'kwargs'])
src['f'] = [par]
src['+depths'] = {_func1: 1, par: 0}
return par, 'a, b, c, *args, d, e, f=1, **kwargs', src
kw_create = _kw_create(_func1)
def test_whole_help(self, sig, doc, help_str):
func = f(sig, pre="from clize import Parameter")
func.__doc__ = doc
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
p_help_str = str(h.show('func'))
self.assertEqual(p_help_str.split(), help_str.split())
def test_preserve_annotations(self):
func = f('self, a:2, b, c:3', 4)
tr = modifiers._PokTranslator(func, kwoargs=('a', 'b'))
self.assertSigsEqual(s('self, c:3, *, a:2, b', 4), signature(tr))
self.assertSigsEqual(s('c:3, *, a:2, b', 4),
signature(safe_get(tr, object(), object)))
def _test_func(self, sig, doc, help_str):
func = f(sig, pre="from clize import Parameter as P")
func.__doc__ = doc
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
h.prepare()
p_help_str = str(h.show('func'))
self.assertEqual(help_str, p_help_str)
def test_attr_conservation_after(self):
func = f('s, a')
pt = modifiers.kwoargs('a')(func)
pt.attr = object()
self.assertIs(pt.attr, modifiers.kwoargs('a')(pt).attr)
bpt = pt.__get__(object(), object)
self.assertIs(pt.attr, bpt.attr)
self.assertIs(pt.attr, modifiers.kwoargs('a')(bpt).attr)
def test_attr_conservation_after(self):
func = f('s, a')
pt = modifiers.kwoargs('a')(func)
pt.attr = object()
self.assertIs(pt.attr, modifiers.kwoargs('a')(pt).attr)
bpt = pt.__get__(object(), object)
self.assertIs(pt.attr, bpt.attr)
self.assertIs(pt.attr, modifiers.kwoargs('a')(bpt).attr)
def test_show_list(self):
func = support.f('par:a', locals={'a': RepTests.oneof_help[1]})
out, err = util.run(func, ['name', 'list'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
bye h2""".split(),
out.getvalue().split())
def _test_func(self, description, footer, sigs, docs, usage, help_str):
funcs = []
for i, sig, doc in zip(count(1), sigs, docs):
func = f(sig)
func.__doc__ = doc
func.__name__ = 'func' + str(i)
funcs.append(func)
sd = runner.SubcommandDispatcher(funcs, description, footer)
self._do_test(sd, usage, help_str)
def test_show_list(self):
func = support.f('par:a', locals={'a': RepTests.mapped_basic[1]})
out, err = self.crun(func, ['name', 'list'])
self.assertEqual('', err.getvalue())
self.assertLinesEqual(
"""
name: Possible values for par:
hello h1
goodbye h2""", out.getvalue())
def _test_func(self, description, footer, sigs, docs, usage, help_str):
funcs = []
for i, sig, doc in zip(count(1), sigs, docs):
func = f(sig)
func.__doc__ = doc
func.__name__ = 'func' + str(i)
funcs.append(func)
sd = runner.SubcommandDispatcher(funcs, description, footer)
self._do_test(sd, usage, help_str)
def test_show_list_morekw(self):
func = support.f('par:a', locals={'a': RepTests.mapped_basic[1]})
out, err = util.run(func, ['name', 'list', '-k', 'xyz'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
goodbye h2""".split(),
out.getvalue().split())
def test_show_list(self):
func = support.f('par:a', locals={'a': RepTests.oneof_help[1]})
out, err = util.run(func, ['name', 'list'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
bye h2""".split(),
out.getvalue().split())
def test_show_list_morekw(self):
func = support.f('par:a', locals={'a': RepTests.mapped_basic[1]})
out, err = util.run(func, ['name', 'list', '-k', 'xyz'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
goodbye h2""".split(),
out.getvalue().split())
class PartialSigTests(object):
_func1 = support.f('a, b, c, *args, d, e, **kwargs')
pos = partial(_func1, 1), 'b, c, *args, d, e, **kwargs'
kwkw = partial(_func1, d=1), 'a, b, c, *args, e, d=1, **kwargs'
kwkws = partial(_func1, f=1), 'a, b, c, *args, d, e, f=1, **kwargs'
kwposlast = partial(_func1, c=1), 'a, b, *, d, e, c=1, **kwargs'
kwposlast = partial(_func1, b=1), 'a, *, d, e, c, b=1, **kwargs'
def _test(self, expected_sig_str, orig_sig_str, exceptions):
orig_func = f(orig_sig_str)
expected_sig = s(expected_sig_str)
func = modifiers.autokwoargs(exceptions=exceptions)(orig_func)
self.assertSigsEqual(expected_sig, signature(func))
if not exceptions: # test the arg-less form of @autokwargs
func = modifiers.autokwoargs(orig_func)
self.assertSigsEqual(expected_sig, signature(func))
def test_show_list(self):
func = support.f('par:a', locals={'a': RepTests.mapped_basic[1]})
out, err = self.crun(func, ['name', 'list'])
self.assertEqual('', err.getvalue())
self.assertLinesEqual(
"""
name: Possible values for par:
hello h1
goodbye h2""",
out.getvalue())
def _test(self, outer, inner, args, kwargs,
expected, expected_get, exp_src, exp_src_get):
outer_f = support.f(outer, name='outer')
inner_f = support.f(inner, name='inner')
forw = specifiers.forwards_to_function(inner_f, *args, **kwargs)(outer_f)
sig = specifiers.signature(forw)
self.assertSigsEqual(sig, support.s(expected))
self.assertSourcesEqual(sig.sources, {
'outer': exp_src[0], 'inner': exp_src[1],
'+depths': ['outer', 'inner']})
sig_get = specifiers.signature(_util.safe_get(forw, object(), object))
self.assertSigsEqual(sig_get, support.s(expected_get))
self.assertSourcesEqual(sig_get.sources, {
'outer': exp_src_get[0], 'inner': exp_src_get[1],
'+depths': ['outer', 'inner']})
def _test(self, expected_sig_str, orig_sig_str, exceptions):
orig_func = f(orig_sig_str)
expected_sig = s(expected_sig_str)
func = modifiers.autokwoargs(exceptions=exceptions)(orig_func)
self.assertSigsEqual(expected_sig, signature(func))
if not exceptions: # test the arg-less form of @autokwargs
func = modifiers.autokwoargs(orig_func)
self.assertSigsEqual(expected_sig, signature(func))
def test_show_list_alt(self):
func = support.f('par:a',
locals={'a': RepTests.mapped_alternate_list[1]})
out, err = util.run(func, ['name', 'options'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
goodbye h2""".split(),
out.getvalue().split())
def test_show_list_alt(self):
func = support.f('par:a',
locals={'a': RepTests.mapped_alternate_list[1]})
out, err = util.run(func, ['name', 'options'])
self.assertEqual('', err.getvalue())
self.assertEqual(
"""name: Possible values for par:
hello h1
goodbye h2""".split(),
out.getvalue().split())
def test_alt_middle(self):
_func = support.f('')
self.assertRaises(
errors.ArgsBeforeAlternateCommand,
self._test_func,
'*a', [
parser.AlternateCommandParameter(
func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
)
def test_pok_interact(self):
pok = f('self, a, *, b')
annotated = modifiers.annotate(a=1, b=2)(pok)
self.assertSigsEqual(
s('self, a:1, *, b:2'),
signature(annotated)
)
self.assertSigsEqual(
s('a:1, *, b:2'),
signature(safe_get(annotated, object(), object))
)
def test_alt_middle(self):
_func = support.f('')
args = [
'*a', [
parser.AlternateCommandParameter(
func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
exp_msg = ('Error: Arguments found before alternate '
'action parameter --alt')
with self.assertRaises(errors.ArgsBeforeAlternateCommand, msg=exp_msg):
self._test(*args)
def test_preserve_annotations(self):
func = f('self, a:2, b, c:3', 4)
tr = modifiers._PokTranslator(func, kwoargs=('a', 'b'))
self.assertSigsEqual(
s('self, c:3, *, a:2, b', 4),
signature(tr)
)
self.assertSigsEqual(
s('c:3, *, a:2, b', 4),
signature(safe_get(tr, object(), object))
)
def test_alt_middle(self):
_func = support.f('')
args = [
'*a',
[parser.AlternateCommandParameter(func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
exp_msg = ('Error: Arguments found before alternate '
'action parameter --alt')
with self.assertRaisesRegex(errors.ArgsBeforeAlternateCommand,
exp_msg):
self._test(*args)
def test_alt_middle(self):
_func = support.f('')
args = [
'*a',
[parser.AlternateCommandParameter(func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
self.assertRaises(errors.ArgsBeforeAlternateCommand, self._test_func,
*args)
try:
self._test_func(*args)
except errors.ArgsBeforeAlternateCommand as e:
self.assertEqual(
'Error: Arguments found before alternate '
'action parameter --alt', str(e))
def test_alt_middle(self):
_func = support.f("")
args = [
"*a",
[parser.AlternateCommandParameter(func=_func, aliases=["--alt"])],
("a", "--alt", "a", "b"),
["a", "b"],
{},
_func,
]
self.assertRaises(errors.ArgsBeforeAlternateCommand, self._test_func, *args)
try:
self._test_func(*args)
except errors.ArgsBeforeAlternateCommand as e:
self.assertEqual("Error: Arguments found before alternate " "action parameter --alt", str(e))
def _test_func(self, sig, doc, help_str):
try:
backw = util.get_terminal_width
except AttributeError:
backw = None
try:
util.get_terminal_width = lambda: 80
func = f(sig, pre="from clize import Parameter as P")
func.__doc__ = doc
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
h.prepare()
p_help_str = str(h.show('func'))
self.assertEqual(help_str, p_help_str)
finally:
if backw is not None:
util.get_terminal_width = backw
def _test_func(self, sig, doc, help_str):
try:
backw = util.get_terminal_width
except AttributeError:
backw = None
try:
util.get_terminal_width = lambda: 80
func = f(sig, pre="from clize import Parameter as P")
func.__doc__ = doc
r = runner.Clize(func)
h = help.ClizeHelp(r, None)
h.prepare()
p_help_str = str(h.show('func'))
self.assertEqual(help_str, p_help_str)
finally:
if backw is not None:
util.get_terminal_width = backw
def test_alt_middle(self):
_func = support.f('')
args = [
'*a', [
parser.AlternateCommandParameter(
func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
self.assertRaises(
errors.ArgsBeforeAlternateCommand,
self._test_func, *args)
try:
self._test_func(*args)
except errors.ArgsBeforeAlternateCommand as e:
self.assertEqual(
'Error: Arguments found before alternate '
'action parameter --alt', str(e))
def test_use_twice(self):
annotator = modifiers.annotate(a=1)
self.assertSigsEqual(s('a:1, b'), signature(annotator(f('a, b'))))
self.assertSigsEqual(s('a:1'), signature(annotator(f('a'))))
def _test_func(self, sig_str, annotation, doc, expected):
f = support.f(sig_str, locals={'a': annotation})
f.__doc__ = doc
cli = runner.Clize.get_cli(f)
self.assertEqual(expected.split(), cli('func', '--help').split())
def _test(self, expected_sig_str, orig_sig_str, start):
orig_func = f(orig_sig_str)
func = modifiers.kwoargs(start=start)(orig_func)
self.assertSigsEqual(s(expected_sig_str), signature(func))
from mock import patch
import ast
from sigtools import support, modifiers, specifiers, signatures, _util, _autoforwards
from sigtools.tests.util import Fixtures, tup
if sys.version_info >= (3, ):
from sigtools.tests import autoforwards_py3
Py3AutoforwardsTests = autoforwards_py3.Py3AutoforwardsTests
Py3UnknownAutoforwardsTests = autoforwards_py3.Py3UnknownAutoforwardsTests
if sys.version_info >= (3, 5):
from sigtools.tests import autoforwards_py35
Py35AutoforwardsTests = autoforwards_py35.Py35UnknownAutoforwardsTests
_wrapped = support.f('x, y, *, z', name='_wrapped')
def func(*args, **kwargs):
pass
class AutoforwardsMarkerReprs(Fixtures):
def _test(self, obj, exp_repr):
self.assertEqual(repr(obj), exp_repr)
_af = _autoforwards
name = _af.Name('spam'), "<name 'spam'>"
attribute = _af.Attribute(_af.Name('ham'),
'eggs'), "<attribute <name 'ham'>.eggs>"
class AutoforwardsTests(Fixtures):
def _test(self, func, expected, sources, incoherent=False):
sig = specifiers.signature(func)
self.assertSigsEqual(sig, support.s(expected))
self.assertSourcesEqual(sig.sources, sources, func)
if not incoherent:
support.test_func_sig_coherent(func,
check_return=False,
check_invalid=False)
@tup('a, b, x, y, *, z', {
'global_': ('a', 'b'),
'_wrapped': ('x', 'y', 'z')
})
def global_(a, b, *args, **kwargs):
return _wrapped(*args, **kwargs)
def _make_closure():
wrapped = _wrapped
def wrapper(b, a, *args, **kwargs):
return wrapped(*args, **kwargs)
return wrapper
closure = (_make_closure(), 'b, a, x, y, *, z', {
'wrapper': 'ba',
'_wrapped': 'xyz'
})
@tup('a, b, y', {'args': 'ab', '_wrapped': 'y'})
def args(a, b, *args, **kwargs):
return _wrapped(a, *args, z=b, **kwargs)
@tup('a, b, *, z', {'using_other_varargs': 'ab', '_wrapped': 'z'})
def using_other_varargs(a, b, **kwargs):
return _wrapped(a, *b, **kwargs)
# def test_external_args(self):
# def l1():
# a = None
# def l2(**kwargs):
# nonlocal a
# _wrapped(*a, **kwargs)
# return l2
# self._test_func(l1(), '*, z')
@tup('x, y, /, *, kwop', {'kwo': ['kwop'], '_wrapped': 'xy'})
@modifiers.kwoargs('kwop')
def kwo(kwop, *args):
_wrapped(*args, z=kwop)
@tup('a, b, y, *, z', {'subdef': 'ab', '_wrapped': 'yz'})
def subdef(a, b, *args, **kwargs):
def func():
_wrapped(42, *args, **kwargs)
func()
@tup('a, b, y, *, z', {'subdef_lambda': 'ab', '_wrapped': 'yz'})
def subdef_lambda(a, b, *args, **kwargs):
(lambda: _wrapped(42, *args, **kwargs))()
@tup('a, b, x, y, *, z', {0: 'ab', '_wrapped': 'xyz'})
def rebind_in_subdef(a, b, *args, **kwargs):
def func():
args = 1,
kwargs = {'z': 2}
_wrapped(42, *args, **kwargs)
_wrapped(*args, **kwargs)
func()
@tup('a, b, x, y, *, z', {'rebind_subdef_param': 'ab', '_wrapped': 'xyz'})
def rebind_subdef_param(a, b, *args, **kwargs):
def func(*args, **kwargs):
_wrapped(42, *args, **kwargs)
_wrapped(*args, **kwargs)
func(2, z=3)
@tup('a, b, *args, **kwargs',
{'rebind_subdef_lambda_param': ['a', 'b', 'args', 'kwargs']})
def rebind_subdef_lambda_param(a, b, *args, **kwargs):
f = lambda *args, **kwargs: _wrapped(*args, **kwargs)
f(1, 2, z=3)
# @tup('a, b, x, y, *, z', {0: 'ab', '_wrapped': 'xyz'})
# def nonlocal_already_executed(a, b, *args, **kwargs):
# def make_ret2(args, kwargs):
# def ret2():
# _wrapped(*args, **kwargs)
# make_ret2(args, kwargs)
# def ret1():
# nonlocal args, kwargs
# args = ()
# kwargs = {}
def test_partial(self):
def _wrapper(wrapped, a, *args, **kwargs):
return wrapped(*args, **kwargs)
func = partial(_wrapper, _wrapped)
sig = specifiers.signature(func)
self.assertSigsEqual(sig, support.s('a, x, y, *, z'))
self.assertEqual(
sig.sources, {
'a': [_wrapper],
'x': [_wrapped],
'y': [_wrapped],
'z': [_wrapped],
'+depths': {
func: 0,
_wrapper: 1,
_wrapped: 2
}
})
support.test_func_sig_coherent(func,
check_return=False,
check_invalid=False)
@staticmethod
@modifiers.kwoargs('wrapped')
def _wrapped_kwoarg(a, wrapped, *args, **kwargs):
return wrapped(*args, **kwargs) # pragma: no cover
def test_partial_kwo(self):
"""When given keyword arguments, functools.partial only makes them
defaults. The full signature is therefore not fully determined, since
the user can replace wrapped and change the meaning of *args, **kwargs.
The substitution could be made in good faith that the user wouldn't
change the value of the parameter, but this would potentially cause
confusing documentation where a function description says remaining
arguments will be forwarded to the given function, while the signature
in the documentation only shows the default target's arguments.
"""
func = partial(AutoforwardsTests._wrapped_kwoarg, wrapped=_wrapped)
expected = support.s('a, *args, wrapped=w, **kwargs',
locals={'w': _wrapped})
self.assertSigsEqual(specifiers.signature(func), expected)
_wrapped_attr = staticmethod(support.f('d, e, *, f'))
@tup('a, d, e, *, f', {0: 'a', 'func': 'def'})
def global_attribute(a, *args, **kwargs):
AutoforwardsTests._wrapped_attr(*args, **kwargs)
def test_instance_attribute(self):
class A(object):
def wrapped(self, x, y):
pass
def method(self, a, *args, **kwargs):
self.wrapped(a, *args, **kwargs)
a = A()
self._test(a.method, 'a, y', {0: 'a', 'wrapped': 'y'})
def test_multiple_method_calls(self):
class A(object):
def wrapped_1(self, x, y):
pass
def wrapped_2(self, x, y):
pass
def method(self, a, *args, **kwargs):
self.wrapped_1(a, *args, **kwargs)
self.wrapped_2(a, *args, **kwargs)
self._test(
A().method, 'a, y',
_util.OrderedDict([(0, 'a'), ('method', 'a'), ('wrapped_1', 'y'),
('wrapped_2', 'y'),
('+depths', {
'method': 0,
'wrapped_1': 1,
'wrapped_2': 1
})]))
@staticmethod
@modifiers.kwoargs('b')
def _deeparg_l1(l2, b, *args, **kwargs):
l2(*args, **kwargs)
@staticmethod
@modifiers.kwoargs('c')
def _deeparg_l2(l3, c, *args, **kwargs):
l3(*args, **kwargs)
@tup('x, y, *, a, b, c, z', {
0: 'a',
'_deeparg_l1': 'b',
'_deeparg_l2': 'c',
_wrapped: 'xyz'
})
@modifiers.kwoargs('a')
def deeparg(a, *args, **kwargs):
AutoforwardsTests._deeparg_l1(AutoforwardsTests._deeparg_l2, _wrapped,
*args, **kwargs)
@staticmethod
@modifiers.kwoargs('l2')
def _deeparg_kwo_l1(l2, b, *args, **kwargs):
l2(*args, **kwargs)
@staticmethod
@modifiers.kwoargs('l3')
def _deeparg_kwo_l2(l3, c, *args, **kwargs):
l3(*args, **kwargs)
@tup('a, b, c, x, y, *, z', {
0: 'a',
'_deeparg_kwo_l1': 'b',
'_deeparg_kwo_l2': 'c',
_wrapped: 'xyz'
})
def deeparg_kwo(a, *args, **kwargs):
AutoforwardsTests._deeparg_kwo_l1(*args,
l2=AutoforwardsTests._deeparg_kwo_l2,
l3=_wrapped,
**kwargs)
@tup('a, x, y, *, z', {0: 'a', _wrapped: 'xyz'})
def call_in_args(a, *args, **kwargs):
func(_wrapped(*args, **kwargs))
@tup('a, x, y, *, z', {0: 'a', _wrapped: 'xyz'})
def call_in_kwargs(a, *args, **kwargs):
func(kw=_wrapped(*args, **kwargs))
@tup('a, x, y, *, z', {0: 'a', _wrapped: 'xyz'})
def call_in_varargs(a, *args, **kwargs):
func(*_wrapped(*args, **kwargs))
@tup('a, x, y, *, z', {
0: 'a',
_wrapped: 'xyz',
'+depths': ['call_in_varkwargs', '_wrapped']
})
def call_in_varkwargs(a, *args, **kwargs):
func(**_wrapped(*args, **kwargs))
def test_functools_wrapped(self):
@wraps(_wrapped)
def func(a, *args, **kwargs):
_wrapped(1, *args, **kwargs)
sig = specifiers.signature(func)
self.assertSigsEqual(sig, support.s('a, y, *, z'))
self.assertEqual(
sig.sources, {
'+depths': {
func: 0,
_wrapped: 1
},
'a': [func],
'y': [_wrapped],
'z': [_wrapped]
})
support.test_func_sig_coherent(func,
check_return=False,
check_invalid=False)
def test_decorator_wraps(self):
def decorator(function):
@wraps(function)
@modifiers.autokwoargs
def _decorated(a, b=2, *args, **kwargs):
function(1, *args, **kwargs)
return _decorated
func = decorator(_wrapped)
sig = specifiers.signature(func)
self.assertSigsEqual(sig, support.s('a, y, *, b=2, z'))
self.assertEqual(
sig.sources, {
'+depths': {
func: 0,
_wrapped: 1
},
'a': [func],
'b': [func],
'y': [_wrapped],
'z': [_wrapped]
})
support.test_func_sig_coherent(func,
check_return=False,
check_invalid=False)
@tup('a, b, *args, z', {
'unknown_args': ['a', 'b', 'args'],
'_wrapped': 'z'
})
def unknown_args(a, b, *args, **kwargs):
args = (1, 2)
return _wrapped(*args, **kwargs)
# @tup('a, b, c, x, y, *, z', {0: 'ab', 'sub': 'c', '_wrapped': 'xyz'})
# def use_subdef(a, b, *args, **kwargs):
# def sub(c, *args, **kwargs):
# _wrapped(*args, **kwargs)
# sub(1, *args, **kwargs)
@tup('a, b, x=None, y=None, *, z=None', {0: 'ab', '_wrapped': 'xyz'})
def pass_to_partial(a, b, *args, **kwargs):
partial(_wrapped, *args, **kwargs)
@tup('a, b, y=None', {0: 'ab', '_wrapped': 'y'})
def pass_to_partial_with_args(a, b, *args, **kwargs):
partial(_wrapped, a, *args, z=b, **kwargs)
@tup('x, y, *, z', {'_wrapped': 'xyz'})
def kwargs_passed_to_func_after(*args, **kwargs):
_wrapped(*args, **kwargs)
func(kwargs)
@tup('x, y, *, z', {'_wrapped': 'xyz'})
def args_passed_to_func(*args, **kwargs):
func(args)
_wrapped(*args, **kwargs)
def test_unused_annotation(self):
self.assertRaises(ValueError, modifiers.annotate(a=1, c=2), f('a, b'))
def test_pok_interact(self):
pok = f('self, a, *, b')
annotated = modifiers.annotate(a=1, b=2)(pok)
self.assertSigsEqual(s('self, a:1, *, b:2'), signature(annotated))
self.assertSigsEqual(s('a:1, *, b:2'),
signature(safe_get(annotated, object(), object)))
class ExtraParamsTests(Fixtures):
def _test(self, sig_str, extra, args, posargs, kwargs, func):
sig = support.s(sig_str)
csig = parser.CliSignature.from_signature(sig, extra=extra)
ba = self.read_arguments(csig, args)
self.assertEqual(ba.args, posargs)
self.assertEqual(ba.kwargs, kwargs)
self.assertEqual(ba.func, func)
_func = support.f('')
_func2 = support.f('')
alt_cmd = ('', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', 'a', '-b', '--third'), ['test --alt', 'a', '-b',
'--third'], {}, _func)
alt_cmd2 = ('', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', '--alpha', '-b'), ['test --alt', '--alpha', '-b'], {}, _func)
flb_cmd_start = ('', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('--alt', '-a', 'b', '--third'), ['test --alt', '-a', 'b',
'--third'], {}, _func)
flb_cmd_valid = ('*a', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('a', '--alt', 'b', '-c', '--fourth'), ['test --alt'], {}, _func)
flb_cmd_invalid = ('', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('a', '--alt', 'a', '-b'), ['test --alt'], {}, _func)
flb_cmd_invalid_valid = ('a: int, b', [
parser.FallbackCommandParameter(func=_func, aliases=['--alt'])
], ('xyz', 'abc', '--alt', 'def', '-g', '--hij'), ['test --alt'], {},
_func)
flb_after_alt = ('a: int, b', [
parser.AlternateCommandParameter(func=_func, aliases=['--alt']),
parser.FallbackCommandParameter(func=_func2, aliases=['--flb']),
], ('--invalid', '--alt', '--flb'), ['test --flb'], {}, _func2)
def test_alt_middle(self):
_func = support.f('')
args = [
'*a',
[parser.AlternateCommandParameter(func=_func, aliases=['--alt'])],
('a', '--alt', 'a', 'b'), ['a', 'b'], {}, _func
]
exp_msg = ('Error: Arguments found before alternate '
'action parameter --alt')
with self.assertRaisesRegex(errors.ArgsBeforeAlternateCommand,
exp_msg):
self._test(*args)
def test_param_extras(self):
extra_params = [
parser.FlagParameter(value=True,
conv=parser.is_true,
aliases=['-' + name],
argument_name=name) for name in 'abc'
]
param = parser.PositionalParameter(display_name='one',
argument_name='one')
param.extras = extra_params
csig = parser.CliSignature([param])
self.assertEqual('[-a] [-b] [-c] one', str(csig))
def _test(self, expected_sig_str, orig_sig_str, end):
orig_func = f(orig_sig_str)
func = modifiers.posoargs(end=end)(orig_func)
self.assertSigsEqual(s(expected_sig_str), signature(func))
def test_merge_other(self):
orig_func = f('a, b')
func = modifiers.kwoargs('b')(modifiers.posoargs(end='a')(orig_func))
self.assertSigsEqual(s('<a>, *, b'), signature(func))
def _test(self, expected_sig_str, orig_sig_str, end):
orig_func = f(orig_sig_str)
func = modifiers.posoargs(end=end)(orig_func)
self.assertSigsEqual(s(expected_sig_str), signature(func))
def _test(self, expected_sig_str, orig_sig_str, start):
orig_func = f(orig_sig_str)
func = modifiers.kwoargs(start=start)(orig_func)
self.assertSigsEqual(s(expected_sig_str), signature(func))
def _test(self, sig_str, posoargs, kwoargs):
self.assertRaises(
ValueError,
modifiers._PokTranslator, f(sig_str), posoargs, kwoargs)
def test_posoargs_end_missing_raises(self):
func = f('')
self.assertRaises(ValueError, modifiers.posoargs(end='a'), func)
def test_kwoargs_start_missing_raises(self):
func = f('')
self.assertRaises(ValueError, modifiers.kwoargs(start='a'), func)
def test_unused_annotation(self):
self.assertRaises(
ValueError,
modifiers.annotate(a=1, c=2), f('a, b')
)
