def test_serialize_iterator_of_frozen_dicts(self):
data = iter(
[
yaql_utils.FrozenDict(a=1, b=2, c=iter([1, 2, 3])),
yaql_utils.FrozenDict(
a=11,
b=yaql_utils.FrozenDict(b='222'),
c=iter(
[
1,
yaql_utils.FrozenDict(
a=iter([4, yaql_utils.FrozenDict(a=99)])
)
]
)
)
]
)
json_str = utils.to_json_str(data)
self.assertIsNotNone(json_str)
# Checking the first item.
self.assertIn('"a": 1', json_str)
self.assertIn('"b": 2', json_str)
self.assertIn('"c": [1, 2, 3]', json_str)
# Checking the first item.
self.assertIn('"a": 11', json_str)
self.assertIn('"b": {"b": "222"}', json_str)
self.assertIn('"c": [1, {"a": [4, {"a": 99}]}]', json_str)
def modify(self, obj):
"""Remove object from given model"""
objects = self._get_objects_by_id(obj)
self._check_present(self._object_id, objects)
for _obj in objects.values():
for prop_name in _obj.type.properties:
try:
val = _obj.get_property(prop_name)
except exceptions.UninitializedPropertyAccessError:
continue
if self._match_object_id(self._object_id, val):
_obj.set_property(prop_name, None)
# remove object from list
elif isinstance(val, tuple):
filtered_list = list(val)
for item in val:
if self._match_object_id(self._object_id, item):
filtered_list.remove(item)
if len(filtered_list) < len(val):
_obj.set_property(prop_name, tuple(filtered_list))
# remove object from dict
elif isinstance(val, utils.FrozenDict):
filtered_dict = {
k: v
for k, v in val.items()
if not self._match_object_id(self._object_id, k)
and not self._match_object_id(self._object_id, v)
}
if len(filtered_dict) < len(val):
_obj.set_property(prop_name,
utils.FrozenDict(filtered_dict))
def _map_dict(self, data, spec, context, path):
if data is None or data is dsl.NO_VALUE:
data = {}
if not isinstance(data, utils.MappingType):
raise exceptions.ContractViolationException(
'Value {0} is not of a dictionary type'.format(
helpers.format_scalar(data)))
if not spec:
return data
result = {}
yaql_key = None
for key, value in six.iteritems(spec):
if isinstance(key, dsl_types.YaqlExpression):
if yaql_key is not None:
raise exceptions.DslContractSyntaxError(
'Dictionary contract '
'cannot have more than one expression key')
else:
yaql_key = key
else:
result[key] = self._map(
data.get(key), value, context,
'{0}[{1}]'.format(path, helpers.format_scalar(key)))
if yaql_key is not None:
yaql_value = spec[yaql_key]
for key, value in six.iteritems(data):
if key in result:
continue
key = self._map(key, yaql_key, context, path)
result[key] = self._map(
value, yaql_value, context,
'{0}[{1}]'.format(path, helpers.format_scalar(key)))
return utils.FrozenDict(result)
def _map_dict(self, data, spec, context):
if data is None or data is dsl.NO_VALUE:
data = {}
if not isinstance(data, utils.MappingType):
raise exceptions.ContractViolationException(
'Supplied is not of a dictionary type')
if not spec:
return data
result = {}
yaql_key = None
for key, value in spec.iteritems():
if isinstance(key, dsl_types.YaqlExpression):
if yaql_key is not None:
raise exceptions.DslContractSyntaxError(
'Dictionary contract '
'cannot have more than one expression keys')
else:
yaql_key = key
else:
result[key] = self._map(data.get(key), value, context)
if yaql_key is not None:
yaql_value = spec[yaql_key]
for key, value in data.iteritems():
if key in result:
continue
result[self._map(key, yaql_key,
context)] = self._map(value, yaql_value,
context)
return utils.FrozenDict(result)
def dict__(items, engine):
result = {}
for t in items:
it = iter(t)
key = next(it)
value = next(it)
result[key] = value
utils.limit_memory_usage(engine, (1, result))
return utils.FrozenDict(result)
def test_serialize_generator(self):
def _list_stream(_list):
for i in _list:
yield i
gen = _list_stream(
[1, yaql_utils.FrozenDict(a=1), _list_stream([12, 15])]
)
self.assertEqual('[1, {"a": 1}, [12, 15]]', utils.to_json_str(gen))
def test_serialize_frozen_dict(self):
data = yaql_utils.FrozenDict(a=1, b=2, c=iter([1, 2, 3]))
json_str = utils.to_json_str(data)
self.assertIsNotNone(json_str)
self.assertIn('"a": 1', json_str)
self.assertIn('"b": 2', json_str)
self.assertIn('"c": [1, 2, 3]', json_str)
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(src.iteritems(),
((key, value), ))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def test_evaluate(self):
yaql_value = mock.Mock(yaql_expression.YaqlExpression,
return_value='atom')
complex_value = {yaql_value: ['some', (1, yaql_value), 'hi!'],
'sample': [yaql_value, xrange(5)]}
complex_literal = utils.FrozenDict({
'atom': ('some', (1, 'atom'), 'hi!'),
'sample': ('atom', (0, 1, 2, 3, 4))
})
context = yaql.create_context()
evaluated_value = helpers.evaluate(yaql_value, context)
evaluated_complex_value = helpers.evaluate(complex_value, context)
self.assertEqual('atom', evaluated_value)
self.assertEqual(complex_literal, evaluated_complex_value)
def dict_(engine, *args):
""":yaql:dict
Returns dictionary of provided keyword values.
:signature: dict([args])
:arg [args]: arguments to create a dictionary
:argType [args]: mappings
:returnType: dictionary
.. code::
yaql> dict(a => 1, b => 2)
{ "a": 1, "b": 2}
"""
utils.limit_memory_usage(engine, *((1, arg) for arg in args))
return utils.FrozenDict((t.source, t.destination) for t in args)
def dict_set_many(engine, d, replacements):
""":yaql:set
Returns dict with replacements keys set to replacements values.
:signature: dict.set(replacements)
:receiverArg dict: input dictionary
:argType dict: dictionary
:arg replacements: mapping with keys and values to be set on input dict
:argType key: dictionary
:returnType: dictionary
.. code::
yaql> {"a" => 1, "b" => 2}.set({"b" => 3, "c" => 4})
{"a": 1, "c": 4, "b": 3}
"""
utils.limit_memory_usage(engine, (1, d), (1, replacements))
return utils.FrozenDict(itertools.chain(d.items(), replacements.items()))
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(six.iteritems(src), ((key, value), ))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, context['#root_context'])
elif isinstance(
src,
(dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
helpers.get_executor().set_static_property(
mc, key, value, context['#root_context'])
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def dict_set_many_inline(engine, d, *args):
""":yaql:set
Returns dict with args keys set to args values.
:signature: dict.set([args])
:receiverArg dict: input dictionary
:argType dict: dictionary
:arg [args]: key-values to be set on input dict
:argType [args]: chain of mappings
:returnType: dictionary
.. code::
yaql> {"a" => 1, "b" => 2}.set("b" => 3, "c" => 4)
{"a": 1, "c": 4, "b": 3}
"""
utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args))
return utils.FrozenDict(
itertools.chain(d.items(), ((t.source, t.destination) for t in args)))
def combine_dicts(left, right, engine):
""":yaql:operator +
Returns combined left and right dictionaries.
:signature: left + right
:arg left: left dictionary
:argType left: mapping
:arg right: right dictionary
:argType right: mapping
:returnType: mapping
.. code::
yaql> {"a" => 1, b => 2} + {"b" => 3, "c" => 4}
{"a": 1, "c": 4, "b": 3}
"""
utils.limit_memory_usage(engine, (1, left), (1, right))
d = dict(left)
d.update(right)
return utils.FrozenDict(d)
def evaluate(value, context):
if isinstance(value, (dsl_types.YaqlExpression,
yaql.language.expressions.Statement)):
return value(context)
elif isinstance(value, yaqlutils.MappingType):
return yaqlutils.FrozenDict(
(evaluate(d_key, context),
evaluate(d_value, context))
for d_key, d_value in six.iteritems(value))
elif yaqlutils.is_sequence(value):
return tuple(evaluate(t, context) for t in value)
elif isinstance(value, yaqlutils.SetType):
return frozenset(evaluate(t, context) for t in value)
elif yaqlutils.is_iterable(value):
return tuple(
evaluate(t, context)
for t in yaqlutils.limit_iterable(
value, constants.ITERATORS_LIMIT))
elif isinstance(value, dsl_types.MuranoObjectInterface):
return value.object
else:
return value
def dict__(items, engine):
""":yaql:dict
Returns dictionary with keys and values built on items pairs.
:signature: dict(items)
:arg items: list of pairs [key, value] for building dictionary
:argType items: list
:returnType: dictionary
.. code::
yaql> dict([["a", 2], ["b", 4]])
{"a": 2, "b": 4}
"""
result = {}
for t in items:
it = iter(t)
key = next(it)
value = next(it)
result[key] = value
utils.limit_memory_usage(engine, (1, result))
return utils.FrozenDict(result)
def dict_set(engine, d, key, value):
""":yaql:set
Returns dict with provided key set to value.
:signature: dict.set(key, value)
:receiverArg dict: input dictionary
:argType dict: dictionary
:arg key: key
:argType key: keyword
:arg value: value to be set to input key
:argType value: any
:returnType: dictionary
.. code::
yaql> {"a" => 1, "b" => 2}.set("c", 3)
{"a": 1, "b": 2, "c": 3}
yaql> {"a" => 1, "b" => 2}.set("b", 3)
{"a": 1, "b": 3}
"""
utils.limit_memory_usage(engine, (1, d), (1, key), (1, value))
return utils.FrozenDict(itertools.chain(d.items(), ((key, value), )))
def dict_(engine, *args):
utils.limit_memory_usage(engine, *((1, arg) for arg in args))
return utils.FrozenDict((t.source, t.destination) for t in args)
def combine_dicts(left, right, engine):
utils.limit_memory_usage(engine, (1, left), (1, right))
d = dict(left)
d.update(right)
return utils.FrozenDict(d)
def dict_set_many_inline(engine, d, *args):
utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args))
return utils.FrozenDict(
itertools.chain(six.iteritems(d),
((t.source, t.destination) for t in args)))
def dict_set_many(engine, d, replacements):
utils.limit_memory_usage(engine, (1, d), (1, replacements))
return utils.FrozenDict(
itertools.chain(six.iteritems(d), six.iteritems(replacements)))
def dict_set(engine, d, key, value):
utils.limit_memory_usage(engine, (1, d), (1, key), (1, value))
return utils.FrozenDict(itertools.chain(six.iteritems(d),
((key, value), )))
def __init__(self, ply_lexer, ply_parser, options, factory):
self._lexer = ply_lexer
self._parser = ply_parser
self._options = utils.FrozenDict(options or {})
self._factory = factory
