def _serialize(self, nested_obj, attr, obj): # Load up the schema first. This allows a RegistryError to be raised # if an invalid schema name was passed schema = self.schema if nested_obj is None: return None if self.many and utils.is_iterable_but_not_string(nested_obj): nested_obj = list(nested_obj) if not self.__updated_fields: schema._update_fields(obj=nested_obj, many=self.many) self.__updated_fields = True ret, errors = schema.dump(nested_obj, many=self.many, update_fields=not self.__updated_fields) if isinstance(self.only, basestring): # self.only is a field name only_field = self.schema.fields[self.only] key = ''.join( [self.schema.prefix or '', only_field.dump_to or self.only]) if self.many: return utils.pluck(ret, key=key) else: return ret[key] if errors: raise ValidationError(errors, data=ret) return ret
def __init__(self, default=None, attribute=None, error=None, validate=None, required=False, **metadata): self.default = default self.attribute = attribute if error: warnings.warn('The error parameter is deprecated. Raise a ' 'marshmallow.ValidationError in your validators ' 'instead.', category=DeprecationWarning) self.error = error self.validate = validate if utils.is_iterable_but_not_string(validate): if not utils.is_generator(validate): self.validators = validate else: self.validators = [i for i in validate()] elif callable(validate): self.validators = [validate] elif validate is None: self.validators = [] else: raise ValueError("The 'validate' parameter must be a callable " 'or a collection of callables.') self.required = required self.metadata = metadata self._creation_index = Field._creation_index Field._creation_index += 1 self.parent = FieldABC.parent
def pedido_get_list(self): offset = int(self.request.GET.get('start', 0)) limit = int(self.request.GET.get('size', 10)) sort = self.request.GET.get('sort', 'finalizacao') order = self.request.GET.get('order', 'asc') cliente = self.request.GET.get('cliente') pedidos = Pedido.list(self.current_user.empresa_id, offset, limit, sort, order, cliente) total = Pedido.total(self.current_user.empresa_id, cliente)[0] schema = PedidoSchema(many=is_iterable_but_not_string(pedidos), strict=True) schema.context['user'] = self.request.user result = schema.dump(pedidos) if pedidos: res = dumps(dict( data=dict(code=200, totalItems=total, pedidos=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def __init__(self, default=missing_, attribute=None, load_from=None, error=None, validate=None, required=False, allow_none=False, load_only=False, dump_only=False, missing=missing_, **metadata): self.default = default self.attribute = attribute self.load_from = load_from # this flag is used by Unmarshaller if error: warnings.warn('The error parameter is deprecated. Raise a ' 'marshmallow.ValidationError in your validators ' 'instead.', category=DeprecationWarning) self.error = error self.validate = validate if utils.is_iterable_but_not_string(validate): if not utils.is_generator(validate): self.validators = validate else: self.validators = list(validate) elif callable(validate): self.validators = [validate] elif validate is None: self.validators = [] else: raise ValueError("The 'validate' parameter must be a callable " "or a collection of callables.") self.required = required self.allow_none = allow_none self.load_only = load_only self.dump_only = dump_only self.missing = missing self.metadata = metadata self._creation_index = Field._creation_index Field._creation_index += 1 self.parent = FieldABC.parent
def dump(self, obj, many=None, update_fields=True, **kwargs): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :param bool update_fields: Whether to update the schema's field classes. Typically set to `True`, but may be `False` when serializing a homogenous collection. This parameter is used by `fields.Nested` to avoid multiple updates. :return: A tuple of the form (``data``, ``errors``) :rtype: `MarshalResult`, a `collections.namedtuple` .. versionadded:: 1.0.0 """ many = self.many if many is None else bool(many) if not many and utils.is_collection( obj) and not utils.is_keyed_tuple(obj): warnings.warn( 'Implicit collection handling is deprecated. Set ' 'many=True to serialize a collection.', category=DeprecationWarning) if many and utils.is_iterable_but_not_string(obj): obj = list(obj) processed_obj = self._invoke_dump_processors(PRE_DUMP, obj, many, original_data=obj) if update_fields: self._update_fields(processed_obj, many=many) try: preresult = self._marshal( processed_obj, self.fields, many=many, # TODO: Remove self.__accessor__ in a later release accessor=self.get_attribute or self.__accessor__, dict_class=self.dict_class, index_errors=self.opts.index_errors, **kwargs) except ValidationError as error: errors = self._marshal.errors preresult = error.data if self.strict: raise error else: errors = {} result = self._postprocess(preresult, many, obj=obj) result = self._invoke_dump_processors(POST_DUMP, result, many, original_data=obj) return MarshalResult(result, errors)
def dump(self, obj, *, many=None): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :return: A dict of serialized data :rtype: dict .. versionadded:: 1.0.0 .. versionchanged:: 3.0.0b7 This method returns the serialized data rather than a ``(data, errors)`` duple. A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised if ``obj`` is invalid. """ error_store = ErrorStore() errors = {} many = self.many if many is None else bool(many) if many and is_iterable_but_not_string(obj): obj = list(obj) if self._has_processors(PRE_DUMP): try: processed_obj = self._invoke_dump_processors( PRE_DUMP, obj, many=many, original_data=obj ) except ValidationError as error: errors = error.normalized_messages() result = None else: processed_obj = obj if not errors: result = self._serialize( processed_obj, fields_dict=self.fields, error_store=error_store, many=many, accessor=self.get_attribute, dict_class=self.dict_class, index_errors=self.opts.index_errors, ) errors = error_store.errors if not errors and self._has_processors(POST_DUMP): try: result = self._invoke_dump_processors( POST_DUMP, result, many=many, original_data=obj ) except ValidationError as error: errors = error.normalized_messages() if errors: exc = ValidationError(errors, data=obj, valid_data=result) # User-defined error handler self.handle_error(exc, obj, many=many) raise exc return result
def __init__( self, default=missing_, attribute=None, load_from=None, dump_to=None, error=None, validate=None, required=False, allow_none=None, load_only=False, dump_only=False, missing=missing_, error_messages=None, **metadata ): self.default = default self.attribute = attribute self.load_from = load_from # this flag is used by Unmarshaller self.dump_to = dump_to # this flag is used by Marshaller self.validate = validate if utils.is_iterable_but_not_string(validate): if not utils.is_generator(validate): self.validators = validate else: self.validators = list(validate) elif callable(validate): self.validators = [validate] elif validate is None: self.validators = [] else: raise ValueError( "The 'validate' parameter must be a callable " "or a collection of callables." ) self.required = required # If missing=None, None should be considered valid by default if allow_none is None: if missing is None: self.allow_none = True else: self.allow_none = False else: self.allow_none = allow_none self.load_only = load_only self.dump_only = dump_only self.missing = missing self.metadata = metadata self._creation_index = Field._creation_index Field._creation_index += 1 # Collect default error message from self and parent classes messages = {} for cls in reversed(self.__class__.__mro__): messages.update(getattr(cls, "default_error_messages", {})) messages.update(error_messages or {}) self.error_messages = messages
def __init__(self, default=missing_, attribute=None, load_from=None, error=None, validate=None, required=False, allow_none=False, load_only=False, dump_only=False, missing=missing_, error_messages=None, **metadata): self.default = default self.attribute = attribute self.load_from = load_from # this flag is used by Unmarshaller self.validate = validate if utils.is_iterable_but_not_string(validate): if not utils.is_generator(validate): self.validators = validate else: self.validators = list(validate) elif callable(validate): self.validators = [validate] elif validate is None: self.validators = [] else: raise ValueError("The 'validate' parameter must be a callable " "or a collection of callables.") if isinstance(required, basestring): warnings.warn( 'Passing a string for `required` is deprecated. Pass ' '{"required": "Your message"} to `error_messages` instead.', DeprecationWarning) self.required = required if isinstance(allow_none, basestring): warnings.warn( 'Passing a string for `allow_none` is deprecated. Pass ' '{"null": "Your message"} to `error_messages` instead.', DeprecationWarning) self.allow_none = allow_none self.load_only = load_only self.dump_only = dump_only self.missing = missing self.metadata = metadata self._creation_index = Field._creation_index Field._creation_index += 1 self.parent = FieldABC.parent # Collect default error message from self and parent classes messages = {} for cls in reversed(self.__class__.__mro__): messages.update(getattr(cls, 'default_error_messages', {})) messages.update(error_messages or {}) self.error_messages = messages
def dump(self, obj, many=None, update_fields=True, **kwargs): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :param bool update_fields: Whether to update the schema's field classes. Typically set to `True`, but may be `False` when serializing a homogenous collection. This parameter is used by `fields.Nested` to avoid multiple updates. :return: A tuple of the form (``data``, ``errors``) :rtype: `MarshalResult`, a `collections.namedtuple` .. versionadded:: 1.0.0 """ many = self.many if many is None else bool(many) if not many and utils.is_collection(obj) and not utils.is_keyed_tuple(obj): warnings.warn('Implicit collection handling is deprecated. Set ' 'many=True to serialize a collection.', category=DeprecationWarning) if many and utils.is_iterable_but_not_string(obj): obj = list(obj) processed_obj = self._invoke_dump_processors(PRE_DUMP, obj, many, original_data=obj) if update_fields: self._update_fields(processed_obj, many=many) try: preresult = self._marshal( processed_obj, self.fields, many=many, # TODO: Remove self.__accessor__ in a later release accessor=self.get_attribute or self.__accessor__, dict_class=self.dict_class, index_errors=self.opts.index_errors, **kwargs ) except ValidationError as error: errors = self._marshal.errors preresult = error.data if self.strict: raise error else: errors = {} result = self._postprocess(preresult, many, obj=obj) result = self._invoke_dump_processors(POST_DUMP, result, many, original_data=obj) return MarshalResult(result, errors)
def build_validator_list(src): if src is None: return [] if utils.is_iterable_but_not_string(src): if utils.is_generator(src): return list(src) else: return src elif callable(src): return [src] else: raise ValueError("The 'validate' parameter must be a callable " "or a collection of callables.")
def __init__(self, default=missing_, attribute=None, load_from=None, dump_to=None, error=None, validate=None, required=False, allow_none=None, load_only=False, dump_only=False, missing=missing_, error_messages=None, **metadata): self.default = default self.attribute = attribute self.load_from = load_from # this flag is used by Unmarshaller self.dump_to = dump_to # this flag is used by Marshaller self.validate = validate if utils.is_iterable_but_not_string(validate): if not utils.is_generator(validate): self.validators = validate else: self.validators = list(validate) elif callable(validate): self.validators = [validate] elif validate is None: self.validators = [] else: raise ValueError("The 'validate' parameter must be a callable " "or a collection of callables.") self.required = required # If missing=None, None should be considered valid by default if allow_none is None: if missing is None: self.allow_none = True else: self.allow_none = False else: self.allow_none = allow_none self.load_only = load_only self.dump_only = dump_only self.missing = missing self.metadata = metadata self._creation_index = Field._creation_index Field._creation_index += 1 self.parent = FieldABC.parent # Collect default error message from self and parent classes messages = {} for cls in reversed(self.__class__.__mro__): messages.update(getattr(cls, 'default_error_messages', {})) messages.update(error_messages or {}) self.error_messages = messages
def tamanho_get_list(self): tamanhos = Tamanho.list(self.current_user.empresa_id) total = Tamanho.total(self.current_user.empresa_id)[0] schema = TamanhoSchema(many=is_iterable_but_not_string(tamanhos), strict=True) result = schema.dump(tamanhos) if tamanhos: res = dumps(dict( data=dict(code=200, totalItems=total, tamanhos=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def endereco_get_list(self): cliente_hash_id = self.request.matchdict.get('cliHashid') cliente_id = get_decoded_id('clientes', cliente_hash_id, self.current_user.empresa_id) enderecos = Endereco.list(cliente_id) schema = EnderecoSchema(many=is_iterable_but_not_string(enderecos), strict=True) result = schema.dump(enderecos) if enderecos: res = dumps(dict( data=dict( code=200, enderecos=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def adicional_get_list(self): adicionais = Adicional.list(self.current_user.empresa_id) total = Adicional.total(self.current_user.empresa_id)[0] schema = AdicionalSchema(many=is_iterable_but_not_string(adicionais), strict=True) schema.context['user'] = self.request.user result = schema.dump(adicionais) if adicionais: res = dumps(dict( data=dict(code=200, totalItems=total, adicionais=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def dump(self, obj, *, many=None): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :return: A dict of serialized data :rtype: dict .. versionadded:: 1.0.0 .. versionchanged:: 3.0.0b7 This method returns the serialized data rather than a ``(data, errors)`` duple. A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised if ``obj`` is invalid. .. versionchanged:: 3.0.0rc9 Validation no longer occurs upon serialization. """ many = self.many if many is None else bool(many) if many and is_iterable_but_not_string(obj): obj = list(obj) if self._has_processors(PRE_DUMP): processed_obj = self._invoke_dump_processors(PRE_DUMP, obj, many=many, original_data=obj) else: processed_obj = obj result = self._serialize(processed_obj, many=many) if self._has_processors(POST_DUMP): result = self._invoke_dump_processors(POST_DUMP, result, many=many, original_data=obj) return result
def cliente_get_list(self): offset = int(self.request.GET.get('start', 0)) limit = int(self.request.GET.get('size', 10)) sort = self.request.GET.get('sort', 'nome') order = self.request.GET.get('order', 'asc') nome = self.request.GET.get('nome') telefone = self.request.GET.get('telefone') ativo = self.request.GET.get('ativo') q = self.request.GET.get('q', 'list') # 'q' define retorno de lista completa ou tipo select (valor/label) if q == 'select' and (nome or telefone): clientes = Cliente.select_list(self.current_user.empresa_id, limit, nome, telefone) total = len(clientes) schema = ClienteSelectSchema(many=True, strict=True) else: clientes = Cliente.list(self.current_user.empresa_id, offset, limit, sort, order, nome, ativo) total = Cliente.total(self.current_user.empresa_id, nome, ativo)[0] schema = ClienteSchema(many=is_iterable_but_not_string(clientes), strict=True) result = schema.dump(clientes) if clientes: res = dumps(dict( data=dict(code=200, totalItems=total, clientes=result.data)), ensure_ascii=False) return HTTPOk(body=res, content_type='application/json; charset=UTF-8') msg = 'Nenhum registro encontrado' res = dumps(dict(error=dict(code=404, message=msg)), ensure_ascii=False) return HTTPNotFound(body=res, content_type='application/json; charset=UTF-8')
def ensure_list(value): return value if is_iterable_but_not_string(value) else [value]
def dump(self, obj, many=None, update_fields=True): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :param bool update_fields: Whether to update the schema's field classes. Typically set to `True`, but may be `False` when serializing a homogenous collection. This parameter is used by `fields.Nested` to avoid multiple updates. :return: A dict of serialized data :rtype: dict .. versionadded:: 1.0.0 .. versionchanged:: 3.0.0b7 This method returns the serialized data rather than a ``(data, errors)`` duple. A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised if ``obj`` is invalid. """ # Callable marshalling object marshal = marshalling.Marshaller(prefix=self.prefix) errors = {} many = self.many if many is None else bool(many) if many and utils.is_iterable_but_not_string(obj): obj = list(obj) if self._has_processors(PRE_DUMP): try: processed_obj = self._invoke_dump_processors( PRE_DUMP, obj, many, original_data=obj, ) except ValidationError as error: errors = error.normalized_messages() result = None else: processed_obj = obj if not errors: if update_fields: obj_type = type(processed_obj) if obj_type not in self._types_seen: self._update_fields(processed_obj, many=many) if not isinstance(processed_obj, Mapping): self._types_seen.add(obj_type) try: result = marshal( processed_obj, self.fields, many=many, accessor=self.get_attribute, dict_class=self.dict_class, index_errors=self.opts.index_errors, ) except ValidationError as error: errors = marshal.errors result = error.data if not errors and self._has_processors(POST_DUMP): try: result = self._invoke_dump_processors( POST_DUMP, result, many, original_data=obj, ) except ValidationError as error: errors = error.normalized_messages() if errors: exc = ValidationError(errors, field_names=marshal.error_field_names, data=obj, valid_data=result, **marshal.error_kwargs) # User-defined error handler self.handle_error(exc, obj) raise exc return result
def dump(self, obj, many=None, update_fields=True, **kwargs): """Serialize an object to native Python data types according to this Schema's fields. :param obj: The object to serialize. :param bool many: Whether to serialize `obj` as a collection. If `None`, the value for `self.many` is used. :param bool update_fields: Whether to update the schema's field classes. Typically set to `True`, but may be `False` when serializing a homogenous collection. This parameter is used by `fields.Nested` to avoid multiple updates. :return: A tuple of the form (``data``, ``errors``) :rtype: `MarshalResult`, a `collections.namedtuple` .. versionadded:: 1.0.0 """ errors = {} many = self.many if many is None else bool(many) if many and utils.is_iterable_but_not_string(obj): obj = list(obj) if self._has_processors: try: processed_obj = self._invoke_dump_processors(PRE_DUMP, obj, many, original_data=obj) except ValidationError as error: errors = error.normalized_messages() result = None else: processed_obj = obj if not errors: if update_fields: obj_type = type(processed_obj) if obj_type not in self._types_seen: self._update_fields(processed_obj, many=many) if not isinstance(processed_obj, Mapping): self._types_seen.add(obj_type) try: preresult = self._marshal(processed_obj, self.fields, many=many, accessor=self.get_attribute, dict_class=self.dict_class, index_errors=self.opts.index_errors, **kwargs) except ValidationError as error: errors = self._marshal.errors preresult = error.data result = self._postprocess(preresult, many, obj=obj) if not errors and self._has_processors: try: result = self._invoke_dump_processors(POST_DUMP, result, many, original_data=obj) except ValidationError as error: errors = error.normalized_messages() if errors: exc = ValidationError(errors, field_names=self._marshal.error_field_names, fields=self._marshal.error_fields, data=obj, **self._marshal.error_kwargs) self.handle_error(exc, obj) if self.strict: raise exc return MarshalResult(result, errors)
async def async_dump(self, obj, many=None, update_fields=True, **kwargs): # Callable marshalling object marshal = Marshaller(prefix=self.prefix) errors = {} many = self.many if many is None else bool(many) if many and utils.is_iterable_but_not_string(obj): obj = list(obj) if self._has_processors: try: processed_obj = await self._async_invoke_dump_processors( ASYNC_PRE_DUMP, obj, many, original_data=obj) except ValidationError as error: errors = error.normalized_messages() result = None else: processed_obj = obj if not errors: if update_fields: obj_type = type(processed_obj) if obj_type not in self._types_seen: self._update_fields(processed_obj, many=many) if not isinstance(processed_obj, Mapping): self._types_seen.add(obj_type) try: preresult = marshal( processed_obj, self.fields, many=many, # TODO: Remove self.__accessor__ in a later release accessor=self.get_attribute or self.__accessor__, dict_class=self.dict_class, index_errors=self.opts.index_errors, **kwargs) except ValidationError as error: errors = marshal.errors preresult = error.data result = self._postprocess(preresult, many, obj=obj) if not errors and self._has_processors: try: result = await self._async_invoke_dump_processors( ASYNC_POST_DUMP, result, many, original_data=obj) except ValidationError as error: errors = error.normalized_messages() if errors: # TODO: Remove self.__error_handler__ in a later release if self.__error_handler__ and callable(self.__error_handler__): self.__error_handler__(errors, obj) exc = ValidationError(errors, field_names=marshal.error_field_names, fields=marshal.error_fields, data=obj, **marshal.error_kwargs) self.handle_error(exc, obj) if self.strict: raise exc return MarshalResult(result, errors)