def __init__(self, step_function, *args, **kwargs):
'''
Construct the step profile.
Give the `*args` and/or `**kwargs` that you want to use for the step
function.
'''
# Perhaps we were passed a `StepProfile` object instead of args
# and kwargs? If so load that one, cause we're all cool and nice.
candidate = None
if len(args) == 1 and len(kwargs) == 0:
candidate = args[0]
if len(args) == 0 and len(kwargs) == 1 and \
('step_profile' in kwargs):
candidate = kwargs['step_profile']
if isinstance(candidate, StepProfile):
ArgumentsProfile.__init__(self, candidate.step_function,
*((Placeholder, ) + candidate.args),
**candidate.kwargs)
else:
ArgumentsProfile.__init__(self, step_function,
*((Placeholder, ) + args), **kwargs)
assert self.args[0] is Placeholder
self.args = self.args[1:]
'''The `*args` that will be passed to the step function.'''
self.kwargs = self.kwargs
'''The `*kwargs` that will be passed to the step function.'''
self.step_function = self.function
'''The step function that will be used to crunch the simulation.'''
def test_defaultful_long_last():
'''
Test `ArgumentsProfile` on function with long last defaultful argument.
The point is that `ArgumentsProfile` prefers specifying all arguments
leading to the last long one rather than specifying the keyword, because it
results in a shorter overall call.
'''
def func(a, b, c=3, dragon=4): pass
a1 = ArgumentsProfile(func, 1, 2)
assert a1.args == (1, 2)
assert not a1.kwargs
a2 = ArgumentsProfile(func, 1, 2, 3, 4)
a3 = ArgumentsProfile(func, a=1, b=2, c=3, dragon=4)
a4 = ArgumentsProfile(func, c=3, dragon=4, a=1, b=2)
a5 = ArgumentsProfile(func, 1, 2, c=3, dragon=4)
assert a1 == a2 == a3 == a4 == a5
a6 = ArgumentsProfile(func, 1, 2, dragon='booyeah')
assert a6.args == (1, 2, 3, 'booyeah')
assert not a6.kwargs
a7 = ArgumentsProfile(func, 1, 2, 3, 'booyeah')
a8 = ArgumentsProfile(func, 1, 2, c=3, dragon='booyeah')
assert a6 == a7 == a8
def test_unhashable_star_empty():
'''Test `ArgumentsProfile` hashing and handling of `*()`.'''
def func(a, b, c=3, d=4, **kwargs):
pass
assert sys.version_info[0] == 2
assert sys.version_info[1] >= 5
if sys.version_info[1] == 5:
raise nose.SkipTest("Python 2.5 can't compile this test.")
a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), set([1, (3, 4)]),
meow=[1, 2, {1: [1, 2]}])
assert a2.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
assert a2.kwargs == OrderedDict(
(('meow', [1, 2, {1: [1, 2]}]),)
)
# Python 2.5 can't compile the following, so we're compiling it dynamically
# so as to not prevent Python 2.5 from being able to compile this module:
exec("a3 = ArgumentsProfile(func, *(), b=({'a': 'b'},),"
"c=set([1, (3, 4)]), a=7,"
"meow=[1, 2, {1: [1, 2]}])")
assert a3.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
assert a3.kwargs == OrderedDict(
(('meow', [1, 2, {1: [1, 2]}]),)
)
assert hash(a2) == hash(a3)
def test_defaultful_and_star_args():
'''Test `ArgumentsProfile` with defaultful arguments and `*args`.'''
def func(a, b, c=3, draconian=4, *args): pass
a1 = ArgumentsProfile(func, 1, 2)
assert a1.args == (1, 2)
assert not a1.kwargs
a2 = ArgumentsProfile(func, 1, 2, draconian='kapow')
assert a2.args == (1, 2, 3, 'kapow')
assert not a2.kwargs
a3 = ArgumentsProfile(func, 1, 2, 3, 'kapow')
assert a2 == a3
a4 = ArgumentsProfile(func, 1, 2, 3, 'kapow', 'meow_frr')
assert a4.args == (1, 2, 3, 'kapow', 'meow_frr')
assert not a4.kwargs
def test_many_defaultfuls_some_long_2():
'''
Test `ArgumentsProfile` with many defaultful arguments, some of them long.
'''
def func(a, b, c=3, dragon=4, e=5, f=6, glide=7, human=8, iris=9): pass
a1 = ArgumentsProfile(func, 1, 2, glide='boom')
assert a1.args == (1, 2)
assert a1.kwargs == OrderedDict((('glide', 'boom'),))
a2 = ArgumentsProfile(func, 1, 2, 3, 4, 5, 6, 'boom')
a3 = ArgumentsProfile(func, 1, 2, 3, glide='boom')
assert a1 == a2 == a3
a4 = ArgumentsProfile(func, 1, 2, glide='boom',
human='pow', iris='badabang')
a5 = ArgumentsProfile(func, 1, 2, 3, 4, 5, 6, 'boom', 'pow', 'badabang')
assert a4 == a5
assert a4.args == (1, 2, 3, 4, 5, 6, 'boom', 'pow', 'badabang')
assert not a4.kwargs
def test_unhashable():
'''Test hashing of `ArgumentsProfile` that has unhashable arguments.'''
def func(a, b, c=3, d=4, **kwargs):
pass
a1 = ArgumentsProfile(func, 7, {1: 2})
assert a1.args == (7, {1: 2})
assert not a1.kwargs
hash(a1)
a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), set([1, (3, 4)]),
meow=[1, 2, {1: [1, 2]}])
assert a2.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
assert a2.kwargs == OrderedDict(
(('meow', [1, 2, {1: [1, 2]}]),)
)
d = {a1: 1, a2: 2}
assert d[a1] == 1
assert d[a2] == 2
def test_many_defaultfuls_some_long():
'''
Test `ArgumentsProfile` with many defaultful arguments, some of them long.
'''
def func(a, b, c=3, dragon=4, e=5, f=6, glide=7, human=8): pass
a1 = ArgumentsProfile(func, 1, 2, glide='boom')
assert a1.args == (1, 2)
assert a1.kwargs == OrderedDict((('glide', 'boom'),))
a2 = ArgumentsProfile(func, 1, 2, 3, 4, 5, 6, 'boom')
a3 = ArgumentsProfile(func, 1, 2, 3, glide='boom')
assert a1 == a2 == a3
a4 = ArgumentsProfile(func, 1, 2, glide='boom', human='pow')
a5 = ArgumentsProfile(func, 1, 2, 3, 4, 5, 6, 'boom', 'pow')
# edge case, second priority
assert a4.args == (1, 2)
assert a4.kwargs == OrderedDict((('glide', 'boom'), ('human', 'pow')))
assert a4 == a5
def test_only_defaultless():
'''
Test `ArgumentsProfile` on a function with defaultless arguments only.
'''
def func(a, b, c): pass
a1 = ArgumentsProfile(func, 1, 2, 3)
assert a1.args == (1, 2, 3)
assert not a1.kwargs
a2 = ArgumentsProfile(func, 1, c=3, b=2)
a3 = ArgumentsProfile(func, c=3, a=1, b=2)
a4 = ArgumentsProfile(func, 1, **{'c': 3, 'b': 2})
a5 = ArgumentsProfile(func, **OrderedDict((('c', 3), ('b', 2), ('a', 1))))
assert a1 == a2 == a3 == a4 == a5
for arg_prof in [a1, a2, a3, a4, a5]:
### Testing `.iteritems`: #############################################
# #
assert dict(arg_prof) == {'a': 1, 'b': 2, 'c': 3}
assert OrderedDict(arg_prof) == \
OrderedDict((('a', 1), ('b', 2), ('c', 3)))
# #
### Finished testing `.iteritems`. ####################################
### Testing `.__getitem__`: ###########################################
# #
assert (arg_prof['a'], arg_prof['b'], arg_prof['c']) == (1, 2, 3)
with cute_testing.RaiseAssertor(KeyError):
arg_prof['non_existing_key']
# #
### Finished testing `.__getitem__`. ##################################
### Testing `.get`: ###################################################
# #
assert arg_prof.get('a') == arg_prof.get('a', 'asdfasdf') == 1
assert arg_prof.get('non_existing_key', 7) == 7
assert arg_prof.get('non_existing_key') is None
def test_many_defaultfuls_and_star_args():
'''Test `ArgumentsProfile` with many defaultful arguments and `*args`.'''
def func(a, b, c='three', d='four', e='five', f='six', *args): pass
a1 = ArgumentsProfile(func, 'one', 'two', f='roar')
assert a1.args == ('one', 'two')
assert a1.kwargs == OrderedDict((('f', 'roar'),))
a2 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five', 'roar')
assert a1 == a2
# Specifying `*args`, so can't specify pre-`*args` arguments by keyword:
a3 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five', 'roar',
'meow_frr')
assert a3.args == ('one', 'two', 'three', 'four', 'five', 'roar',
'meow_frr')
assert not a3.kwargs
a4 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five', 'six',
3, 1, 4, 1, 5, 9, 2)
assert a4.args == ('one', 'two', 'three', 'four', 'five', 'six',
3, 1, 4, 1, 5, 9, 2)
assert not a4.kwargs
assert a4['*'] == (3, 1, 4, 1, 5, 9, 2)
def __init__(self, step_function, *args, **kwargs):
'''
Construct the step profile.
Give the `*args` and/or `**kwargs` that you want to use for the step
function.
'''
# Perhaps we were passed a `StepProfile` object instead of args
# and kwargs? If so load that one, cause we're all cool and nice.
candidate = None
if len(args) == 1 and len(kwargs) == 0:
candidate = args[0]
if len(args) == 0 and len(kwargs) == 1 and \
('step_profile' in kwargs):
candidate = kwargs['step_profile']
if isinstance(candidate, StepProfile):
ArgumentsProfile.__init__(self, candidate.step_function,
*((Placeholder,) + candidate.args),
**candidate.kwargs)
else:
ArgumentsProfile.__init__(self, step_function,
*((Placeholder,) + args),
**kwargs)
assert self.args[0] is Placeholder
self.args = self.args[1:]
'''The `*args` that will be passed to the step function.'''
self.kwargs = self.kwargs
'''The `*kwargs` that will be passed to the step function.'''
self.step_function = self.function
'''The step function that will be used to crunch the simulation.'''
def test_defaultful_long_first():
'''
Test `ArgumentsProfile` on function with long first defaultful argument.
'''
def func(a, b, creativity=3, d=4): pass
a1 = ArgumentsProfile(func, 1, 2)
assert a1.args == (1, 2)
assert not a1.kwargs
a2 = ArgumentsProfile(func, 1, 2, 3, 4)
a3 = ArgumentsProfile(func, a=1, b=2, creativity=3, d=4)
a4 = ArgumentsProfile(func, creativity=3, d=4, a=1, b=2)
a5 = ArgumentsProfile(func, 1, 2, creativity=3, d=4)
assert a1 == a2 == a3 == a4 == a5
a6 = ArgumentsProfile(func, 1, 2, d='booyeah')
assert a6.args == (1, 2)
assert a6.kwargs == OrderedDict((('d', 'booyeah'),))
a7 = ArgumentsProfile(func, 1, 2, 3, 'booyeah')
a8 = ArgumentsProfile(func, 1, 2, creativity=3, d='booyeah')
assert a6 == a7 == a8
def __eq__(self, other):
return isinstance(other, StepProfile) and \
ArgumentsProfile.__eq__(self, other)
def __eq__(self, other):
return isinstance(other, StepProfile) and \
ArgumentsProfile.__eq__(self, other)
def test_simplest_defaultful():
'''
Test `ArgumentsProfile` on a function with defaultful arguments.
'''
def func(a, b, c='three', d='four'): pass
a1 = ArgumentsProfile(func, 'one', 'two')
assert a1.args == ('one', 'two')
assert not a1.kwargs
a2 = ArgumentsProfile(func, 'one', 'two', 'three')
a3 = ArgumentsProfile(func, 'one', 'two', 'three', 'four')
assert a1 == a2 == a3
a4 = ArgumentsProfile(func, 'one', 'two', 'dynamite')
assert a1 != a4
assert a4.args == ('one', 'two', 'dynamite')
assert not a4.kwargs
a5 = ArgumentsProfile(func, 'one', 'two', c='dynamite')
a6 = ArgumentsProfile(func, 'one', 'two', 'dynamite', 'four')
a7 = ArgumentsProfile(func, 'one', 'two', c='dynamite', d='four')
a8 = ArgumentsProfile(func, 'one', 'two', 'dynamite', d='four')
a9 = ArgumentsProfile(func, a='one', b='two', c='dynamite', d='four')
a10 = ArgumentsProfile(func, d='four', c='dynamite', b='two', a='one')
a11 = ArgumentsProfile(func, 'one', c='dynamite', d='four', b='two')
assert a4 == a5 == a6 == a7 == a8 == a9 == a10 == a11
a12 = ArgumentsProfile(func, 'one', 'two', d='bang')
assert a12.args == ('one', 'two')
assert a12.kwargs == OrderedDict((('d', 'bang'),))
a13 = ArgumentsProfile(func, 'one', 'two', 'three', d='bang')
a14 = ArgumentsProfile(func, 'one', 'two', c='three', d='bang')
a15 = ArgumentsProfile(func, 'one', 'two', 'three', 'bang')
a16 = ArgumentsProfile(func, a='one', b='two', c='three', d='bang')
a17 = ArgumentsProfile(func, b='two', c='three', d='bang', a='one')
assert a13 == a14 == a15 == a16 == a17
def test_defaultfuls_and_star_kwargs():
'''Test `ArgumentsProfile` with defaultful arguments and `**kwargs`.'''
def func(a, b, c=3, d=4, **kwargs): pass
a1 = ArgumentsProfile(func, 1, 2)
assert a1.args == (1, 2)
assert not a1.kwargs
# Alphabetic ordering among the `**kwargs`, but `d` is first because it's a
# non-star:
a2 = ArgumentsProfile(func, 1, 2, d='bombastic', zany=True, blue=True)
assert a2.args == (1, 2)
assert a2.kwargs == OrderedDict(
(('d', 'bombastic'), ('blue', True), ('zany', True))
)
a3 = ArgumentsProfile(func, 1, b=2, blue=True, d='bombastic', zany=True)
a4 = ArgumentsProfile(func, zany=True, a=1, b=2, blue=True, d='bombastic')
a5 = ArgumentsProfile(func, 1, 2, 3, 'bombastic', zany=True, blue=True)
assert a2 == a3 == a4 == a5
for arg_prof in [a2, a3, a4, a5]:
# Testing `.iteritems`:
assert OrderedDict(arg_prof) == OrderedDict(
(('a', 1), ('b', 2), ('c', 3), ('d', 'bombastic'), ('blue', True),
('zany', True))
)
### Testing `.__getitem__`: ###########################################
# #
assert (arg_prof['a'], arg_prof['b'], arg_prof['c'], arg_prof['d'],
arg_prof['blue'], arg_prof['zany']) == \
(1, 2, 3, 'bombastic', True, True)
with cute_testing.RaiseAssertor(KeyError):
arg_prof['non_existing_key']
# #
### Finished testing `.__getitem__`. ##################################
### Testing `.get`: ###################################################
# #
assert arg_prof.get('d') == arg_prof.get('d', 7) == 'bombastic'
assert arg_prof.get('non_existing_key', 7) == 7
assert arg_prof.get('non_existing_key') is None
# #
### Finished testing `.get`. ##########################################
### Testing `.iterkeys`, `.keys` and `__iter__`: ######################
# #
assert list(arg_prof.iterkeys()) == list(arg_prof.keys()) == \
list(arg_prof) == ['a', 'b', 'c', 'd', 'blue', 'zany']
# #
### Finished testing `.iterkeys`, `.keys` and `__iter__`. #############
### Testing `.itervalues` and `.values`: ##############################
# #
assert list(arg_prof.itervalues()) == list(arg_prof.values()) == \
[1, 2, 3, 'bombastic', True, True]
# #
### Finished testing `.itervalues` and `.values`. #####################
### Testing `.__contains__`: ##########################################
# #
for key in arg_prof:
assert key in arg_prof
assert 'agaofgnafgadf' not in arg_prof
assert '**' not in arg_prof
def test_method_equality():
'''
Test for bug where methods are compared with `is` instead of `==`.
This causes failure with both bound and unbound methods.
'''
class C(object):
def my_method(self, *args):
pass
c1 = C()
c2 = C()
assert ArgumentsProfile(C.my_method, c1) == \
ArgumentsProfile(C.my_method, c1)
assert ArgumentsProfile(C.my_method, c1, 7, 'meow') == \
ArgumentsProfile(C.my_method, c1, 7, 'meow')
assert ArgumentsProfile(C.my_method, c1) != \
ArgumentsProfile(C.my_method, c1, 7, 'meow')
assert ArgumentsProfile(C.my_method, c1) != ArgumentsProfile(c1.my_method)
assert ArgumentsProfile(C.my_method, c2) != ArgumentsProfile(c1.my_method)
assert ArgumentsProfile(c1.my_method) == ArgumentsProfile(c1.my_method)
assert ArgumentsProfile(c1.my_method, 7, 'meow') == \
ArgumentsProfile(c1.my_method, 7, 'meow')
assert ArgumentsProfile(c1.my_method) != ArgumentsProfile(c1.my_method, 7,
'meow')
assert ArgumentsProfile(c1.my_method) != ArgumentsProfile(c2.my_method)
assert ArgumentsProfile(c1.my_method, 7, 'meow') != \
ArgumentsProfile(c2.my_method, 7, 'meow')
def test_many_defaultfuls_and_star_args_and_star_kwargs():
'''
Test `ArgumentsProfile` with defaultful arguments, `*args` and `**kwargs`.
'''
def func(a, b, c='three', d='four', e='five', f='six', *args, **kwargs):
pass
func(None, None)
a1 = ArgumentsProfile(func, 'one', 'two', f='boomboomboom', __awesome=True,
big=True)
assert a1.args == ('one', 'two')
assert a1.kwargs == OrderedDict(
(('f', 'boomboomboom'), ('big', True), ('__awesome', True))
)
a2 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five',
'bombastic', 'meow_frr', __funky=None, zany=True,
_wet=False, blue=True)
assert a2.args == ('one', 'two', 'three', 'four', 'five', 'bombastic',
'meow_frr')
assert a2.kwargs == OrderedDict(
(('blue', True), ('zany', True), ('_wet', False), ('__funky', None))
)
a3 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five',
'bombastic', 'meow_frr', zany=True, __funky=None,
blue=True, _wet=False, **OrderedDict())
assert a2 == a3
for arg_prof in [a2, a3]:
# Testing `.iteritems`:
assert OrderedDict(arg_prof) == OrderedDict(
(('a', 'one'), ('b', 'two'), ('c', 'three'), ('d', 'four'),
('e', 'five'), ('f', 'bombastic'), ('*', ('meow_frr',)),
('blue', True), ('zany', True), ('_wet', False),
('__funky', None))
)
### Testing `.__getitem__`: ###########################################
# #
assert (arg_prof['a'], arg_prof['b'], arg_prof['c'], arg_prof['d'],
arg_prof['e'], arg_prof['f'], arg_prof['*'], arg_prof['blue'],
arg_prof['zany'], arg_prof['_wet'], arg_prof['__funky']) == \
('one', 'two', 'three', 'four', 'five', 'bombastic',
('meow_frr',), True, True, False, None)
with cute_testing.RaiseAssertor(KeyError):
arg_prof['non_existing_key']
# #
### Finished testing `.__getitem__`. ##################################
### Testing `.get`: ###################################################
# #
assert arg_prof.get('d') == arg_prof.get('d', 7) == 'four'
assert arg_prof.get('non_existing_key', 7) == 7
assert arg_prof.get('non_existing_key') is None
# #
### Finished testing `.get`. ##########################################
### Testing `.iterkeys`, `.keys` and `__iter__`: ######################
# #
assert list(arg_prof.iterkeys()) == list(arg_prof.keys()) == \
list(arg_prof) == \
['a', 'b', 'c', 'd', 'e', 'f', '*', 'blue', 'zany', '_wet',
'__funky']
# #
### Finished testing `.iterkeys`, `.keys` and `__iter__`. #############
### Testing `.itervalues` and `.values`: ##############################
# #
assert list(arg_prof.itervalues()) == list(arg_prof.values()) == \
['one', 'two', 'three', 'four', 'five', 'bombastic', ('meow_frr',),
True, True, False, None]
# #
### Finished testing `.itervalues` and `.values`. #####################
### Testing `.iteritems` and `.items`: ################################
# #
items_1 = list(arg_prof.iteritems())
items_2 = arg_prof.items()
assert items_1 == items_2 == zip(arg_prof.keys(), arg_prof.values())
# #
### Finished testing `.iteritems` and `.items`. #######################
### Testing `.__contains__`: ##########################################
# #
for key in arg_prof:
assert key in arg_prof