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