Python utils.secure_filename函数代码示例

def upload():

    if request.method == 'POST':
        # try:
        pid = request.form["pid"]
        file_synonym = request.files["file1"]
        file_knowledge = request.files["file2"]

        print(file_synonym.filename)
        print(file_knowledge.filename)
        print(">>>>>>>")
        basepath = os.path.dirname(__file__)
        upload_path_synonyms = os.path.join(basepath, "load_file", "synonyms",
                                            secure_filename(file_synonym.filename))
        upload_path_knowledge = os.path.join(basepath, "load_file", "knowledge",
                                            secure_filename(file_knowledge.filename))
        upload_path_knowledge = os.path.join('/home/xp/work/upload_file/load_file/knowledge', file_knowledge.filename)
        print('------------', upload_path_synonyms)
        print('------------', upload_path_knowledge)
        file_synonym.save(upload_path_synonyms)
        file_knowledge.save(upload_path_knowledge)
        redirect(url_for('upload',file_name=file_synonym.filename))
        redirect(url_for('upload', file_name=file_knowledge.filename))
        print("保存成功")

        # except Exception as e:
        #     print("失败",e)
    # print(">>>MMMM")
    return render_template('index.html')

def shapefile_upload():
    shapefiles = request.files.getlist('shapefile[]')
    if len(shapefiles) == 0:
        # todo -- not supposed to come here; if this is keeps not being printed out, remove the whole if-clause
        print('Apparently uploaded empty list of files...?')
        return '200'

    shapefile_name = secure_filename(shapefiles[0].filename)
    shapefile_name = shapefile_name[:shapefile_name.index('.')] + '.shp'
    path = str(os.path.join(get_shape_path(), shapefile_name))
    already_registered = Shapefile.query.filter(Shapefile.path == path).count() > 0
    if already_registered:
        print('Shapefile \''+  shapefile_name + '\' has already been uploaded before.')
        return '200'

    if not os.path.exists(get_shape_path()):
        os.makedirs(get_shape_path())

    for file in shapefiles:
        filename = secure_filename(file.filename)
        target = os.path.join(get_shape_path(), filename)
        file.save(target)
        print('Successfully uploaded file \'' + target + '\'')
    persist(shapefile_name, path)

    return '200'

def upload_game_file(platform_id):
	"""Upload a game rom file to the platforms rom folder."""

	try:
		f = request.files['file']
		platform = models.Platform.query.get_or_404(platform_id)

		file_type = os.path.splitext(utils.secure_filename(f.filename))[1][1:]
		filename_noExtension = os.path.splitext(utils.secure_filename(f.filename))[0]
		full_filename = utils.secure_filename(f.filename)

		if file_type == platform.extension:  # is this the file type we are using for roms?
			if not os.path.exists(platform.roms_path):
				os.makedirs(platform.roms_path)

			f.save(os.path.join(platform.roms_path, full_filename))
			game_id = ScanRoms.addGameRom(str(platform.id), filename_noExtension)

			return jsonify(result='OK', file_name=filename_noExtension, file_type=file_type, game_id=game_id)

		else:
			return jsonify(result='ERROR', file_name=filename_noExtension, file_type=file_type,
						   msg='Wrong file extension for platforms settings. Received ' + file_type + ' should be ' + platform.extension)

	except Exception, e:
		return jsonify(result='ERROR', file_name=filename_noExtension, file_type=file_type, msg=str(e))

def upload_file():
    if not session.get('logged_in'):
        abort(404)
    # List images os.listdir(os.path.join(getcwd(),'static/'))
    images = os.listdir(app.config['UPLOAD_FOLDER'])
    if request.method == 'POST':
        try:
            file = request.files['file']
        except RequestEntityTooLarge:
            abort(413)
        if not file:
            error = u'Select a file please.'
            return render_template('upload.html', **locals())
        # file ok, type ok
        elif file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
            info = u'The file {} has been successfully uploaded.'.format(filename)
            return render_template('upload.html', **locals())
        # file ok, type ko
        elif file and  not allowed_file(file.filename):
            filename = secure_filename(file.filename)
            error = u'File extension {} not allowed'.format(filename)
            return render_template('upload.html', **locals())
    return render_template('upload.html', images=images)

def upload(app, url):
    if 'file' not in request.files:
        raise InvalidUsage('No file attached')
    file = request.files['file']
    if secure_filename(file.filename)[-4:] !='.zip':
        raise InvalidUsage('The uploaded file is not a zipfile.')
    target_folder = join(app.projects_path(), secure_filename(file.filename)[:-4])
    if not commonprefix([target_folder, app.projects_path()]) == app.projects_path(): # out of the server folder
        raise InvalidUsage('Invalid filename')
    if not exists(target_folder):
        makedirs(target_folder)
    else:
        raise InvalidUsage('Project of the same name already exists.')
    try:
        zip_ref = zipfile.ZipFile(file, 'r')
    except:
        raise InvalidUsage('The file ' + file + ' is not recognised as a zip file.')
    try:
        zip_ref.extractall(target_folder)
    except:
        raise InvalidUsage('The extraction of the file ' + file + ' failed.')
    if not exists(join(target_folder, configure_filename)):
        shutil.rmtree(target_folder)
        raise InvalidUsage('The file does not contain a tremppi project.')
    write_projects(app.projects_path())
    return 'upload successful'

def test_secure_filename():
    assert utils.secure_filename('My cool movie.mov') == 'My_cool_movie.mov'
    assert utils.secure_filename('../../../etc/passwd') == 'etc_passwd'
    assert utils.secure_filename(u'i contain cool \xfcml\xe4uts.txt') == \
        'i_contain_cool_umlauts.txt'
    assert utils.secure_filename('__filename__') == 'filename'
    assert utils.secure_filename('foo$&^*)bar') == 'foobar'

 def _make_zip(self, project, ty):
     name = self._project_name_latin_encoded(project)
     dataframe = self._respond_csv(ty, project.id)
     if dataframe is not None:
         info_dataframe = self._respond_csv(ty, project.id, info_only=True)
         datafile = tempfile.NamedTemporaryFile()
         info_datafile = tempfile.NamedTemporaryFile()
         try:
             dataframe.to_csv(datafile, index=False,
                              encoding='utf-8')
             info_dataframe.to_csv(
                 info_datafile, index=False, encoding='utf-8')
             datafile.flush()
             info_datafile.flush()
             zipped_datafile = tempfile.NamedTemporaryFile()
             try:
                 _zip = self._zip_factory(zipped_datafile.name)
                 _zip.write(
                     datafile.name, secure_filename('%s_%s.csv' % (name, ty)))
                 _zip.write(
                     info_datafile.name, secure_filename('%s_%s_info_only.csv' % (name, ty)))
                 _zip.close()
                 container = "user_%d" % project.owner_id
                 _file = FileStorage(
                     filename=self.download_name(project, ty), stream=zipped_datafile)
                 uploader.upload_file(_file, container=container)
             finally:
                 zipped_datafile.close()
         finally:
             datafile.close()
             info_datafile.close()

def get_ldd(campaign_model):
	env = dict(os.environ)
	if 'LD_LIBRARY_PATH' in env:
		env['LD_LIBRARY_PATH'] = ':' + env['LD_LIBRARY_PATH']
	else:
		env['LD_LIBRARY_PATH'] = ''
	env['LD_LIBRARY_PATH'] = os.path.join(current_app.config['DATA_DIRECTORY'], secure_filename(campaign_model.name), 'libraries') + env['LD_LIBRARY_PATH']
	try:
		p = subprocess.Popen(['ldd', os.path.join(current_app.config['DATA_DIRECTORY'], secure_filename(campaign_model.name), 'executable')], env=env, stdout=subprocess.PIPE)
		process_output = p.communicate()
	except FileNotFoundError:
		ldd = None
	else:
		ldd = []
		for line in process_output[0].decode('ascii').split('\n'):
			if not line or line[0] != '\t':
				continue
			parts = line.split()
			if len(parts) < 3:
				continue
			found = 'not found' not in line
			if found:
				path = parts[2]
				if path.startswith(current_app.config['DATA_DIRECTORY']):
					ldd_row = (parts[0], 'info', path.rsplit(os.path.sep, 1)[-1])
				else:
					ldd_row = (parts[0], '', path)
			else:
				ldd_row = (parts[0], 'danger', 'Not Found')
			if ldd_row not in ldd:
				ldd.append(ldd_row)
	return ldd

def upload(upload_file, image_data, user):
    """Upload a photo to the blobstore and create a photo entity to index it.

    Args:
        upload_file: the file the user uploaded.
        image_data: the raw file data to be stored as a blob.
        user: the user who uploaded the file.

    Returns:
        the photo entity for the uploaded file.
    """

    filename = secure_filename(upload_file.filename)
    blob_key = _write_to_blobstore(filename, image_data,
                                   upload_file.content_type)

    image = Image.open(StringIO(image_data))

    thumbnail = _create_circle_thumbnail(image)
    thumb_filename = secure_filename('%s_thumb' % upload_file.filename)
    thumb_key = _write_to_blobstore(thumb_filename, thumbnail, 'image/png')

    exif_data = exif.get_exif_data(image)
    lat, lon = exif.get_lat_lon(exif_data)
    coordinates = None if not lat or not lon else ndb.GeoPt(lat, lon)
    timestamp = exif.get_datetime(exif_data)

    photo = Photo(name=filename, owner=user.key, primary_blob_key=blob_key,
                  thumb_blob_key=thumb_key, coordinates=coordinates,
                  timestamp=timestamp)
    photo.put()

    return photo

def edit_file():
    if request.method == 'GET':
        fname = request.args.get('n')
        fsize = "%d kB" % math.trunc(os.path.getsize(os.path.join(files_dir_os, fname)) / 1024)
        events = TennisEvent.get_events_with_att(fname)
        src = EventSource.get(os.path.join(fname[:4], fname[5:]))  # Todo: od klicu sestavim z '/', ne glede na OS
        title = src['desc'] if src else ""
        view = src['view'] if src and src in ['0', '1'] else "1"
        # log_info("view=%s." % view)
        players = src['players_on_pic'] if src else ""
        return render_template("editFile.html", year=fname[:4], fname=fname[5:], fsize=fsize,
                               years=TennisEvent.Years, events=events, title=title, view=view, players=players)
    elif request.method == 'POST':
        old_year, old_fname = request.form['old_year'], request.form['old_fname']
        new_year = secure_filename(request.form.get('new_year') or old_year)
        new_fname = secure_filename(request.form['new_fname'])
        old_title, new_title = request.form['old_title'], request.form['new_title']
        old_view, new_view = request.form['old_view'], request.form['new_view']
        old_players, new_players = request.form['old_players'], request.form['new_players']
        old_att = os.path.join(files_dir_os, old_year, old_fname)
        new_att = os.path.join(files_dir_os, new_year, new_fname)

        if request.form["Status"][:5] == unicode("Popravi"[:5]):
            log_info("Audit: rename file %s/%s to %s/%s" % (old_year, old_fname, new_year, new_fname))
            os.rename(old_att, new_att)
            TennisEvent.update_all_atts(old_year, old_fname, new_fname)
            # ToDo: delete old entry, if necessary (year | file_name changes)
            s = EventSource(file_name=os.path.join(new_year, new_fname),
                            desc=new_title, view=new_view, players_on_pic=new_players)
            s.update()
        elif request.form["Status"][:5] == unicode("Kopiraj"[:5]):
            log_info("Audit: copy file %s/%s to %s/%s" % (old_year, old_fname, new_year, new_fname))
            shutil.copyfile(old_att, new_att)

        return redirect(request.args.get("next") or url_for("tennis_events_old"))

def upload_image():
    if request.method == "POST":
        f = request.files["file"]
        bf = request.files["blurred_file"]
        if f and bf:
            filename = os.path.join(app.config["UPLOAD_FOLDER"],
                    secure_filename(f.filename))
            blurred_filename = os.path.join(app.config["UPLOAD_FOLDER"],
					secure_filename(bf.filename))
            f.save(filename)
            bf.save(blurred_filename)
            if query_db("select * from images where title = ?",
                    [request.form["title"]], one=True) is None:
                db = get_db()
                # TODO: We should actually have a check box for has nudity and
                # also accept a second file upload for the blurred file
                db.execute("""insert into images (title, artist, work_type,
                    culture, has_nudity, filename, blurred_filename)
                    values (?, ?, ?, ?, ?, ?, ?)""", [request.form["title"],
                        request.form["artist"], request.form["work_type"],
                        request.form["culture"], False, filename, blurred_filename])
                db.commit()
        return redirect("/upload")

    return """

def upload():
    """ File uploading handler. """
    url = request.args.get('url', None)
    delete = request.args.get('delete', None)
    if request.method == 'POST':
        file = request.files['file']
        if file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file.save(safe_join(app.config['UPLOAD_FOLDER'], filename))
            flash('File ' + filename + ' was uploaded!', 'info')
        else:
            flash('File was not uploaded!', 'error')
    if url is not None:
        file = file_from_url(url)
        if file and allowed_file(file['name']):
            file_name = secure_filename(file['name'])
            file_path = safe_join(app.config['UPLOAD_FOLDER'], file_name)
            with open(file_path, 'wb') as f:
                f.write(file['content'])
            flash('File ' + file_name + ' was uploaded!', 'info')
        else:
            flash('Can not download file!', 'error')
    if delete is not None:
        file = safe_join(app.config['UPLOAD_FOLDER'], delete)
        try:
            os.remove(file)
            flash('Success!', 'info')
        except FileNotFoundError:
            flash('File not found!', 'error')
        except Exception:
            abort(500)
    files = show_files()
    return render_template('upload.html', context={"files": files})

def create_waterproofing():
    #figure out how to resize the image
    form = ReportForm()
    if request.method == 'POST':
        if request.form['action'] == 'Upload':
            bim_file = form.bimimg.data
            if bim_file and allowed_file(bim_file.filename):
                bim_filename = secure_filename(str(uuid.uuid4()) + bim_file.filename)
                bim_file.save(os.path.join(app.config['UPLOAD_FOLDER'], bim_filename))
            else:
                bim_filename = ""
            site_file = form.siteimg.data
            if site_file and allowed_file(site_file.filename):
                site_filename = secure_filename(str(uuid.uuid4()) + site_file.filename)
                site_file.save(os.path.join(app.config['UPLOAD_FOLDER'], site_filename))
            else:
                site_filename = ""
            f = Report(bimimg_filename = bim_filename, siteimg_filename = site_filename, site_caption = form.site_caption.data, date = form.date.data, note = form.note.data, summary = form.summary.data)
            db.session.add(f)
            db.session.commit()
            return redirect(url_for('report_waterproofing'))
        elif request.form['action'] == 'Edit Previous':
            id_object = form.edit_date.data
            r = Report.query.get(id_object.id)
            id = r.id
            return redirect(url_for('edit_waterproofing', id=id))
    elif request.method == 'GET':
        return render_template('create_waterproofing.html', form=form, data_type="Weekly Report", action="Add a")

def import_bookmarks():
    """Import bookmarks from file with json format."""
    if request.method == 'POST':
        filefile = request.files['file']
        if filefile:
            secure_filename(filefile.filename)
            data = filefile.read()
            try:
                decoded_data = data.decode('unicode_escape')
                json_data = json.loads(decoded_data)
                for category_name, value in json_data.items():
                    category = Category(name=category_name.lower())
                    db.session.add(category)
                    db.session.flush()
                    db.session.refresh(category)
                    if isinstance(value, list):
                        for link in value:
                            bookmark = Bookmark(
                                title=urlparse(link).netloc, url=link,
                                category_id=category.id, user_id=g.user.id)
                            db.session.add(bookmark)
                    elif isinstance(value, dict):
                        for title, link in value.items():
                            bookmark = Bookmark(title=title, url=link,
                                                category_id=category.id,
                                                user_id=g.user.id)
                            db.session.add(bookmark)
                db.session.commit()
            except Exception as e:
                db.session.rollback()
                with open('my_error_log.txt') as fob:
                    fob.write(str(e))
    return render_template('bookmarks/import_bookmarks.html')

 def test_secure_filename(self):
     self.assert_equal(utils.secure_filename('My cool movie.mov'),
                       'My_cool_movie.mov')
     self.assert_equal(utils.secure_filename('../../../etc/passwd'),
                       'etc_passwd')
     self.assert_equal(utils.secure_filename(u'i contain cool \xfcml\xe4uts.txt'),
                       'i_contain_cool_umlauts.txt')