def test_from_function(self):
function = lambda: None
signature = Signature.from_function(function)
self.assert_equal(signature.positional_arguments, [])
self.assert_equal(signature.keyword_arguments, [])
self.assert_equal(signature.annotations, {})
self.assert_equal(signature.arbitary_positional_arguments, None)
self.assert_equal(signature.arbitary_keyword_arguments, None)
self.assert_equal(signature.defaults, {})
self.assert_equal(signature.documentation, None)
function = lambda a, b: None
signature = Signature.from_function(function)
self.assert_equal(signature.positional_arguments, ["a", "b"])
function = lambda a=1, b=2: None
signature = Signature.from_function(function)
self.assert_equal(signature.positional_arguments, ["a", "b"])
self.assert_equal(signature.keyword_arguments, [])
self.assert_equal(signature.defaults, {"a": 1, "b": 2})
def function():
"""Test"""
signature = Signature.from_function(function)
self.assert_equal(signature.documentation, "Test")
def test_from_method(self):
class TestClass(object):
def test_method(self, a, b):
"""Test"""
signature = Signature.from_method(TestClass.test_method)
self.assert_equal(signature.positional_arguments, ["a", "b"])
self.assert_equal(signature.documentation, "Test")
signature = Signature.from_method(TestClass.test_method, documentation="Foo")
self.assert_equal(signature.documentation, "Foo")
signature = Signature.from_method(TestClass().test_method)
self.assert_equal(signature.positional_arguments, ["a", "b"])
def test_from_object(self):
class TestClass(object):
def __call__(self, a, b):
pass
signature = Signature.from_object(TestClass())
self.assert_equal(signature.positional_arguments, ["a", "b"])
def __init__(self, options=None, commands=None, positionals=None):
self.options = OrderedDict()
self.add_option("__awwparse_help", HelpOption())
self.add_options(self.__class__.options)
if options is not None:
self.add_options(options)
self.commands = OrderedDict()
self.add_commands(self.__class__.commands)
if commands is not None:
self.add_commands(commands)
self.positionals = parse_positional_signature(
force_list(self.__class__.positionals),
require_metavar=True
)
if positionals is not None:
self.add_positionals(positionals)
self.parent = None
signature = Signature.from_method(self.main)
if signature.annotations:
self._populate_from_signature(self, signature)
for name in dir(self):
try:
attribute = getattr(self, name)
except AttributeError:
# maybe raised by properties; can be safely ignored
continue
if isinstance(attribute, Command):
if not isinstance(attribute.main, MethodType):
attribute.main = partial(attribute.main, self)
self.add_command(name, attribute)
def decorate(method):
signature = Signature.from_method(method)
if not signature.annotations:
method.__annotations__ = dict(zip(signature.names, positionals))
command = type(
method.__name__,
(cls, ),
{
"__module__": method.__module__,
"__doc__": method.__doc__,
"main": staticmethod(method)
}
)()
return command
def decorate(function):
signature = Signature.from_function(function)
if not signature.annotations:
signature.annotations = dict(zip(signature.names, positionals))
command = type(
function.__name__,
(cls, ),
{
"__module__": function.__module__,
"__doc__": function.__doc__
}
)()
command.main = function
cls._populate_from_signature(command, signature)
return command
def test_names(self):
def function(a, b, c=None, *args, **kwargs):
pass
self.assert_equal(Signature.from_function(function).names, ["a", "b", "c", "args", "kwargs"])
