def _build_arg_mapping(self,
executor,
requires=None,
rebind=None,
auto_extract=True,
ignore_list=None):
required, optional = _build_arg_mapping(self.name,
requires,
rebind,
executor,
auto_extract,
ignore_list=ignore_list)
# Form the real rebind mapping, if a key name is the same as the
# key value, then well there is no rebinding happening, otherwise
# there will be.
rebind = collections.OrderedDict()
for (arg_name, bound_name) in itertools.chain(six.iteritems(required),
six.iteritems(optional)):
rebind.setdefault(arg_name, bound_name)
requires = sets.OrderedSet(six.itervalues(required))
optional = sets.OrderedSet(six.itervalues(optional))
if self.inject:
inject_keys = frozenset(six.iterkeys(self.inject))
requires -= inject_keys
optional -= inject_keys
return rebind, requires, optional
def test_intersection(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3, 4, 5])
es = set(s)
es2 = set(s2)
self.assertEqual(es.intersection(es2), s.intersection(s2))
self.assertEqual(es2.intersection(s), s2.intersection(s))
def test_difference(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3])
es = set(s)
es2 = set(s2)
self.assertEqual(es.difference(es2), s.difference(s2))
self.assertEqual(es2.difference(es), s2.difference(s))
def test_union(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3, 4])
es = set(s)
es2 = set(s2)
self.assertEqual(es.union(es2), s.union(s2))
self.assertEqual(es2.union(es), s2.union(s))
def test_multi_union(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3, 4])
s3 = sets.OrderedSet([4, 5, 6])
es = set(s)
es2 = set(s2)
es3 = set(s3)
self.assertEqual(es.union(es2, es3), s.union(s2, s3))
def test_multi_intersection(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3, 4, 5])
s3 = sets.OrderedSet([1, 2])
es = set(s)
es2 = set(s2)
es3 = set(s3)
self.assertEqual(es.intersection(s2, s3), s.intersection(s2, s3))
self.assertEqual(es2.intersection(es3), s2.intersection(s3))
def test_multi_difference(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3])
s3 = sets.OrderedSet([3, 4, 5])
es = set(s)
es2 = set(s2)
es3 = set(s3)
self.assertEqual(es3.difference(es), s3.difference(s))
self.assertEqual(es.difference(es3), s.difference(s3))
self.assertEqual(es2.difference(es, es3), s2.difference(s, s3))
def test_pickleable(self):
items = [10, 9, 8, 7]
s = sets.OrderedSet(items)
self.assertEqual(items, list(s))
s_bin = pickle.dumps(s)
s2 = pickle.loads(s_bin)
self.assertEqual(s, s2)
self.assertEqual(items, list(s2))
def __init__(self,
name=None,
provides=None,
requires=None,
auto_extract=True,
rebind=None,
inject=None,
ignore_list=None,
revert_rebind=None,
revert_requires=None):
if provides is None:
provides = self.default_provides
self.name = name
self.version = (1, 0)
self.inject = inject
self.save_as = _save_as_to_mapping(provides)
self.provides = sets.OrderedSet(self.save_as)
if ignore_list is None:
ignore_list = []
self.rebind, exec_requires, self.optional = self._build_arg_mapping(
self.execute,
requires=requires,
rebind=rebind,
auto_extract=auto_extract,
ignore_list=ignore_list)
revert_ignore = ignore_list + list(_default_revert_args)
revert_mapping = self._build_arg_mapping(self.revert,
requires=revert_requires
or requires,
rebind=revert_rebind
or rebind,
auto_extract=auto_extract,
ignore_list=revert_ignore)
(self.revert_rebind, addl_requires,
self.revert_optional) = revert_mapping
# TODO(bnemec): This should be documented as an ivar, but can't be due
# to https://github.com/sphinx-doc/sphinx/issues/2549
#: A :py:class:`~zag.types.sets.OrderedSet` of inputs this atom
#: requires to function.
self.requires = exec_requires.union(addl_requires)
def _build_arg_mapping(atom_name,
reqs,
rebind_args,
function,
do_infer,
ignore_list=None):
"""Builds an input argument mapping for a given function.
Given a function, its requirements and a rebind mapping this helper
function will build the correct argument mapping for the given function as
well as verify that the final argument mapping does not have missing or
extra arguments (where applicable).
"""
# Build a list of required arguments based on function signature.
req_args = reflection.get_callable_args(function, required_only=True)
all_args = reflection.get_callable_args(function, required_only=False)
# Remove arguments that are part of ignore list.
if ignore_list:
for arg in ignore_list:
if arg in req_args:
req_args.remove(arg)
else:
ignore_list = []
# Build the required names.
required = collections.OrderedDict()
# Add required arguments to required mappings if inference is enabled.
if do_infer:
required.update((a, a) for a in req_args)
# Add additional manually provided requirements to required mappings.
if reqs:
if isinstance(reqs, six.string_types):
required.update({reqs: reqs})
else:
required.update((a, a) for a in reqs)
# Update required mappings values based on rebinding of arguments names.
required.update(_build_rebind_dict(req_args, rebind_args))
# Determine if there are optional arguments that we may or may not take.
if do_infer:
opt_args = sets.OrderedSet(all_args)
opt_args = opt_args - set(
itertools.chain(six.iterkeys(required), iter(ignore_list)))
optional = collections.OrderedDict((a, a) for a in opt_args)
else:
optional = collections.OrderedDict()
# Check if we are given some extra arguments that we aren't able to accept.
if not reflection.accepts_kwargs(function):
extra_args = sets.OrderedSet(six.iterkeys(required))
extra_args -= all_args
if extra_args:
raise ValueError('Extra arguments given to atom %s: %s' %
(atom_name, list(extra_args)))
# NOTE(imelnikov): don't use set to preserve order in error message
missing_args = [arg for arg in req_args if arg not in required]
if missing_args:
raise ValueError('Missing arguments for atom %s: %s' %
(atom_name, missing_args))
return required, optional
def test_empty_intersection(self):
s = sets.OrderedSet([1, 2, 3])
es = set(s)
self.assertEqual(es.intersection(), s.intersection())
def test_retain_ordering(self):
items = [10, 9, 8, 7]
s = sets.OrderedSet(iter(items))
self.assertEqual(items, list(s))
def test_empty_union(self):
s = sets.OrderedSet([1, 2, 3])
es = set(s)
self.assertEqual(es.union(), s.union())
def test_empty_difference(self):
s = sets.OrderedSet([1, 2, 3])
es = set(s)
self.assertEqual(es.difference(), s.difference())
def test_retain_duplicate_ordering(self):
items = [10, 9, 10, 8, 9, 7, 8]
s = sets.OrderedSet(iter(items))
self.assertEqual([10, 9, 8, 7], list(s))
def test_subset(self):
s = sets.OrderedSet([1, 2, 3])
s2 = sets.OrderedSet([2, 3])
self.assertTrue(s2.issubset(s))
self.assertFalse(s2.issuperset(s))
def test_length(self):
items = [10, 9, 8, 7]
s = sets.OrderedSet(iter(items))
self.assertEqual(4, len(s))
def test_duplicate_length(self):
items = [10, 9, 10, 8, 9, 7, 8]
s = sets.OrderedSet(iter(items))
self.assertEqual(4, len(s))
def test_contains(self):
items = [10, 9, 8, 7]
s = sets.OrderedSet(iter(items))
for i in items:
self.assertIn(i, s)
def test_copy(self):
items = [10, 9, 8, 7]
s = sets.OrderedSet(iter(items))
s2 = s.copy()
self.assertEqual(s, s2)
self.assertEqual(items, list(s2))