Python werkzeug.parse_options_header函数代码示例

    def test_attachment(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f, as_attachment=True)
                value, options = parse_options_header(rv.headers['Content-Disposition'])
                assert value == 'attachment'
            # mimetypes + etag
            assert len(captured) == 2

        with app.test_request_context():
            assert options['filename'] == 'index.html'
            rv = flask.send_file('static/index.html', as_attachment=True)
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.html'

        with app.test_request_context():
            rv = flask.send_file(StringIO('Test'), as_attachment=True,
                                 attachment_filename='index.txt',
                                 add_etags=False)
            assert rv.mimetype == 'text/plain'
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.txt'

def post_comment(key):
	battle = Battle.get(key)
	now = datetime.now()
	if request.form.has_key('leftbox'):
		comment = request.form.get('leftbox')
		left_comment = Comment(parent=battle, comment=comment, author=users.get_current_user(), side="left", when=now)
		if request.files['left_image']:
			image_file = request.files['left_image']
			headers = image_file.headers['Content-Type']
			blob_key = parse_options_header(headers)[1]['blob-key']
			left_comment.blob_key = blob_key
			left_comment.image_url = images.get_serving_url(blob_key)
		left_comment.put()
		send_emails(key, comment)
	elif request.form.has_key('rightbox'):
		comment = request.form.get('rightbox')
		right_comment = Comment(parent=battle, comment=comment, author=users.get_current_user(), side="right", when=now)
		if request.files['right_image']:
			image_file = request.files['right_image']
			headers = image_file.headers['Content-Type']
			blob_key = parse_options_header(headers)[1]['blob-key']
			right_comment.blob_key = blob_key
			right_comment.image_url = images.get_serving_url(blob_key)
		right_comment.put()
		send_emails(key, comment)
	return left_right(key)

def parse_response(resp, content, strict=False, content_type=None):
    """
    Parse the response returned by :meth:`OAuthRemoteApp.http_request`.
    """
    ct = resp.headers.get('content-type')
    if not ct and content.lower().strip().startswith('callback('):
        ct = 'application/json'
    if not ct:
        ct = content_type
    if not ct:
        ct = 'application/json'
    ct, options = parse_options_header(ct)

    if ct in ('application/json', 'text/javascript'):
        if content.lower().strip().startswith('callback('):
            content = content.strip().replace('callback(', '', 1).strip("); ")
        return json.loads(content)

    if ct in ('application/xml', 'text/xml'):
        return get_etree().fromstring(content)

    if ct != 'application/x-www-form-urlencoded' and strict:
        return content
    charset = options.get('charset', 'utf-8')
    return url_decode(content, charset=charset).to_dict()

def paper_upload_view():
	# big thanks to Stack Overflow user Koffee for explaining how this works
	# http://stackoverflow.com/a/18073466/2752467
	f = request.files['file']
	header = f.headers['Content-Type']
	parsed_header = parse_options_header(header)
	blob_key = blobstore.BlobKey(parsed_header[1]['blob-key'])
	
	paper_key = request.args.get("id")
	paper = ndb.Key(urlsafe=paper_key).get()

	blob_stream = blobstore.BlobReader(blob_key)
	if not is_pdf(blob_stream):
		blob_stream.close()
		blobstore.delete(blob_key)
		return redirect(url_rule["paper"] + "?id=" + paper_key
			+ "&ispdf=false")
	blob_stream.close()

	# sanity check: file is associated with a paper owned by the current user
	if paper and paper.author == \
		lookup_user(users.get_current_user().user_id()).key:
		if paper.file != None:
			# prevent old versions of file from being orphaned
			blobstore.delete(paper.file)
		paper.file = blob_key
		paper.put()
	
	# paper_view_get() will handle most error scenarios
	return redirect(url_rule["paper"] + "?id=" + paper_key
		+ "&update=success")

def resource_db_from_upload():
  try:
    uploaded_file = flask.request.files['file']
  except:
    return None
  headers = uploaded_file.headers['Content-Type']
  blob_info_key = werkzeug.parse_options_header(headers)[1]['blob-key']
  blob_info = blobstore.BlobInfo.get(blob_info_key)

  image_url = None
  if blob_info.content_type.startswith('image'):
    try:
      image_url = images.get_serving_url(blob_info.key())
    except:
      pass

  resource_db = model.Resource(
      user_key=auth.current_user_key(),
      blob_key=blob_info.key(),
      name=blob_info.filename,
      content_type=blob_info.content_type,
      size=blob_info.size,
      image_url=image_url,
      bucket_name=config.CONFIG_DB.bucket_name or None,
    )
  resource_db.put()
  return resource_db

def parse_response(resp):
    '''
    Inspects a :class:`requests.Response` object and returns the content in a
    more usable form. The following parsing checks are done:

    1. JSON, using the `json` attribute.
    2. XML, using :func:`get_etree`.
    3. RSS or Atom, using :mod:`feedparser`, if available.
    4. Query string, using :func:`parse_utf8_qsl`.
    5. If all else fails the plain-text `content` is returned.

    :param resp: A `requests.Response` object.
    '''
    if resp.json is not None:
        return resp.json

    ct, _ = parse_options_header(resp.headers.get('content-type'))

    if ct in ('application/xml', 'text/xml'):
        etree = get_etree()
        if etree is not None:
            return etree.fromstring(resp.content)

    if ct in ('application/atom+xml', 'application/rss+xml'):
        try:
            import feedparser
            return feedparser.parse(resp.content)
        except:
            pass

    if isinstance(resp.content, basestring):
        return parse_utf8_qsl(resp.content)

    return resp.content

def cfg_upload_bg():
    u, u_i = checkUserLoggedIn()
    if u and u_i:
        usr = sp_data.ExternalUser.query()
        us = [u for u in usr if str(u.source)==str(u_i['source']) and str(u.userID)==u_i['userID']]
        if len(us)>0:
            user = us[0]
            image=request.files["filename"]
            header = image.headers['Content-Type']
            parsed_header = parse_options_header(header)
            blob_key = parsed_header[1]['blob-key']
            l = images.get_serving_url(blob_key)
            user.backgroundImageURL = l
            user.backgroundImageKey=BlobKey(blob_key)

            #import datetime
            #user.imgUrl="http://startpage-1072.appspot.com/img/{0}/{1}/{2}".format(us[0].source,us[0].userID,datetime.datetime.now())
            user.put()
            if request.cookies.has_key('first-login') and request.cookies.get('first-login')==str(True):
                return redirect(url_for('setup_three'))
            else:
                return redirect(url_for('edit',message="Success! Your startpage's got a new background image.")+"#image")
        else:
            return jsonResponse({'status':'error'})
    else:
        return redirect(url_for('login'))

def results_leasingfinder():
    if request.method == 'POST':
        month_list_entity = ds.get_saved_months('month_list_leasing')
        if month_list_entity != None:
            tmp_months_to_show = month_list_entity.month_list_leasing
        leasingfinder_data_final = []
        one_entry_dict = {}
        f = request.files['file']
        header = f.headers['Content-Type']
        parsed_header = parse_options_header(header)
        blob_key = parsed_header[1]['blob-key']
        blob_info = blobstore.get(blob_key)
        blob_data = blob_info.open().read()
        if blob_info.content_type == 'application/json':
            leasingfinder_data = leasingfinder.parse_csv_or_json(json.load(StringIO.StringIO(blob_data)))
        elif blob_info.content_type == 'text/csv' or blob_info.content_type == 'application/octet-stream':
            leasingfinder_data = leasingfinder.parse_csv_or_json(csv.DictReader(StringIO.StringIO(blob_data)))
        elif blob_info.content_type == 'text/html':
            leasingfinder_data = leasingfinder.parse_html_hertz(blob_data)
        else:
            blobstore.delete(blob_key)
            return "Error, not able to parse the file uploaded, file format: %s not supported."%blob_info.content_type

        for i in leasingfinder_data:
            entry_key = str(i['year'])+str(i['brand'])+str(i['name'])+str(i['price_date'])
            if int(i['leasing_months']) != 0:
                i['average leasing'] = (int(i['leasing_months'])*int(i['lease'])+int(i['due_at_signing']))/int(i['leasing_months'])
            if int(i['hwy_mpg']) != 0:
                i['average mpg'] = (int(i['hwy_mpg'])+int(i['city_mpg']))/2
            i['price_date'] = i['price_date'][:6]
            ds.save_general_entity(entry_key, i)

#            leasingfinder_data_final.append(json.dumps(i))
#            one_entry_dict = {}
            #use orderdict!
#            for j,key in enumerate(i.keys()):
#                one_entry_dict['index'+str(j)] = i[key]
#            index_nums = one_entry_dict.keys()
#            leasingfinder_data_final_keys = i.keys()
#            str_to_index_mapping = dict(zip(leasingfinder_data_final_keys, index_nums))

        tmp_month = i['price_date']
        if tmp_month not in tmp_months_to_show:
            for i,m in enumerate(tmp_months_to_show):
                if int(tmp_month) > int(m):
                    tmp_months_to_show.insert(i, tmp_month)
                    ds.save_updated_months('month_list_leasing', tmp_months_to_show)

        blobstore.delete(blob_key)
        #new URL for next upload
#        upload_url = blobstore.create_upload_url('/leasingfinder/results')
#        print leasingfinder_data_final
#        my_title = "Yeah! Totally %d cars found. Check out the lower left corner ones!"%len(leasingfinder_data_final)
#        return render_template('leasing_finder_show.html', uploadurl=upload_url,
#                leasingfinder_data = leasingfinder_data_final, my_title = my_title)
        return redirect('leasingfinder')

def parse_response(resp, content, strict=False):
    ct, options = parse_options_header(resp['content-type'])
    if ct in ('application/json', 'text/javascript'):
        return json.loads(content)
    elif ct in ('application/xml', 'text/xml'):
        return get_etree().fromstring(content)
    elif ct != 'application/x-www-form-urlencoded':
        if strict:
            return content
    charset = options.get('charset', 'utf-8')
    return url_decode(content, charset=charset).to_dict()

def upload_photo():
	f = request.files['file']
	header = f.headers['Content-Type']
	parsed_header = parse_options_header(header)
	blob_key = parsed_header[1]['blob-key']

	image = Image(blobKey=blob_key, id=blob_key)

	image.put()

	return make_response(blob_key, http.CREATED)

def check_file_upload(request):
    # This can later be expanded to check file size, type, etc.
    "Checks if a file was uploaded. Returns the BlobKey if so or None if not."
    try:
        blob_file = request.files["file"]
    except BadRequestKeyError:
        return None
    else:
        # Copied with little understanding from https://gist.github.com/merqurio/c0b62eb1e1769317907f
        headers = parse_options_header(blob_file.headers["Content-Type"])
        return blobstore.BlobKey(headers[1]["blob-key"])

def add_icon():
    domainlist = request.form.get('domains')
    image = request.files.get('icon')
    header = image.headers['Content-Type']
    parsed_header = parse_options_header(header)
    blob_key = parsed_header[1]['blob-key']
    theKey =BlobKey(blob_key)
    theDomains = domainlist.split(',')

    newDomain = sp_data.appIconProposed(domains=domainlist, imageKey=theKey, imageURL=images.get_serving_url(blob_key))
    newDomain.put()
    return redirect(url_for('icons'))

def saveimage(key):
    category = Category.get(key)
    items = Item.all().ancestor(category)
    item = Item.all().ancestor(category).filter("title =", request.form.get("items")).get()
    if request.method == "POST":
        image_file = request.files["image"]
        headers = image_file.headers["Content-Type"]
        blob_key = parse_options_header(headers)[1]["blob-key"]
        item.blob_key = blob_key
        item.image_url = images.get_serving_url(blob_key)
        item.put()
    return redirect("edit/images/" + key)

def userprofilephotoconfirm():
    member = MemberInfo()

    #this will cause an ugly key error if we don't handle it properly
    try:
      inputUploadedPictureFile = request.files['inputProfilepicture']
      if inputUploadedPictureFile:
        header = inputUploadedPictureFile.headers['Content-Type']
        parsed_header = parse_options_header(header)
        blob_key = parsed_header[1]['blob-key']
    except:
      #no need to log this error output
      dummyvariable = ""

      #a user is uploading a picture, either new if they did not have one prior, or uploaded a new one which would delete the old one
      if inputUploadedPictureFile:
        if member.pictureblobstorekey:
          blobstore.delete(member.pictureblobstorekey)
          images.delete_serving_url(member.pictureblobstorekey)
        member.pictureservingurl = images.get_serving_url(blob_key)
        member.pictureblobstorekey = blob_key
        member.put()

      return render_template('userprofilephotosaved.html', member=member)
    except:
      try:
        #If you couldn't complete the user save, be sure to delete the photo from the blobstore or re-use it later (to avoid a lost child hanging around)
        inputUploadedPictureFile = request.files['inputProfilepicture']
        if inputUploadedPictureFile:
          header = inputUploadedPictureFile.headers['Content-Type']
          parsed_header = parse_options_header(header)
          blob_key = parsed_header[1]['blob-key']
          blobstore.delete(blob_key)
      except:
        #no need to log this error output
        dummyvariable = ""
      #Create a new form POST URL for the blobstore
      userprofilephoto_form_url = blobstore.create_upload_url('/userprofilephotoconfirm')
      return render_template('userprofilephoto.html', member=member, userprofilephoto_form_url=userprofilephoto_form_url, user_profilepicturesrc=user_profilepicturesrc, alertmessage='Oops!', userprofilephoto_form_url=userprofilephoto_form_url, user_profilepicturesrc=user_profilepicturesrc)

    def test_attachment(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, "static/index.html"))
                rv = flask.send_file(f, as_attachment=True)
                value, options = parse_options_header(rv.headers["Content-Disposition"])
                assert value == "attachment"
            # mimetypes + etag
            assert len(captured) == 2

        with app.test_request_context():
            assert options["filename"] == "index.html"
            rv = flask.send_file("static/index.html", as_attachment=True)
            value, options = parse_options_header(rv.headers["Content-Disposition"])
            assert value == "attachment"
            assert options["filename"] == "index.html"

        with app.test_request_context():
            rv = flask.send_file(StringIO("Test"), as_attachment=True, attachment_filename="index.txt", add_etags=False)
            assert rv.mimetype == "text/plain"
            value, options = parse_options_header(rv.headers["Content-Disposition"])
            assert value == "attachment"
            assert options["filename"] == "index.txt"