def test_smart_dict(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
self.assertEqual(d.keys(), ['a', 'foo'])
self.assertTrue('foo.a' in d)
del d['foo']
self.assertEqual(d.keys(), ['a'])
self.assertEqual(d['a'], [{'b': 1}, {'b': 2}, {'b': 3}])
self.assertEqual(d['a[0]'], {'b': 1})
self.assertEqual(d['a.b'], [1, 2, 3])
self.assertEqual(d['a[1:]'], [{'b': 2}, {'b': 3}])
d.set('a', {'b': 4}, extend=True)
self.assertEqual(d['a'], [{'b': 1}, {'b': 2}, {'b': 3}, {'b': 4}])
d.set('a', [{'b': 1}, {'b': 2}, {'b': 3}], extend=False)
self.assertEqual(d['a'], [{'b': 1}, {'b': 2}, {'b': 3}])
self.assertEqual(d.get('does not exists'), None)
d = SmartDict()
d.set('a.b.c[n]', 'foo', True)
self.assertEqual(d['a.b.c'], ['foo'])
d.set('a.b.c[n]', 'bar', True)
self.assertEqual(d['a.b.c'], ['foo', 'bar'])
d.set('a.b.c', ['foo'], False)
self.assertEqual(d['a.b.c'], ['foo'])
def test_smart_update(self):
d = SmartDict()
d2 = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['c.d'] = [{'e': 4}, {'f': 5}]
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
d2['qwerty'] = {'t': 'u', 'i': 'o'}
d2['qwe.rty'] = [{'n': 34}, {'x': 3}]
d.update(d2)
d3 = SmartDict({
'a': [{
'b': 1
}, {
'b': 2
}, {
'b': 3
}],
'c': {
'd': [{
'e': 4
}, {
'f': 5
}]
},
'foo': {
'a': 'world',
'b': 'hello'
},
'qwe': {
'rty': [{
'n': 34
}, {
'x': 3
}]
},
'qwerty': {
'i': 'o',
't': 'u'
}
})
self.assertTrue(d == d3)
def test_smart__contains(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
self.assertFalse('.' in d)
self.assertFalse('[' in d)
def test_smart_has_key(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['c.d'] = [{'e': 4}, {'f': 5}]
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
self.assertTrue('c' in d)
self.assertFalse('v' in d)
self.assertTrue('c.d' in d)
self.assertTrue('foo.b' in d)
def test_smart_iter(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
iterator = iter(d)
self.assertEqual(iterator.next(), 'a')
self.assertEqual(iterator.next(), 'foo')
self.assertRaises(StopIteration, iterator.next)
def test_smart_itervalues(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['c.d'] = [{'e': 4}, {'f': 5}]
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
iterator = d.itervalues()
self.assertEqual(iterator.next(), [{'b': 1}, {'b': 2}, {'b': 3}])
self.assertEqual(iterator.next(), {'d': [{'e': 4}, {'f': 5}]})
self.assertEqual(iterator.next(), {'a': 'world', 'b': 'hello'})
self.assertRaises(StopIteration, iterator.next)
def test_smart_repr(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['c.d'] = [{'e': 4}, {'f': 5}]
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
self.assertEqual(
repr(d), "{'a': [{'b': 1}, {'b': 2}, {'b': 3}], " +
"'c': {'d': [{'e': 4}, {'f': 5}]}, " +
"'foo': {'a': 'world', 'b': 'hello'}}")
del d['c']
self.assertEqual(
repr(d), "{'a': [{'b': 1}, {'b': 2}, {'b': 3}], " +
"'foo': {'a': 'world', 'b': 'hello'}}")
def test_smart_items(self):
d = SmartDict()
d['foo'] = {'a': 'world', 'b': 'hello'}
d['a'] = [{'b': 1}, {'b': 2}, {'b': 3}]
d['c.d'] = [{'e': 4}, {'f': 5}]
self.assertTrue(d.items(), [('a', [{
'b': 1
}, {
'b': 2
}, {
'b': 3
}]), ('c', {
'd': [{
'e': 4
}, {
'f': 5
}]
}), ('foo', {
'a': 'world',
'b': 'hello'
})])
def test_smart_insert_special_chars(self):
d = SmartDict({'a': 'world', 'b': 'hello'})
self.assertRaises(KeyError, setitem, d, ".", "dot")
self.assertRaises(KeyError, setitem, d, "[", "open bracket")
self.assertRaises(KeyError, setitem, d, "]", "close bracket")
def __init__(self,
json=None,
set_default_values=False,
process_model_info=False,
**kwargs):
"""If no JSON, a new structure will be created.
Typically the JSON structure needs a few mandatory fields and subfields
that are created here, the final JSON should look like this::
{
'__meta_metadata': {
'__additional_info__': {...},
'__model_info__': {'model_names': [...], ....},
'__aliases__': {...},
'__errors__': [...],
'__continuable_errors__': []
}
}
The content of `__additional_info__` is, usually, the content of
kwargs.
This object maintains two different dictionaries, one with the pure
JSON representation, `_dict` and a second one with the BSON
representation of the former. This behavior helps whenever dealing with
JSON databases like PostgreSQL.
The content of the BSON dictionary is typically the same as in the JSON
one, only if the `json` section is described in the definition of the
field the content might change, a good example of this behavior are the
date fields.
See :class:`~.jsonext.parsers.json_extra_parser:JsonExtraParser`.
:param json: JSON to build the dictionary.
:param set_defaul_values: If `True` default values will be set.
:param process_model_info: If `True` all model info will be parsed.
:param kwargs: Everything that would be useful inside
`__additional_info__`. Although it could be used also for:
* `model=['model1', 'model2']`, in this case this key will be
deleted from `kwargs` and used as model names inside
`__model_info__`.
"""
super(SmartJson, self).__init__(json)
self._dict_bson = SmartDict()
if not json or '__meta_metadata__' not in json:
model_names = kwargs.get('model', [
'__default__',
])
if 'model' in kwargs:
del kwargs['model']
if isinstance(model_names, six.string_types):
model_names = [
model_names,
]
self._dict['__meta_metadata__'] = dict()
self._dict['__meta_metadata__']['__additional_info__'] = kwargs
self._dict['__meta_metadata__']['__model_info__'] = \
dict(names=model_names)
self._dict['__meta_metadata__']['__aliases__'] = dict()
self._dict['__meta_metadata__']['__errors__'] = list()
self._dict['__meta_metadata__']['__continuable_errors__'] = list()
if process_model_info:
Reader.process_model_info(self)
if set_default_values:
self.set_default_values()
