def parse_attrs(cls, attrs, decrypt=True, output=True):
res = {}
for k, v in attrs.iteritems():
if isinstance(v, Missing):
continue
# TODO
if isinstance(v, Expression):
continue
field = getattr(cls, k)
# TODO
if not hasattr(field, 'type'):
continue
if v is not None or not field.noneable:
if not type_checker(field.type, v):
v = field.parse(v)
if not type_checker(field.type, v):
raise ParseError(
'The parsed value of {}.{} is not a {} type: {}. '
'Please check the parser of this field'
' or your input data.'.format(cls.__name__, k, field.type,
repr(v)))
if decrypt:
v = field.decrypt_func(v) if field.encrypt else v
if output:
v = field.output(v) if field.output else v
res[k] = v
return res
def _get_multi(cls, idents, filter_none=True):
if not idents:
return []
if not type_checker([dict], idents):
pk_name = cls.get_singleness_pk_name()
pk_field = getattr(cls, pk_name)
items = cls._get_multi_by(pk_field.in_(idents))
mapping = {str(getattr(item, pk_name)): item for item in items}
else:
ident = idents[0]
items = cls._get_multi_by(
UnionField(*[getattr(cls, k) for k in ident]).in_(
[_ident.values() for _ident in idents]))
mapping = {
tuple(str(getattr(item, k)) for k in ident): item
for item in items
}
res = []
for ident in idents:
if not isinstance(ident, dict):
item = mapping.get(str(ident))
else:
item = mapping.get(tuple(map(str, ident.values())))
if item is None and filter_none:
continue
res.append(item)
return res
def _get(self, obj, objtype):
attr_name = self.attr_name
data = self._get_data(obj)
parsed_data = self._get_parsed_data(obj)
if attr_name in parsed_data:
return parsed_data[attr_name]
v = data.get(attr_name, missing)
if v is not missing:
if isinstance(v, Expression):
return v
if not type_checker(self.type, v) and (v is not None
or not self.noneable):
v = transform_type(v, self.type)
if self.output:
v = self.output(v)
parsed_data[attr_name] = v
return v
if self.noneable or obj._olo_is_new:
return
raise AttributeError( # pragma: no cover
'Cannot found `{}` from `{}` instance'.format(
self.name, obj.__class__.__name__))
def test_type_checker(self):
self.assertTrue(type_checker(int, 1))
self.assertTrue(type_checker(str, '1'))
self.assertTrue(type_checker(list, ['a']))
self.assertTrue(type_checker(dict, {'a': 1}))
self.assertTrue(type_checker({}, {'a': 1}))
self.assertTrue(type_checker(datetime, datetime.now()))
self.assertFalse(type_checker(int, '1'))
self.assertFalse(type_checker(str, 1))
self.assertFalse(type_checker(list, {'a': 1}))
self.assertFalse(type_checker(dict, [1]))
self.assertFalse(type_checker(datetime, 1))
self.assertTrue(type_checker([], [1, 2, 3]))
self.assertTrue(type_checker([int], [1, 2, 3]))
self.assertTrue(type_checker({int: str}, {1: '1', 2: '2', 3: '3'}))
self.assertTrue(
type_checker({int: [int]}, {
1: [1, 2, 3],
2: [3, 4, 5],
3: [5, 6, 7, 8, 9]
}))
self.assertFalse(type_checker([int], [1, 2, 3, '4']))
self.assertFalse(type_checker({int: str}, {1: '1', 2: '2', 3: 3}))
self.assertFalse(
type_checker({int: [int]}, {
1: [1, 2, 3],
2: [3, 4, 5],
3: [5, 6, 7, 8, '9']
}))
self.assertFalse(type_checker({str: int}, {'a': 1, 'b': '2'}))
self.assertTrue(type_checker((int, ), (1, )))
self.assertFalse(type_checker((int, ), (1, 2)))
self.assertTrue(type_checker((int, str), (1, "a")))
self.assertTrue(type_checker((int, (str, )), (1, ("a", ))))
self.assertFalse(type_checker((int, (str, )), (1, ("a", "b"))))
# Just make coverage happing!!!
self.assertFalse(type_checker({int}, {1}))
