class ListSchema(Schema): foos = fields.List(fields.Str())
import json from django.http import HttpResponse from django.views.generic import View import marshmallow as ma from webargs import fields, ValidationError from webargs.djangoparser import parser, use_args, use_kwargs from webargs.core import MARSHMALLOW_VERSION_INFO hello_args = { 'name': fields.Str(missing='World', validate=lambda n: len(n) >= 3), } hello_multiple = {'name': fields.List(fields.Str())} class HelloSchema(ma.Schema): name = fields.Str(missing='World', validate=lambda n: len(n) >= 3) strict_kwargs = {'strict': True} if MARSHMALLOW_VERSION_INFO[0] < 3 else {} hello_many_schema = HelloSchema(many=True, **strict_kwargs) def json_response(data, **kwargs): return HttpResponse(json.dumps(data), content_type='application/json', **kwargs) def echo(request): try:
from webargs import fields, validate from webargs.flaskparser import use_args from optimizers import standard as optimize_standard, OptimizeError from lineups import LineupError app = Flask(__name__) cors = CORS(app) version_types = [ '0.2-lin-reg-dfn-min', '0.2-lin-reg-rg-min', '0.1-dfn', '0.1-rg'] optimize_args = { "date": fields.Date(required=True), "site": fields.String(require=True, validate=validate.OneOf(["fd"])), "exclude": fields.List(fields.Int(), missing=[]), "include": fields.List(fields.Int(), missing=[]), "version": fields.String(require=True, validate=validate.OneOf(version_types)), } # Return validation errors as JSON @app.errorhandler(422) @app.errorhandler(400) def handle_error(err): headers = err.data.get("headers", None) messages = err.data.get("messages", ["Invalid request."]) if headers: return jsonify({"errors": messages}), err.code, headers else: return jsonify({"errors": messages}), err.code
return { 'per_page': per_page, 'last_index': field( missing=None, description=description or 'Index of last result from previous page', ), } names = { 'q': fields.List(fields.Str, required=True, description='Name (candidate or committee) to search for'), } query = { 'q': fields.Str(required=False, description='Text to search legal documents for.'), 'from_hit': fields.Int(required=False, description='Get results starting from this index.'), 'hits_returned': fields.Int(required=False, description='Number of results to return (max 10).'), 'type': fields.Str(required=False,
class TransactionInputEndpoint(Resource): """ Class implementing transaction input API """ args_transaction = {'transaction_ids': fields.List(fields.Integer())} @use_kwargs(args_transaction) def get(self, transaction_ids): """ Method for GET request :param transaction_ids: """ try: transaction_ids = list(set(list(transaction_ids))) request = {"transaction_ids": transaction_ids} response = {} # Validate User Input validations_result = validate_transaction_ids(transaction_ids) if validations_result is not None and len(validations_result) > 0: response = { "ResponseCode": ResponseCodes.InvalidRequestParameter.value, "ResponseDesc": ResponseCodes.InvalidRequestParameter.name, "ValidationErrors": validations_result } else: transaction_inputs_dict = {} for transaction_id in sorted(transaction_ids): transaction_inputs = db_session.query( TransactionInput).filter( TransactionInput.transaction_id == transaction_id).all() previous_output_ids = [] trans_input_list = [] total_num_of_inputs = 0 for transaction_input in transaction_inputs: trans_input_as_dict = serialize_transaction_input( transaction_input) prev_output_id = trans_input_as_dict[ "PreviousTransactionOutputId"] if prev_output_id is not None: prev_out = db_session.query(Output).filter( Output.id == prev_output_id).one() trans_input_as_dict["Value"] = prev_out.value previous_output_ids.append(prev_output_id) prev_addresses = [] prev_address = db_session.query( OutputAddress, Address).filter( OutputAddress.output_id == prev_output_id ).filter(Address.id == OutputAddress.address_id).all() for address in prev_address: address_as_dict = serialize_address( address.Address) prev_addresses.append(address_as_dict) trans_input_as_dict[ "InputAddresses"] = prev_addresses trans_input_list.append(trans_input_as_dict) total_num_of_inputs = total_num_of_inputs + 1 transaction_inputs_dict[transaction_id] = { "NumberOfInputs": total_num_of_inputs, "TransactionInputs": trans_input_list } if total_num_of_inputs > 0: response = { 'ResponseCode': ResponseCodes.Success.value, 'ResponseDesc': ResponseCodes.Success.name, 'TransactionInputData': transaction_inputs_dict } else: response = { "ResponseCode": ResponseCodes.NoDataFound.value, "ResponseDesc": ResponseCodes.NoDataFound.name, "ErrorMessage": ResponseDescriptions.NoDataFound.value } except Exception as ex: response = { "ResponseCode": ResponseCodes.InternalError.value, "ResponseDesc": ResponseCodes.InternalError.name, "ErrorMessage": str(ex) } finally: return response
import asyncio import aiohttp import marshmallow as ma from aiohttp import web from aiohttp.web import json_response from webargs import fields from webargs.aiohttpparser import parser, use_args, use_kwargs from webargs.core import MARSHMALLOW_VERSION_INFO, json hello_args = { "name": fields.Str(missing="World", validate=lambda n: len(n) >= 3) } hello_multiple = {"name": fields.List(fields.Str())} class HelloSchema(ma.Schema): name = fields.Str(missing="World", validate=lambda n: len(n) >= 3) if MARSHMALLOW_VERSION_INFO[0] < 3: class Meta: strict = True strict_kwargs = {"strict": True} if MARSHMALLOW_VERSION_INFO[0] < 3 else {} hello_many_schema = HelloSchema(many=True, **strict_kwargs) # variant which ignores unknown fields exclude_kwargs = ({ "strict": True
"citizen_id": fields.Int(required=True), "town": fields.Str(required=True), "street": fields.Str(required=True), "building": fields.Str(required=True), "apartment": fields.Int(required=True), "name": fields.Str(required=True), "birth_date": fields.Str( validate=partial(check_valid_date, date_format=config['birth_date_format']), required=True ), "gender": fields.Str( validate=validate.OneOf(config['valid_genders']), required=True ), "relatives": fields.List( fields.Int(), required=True ) } recieve_import_data_args = { "citizens": fields.List( fields.Nested(citizen_info, required=True), required=True ) } update_citizen_info_args = { "town": fields.Str(), "street": fields.Str(), "building": fields.Str(),
from pyramid.config import Configurator import marshmallow as ma from webargs import fields, ValidationError from webargs.pyramidparser import parser, use_args, use_kwargs hello_args = { 'name': fields.Str(missing='World', validate=lambda n: len(n) >= 3), } hello_multiple = { 'name': fields.List(fields.Str()) } class HelloSchema(ma.Schema): name = fields.Str(missing='World', validate=lambda n: len(n) >= 3) hello_many_schema = HelloSchema(strict=True, many=True) def echo(request): return parser.parse(hello_args, request) def echo_query(request): return parser.parse(hello_args, request, locations=('query', )) @use_args(hello_args) def echo_use_args(request, args): return args @use_args({'value': fields.Int()}, validate=lambda args: args['value'] > 42) def echo_use_args_validated(request, args): return args
def make_multi_sort_args(default=None, validator=None, default_hide_null=False, default_reverse_nulls=True, default_nulls_only=False): args = make_sort_args(default, validator, default_hide_null, default_reverse_nulls, default_nulls_only) args['sort'] = fields.List(fields.Str, missing=default, validate=validator, required=False, allow_none=True, description='Provide a field to sort by. Use - for descending order.',) return args
class AuthorSchema(ma.Schema): name = fields.Str(missing="World", validate=lambda n: len(n) >= 3) works = fields.List(fields.Str())
def test_it_should_parse_multiple_arg_required(self): args = {"foo": fields.List(fields.Int(), required=True)} request = make_json_request({}) msg = "Missing data for required field." with pytest.raises(tornado.web.HTTPError, match=msg): parser.parse(args, request)
class CustomSchema(ma.Schema): works = fields.List( fields.Nested({ "author": fields.Str(), "workname": fields.Str() }))
from webargs import fields from project.api.models import db, WebsiteDuplicated from project.api.schemas import OneOf, length_validator from project.api.exceptions.customs import RecordNotFound def id_in_db(id): if not db.session.query(WebsiteDuplicated).filter_by(id=id).first(): raise RecordNotFound('无此数据') delete_args = { 'ids': fields.List(fields.Int(validate=id_in_db), required=True) } restore_args = { 'ids': fields.List(fields.Int(validate=id_in_db), required=True) } query_args = { 'page': fields.Int(missing=0), 'size': fields.Int(missing=25, validate=length_validator), 'order': fields.Nested({ 'field': fields.Str(missing='create_time'), 'direction': fields.Str(missing='desc', validate=OneOf(['asc', 'desc'])) }, missing={}), 'filter': fields.Nested({ 'url': fields.Str(), 'title': fields.Str(), 'effective_url': fields.Str()
def test_int_list_allowed_missing(web_request, parser): args = {"name": fields.List(fields.Int())} web_request.json = {} result = parser.parse(args, web_request) assert result == {}
def test_multiple_arg_required_with_int_conversion(web_request, parser): args = {'ids': fields.List(fields.Int(), required=True)} web_request.json = {'fakedata': True} with pytest.raises(ValidationError) as excinfo: parser.parse(args, web_request) assert excinfo.value.messages == {'ids': ['Missing data for required field.']}
query_recycler_schema = { 'start': fields.Int(missing=0), 'length': fields.Int(missing=15, validate=length_validator), 'order': fields.Nested( { 'field': fields.Str(missing='create_time'), 'direction': fields.Str(missing='desc', validate=OneOf(['asc', 'desc'])) }, missing={}), 'fields': fields.List(fields.Str()), 'filter': fields.Nested( { 'url': fields.Str(missing=""), 'title': fields.Str(missing=""), 'domain': fields.Str(missing=""), 'host_dept': fields.Str(missing="") }, missing={}) } delete_website_recycler_args = { 'website_recycler_ids': fields.List(fields.Int(validate=website_id_in_db), required=True) }
def test_type_conversion_with_multiple_required(web_request, parser): web_request.json = {} args = {'ids': fields.List(fields.Int(), required=True)} with pytest.raises(ValidationError) as excinfo: parser.parse(args, web_request) assert 'Missing data for required field.' in str(excinfo)
def test_parse_required_list(parser, web_request): web_request.json = {'bar': []} args = {'foo': fields.List(fields.Field(), required=True)} with pytest.raises(ValidationError) as excinfo: parser.parse(args, web_request) assert excinfo.value.messages['foo'][0] == 'Missing data for required field.'
from . import messages from . import util from .download_file_and_redirect import download_file_and_redirect from .git_progress import Progress from .pull_from_remote import pull_from_remote from .config import Config thread_pool = ThreadPoolExecutor(max_workers=4) url_args = { 'file_url': fields.Str(), 'domain': fields.Str(), 'account': fields.Str(), 'repo': fields.Str(), 'branch': fields.Str(), 'path': fields.List(fields.Str()), 'notebook_path': fields.Str(), } class LandingHandler(IPythonHandler): """ Landing page containing option to download. Option 1 -------- ?file_url=public_file_url Example: ?file_url=http://localhost:8000/README.md
def test_parse_list_allow_none(parser, web_request): web_request.json = {'foo': None} args = {'foo': fields.List(fields.Field(allow_none=True), allow_none=True)} assert parser.parse(args, web_request) == {'foo': None}
@app.route("/orders/<int:order_id>", methods=["GET"]) @marshal_with(OrderSchema()) def route_order_get_by_id(order_id): order = Order.query.filter(Order.id == order_id).first() if not order: return abort(400, "The order with id: {0} does not exists".format(order_id)) return order @app.route("/orders", methods=["POST"]) @marshal_with(OrderSchema()) @use_kwargs({ "buyer_id": fields.Int(), "seller_id": fields.Int(), "line_items": fields.List(fields.Dict()), }) def route_order_create(buyer_id, seller_id, line_items): order = Order(buyer_id=buyer_id, seller_id=seller_id, line_items=[]) total = 0 for li in line_items: product = Product.query.filter(Product.id == li['product_id']).first() total += li['quantity'] * product.price item = LineItem(product=product, order=order, quantity=li['quantity'], unit_price=li['quantity'] * product.price) order.line_items.append(item) order.total = total db.session.add(order) db.session.commit()
def test_parse_list_dont_allow_none(parser, web_request): web_request.json = {'foo': None} args = {'foo': fields.List(fields.Field(), allow_none=False)} with pytest.raises(ValidationError) as excinfo: parser.parse(args, web_request) assert excinfo.value.messages['foo'][0] == 'Field may not be null.'
'bounds': fields.Nested({ 'north_east': fields.Nested({'lat': fields.Float(), 'lng': fields.Float()}, required=True), 'south_west': fields.Nested({'lat': fields.Float(), 'lng': fields.Float()}, required=True) }, required=True) } _create_args = { **_base_args, 'name': fields.String(required=True) } _update_args = { 'areas': fields.List( fields.Nested({ **_base_args, 'id': fields.Int(required=True), 'name': fields.String() }, required=True) ) } class RHMapAreas(RHRoomBookingAdminBase): @use_args(_create_args) def _process_POST(self, args): create_area(**args) return map_areas_schema.jsonify(MapArea.query) @use_kwargs(_update_args) def _process_PATCH(self, areas): for area in areas:
def test_parse_missing_list(parser, web_request): web_request.json = {} args = {'things': fields.List(fields.Field())} assert parser.parse(args, web_request) == {}
from indico.modules.rb.models.rooms import Room from indico.modules.rb_new.schemas import aspects_schema, map_rooms_schema, room_details_schema, rooms_schema from indico.modules.rb_new.util import ( get_buildings, get_equipment_types, get_existing_room_occurrences, get_rooms_availability, get_suggestions, group_by_occurrence_date, has_managed_rooms, search_for_rooms, serialize_occurrences) from indico.modules.users.models.users import User from indico.util.date_time import iterdays from indico.util.i18n import _ from indico.web.util import jsonify_data NUM_SUGGESTIONS = 5 search_room_args = { 'capacity': fields.Int(), 'equipment': fields.List(fields.Str()), 'favorite': fields.Bool(), 'mine': fields.Bool(), 'text': fields.Str(), 'start_dt': fields.DateTime(), 'end_dt': fields.DateTime(), 'repeat_frequency': EnumField(RepeatFrequency), 'repeat_interval': fields.Int(missing=0), 'building': fields.Str(), 'floor': fields.Str(), 'sw_lat': fields.Float(validate=lambda x: -90 <= x <= 90), 'sw_lng': fields.Float(validate=lambda x: -180 <= x <= 180), 'ne_lat': fields.Float(validate=lambda x: -90 <= x <= 90), 'ne_lng': fields.Float(validate=lambda x: -180 <= x <= 180) }
def test_get_value_multidict(input_dict): field = fields.List(fields.Str()) assert get_value(input_dict, 'foos', field) == ['a', 'b']
blueprint = Blueprint("inspirehep_curation", __name__, url_prefix="/curation") parser = FlaskParser() @parser.error_handler def handle_error(error, req, schema, error_status_code, error_headers): message = f"Incorrect input type for fields: {''.join(error.field_names)}" abort(400, message) @blueprint.route("/literature/<int:pid_value>/keywords", methods=["PUT"]) @login_required_with_roles([Roles.cataloger.value]) @parser.use_args( { "_desy_bookkeeping": fields.Dict(required=False), "keywords": fields.List(fields.String, required=False), "energy_ranges": fields.List(fields.String, required=False), }, locations=("json",), ) def add_keywords(args, pid_value): keywords = args.get("keywords") desy_bookkeeping = args.get("_desy_bookkeeping") energy_ranges = args.get("energy_ranges") if not any([keywords, desy_bookkeeping, energy_ranges]): return ( jsonify( success=False, message="None of required fields was passed", ), 400,
def test_int_list_allowed_missing(web_request, parser): args = {'name': fields.List(fields.Int())} web_request.json = {'fakedata': True} result = parser.parse(args, web_request) assert result == {}
def test_it_should_parse_multiple_arg_required(self): args = {'foo': fields.List(fields.Int(), required=True)} request = make_json_request({}) with pytest.raises(tornado.web.HTTPError) as excinfo: parser.parse(args, request) assert 'Missing data for required field.' in str(excinfo)
def test_parse_empty_list(parser, web_request): web_request.json = {"things": []} args = {"things": fields.List(fields.Field())} assert parser.parse(args, web_request) == {"things": []}