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'])
