def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('title', type=str, location='json') self.reqparse.add_argument('description', type=str, location='json') self.reqparse.add_argument('done', type=bool, location='json') super(GetCriteriaUsed, self).__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('title', type=str, location='json') self.reqparse.add_argument('description', type=str, location='json') self.reqparse.add_argument('done', type=bool, location='json') super(ChangePassword, self).__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() self.svc_members = flask.current_app.config['SVC_MEMBERS'] super(BookmarkAPI, self).__init__() self.reqparse.add_argument('bookmark_id', type = str, required = True, help = 'No bookmark id provided', location = 'json')
def __init__(self, *args, **kwargs): RestResource.__init__(self, *args, **kwargs) self._parser = reqparse.RequestParser() self._parser.add_argument("name", type=str) self._parser.add_argument("url", type=str)
from flask.ext.restful import reqparse, abort, Api, Resource from flask import url_for, redirect, render_template import json import string import pickle from app import app from train import gather, restart, gather_status import sys import uuid from schema.job import Job from util import parse_task_information, retrain, getLatestCheckpoint, split_examples, parse_answers from crowdjs_util import get_task_data train_parser = reqparse.RequestParser() train_parser.add_argument('event_name', type=str, required=True) train_parser.add_argument('event_definition', type=str, required=True) train_parser.add_argument('event_pos_example_1', type=str, required=True) train_parser.add_argument('event_pos_example_1_trigger', type=str, required=True) train_parser.add_argument('event_pos_example_2', type=str, required=True) train_parser.add_argument('event_pos_example_2_trigger', type=str, required=True) train_parser.add_argument('event_pos_example_nearmiss', type=str, required=True) train_parser.add_argument('event_neg_example', type=str, required=True) train_parser.add_argument('event_neg_example_nearmiss', type=str, required=True) train_parser.add_argument('budget', type=str, required=True) train_parser.add_argument('control_strategy', type=str, required=True)
def __init__(self): # journeys must have a custom authentication process ResourceUri.__init__(self, authentication=False) ResourceUtc.__init__(self) modes = ["walking", "car", "bike", "bss"] types = { "all": "All types", "best": "The best journey", "rapid": "A good trade off between duration, changes and constraint respect", 'no_train': "Journey without train", 'comfort': "A journey with less changes and walking", 'car': "A journey with car to get to the public transport", 'less_fallback_walk': "A journey with less walking", 'less_fallback_bike': "A journey with less biking", 'less_fallback_bss': "A journey with less bss", 'fastest': "A journey with minimum duration", 'non_pt_walk': "A journey without public transport, only walking", 'non_pt_bike': "A journey without public transport, only biking", 'non_pt_bss': "A journey without public transport, only bike sharing", } self.parsers = {} self.parsers["get"] = reqparse.RequestParser( argument_class=ArgumentDoc) parser_get = self.parsers["get"] parser_get.add_argument("from", type=unicode, dest="origin") parser_get.add_argument("to", type=unicode, dest="destination") parser_get.add_argument("datetime", type=date_time_format) parser_get.add_argument("datetime_represents", dest="clockwise", type=dt_represents, default=True) parser_get.add_argument("max_nb_transfers", type=int, dest="max_transfers") parser_get.add_argument("first_section_mode[]", type=option_value(modes), dest="origin_mode", action="append") parser_get.add_argument("last_section_mode[]", type=option_value(modes), dest="destination_mode", action="append") parser_get.add_argument( "max_duration_to_pt", type=int, description="maximal duration of non public transport in second") parser_get.add_argument( "max_walking_duration_to_pt", type=int, description= "maximal duration of walking on public transport in second") parser_get.add_argument( "max_bike_duration_to_pt", type=int, description="maximal duration of bike on public transport in second" ) parser_get.add_argument( "max_bss_duration_to_pt", type=int, description="maximal duration of bss on public transport in second" ) parser_get.add_argument( "max_car_duration_to_pt", type=int, description="maximal duration of car on public transport in second" ) parser_get.add_argument("walking_speed", type=float_gt_0) parser_get.add_argument("bike_speed", type=float_gt_0) parser_get.add_argument("bss_speed", type=float_gt_0) parser_get.add_argument("car_speed", type=float_gt_0) parser_get.add_argument("forbidden_uris[]", type=str, action="append") parser_get.add_argument("count", type=int) parser_get.add_argument("min_nb_journeys", type=int) parser_get.add_argument("max_nb_journeys", type=int) parser_get.add_argument("type", type=option_value(types), default="all") parser_get.add_argument("disruption_active", type=boolean, default=False) # a supprimer parser_get.add_argument("max_duration", type=int, default=3600 * 24) parser_get.add_argument("wheelchair", type=boolean, default=False) parser_get.add_argument("debug", type=boolean, default=False, hidden=True) # for retrocompatibility purpose, we duplicate (without []): parser_get.add_argument("first_section_mode", type=option_value(modes), action="append") parser_get.add_argument("last_section_mode", type=option_value(modes), action="append") parser_get.add_argument("show_codes", type=boolean, default=False, description="show more identification codes") parser_get.add_argument("traveler_type", type=option_value(acceptable_traveler_types)) parser_get.add_argument( "_override_scenario", type=str, description="debug param to specify a custom scenario") self.method_decorators.append(complete_links(self)) # manage post protocol (n-m calculation) self.parsers["post"] = deepcopy(parser_get) parser_post = self.parsers["post"] parser_post.add_argument("details", type=boolean, default=False, location="json") for index, elem in enumerate(parser_post.args): if elem.name in ["from", "to"]: parser_post.args[index].type = list parser_post.args[index].dest = elem.name parser_post.args[index].location = "json"
def __init__(self): self.reqparse = reqparse.RequestParser() self.req = OneLogin.prepare_from_flask_request(request) super(OneLogin, self).__init__()
from util import parse_task_information, retrain, getLatestCheckpoint, split_examples, parse_answers, write_model_to_file from crowdjs_util import get_task_data from ml.extractors.cnn_core.parse import parse_angli_test_data from ml.extractors.cnn_core.train import train_cnn from api.s3_util import insert_connection_into_s3 import time from api.mturk_connection.mturk_connection import MTurk_Connection from api.mturk_connection.mturk_connection_real import MTurk_Connection_Real from api.mturk_connection.mturk_connection_sim import MTurk_Connection_Sim import cPickle import numpy as np from math import sqrt experiment_parser = reqparse.RequestParser() experiment_parser.add_argument('event_name', type=str, required=True) experiment_parser.add_argument('event_definition', type=str, required=True) experiment_parser.add_argument('event_pos_example_1', type=str, required=True) experiment_parser.add_argument('event_pos_example_1_trigger', type=str, required=True) experiment_parser.add_argument('event_pos_example_2', type=str, required=True) experiment_parser.add_argument('event_pos_example_2_trigger', type=str, required=True) experiment_parser.add_argument('event_pos_example_nearmiss', type=str, required=True) experiment_parser.add_argument('event_neg_example', type=str, required=True) experiment_parser.add_argument('event_neg_example_nearmiss',
def __init__(self, is_collection, collection, *args, **kwargs): kwargs['authentication'] = False ResourceUri.__init__(self, *args, **kwargs) ResourceUtc.__init__(self) self.parsers = {} self.parsers["get"] = reqparse.RequestParser( argument_class=ArgumentDoc) parser = self.parsers["get"] parser.add_argument("start_page", type=int, default=0, description="The page where you want to start") parser.add_argument("count", type=default_count_arg_type, default=25, description="Number of objects you want on a page") parser.add_argument("depth", type=depth_argument, default=1, description="The depth of your object") parser.add_argument( "forbidden_id[]", type=unicode, description="DEPRECATED, replaced by forbidden_uris[]", dest="__temporary_forbidden_id[]", default=[], action="append") parser.add_argument("forbidden_uris[]", type=unicode, description="forbidden uris", dest="forbidden_uris[]", default=[], action="append") parser.add_argument("external_code", type=unicode, description="An external code to query") parser.add_argument("headsign", type=unicode, description="filter vehicle journeys on headsign") parser.add_argument("show_codes", type=boolean, default=False, description="show more identification codes") parser.add_argument("odt_level", type=option_value(odt_levels), default="all", description="odt level") parser.add_argument( "_current_datetime", type=date_time_format, default=datetime.utcnow(), description= "The datetime used to consider the state of the pt object" " Default is the current date and it is used for debug." " Note: it will mainly change the disruptions that concern the object" " The timezone should be specified in the format," " else we consider it as UTC") parser.add_argument( "distance", type=int, default=200, description= "Distance range of the query. Used only if a coord is in the query" ) parser.add_argument( "since", type=date_time_format, description="filters objects not valid before this date") parser.add_argument( "until", type=date_time_format, description="filters objects not valid after this date") parser.add_argument("disable_geojson", type=boolean, default=False, description="remove geojson from the response") if is_collection: parser.add_argument("filter", type=unicode, default="", description="The filter parameter") self.collection = collection self.method_decorators.insert(0, ManageError())
from application.utils import pretty_date from application.utils import frame_range_parse from application.utils import frame_range_merge from application.modules.tasks.model import Task from application.modules.managers.model import Manager from application.modules.jobs.model import Job from application.modules.projects.model import Project from application.modules.settings.model import Setting from application.modules.jobs.model import JobManagers from requests.exceptions import ConnectionError from werkzeug.datastructures import FileStorage task_parser = reqparse.RequestParser() task_parser.add_argument('id', type=int) task_parser.add_argument('status', type=str) task_parser.add_argument('log', type=str) task_parser.add_argument('time_cost', type=int) task_parser.add_argument('activity', type=str) task_parser.add_argument('taskfile', type=FileStorage, location='files') # Used on PUT request when sending individual frames. Will also be used to report # multiple frames statuses (or when sending multiple frames in a zip file). task_parser.add_argument('frames', type=str) task_parser.add_argument('frames_status', type=str) tasks_list_parser = reqparse.RequestParser() tasks_list_parser.add_argument('job_id', type=int) task_status_parser = reqparse.RequestParser()
def country_code(value, name): if len(value) == 2: return value raise ValueError("The parameter {} requires 2 letters value".format(name)) def admin_email(value, name): if EMAIL_RE_.match(value): return value raise ValueError( "The parameter {} is not valid email address".format(name)) # Request parser for cluster POST and PUT requests cluster_reqparser = reqparse.RequestParser() cluster_reqparser.add_argument("name", type=str, location="form", required=True) cluster_reqparser.add_argument("description", type=str, location="form", required=True) cluster_reqparser.add_argument("hostname_ldap_cluster", type=str, location="form", required=True) cluster_reqparser.add_argument("hostname_oxauth_cluster",
class PlanStepIndexAPIView(APIView): parser = reqparse.RequestParser() parser.add_argument('data', default='{}') parser.add_argument('implementation', choices=IMPLEMENTATION_CHOICES, required=True) parser.add_argument('order', type=int, default=0) for name in STEP_OPTIONS.keys(): parser.add_argument(name) def get(self, plan_id): plan = Plan.query.get(plan_id) if plan is None: return {"message": "plan not found"}, 404 return self.respond(list(plan.steps)) @requires_admin def post(self, plan_id): plan = Plan.query.get(plan_id) if plan is None: return {"message": "plan not found"}, 404 args = self.parser.parse_args() step = Step( plan=plan, order=args.order, implementation=args.implementation, ) data = json.loads(args.data) if not isinstance(data, dict): return {"message": "data must be a JSON mapping"}, 400 impl_cls = step.get_implementation(load=False) if impl_cls is None: return {"message": "unable to load build step implementation"}, 400 try: impl_cls(**data) except Exception: return { "message": "unable to create build step provided data" }, 400 step.data = data step.order = args.order db.session.add(step) plan.date_modified = step.date_modified db.session.add(plan) for name in STEP_OPTIONS.keys(): value = args.get(name) if value is None: continue create_or_update(ItemOption, where={ 'item_id': step.id, 'name': name, }, values={ 'value': value, }) return self.serialize(step), 201
def __init__(self): self.parser = reqparse.RequestParser() self.parser.add_argument('count', type=int, help='Count must be an integer number')
from flask import jsonify from flask.ext.restful import Resource, fields, marshal_with, marshal, reqparse from myapi import db from myapi.model.note import NoteModel from myapi.model.message import NoteMessageModel, WorkMessageModel from myapi.model.user import UserModel from myapi.model.work import WorkModel noteparser = reqparse.RequestParser() noteparser.add_argument('message', type=str, location='json', required=True) noteparser.add_argument('noteid', type=int, location='json', required=True) noteparser.add_argument('userid', type=int, location='json', required=True) note_message_result_field = { 'id': fields.Integer, 'message': fields.String, 'publishDate': fields.DateTime, 'note_id': fields.Integer, 'user_id': fields.Integer } class NoteMessage(Resource): def get(self): pass @marshal_with(note_message_result_field) def post(self): args = noteparser.parse_args() message = NoteMessageModel(args.message) db.session.add(message)
def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('content', type=unicode, location='json') super(CliffAPI, self).__init__()
from flask.ext.restful import reqparse, abort, Api, Resource from flask import url_for import json import string import pickle from app import app from util import compute_taboo_words import sys taboo_parser = reqparse.RequestParser() #taboo_parser.add_argument('old_taboo_words', type=str, required=True) taboo_parser.add_argument('old_sentence', type=str, required=True) taboo_parser.add_argument('new_sentence', type=str, required=True) taboo_parser.add_argument('task_id', type=str, required=True) taboo_parser.add_argument('requester_id', type=str, required=True) class ComputeTabooApi(Resource): def post(self): args = taboo_parser.parse_args() #old_taboo_words = args['old_taboo_words'] old_sentence = args['old_sentence'] new_sentence = args['new_sentence'] task_id = str(args['task_id']) requester_id = args['requester_id'] #print "Posting to" #print app.config['CROWDJS_PUT_TASK_DATA_URL'] #print task_id #print requester_id #sys.stdout.flush()
import json import logging from platform import system from os.path import isfile from os.path import join from os import listdir from flask import jsonify from flask.ext.restful import Resource from flask.ext.restful import reqparse from application import db from application.modules.settings.model import Setting parser = reqparse.RequestParser() parser.add_argument('blender_path_linux', type=str) parser.add_argument('blender_path_win', type=str) parser.add_argument('blender_path_osx', type=str) parser.add_argument('render_settings_path_linux', type=str) parser.add_argument('render_settings_path_win', type=str) parser.add_argument('render_settings_path_osx', type=str) parser.add_argument('group', type=str) setting_parser = reqparse.RequestParser() setting_parser.add_argument('value', type=str) class SettingsListApi(Resource): def get(self): settings = Setting.query.all() ret = {}
def __init__(self): self.reqparse = reqparse.RequestParser() super(AccountConfigGet, self).__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() super(Google, self).__init__()
#!/usr/bin/env python # encoding: utf-8 """ File name: session.py Function Des: ... ~~~~~~~~~~ author: Jerry <*****@*****.**> <http://www.skyduy.com> """ from flask.ext.restful import reqparse # ------------ login parser ------------ login_parser = reqparse.RequestParser() login_parser.add_argument( 'username', dest='username', type=str, location='form', required=True, help='This is username', ) login_parser.add_argument( 'password', dest='password', type=str, location='form', required=True, help='This is password', )
def __init__(self): self.reqparse = reqparse.RequestParser() super(Ping, self).__init__()
class ProjectStatsAPIView(APIView): parser = reqparse.RequestParser() parser.add_argument('resolution', type=unicode, location='args', choices=RESOLUTION_CHOICES, default='1d') parser.add_argument('stat', type=unicode, location='args', choices=STAT_CHOICES, required=True) parser.add_argument('agg', type=unicode, location='args', choices=AGG_CHOICES) parser.add_argument('points', type=int, location='args') parser.add_argument('from', type=int, location='args', dest='from_date') def get(self, project_id): project = Project.get(project_id) if not project: return '', 404 args = self.parser.parse_args() points = args.points or POINTS_DEFAULT[args.resolution] if args.from_date: date_end = datetime.fromtimestamp(args.from_date) else: date_end = datetime.now() date_end = date_end.replace(minute=0, second=0, microsecond=0) if args.resolution == '1h': grouper = func.date_trunc('hour', Build.date_created) decr_res = lambda x: x - timedelta(hours=1) elif args.resolution == '1d': grouper = func.date_trunc('day', Build.date_created) date_end = date_end.replace(hour=0) decr_res = lambda x: x - timedelta(days=1) elif args.resolution == '1w': grouper = func.date_trunc('week', Build.date_created) date_end = date_end.replace(hour=0) date_end -= timedelta(days=date_end.weekday()) decr_res = decr_week elif args.resolution == '1m': grouper = func.date_trunc('month', Build.date_created) date_end = date_end.replace(hour=0, day=1) decr_res = decr_month if args.agg: value = getattr(func, args.agg)(ItemStat.value) else: value = func.avg(ItemStat.value) date_begin = date_end.replace() for _ in xrange(points): date_begin = decr_res(date_begin) # TODO(dcramer): put minimum date bounds results = dict( db.session.query( grouper.label('grouper'), value.label('value'), ).filter( ItemStat.item_id == Build.id, ItemStat.name == args.stat, Build.project_id == project.id, Build.date_created >= date_begin, Build.date_created < date_end, ).group_by('grouper')) data = [] cur_date = date_end.replace() for _ in xrange(points): cur_date = decr_res(cur_date) data.append({ 'time': int(float(cur_date.strftime('%s.%f')) * 1000), 'value': int(float(results.get(cur_date, 0))), }) data.reverse() return self.respond(data, serialize=False)
def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('email', location='json') self.reqparse.add_argument('password', location='json') super().__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() super(CertificateUsers, self).__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('title', type=str, location='json') self.reqparse.add_argument('description', type=str, location='json') self.reqparse.add_argument('done', type=bool, location='json') super(UpdateSSIDStrength, self).__init__()
def __init__(self): self.reqparse = reqparse.RequestParser() super(RoleUsers, self).__init__()
def post(self): parser = reqparse.RequestParser() parser.add_argument('node_id', type=str, required=True) parser.add_argument('host_name', type=str, required=True) parser.add_argument('config_key', type=str, required=True) super(InstanceListResource, self).post(parser)
def __init__(self): self.reqparse = reqparse.RequestParser() super(UsersList, self).__init__()
from flask import Flask, request, jsonify from flask.ext.restful import Resource, Api, reqparse from gensim.models.word2vec import Word2Vec as w from gensim import utils, matutils from numpy import exp, dot, zeros, outer, random, dtype, get_include, float32 as REAL,\ uint32, seterr, array, uint8, vstack, argsort, fromstring, sqrt, newaxis, ndarray, empty, sum as np_sum import cPickle import argparse import base64 import sys parser = reqparse.RequestParser() def filter_words(words): if words is None: return return [word for word in words if word in model.vocab] class N_Similarity(Resource): def get(self): parser = reqparse.RequestParser() parser.add_argument('ws1', type=str, required=True, help="Word set 1 cannot be blank!", action='append') parser.add_argument('ws2', type=str, required=True,
def get(self): parser = reqparse.RequestParser() parser.add_argument('w1', type=str, required=True, help="Word 1 cannot be blank!") parser.add_argument('w2', type=str, required=True, help="Word 2 cannot be blank!") args = parser.parse_args() return model.similarity(args['w1'], args['w2'])