python类jsonify()的实例源码

def index():
    code = request.args.get("code", "")
    #app.logger.debug("code:%s" %code)
    #app.logger.debug(request.args)
    if g.signin:
        return "logged_in"
    elif code:
        _data = Get_Access_Token(code)
        app.logger.debug(_data)
        access_token  = _data['access_token']
        uid = _data['uid']
        userData = Get_User_Info(access_token, uid)

        app.logger.debug(userData)

        #resp = render_template('info.html', userData=userData)
        #resp.set_cookie(key="logged_in", value='true', expires=None)

        resp = jsonify(userData)
        resp.set_cookie(key="logged_in", value='true', expires=None)
        return resp
    else:
        return redirect(url_for("login"))

def index():
    code = request.args.get("code", "")
    #app.logger.debug("code:%s" %code)
    #app.logger.debug(request.args)
    if g.signin:
        return "logged_in"
    elif code:
        _data = Get_Access_Token(code)
        access_token  = _data['access_token']
        openid   = Get_OpenID(access_token)['openid']
        userData = Get_User_Info(access_token, openid)

        app.logger.debug(userData)

        #resp = render_template('info.html', userData=userData)
        #resp.set_cookie(key="logged_in", value='true', expires=None)

        resp = jsonify(userData)
        resp.set_cookie(key="logged_in", value='true', expires=None)
        return resp
    else:
        return redirect(url_for("login"))

def index():
    code = request.args.get("code", "")
    #app.logger.debug("code:%s" %code)
    #app.logger.debug(request.args)
    if g.signin:
        return "logged_in"
    elif code:
        _data = Get_Access_Token(code)
        app.logger.debug(_data)
        access_token  = _data['access_token']
        uid = _data['uid']
        userData = Get_User_Info(access_token, uid)

        app.logger.debug(userData)

        #resp = render_template('info.html', userData=userData)
        #resp.set_cookie(key="logged_in", value='true', expires=None)

        resp = jsonify(userData)
        resp.set_cookie(key="logged_in", value='true', expires=None)
        return resp
    else:
        return redirect(url_for("login"))

def upload_music():
    name = request.form.get('name')
    author = request.form.get('author')
    authorID = int(request.form.get('authorID'))
    date = request.form.get('date')
    music_name = request.form.get('musicName')
    img_name = request.form.get('imgName')
    info = request.form.get('musicInfo')
    author_avatar = request.form.get('authorAvatarName')

    upload_result = db.music_insert(name, author, authorID, author_avatar, date, music_name, img_name, info)
    if upload_result == 0:
        dic = {"error": 0, "msg": "OK"}
        return jsonify(dic), 200
    elif upload_result == 1:
        dic = {"error": 21, "msg": "Exist the same name"}
        return jsonify(dic), 409

def predict():
    import ipdb; ipdb.set_trace(context=20)
    if 'file' not in request.files:
        flash('No file part')
        return redirect(request.url)
    file = request.files['file']

    if file.filename == '':
        flash('No selected file')
        return redirect(request.url)

    if file and allowed_file(file.filename):
        filename = secure_filename(file.filename)
        try:
            pokemon_name = predict_mlp(file).capitalize()
            pokemon_desc = pokemon_entries.get(pokemon_name)
            msg = ""
        except Exception as e:
            pokemon_name = None
            pokemon_desc = None
            msg = str(e)

    return jsonify({'name': pokemon_name, 'description': pokemon_desc, "msg": msg})

def get_concepts():
    keywords = request.args.get('keywords', None)
    semanticGroups = request.args.get('semanticGroups', None)
    pageSize = int(request.args.get('pageSize', 1))
    pageNumber = int(request.args.get('pageNumber', 1))

    validatePagination(pageSize, pageNumber)
    validateKeywords(keywords)

    q = GolrSearchQuery(
        term=keywords,
        category=build_categories(semanticGroups),
        rows=pageSize,
        start=getStartIndex(pageNumber, pageSize)
    )

    results = q.exec()

    concepts = []
    for d in results['docs']:
        concept = parse_concept(d)
        concepts.append(concept)

    return jsonify(concepts)

def get_types():

    frequency = {semanticGroup : 0 for semanticGroup in semantic_mapping.keys()}

    results = GolrAssociationQuery(
        rows=0,
        facet_fields=['subject_category', 'object_category']
    ).exec()

    facet_counts = results['facet_counts']

    subject_category = facet_counts['subject_category']
    object_category  = facet_counts['object_category']

    for key in subject_category:
        frequency[monarch_to_UMLS(key)] += subject_category[key]

    for key in object_category:
        frequency[monarch_to_UMLS(key)] += object_category[key]

    return jsonify([{'id' : c, 'idmap' : None, 'frequency' : f} for c, f in frequency.items()])

def get_predicates():

    """
    I'm not quite sure how to best get at all the predicates and tag them as relations with id's
    """

    """
    results = GolrAssociationQuery(
        rows=0,
        facet_fields=['relation']
    ).exec()

    facet_counts = results['facet_counts']

    relations = facet_counts['relation']

    return jsonify([{'id' : "biolink:"+c, 'name' : c, 'definition' : None} for key in relations])
    """
    # Not yet implemented... don't really know how
    return jsonify([])

def make_json_app(import_name, **kwargs):
    """
    Creates a JSON-oriented Flask app.
    All error responses that you don't specifically
    manage yourself will have application/json content
    type, and will contain JSON like this (just an example):
    { "message": "405: Method Not Allowed" }
    """

    def make_json_error(ex):
        response = jsonify(message=str(ex))
        response.status_code = (ex.code if isinstance(ex, HTTPException) else 500)
        return response

    app = Flask(import_name, **kwargs)

    for code in default_exceptions.iterkeys():
        app.register_error_handler(code, make_json_error)

    return app

def messages(room_id):
    room_member = RoomMember.where('room_id', room_id).where('user_id', g.user['id']).first()
    if not room_member:
        return jsonify({'message': "Unknown Room"}), 400

    room = Room.where('id', room_id).with_('members.user').first().serialize()

    for item in room['members']:
        item['user']['username'] = '%s %s' % (item['user']['first_name'],item['user']['last_name'])

    messages = Message.select('messages.*', 'u.first_name', 'u.last_name', 'u.avatar') \
        .where('room_id', room_id) \
        .join('users as u', 'u.id', '=', 'messages.sender_id') \
        .order_by('created_at', 'desc') \
        .limit(100) \
        .get()

    return jsonify({'room': room, 'messages': messages.serialize()}), 200

def s_connect():
    g.user = get_jwt_user()
    if not g.user:
        return jsonify({}), 403

    # get user rooms
    my_rooms = RoomMember.select('room_id').where('user_id', g.user['id']).group_by('room_id').get()
    for room in my_rooms:
        join_room('room-%s' % room.room_id)

    connected_users.append({
        'id': g.user['id'],
        'sid': request.sid
    })

    socketio.emit('user_connect',{'id':g.user['id']})

def do_summary(self, *args, **kwargs):
        return flask.jsonify(self.df.describe().to_dict())

def _process_json(self, df, **kwargs):
        time_frame = None if not kwargs['time_frame'] else kwargs['time_frame']
        from_time = None if not kwargs['from_time'] else kwargs['from_time']
        to_time = None if not kwargs['to_time'] else kwargs['to_time']
        if time_frame and time_frame != 'custom':
            from_time, to_time = self._time_frame(time_frame)
        if from_time or to_time:
            df = df[from_time:to_time]
        if kwargs['columns_data']:
            return flask.jsonify(self.columns_data(df))
        j = df.to_json(date_format='iso', orient=kwargs['orient'], double_precision=2, date_unit='s')
        return flask.jsonify(json.loads(j))

def do_describe(self, *args, **kwargs):
        ret = {'csv_file': self.handler.data_file,
               'last_update': self.last_update,
               'samples': len(self.df),
               'auto_refresh': self.auto_refresh,
               'commands': [x.split('do_')[-1].replace('_', '-') for x in dir(self) if 'do_' in x],
               'status': self._status()}
        return flask.jsonify(ret)

def do_describe(self, *args, **kwargs):
        ret = {'csv_file': self.handler.data_file,
               'started': self.started,
               'last_update': self.last_update,
               'commands': [x.split('do_')[-1].replace('_', '-') for x in dir(self) if 'do_' in x],
               'status': self._status()}
        return flask.jsonify(ret)

def index():
    '''
    Default path to orca server. List all the services available
    '''
    services = ['s3', 'iam', 'ec2']
    resp_obj = {}
    resp_obj['services'] = services
    return jsonify(resp_obj)

def rundeck_list_resources():
    '''
    Return a list of S3 and EC2 Resources from all available profiles
    '''
    resp_obj = {}

    awsconfig = aws_config.AwsConfig()
    profiles = awsconfig.get_profiles()

    # Populate s3 buckets.
    for profile in profiles:
        session = boto3.Session(profile_name=profile)
        s3client = session.client('s3')

        try:
            s3info = s3client.list_buckets()
        except botocore.exceptions.ClientError:
            s3info['Buckets'] = []

        for bucket in s3info['Buckets']:
            bucket_text = "s3: (%s) %s" % (profile, bucket['Name'])
            resp_obj[bucket_text] = bucket['Name']

    # Populate ec2 instances.
    for profile in profiles:
        session = boto3.Session(profile_name=profile)
        ec2client = session.client('ec2', region_name="us-east-1")

        try:
            ec2info = ec2client.describe_instances()
        except botocore.exceptions.ClientError:
            ec2info['Instances'] = []

        for reservation in ec2info['Reservations']:
            for instance in reservation['Instances']:
                instance_text = "ec2: (%s) %s" % \
                    (profile, instance['InstanceId'])
                resp_obj[instance_text] = instance['InstanceId']

    return jsonify(resp_obj)

def list_groups(profile):
    '''
    Return all the groups.
    '''
    resp_obj = {}
    resp_obj['status'] = 'OK'
    awsconfig = aws_config.AwsConfig()
    profiles = awsconfig.get_profiles()

    profile_valid = False
    for configuredprofile in profiles:
        if profile == configuredprofile:
            profile_valid = True

    if not profile_valid:
        resp_obj['status'] = 'FAIL'
        return jsonify(resp_obj)

    session = boto3.Session(profile_name=profile)
    iamclient = session.client('iam')

    try:
        groupinfo = iamclient.list_groups()
    except botocore.exceptions.ClientError:
        groupinfo['Groups'] = []

    groups = []
    for group in groupinfo['Groups']:
        groups.append(group['GroupName'])

    resp_obj['groups'] = groups

    return jsonify(resp_obj)

def custResponse(code=404, message="Error: Not Found", data=None):

    message = {
        "status": code,
        "message": message
    }

    if data:
        for k, v in data.items():
            message[k] = v

    resp = jsonify(message)
    resp.status_code = code

    return resp

def leaderboard():
    if request_wants_json():
        leader_gen = users.generate_leaders(leader_factory=freeze_leader)
        return jsonify({'leaders': list(leader_gen)})
    leader_gen = users.generate_leaders()
    return render_template(
        'leaderboard.html', leader_gen=leader_gen,
    )