Python parser.parse函数代码示例

def add_new_meta_result():
    args = {
        'page_type': Arg(str, required=True),
        'url': Arg(str, default=None),
        'page_param': Arg(str, default=None),
        'h1': Arg(str, default=None),
        'meta_title': Arg(str, default=None),
        'meta_description': Arg(str, default=None),
        'meta_keywords': Arg(str, default=None),
        'og_tags': Arg(str, default='{}'),
        'twitter_cards': Arg(str, default='{}'),
        'gplus_tags': Arg(str, default='{}')
    }

    data = parser.parse(args, request)

    r = requests.post(api_base_url + '/seo/meta_data/add_meta_data', data)

    message = "Error while adding meta data for " + data['page_type'] + ". Review the content and other parameters once, contact admin if that doesn't help!"
    message_color = "red"

    if json.loads(r.text)['result'] and json.loads(r.text)['result'] == 'Success':
        message = "Meta data for " + data['page_type'] + " has been added successfully!"
        message_color = "green"
    
    return render_template('result.html', message=message, message_color=message_color)

 def post(self):
     args = parser.parse(device_args, request)
     device = Devices.query.filter_by(device_name=args['device_name']).first()
     if device is not None:
         return conflict("Device with name {n} already exists".format(n=args['device_name'])), 409
     try:
         device_id = str(uuid.uuid4())
         location = None
         temperature_sensor = False
         humidity_sensor = False
         uptime = 1
         if 'location' in args:
             location = args['location']
         if 'temperature_sensor' in args:
             temperature_sensor = True
         if 'humidity_sensor' in args:
             humidity_sensor = True
         if 'uptime' in args:
             uptime = long(args['uptime'])
         else:
             uptime = long(0)
         device = Devices(device_id=device_id,
                          device_name=args['device_name'],
                          location=location,
                          temperature_sensor=temperature_sensor,
                          humidity_sensor=humidity_sensor,
                          uptime=uptime)
         db.session.add(device)
         db.session.commit()
         return "Location: " + device.url, 200
     except Exception as e:
         return internal_error("Server Error " + str(e)), 500

def update_employes(id):
    employee = Employee.query.get_or_404(id)
    args = parser.parse(EmployeeSchema(strict=True, partial=True,
                        context={'employee_id': employee.id}))
    for key, value in args.items():
        setattr(employee, key, value)
    db.session.commit()
    return build_result(employee, EmployeeSchema())

def user_merge():
  args = parser.parse({
    'user_key': wf.Str(missing=None),
    'user_keys': wf.DelimitedList(wf.Str(), delimiter=',', required=True),
  })

  user_db_keys = [ndb.Key(urlsafe=k) for k in args['user_keys']]
  user_dbs = ndb.get_multi(user_db_keys)
  if len(user_dbs) < 2:
    flask.abort(400)

  user_dbs.sort(key=lambda user_db: user_db.created)
  merged_user_db = user_dbs[0]
  auth_ids = []
  permissions = []
  is_admin = False
  is_active = False
  for user_db in user_dbs:
    auth_ids.extend(user_db.auth_ids)
    permissions.extend(user_db.permissions)
    is_admin = is_admin or user_db.admin
    is_active = is_active or user_db.active
    if user_db.key.urlsafe() == args['user_key']:
      merged_user_db = user_db

  auth_ids = sorted(list(set(auth_ids)))
  permissions = sorted(list(set(permissions)))
  merged_user_db.permissions = permissions
  merged_user_db.admin = is_admin
  merged_user_db.active = is_active
  merged_user_db.verified = False

  form_obj = copy.deepcopy(merged_user_db)
  form_obj.user_key = merged_user_db.key.urlsafe()
  form_obj.user_keys = ','.join(args['user_keys'])

  form = UserMergeForm(obj=form_obj)
  if form.validate_on_submit():
    form.populate_obj(merged_user_db)
    merged_user_db.auth_ids = auth_ids
    merged_user_db.put()

    deprecated_keys = [k for k in user_db_keys if k != merged_user_db.key]
    merge_user_dbs(merged_user_db, deprecated_keys)
    return flask.redirect(
      flask.url_for('user_update', user_id=merged_user_db.key.id()),
    )

  return flask.render_template(
    'user/user_merge.html',
    title='Merge Users',
    html_class='user-merge',
    user_dbs=user_dbs,
    merged_user_db=merged_user_db,
    form=form,
    auth_ids=auth_ids,
    api_url=flask.url_for('api.admin.user.list'),
  )

    def get(self, bucket_id, **kwargs):
        """Get list of objects in the bucket.

        .. http:get:: /files/(uuid:bucket_id)

            Returns a JSON list with all the objects in the bucket.

            **Request**:

            .. sourcecode:: http

                GET /files/0ecc3794-2b57-4834-be61-cb9c3ef60562 HTTP/1.1
                Accept: application/json
                Content-Type: application/json
                Host: localhost:5000

            :reqheader Content-Type: application/json
            :query boolean versions: 1 (or true) in order to  list all the
                                     versions of the files. 0 (or false) for
                                     the most recent versions of each file.

            **Response**:

            .. sourcecode:: http

                HTTP/1.0 200 OK
                Content-Length: 334
                Content-Type: application/json

                [
                    {
                        "checksum": "xxx",
                        "size": 110,
                        "url": "http://localhost:5000/files/c361fd5e.../f.pdf",
                        "uuid": "c361fd5e-5036-4387-8249-5fcc5a37e128"
                    },
                    {
                        "checksum": "xxx",
                        "size": 330,
                        "url": "http://localhost:5000/files/0ff1def.../f2.rst",
                        "uuid": "0ff1def0-5f09-4ba0-8ee8-ff42f99985ae"
                    }
                ]

            :resheader Content-Type: application/json
            :statuscode 200: no error
            :statuscode 403: access denied
            :statuscode 404: page not found
        """
        args = parser.parse(self.get_args, request)
        if bucket_id and Bucket.get(bucket_id):
            object_list = []
            for obj in Object.get_by_bucket(
                bucket_id, versions=args.get('versions', False)
            ).all():
                object_list.append(obj.serialize())
            return {'json': object_list}
        abort(404, 'The specified bucket does not exist or has been deleted.')

 def wrapped(*args, **kwargs):
     req_args = webargs_parser.parse({
         'submission': webargs_fields.Int(),
         'submission_id': webargs_fields.Int()
     })
     submission_id = req_args.get('submission', req_args.get('submission_id'))
     if submission_id is None:
         raise ResponseException("submission_id is required", StatusCode.CLIENT_ERROR)
     return fn(submission_id, *args, **kwargs)

def jsonpify(*args, **kwargs):
  params = parser.parse({'callback': wf.Str(missing=None)})
  if params['callback']:
    content = '%s(%s)' % (
      params['callback'], flask.jsonify(*args, **kwargs).data,
    )
    mimetype = 'application/javascript'
    return flask.current_app.response_class(content, mimetype=mimetype)
  return flask.jsonify(*args, **kwargs)

def validate_employee_data():
    try:
        e = parser.parse(EmployeeSchema(strict=True))
        err = {'error': None}
    except UnprocessableEntity as ex:
        err = {'error': "Validation Error"}
        if hasattr(ex, 'data') and 'messages' in ex.data:
            err.update({'messages': ex.data['messages']})
    return err, 200

 def post(self):
     try:
         args = parser.parse(reading_args)
         log_id = post_reading(args, HUMIDITY)
         return "Location: " + url_for("HumidityReadingsView:get", log_id=log_id, _external=True), 200
     except InvalidRequestException as ire:
         return handle_bad_request(ire.message), 422
     except NotFoundError as nfe:
         return not_found(nfe.message), 404
     except Exception as e:
         print traceback.format_exc()
         return internal_error(), 500

 def delete(self):
     args = parser.parse(device_name_args, request)
     device_name = args['device_name']
     if device_name is not None and len(device_name) > 0:
         try:
             device = Devices.query.filter_by(device_name=device_name).first()
             if device is None:
                 return not_found("Device Not Found " + device_name), 404
             db.session.delete(device)
             db.session.commit()
             return "Device Deleted.", 200
         except Exception as e:
             return internal_error("Server Error " + str(e)), 500

 def get_dbs(cls, query=None, ancestor=None, order=None, limit=None, cursor=None, **kwargs):
   args = parser.parse({
     'cursor': wf.Str(missing=None),
     'limit': wf.Int(missing=None, validate=validate.Range(min=-1)),
     'order': wf.Str(missing=None),
   })
   return util.get_dbs(
     query or cls.query(ancestor=ancestor),
     limit=limit or args['limit'],
     cursor=cursor or args['cursor'],
     order=order or args['order'],
     **kwargs
   )

def get_next_url(next_url=''):
  args = parser.parse({
    'next': wf.Str(missing=None), 'next_url': wf.Str(missing=None)
  })
  next_url = next_url or args['next'] or args['next_url']
  if next_url:
    do_not_redirect_urls = [flask.url_for(u) for u in [
      'signin', 'signup', 'user_forgot', 'user_reset',
    ]]
    if any(url in next_url for url in do_not_redirect_urls):
      return flask.url_for('welcome')
    return is_trusted_url(next_url)
  return is_trusted_url(flask.request.referrer)

def param(name, cast=None):
  def switch(case):
    return {
      int: wf.Int(missing=None),
      bool: wf.Bool(missing=None),
      list: wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
    }.get(case)
  if cast is None or cast is ndb.Key:
    cast_ = wf.Str(missing=None)
  else:
    cast_ = switch(cast) or cast
  args = parser.parse({name: cast_})
  return ndb.Key(urlsafe=args[name]) if cast is ndb.Key else args[name]

 def index(self):
     ## retrieve all items from db and dump it them to a list of json strings
     print "in get function"
     args = parser.parse(index_args, request)
     app.logger.debug('GET request for all {}'.format(self.desc))
     app.logger.debug('Arguments passed in:  {}'.format(args))
     objs = self.obj.query.all()
     if objs:
         obj_dict_list, errors = self.schema(many=True).dump(objs)
         if errors:
             return jsonify(errors), 500
         return jsonify(obj_dict_list)
     else:
         return jsonify({'message' : 'No {}s found'.format(self.desc)})

def add_question():
    args = {
        'question': Arg(str, required=True),
        'option_one': Arg(str, required=True),
        'option_two': Arg(str, required=True),
        'option_three': Arg(str),
        'option_four': Arg(str)
    }
    data = parser.parse(args, request)
    res = interface.insert_question(data['question'],data['option_one'],data['option_two'],data['option_three'],data['option_four'])
    if res:
        a = {'data':res}
        return jsonify(a)
    return 'failed'