Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_it_should_parse_json_arguments(self):
attrs = {"string": fields.Str(), "integer": fields.List(fields.Int())}
request = make_json_request({"string": "value", "integer": [1, 2]})
parsed = parser.parse(attrs, request)
assert parsed["integer"] == [1, 2]
assert parsed["string"] == value
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}
def test_it_should_get_multiple_values(self):
query = [(name, value), (name, value)]
field = fields.List(fields.Field())
request = make_get_request(query)
result = parser.parse_querystring(request, name, field)
assert result == [value, value]
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."
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."
'subset_document_id': wfields.List(wfields.Int()),
})
@marshal_with(SearchResponseSchema())
def post(self, **args):
parent_id = args['parent_id']
subset_document_id = args.pop('subset_document_id', None)
model = _SearchWrapper(cache_dir=self._cache_dir, parent_id=parent_id)
if 'query' in args and 'query_document_id' not in args:
query = args['query']
scores = model.search(query, metric=args['metric'])
elif 'query' not in args and 'query_document_id' in args:
query = pd.DataFrame([{'document_id': args['query_document_id']}])
res_q = model.fe.db_.search(query, drop=False)
scores = model.search(None,
internal_id=res_q.internal_id.values[0],
corpus = List(Str(), missing=None),
field_id = List(Int(), missing=None),
subfield_id = List(Int(), missing=None),
institution_id = List(Int(), missing=None),
state = List(Str(), missing=None),
country = List(Str(), missing=None),
))
def api_ranks(args):
"""
Ranking API.
"""
filters = {f: args[f] for f in [
'corpus',
'field_id',
from __future__ import unicode_literals
from marshmallow_enum import EnumField
from webargs import fields
from indico.legacy.common.cache import GenericCache
from indico.modules.rb.models.reservations import RepeatFrequency
_cache = GenericCache('Rooms')
search_room_args = {
'capacity': fields.Int(),
'equipment': fields.List(fields.Str()),
'features': fields.List(fields.Str(), data_key='feature'),
'favorite': fields.Bool(),
'mine': fields.Bool(),
'text': fields.Str(),
'division': fields.Str(),
'start_dt': fields.DateTime(),
'end_dt': fields.DateTime(),
'repeat_frequency': EnumField(RepeatFrequency),
'repeat_interval': fields.Int(missing=0),
'building': 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)
}
'room_ids': fields.List(fields.Int(), missing=[]),
'start_date': fields.Date(required=True),
'end_date': fields.Date(required=True),
'reason': fields.Str(required=True),
'allowed': PrincipalList(allow_groups=True, required=True),
})
def _process(self, args):
blocking = create_blocking(created_by=session.user, **args)
return jsonify(blockings_schema.dump(blocking, many=False))