def __get_opts_fields(self, declared_fields): '''Return only those field_name:field_obj pairs specified in the fields option of class Meta. ''' # Convert obj to a dict if not isinstance(self.opts.fields, (list, tuple)): raise ValueError("`fields` option must be a list or tuple.") obj_marshallable = utils.to_marshallable_type(self.obj) if isinstance(obj_marshallable, (list, tuple)): # Homogeneous list if len(obj_marshallable) > 0: obj_dict = utils.to_marshallable_type(obj_marshallable[0]) else: # Nothing to serialize return declared_fields else: obj_dict = obj_marshallable new = OrderedDict() for key in self.opts.fields: if key in declared_fields: new[key] = declared_fields[key] else: try: attribute_type = type(obj_dict[key]) except KeyError: raise AttributeError( '"{0}" is not a valid field for {1}.'.format(key, self.obj)) # map key -> field (default to Raw) new[key] = self.TYPE_MAPPING.get(attribute_type, fields.Raw)() return new
def test_marshallable(self): class ObjContainer(object): contained = {"foo": 1} def __marshallable__(self): return self.contained obj = ObjContainer() assert_equal(utils.to_marshallable_type(obj), {"foo": 1})
def test_marshallable(): class ObjContainer(object): contained = {'foo': 1} def __marshallable__(self): return self.contained obj = ObjContainer() assert utils.to_marshallable_type(obj) == {'foo': 1}
def __filter_fields(self, field_names, obj, many=False): """Return only those field_name:field_obj pairs specified by ``field_names``. :param set field_names: Field names to include in the final return dictionary. :returns: An dict of field_name:field_obj pairs. """ # Convert obj to a dict obj_marshallable = utils.to_marshallable_type(obj, field_names=field_names) if obj_marshallable and many: try: # Homogeneous collection obj_prototype = obj_marshallable[0] except IndexError: # Nothing to serialize return self.declared_fields obj_dict = utils.to_marshallable_type(obj_prototype, field_names=field_names) else: obj_dict = obj_marshallable ret = self.dict_class() for key in field_names: if key in self.declared_fields: ret[key] = self.declared_fields[key] else: if obj_dict: try: attribute_type = type(obj_dict[key]) except KeyError: raise AttributeError( '"{0}" is not a valid field for {1}.'.format( key, obj)) field_obj = self.TYPE_MAPPING.get(attribute_type, fields.Field)() else: # Object is None field_obj = fields.Field() # map key -> field (default to Raw) ret[key] = field_obj return ret
def test_to_marshallable_type(self): class Foo(object): CLASS_VAR = 'bar' def __init__(self): self.attribute = 'baz' @property def prop(self): return 42 obj = Foo() u_dict = utils.to_marshallable_type(obj) assert_equal(u_dict['CLASS_VAR'], Foo.CLASS_VAR) assert_equal(u_dict['attribute'], obj.attribute) assert_equal(u_dict['prop'], obj.prop)
def __filter_fields(self, field_names, obj): """Return only those field_name:field_obj pairs specified by ``field_names``. :param set field_names: Field names to include in the final return dictionary. :returns: An OrderedDict of field_name:field_obj pairs. """ # Convert obj to a dict obj_marshallable = utils.to_marshallable_type(obj, field_names=field_names) if obj_marshallable and self.many: try: # Homogeneous collection obj_prototype = obj_marshallable[0] except IndexError: # Nothing to serialize return self.declared_fields obj_dict = utils.to_marshallable_type(obj_prototype, field_names=field_names) else: obj_dict = obj_marshallable ret = OrderedDict() for key in field_names: if key in self.declared_fields: ret[key] = self.declared_fields[key] else: if obj_dict: try: attribute_type = type(obj_dict[key]) except KeyError: raise AttributeError( '"{0}" is not a valid field for {1}.'.format(key, obj)) field_obj = self.TYPE_MAPPING.get(attribute_type, fields.Field)() else: # Object is None field_obj = fields.Field() # map key -> field (default to Raw) ret[key] = field_obj return ret
def test_to_marshallable_type(): class Foo(object): CLASS_VAR = 'bar' def __init__(self): self.attribute = 'baz' @property def prop(self): return 42 obj = Foo() u_dict = utils.to_marshallable_type(obj) assert u_dict['CLASS_VAR'] == Foo.CLASS_VAR assert u_dict['attribute'] == obj.attribute assert u_dict['prop'] == obj.prop
def test_to_marshallable_type_none(): assert utils.to_marshallable_type(None) is None
def test_to_marshallable_type_with_namedtuple(): p = PointNT(24, 42) result = utils.to_marshallable_type(p) assert result['x'] == p.x assert result['y'] == p.y
def _serialize(self, value, attr, obj): try: data = utils.to_marshallable_type(obj) return self.src_str.format(**data) except (TypeError, IndexError) as error: raise MarshallingError(getattr(self, 'error', None) or error)
def test_to_marshallable_type_list(): assert utils.to_marshallable_type(['foo', 'bar']) == ['foo', 'bar']
def test_to_marshallable_type_generator(): gen = (e for e in ['foo', 'bar']) assert utils.to_marshallable_type(gen) == ['foo', 'bar']
def test_to_marshallable_type_none(self): assert_equal(utils.to_marshallable_type(None), None)
def output(self, key, obj): try: data = utils.to_marshallable_type(obj) return self.src_str.format(**data) except (TypeError, IndexError) as error: raise MarshallingError(error)
def _serialize(self, value, attr, obj): try: data = utils.to_marshallable_type(obj) return self.src_str.format(**data) except (TypeError, IndexError) as error: self.fail('format')
def test_to_marshallable_type(self): u = User("Foo", "*****@*****.**") assert_equal(utils.to_marshallable_type(u), u.__dict__)
def test_to_marshallable_type_list(self): assert_equal(utils.to_marshallable_type(['foo', 'bar']), ['foo', 'bar'])
def test_to_marshallable_type_generator(self): gen = (e for e in ['foo', 'bar']) assert_equal(utils.to_marshallable_type(gen), ['foo', 'bar'])