def test_save_folders(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='foo.txt') res = uset.save(tfs, folder='someguy') assert res == 'someguy/foo.txt' assert tfs.saved == '/uploads/someguy/foo.txt'
def test_save_namedext(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='boat.jpg') res = uset.save(tfs, name='photo_123.') assert res == 'photo_123.jpg' assert tfs.saved == '/uploads/photo_123.jpg'
def test_save_named(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='foo.txt') res = uset.save(tfs, name='file_123.txt') assert res == 'file_123.txt' assert tfs.saved == '/uploads/file_123.txt'
def test_conflict(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='foo.txt') self.extant('/uploads/foo.txt') res = uset.save(tfs) assert res == 'foo_1.txt'
def test_implicit_folder(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='boat.jpg') res = uset.save(tfs, name='someguy/photo_123.') assert res == 'someguy/photo_123.jpg' assert tfs.saved == '/uploads/someguy/photo_123.jpg'
def test_multi_conflict(self): uset = UploadSet('files') uset._config = Config('/uploads') tfs = TestingFileStorage(filename='foo.txt') self.extant('/uploads/foo.txt', *('/uploads/foo_%d.txt' % n for n in range(1, 6))) res = uset.save(tfs) assert res == 'foo_6.txt'
def test_conflict_without_extension(self): # Test case for issue #7. uset = UploadSet('files', extensions=('')) uset._config = Config('/uploads') tfs = TestingFileStorage(filename='foo') self.extant('/uploads/foo') res = uset.save(tfs) assert res == 'foo_1'
def test_filenames(self): uset = UploadSet('files') uset._config = Config('/uploads') namepairs = ( ('foo.txt', True), ('boat.jpg', True), ('warez.exe', False) ) for name, result in namepairs: tfs = TestingFileStorage(filename=name) assert uset.file_allowed(tfs, name) is result
def test_secured_filename(self): uset = UploadSet('files', ALL) uset._config = Config('/uploads') tfs1 = TestingFileStorage(filename='/etc/passwd') tfs2 = TestingFileStorage(filename='../../myapp.wsgi') res1 = uset.save(tfs1) assert res1 == 'etc_passwd' assert tfs1.saved == '/uploads/etc_passwd' res2 = uset.save(tfs2) assert res2 == 'myapp.wsgi' assert tfs2.saved == '/uploads/myapp.wsgi'
def test_url_generated(self): app = Flask(__name__) app.config.update( UPLOADED_FILES_DEST='/uploads' ) uset = UploadSet('files') configure_uploads(app, uset) with app.test_request_context(): url = uset.url('foo.txt') gen = url_for('_uploads.uploaded_file', setname='files', filename='foo.txt', _external=True) assert url == gen
def test_url_based(self): app = Flask(__name__) app.config.update( UPLOADED_FILES_DEST='/uploads', UPLOADED_FILES_URL='http://localhost:5001/' ) uset = UploadSet('files') configure_uploads(app, uset) with app.test_request_context(): url = uset.url('foo.txt') assert url == 'http://localhost:5001/foo.txt' assert '_uploads' not in app.blueprints
def upload(): ''' ''' form = PseudoForm() if form.validate_on_submit(): docs = UploadSet('docs',DOCUMENTS) #filename = secure_filename(form.pseudo.data.filename) filename = docs.save(form.pseudo.data) #docs.url(filename) flash('You have save file',filename) else: filename = None return render_template('upload.html',form = form,filename= filename)
def test_path(self): uset = UploadSet('files') uset._config = Config('/uploads') assert uset.path('foo.txt') == '/uploads/foo.txt' assert uset.path('someguy/foo.txt') == '/uploads/someguy/foo.txt' assert (uset.path('foo.txt', folder='someguy') == '/uploads/someguy/foo.txt') assert (uset.path('foo/bar.txt', folder='someguy') == '/uploads/someguy/foo/bar.txt')
import os import re from typing import Union from werkzeug.datastructures import FileStorage from flask_uploads import UploadSet, IMAGES IMAGE_SET = UploadSet("images", IMAGES) # set folder name and allowed extensions def save_image(image: FileStorage, folder: str = None, name: str = None) -> str: return IMAGE_SET.save(image, folder, name) def get_path(filename: str = None, folder: str = None) -> str: return IMAGE_SET.path(filename, folder) def find_image_any_format(filename: str, folder: str) -> Union[str, None]: """ Given a format-less filename, try to find the file by appending each of the allowed formats to the given filename and check if the file exists :param filename: formatless filename :param folder: the relative folder in which to search :return: the path of the image if exists, otherwise None """ for _format in IMAGES: # look for existing avatar and delete it avatar = f"{filename}.{_format}"
@login_required def map_key(): sc = SC() return json.dumps(sc.map_key) @app.errorhandler(404) def page_not_found(error): return render_template('index.html') ############################# Upload Setup ############################ app.config['UPLOADED_XMLFILES_DEST'] = get_tmp_dir() app.config['UPLOADED_IMAGEFILES_DEST'] = os.path.join(sc_dir(), STATIC_DIR) app.config['EARTHQUAKES'] = get_data_dir() app.config['MESSAGES'] = {} xml_files = UploadSet('xmlfiles', ('xml',)) image_files = UploadSet('imagefiles', IMAGES, default_dest=app.config['UPLOADED_IMAGEFILES_DEST']) configure_uploads(app, (xml_files,image_files)) ui = UI() def get_file_type(file_name): ext = file_name.split('.')[-1] if ext in ['jpg', 'jpeg', 'png', 'bmp']: return 'image' elif ext in ['xml']: return 'xml' def parse_args(args_in): args = {} for key in list(args_in.keys()): args[key] = json.loads(args_in[key])
from flask_bootstrap import Bootstrap from config import config_options from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_uploads import UploadSet, configure_uploads, IMAGES from flask_mail import Mail bootstrap = Bootstrap() db = SQLAlchemy() mail = Mail() login_manager = LoginManager() login_manager.session_protection = "strong" login_manager.login_view = "auth.login" photos = UploadSet("photos", IMAGES) def create_app(config_name): app = Flask(__name__) # Creating the app configurations app.config.from_object(config_options[config_name]) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) # configure UploadSet configure_uploads(app, photos)
# create line graph x_axis, y_axis, group_axis = 'date', 'close_price', 'symbol' linechart = support.create_line_chart(S2, x_axis, y_axis, y_axis, group_axis) ''' ''' return render_template( 'visualise.html', linechart=linechart, table=json.dumps(go.Figure(), cls=plotly.utils.PlotlyJSONEncoder), title='Visualise', year=datetime.now().year, message='Visualize digested data using plotly') docs = UploadSet('docs') @app.route('/upload_data', methods=['GET', 'POST']) def upload_data(): print("accessed upload_data!") print("Posted file: {}".format(request.files['file'])) if request.method == 'POST': flash("Machine Data saved.") # get file doc = request.files['file'] parent_dir = 'Application/programs/sample_data/' print(doc.filename)
from flask_uploads import UploadSet, configure_uploads, AUDIO from sqlalchemy import create_engine, desc from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy import create_engine from pytz import timezone from clipthatoff.models import Drop, db, AdminUser, ClickStat, SearchStat from clipthatoff.create import create_app application = app = Flask(__name__) app = create_app() audio = UploadSet('audio', AUDIO) app.config['UPLOADED_AUDIO_DEST'] = os.environ['UPLOAD_PATH'] configure_uploads(app, audio) app.app_context().push() s3 = boto3.client('s3') TIMEZONE = timezone('America/Chicago') @app.route('/') @app.route('/<search_term>') def home(search_term=None, speaker=None): return render_template("index.html", search_term=search_term if search_term and len(search_term) >=3 else None)
from flask_sqlalchemy import SQLAlchemy from flask_jwt_extended import JWTManager from flask_uploads import UploadSet, IMAGES db = SQLAlchemy() jwt = JWTManager() image_set = UploadSet('images', IMAGES)
def test_default_extensions(self): uset = UploadSet('files') uset._config = Config('/uploads') extpairs = (('txt', True), ('jpg', True), ('exe', False)) for ext, result in extpairs: assert uset.extension_allowed(ext) is result
import os from flask import Flask,render_template,request,url_for from flask_uploads import UploadSet, configure_uploads,ALL PEOPLE_FOLDER = os.path.join('static', 'people_photo') app=Flask(__name__) videos= UploadSet('videos',ALL) app.config['UPLOADED_VIDEOS_DEST']='./static' configure_uploads(app,videos) @app.route('/upload',methods=['GET','POST']) def upload(): if request.method=='POST' and 'video' in request.files: filename=videos.save(request.files['video'],name="Video.mp4") os.system('python vidToScreenshots.py --vidName=Video.mp4') return render_template('uploadComplete.html') @app.route('/splitVideo',methods=['GET','POST']) def send(): if request.method=='POST': os.system('python vidToScreenshots.py --vidName=') return "Done" @app.route('/gallery',methods=['GET','POST']) def sendImage(): if request.method=='GET':
class PasswordResetForm(FlaskForm): password = PasswordField('新密码', validators=[ DataRequired(), EqualTo('password2', message='密码必须一致')]) password2 = PasswordField('确认密码', validators=[DataRequired()]) submit = SubmitField('重设密码') from flask_wtf.file import FileField, FileAllowed from flask_uploads import UploadSet, IMAGES PDF = tuple('pdf'.split()) WORD = tuple('doc docx'.split()) pdfs = UploadSet('pdfs',PDF) photos = UploadSet('photos', IMAGES) words = UploadSet('words',WORD) class PdfForm(FlaskForm): pdf = FileField(u'上传PDF文件', validators=[ FileAllowed(['pdf'], u'只能上传PDF!')]) submit = SubmitField('PDF转换为WORD') class PhotoForm(FlaskForm): photo = FileField(u'上传图片', validators=[ FileAllowed(photos, u'只能上传图片!')]) submit = SubmitField('图片转换为WORD') class TranslateForm(FlaskForm):
from flask_wtf import FlaskForm from flask_wtf.file import FileField, FileAllowed from wtforms import TextAreaField, IntegerField, StringField from wtforms.validators import DataRequired, InputRequired, Length from flask_uploads import UploadSet homework_ups = UploadSet('files') class HomeworkForm(FlaskForm): text = TextAreaField('作业') homework_up = FileField( '作业附件', validators=[FileAllowed(homework_ups, '爷爷你上传了什么?')]) class CreateTeamForm(FlaskForm): team_name = StringField('团队名称', validators=[DataRequired()]) status = IntegerField('队伍状态') class MemberForm(FlaskForm): member_id = IntegerField(validators=[InputRequired]) class EditTeam(FlaskForm): new_name = StringField('队伍名称', validators=[DataRequired()])
from flask import Flask, render_template, request from flask_uploads import UploadSet, configure_uploads, ALL fileset = UploadSet('files', ALL) app = Flask(__name__) app.config['UPLOADED_FILES_DEST'] = 'uploads/' configure_uploads(app, fileset) @app.route('/', methods=['GET', 'POST']) def index(): if request.method == 'POST' and 'file' in request.files: filename = fileset.save(request.files['file']) return filename return render_template('upload.html') if __name__ == '__main__': app.run(debug=True)
import config from flask import Flask from flask_bootstrap import Bootstrap from flask_uploads import UploadSet,IMAGES,configure_uploads bootstrap = Bootstrap() photos = UploadSet('PHOTOS') def create_app(): app = Flask(__name__) app.config.from_object(config) bootstrap.init_app(app) configure_uploads(app, photos) from .main import main app.register_blueprint(main) return app
class UploadLogoForm(StripWhitespaceForm): images = UploadSet("images", IMAGES) image = FileField(validators=[FileAllowed(images, "Images only!")])
import shutil from flask import flash, session, make_response from flask import request, render_template, redirect, url_for from flask_uploads import UploadSet, IMAGES, configure_uploads, UploadNotAllowed from apps import app from apps.utils import secure_filename_with_uuid # 登陆装饰器检查登录状态 from apps.forms import LoginForm, RegistForm, PwdForm, InfoForm from apps.model import User from apps.sqlite3_manage import query_user_by_name, query_users_from_db, \ insert_user_to_db, delete_user_by_name, update_user_by_name # 创建 UploadSet 类的实例 photosSet = UploadSet(name='photos', extensions=IMAGES) # 配置FlaskUpLoad 和 app configure_uploads(app, photosSet) def user_login_req(f): @wraps(f) def decorated_function(*args, **kwargs): if "user_name" not in session: return redirect(url_for("user_login", next=request.url)) return f(*args, **kwargs) return decorated_function
def configure_map_uploads(app): maps = UploadSet("maps", extensions=["dat"]) configure_uploads(app, maps) logger.info("Map uploads configured.") return maps
model = keras.models.load_model("./saved_models/weights.best.basic_cnn.hdf5") le = LabelEncoder() le.classes_ = np.load("./saved_models/classes.npy") # data dims num_rows = 40 num_columns = 174 num_channels = 1 # CODE FOR FLASK APP app = Flask(__name__, static_folder=os.path.join(os.getcwd(), "static")) app.config['SECRET_KEY'] = "clishmaclaver" app.config['UPLOADED_AUDIOSET_DEST'] = "static" audioset = UploadSet("audioset", AUDIO) configure_uploads(app, audioset) class AudioClassifyForm(FlaskForm): audio = FileField("audio") @app.route("/", methods=["GET", "POST"]) def home(): form = AudioClassifyForm() if form.validate_on_submit(): filename = audioset.save(form.audio.data) filename = os.path.join(os.getcwd(), "static", filename) features = extract_features(filename) features = features.reshape(40, 174, 1)
import cache from flask import (Flask, make_response, request, jsonify, session, render_template, redirect, url_for, send_from_directory, flash, abort) from flask.ext.pymongo import PyMongo from flask_uploads import (UploadSet, configure_uploads, IMAGES, DATA, DOCUMENTS, UploadConfiguration) from logging import FileHandler from werkzeug import secure_filename from utilities import ObjectIdCleaner app = Flask(__name__) app.config.from_pyfile('conf.py') mongo = PyMongo(app) plugin_upload = UploadSet('plugins', ('js', 'css'), default_dest=lambda app: app.instance_path) plugin_upload._config = UploadConfiguration(app.config.get( 'PLUGIN_UPLOAD_FOLDER')) files_upload = UploadSet('files', IMAGES + DOCUMENTS + DATA + ('pdf',), default_dest=lambda app: app.instance_path) files_upload._config = UploadConfiguration(app.config.get( 'FILE_UPLOAD_FOLDER')) configure_uploads(app, plugin_upload) configure_uploads(app, files_upload) app.register_blueprint(cache.cache, url_prefix='/cache') bson.ObjId = bson.objectid.ObjectId # handy reference to otherwise long name
from flask import Flask, render_template from flask_wtf import FlaskForm from wtforms import FileField from flask_uploads import configure_uploads, IMAGES, UploadSet app = Flask(__name__) app.config['SECRET_KEY'] = 'thisisasecret' app.config['UPLOADED_IMAGES_DEST'] = 'uploads/images' images = UploadSet('images', IMAGES) configure_uploads(app, images) class MyForm(FlaskForm): image = FileField('image') @app.route('/', methods=['GET', 'POST']) def index(): form = MyForm() if form.validate_on_submit(): filename = images.save(form.image.data) return f'Filename: { filename }' return render_template('index.html', form=form)
""" from flask_cors import CORS from flask_elasticsearch import FlaskElasticsearch from flask_jwt_extended import JWTManager from flask_mail import Mail from flask_sqlalchemy import SQLAlchemy from flask_principal import Principal from alexandria.modules.utils.vendor.flask_restplus_patched import Api from flask_babel import Babel from flask_migrate import Migrate # from flask_caching import Cache from flask_rq2 import RQ from flask_uploads import IMAGES, UploadSet __author__ = 'oclay' es = FlaskElasticsearch(using='default') db = SQLAlchemy() api = Api(prefix='/api', doc='/api/doc', ui=False, title='Alexandria API') jwt = JWTManager() rq = RQ() principal = Principal() mail = Mail() migrate = Migrate() babel = Babel() # cache = Cache() corsd = CORS() document_file = UploadSet('documents', ('pdf',)) thumbnail_image = UploadSet('thumbnails', IMAGES) profile_image = UploadSet('profiles', IMAGES)
from flask import Flask from flask_mongoengine import MongoEngine from flask_cors import CORS from flask_jwt_extended import JWTManager from flask_uploads import UploadSet, configure_uploads from config import config_map db = MongoEngine() jwt = JWTManager() files = UploadSet('files') def create_app(config_name): """ :param config_name: str 配置名称:{develop,product} :return: """ app = Flask(__name__) app.config.from_object(config_map.get(config_name)) # 允许跨域 CORS(app, supports_credentials=True) db.init_app(app) jwt.init_app(app) configure_uploads(app, files) from app import service_api from app import process_manage_api from app import data_manage_api app.register_blueprint(service_api.api, url_prefix='/service') app.register_blueprint(process_manage_api.api,
from flask import render_template, redirect, session, url_for from flask_uploads import configure_uploads, UploadSet, send_from_directory from web.forms import UploadFile import json as json from networkx.exception import NetworkXError # imports will be needed later # import requests from os.path import join, dirname, realpath import os import networkx as nx # from networkx import NetworkXError as NetworkXError # from datetime import datetime graph = UploadSet( 'graph', app.config['ALLOWED_EXTENSIONS'] ) # configures flask file uploads likes to allowed extention env variable configure_uploads(app, graph) # instantiates file upload object @app.route("/", methods=['GET', 'POST']) def home(): # gets class objects with form form = UploadFile() if form.validate_on_submit(): #vaildats form filename = graph.save( form.choosefile.data ) # see docs https://pypi.org/project/Flask-Uploads/ print(filename) # prints file name to teminal
from datetime import datetime from flask import Blueprint, render_template, redirect, url_for, flash, abort, request from flask_login import login_required, current_user import commonmark from app import db from app.decorators import admin_required from app.models import * from app.blueprints.admin.views import admin from wtforms import Flags from .forms import * from flask_uploads import UploadSet, IMAGES from flask_wtf.file import FileAllowed images = UploadSet('images', IMAGES) photos = UploadSet('photos', IMAGES) @admin.route('/settings/team/') @login_required @admin_required def team_dashboard(): """Team dashboard page.""" return render_template('admin/team/team_settings_dashboard.html') @admin.route('/add/team', methods=['Get', 'POST']) @login_required def add_team(): org = Organisation.query.get(1) form = TeamForm()
from pymongo import MongoClient from celery import Celery from flask_uploads import UploadSet, configure_uploads, TEXT, patch_request_class from config import * bootstrap = Bootstrap() mail = Mail() moment = Moment() db = MongoClient() celery = Celery(APP_NAME, broker=CELERY_BROKER_URL) texts = UploadSet('texts', TEXT) login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'auth.signin' def create_app(): app = Flask(__name__) app.config.from_object('config') bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) login_manager.init_app(app)
from logging.handlers import RotatingFileHandler, SMTPHandler from flask_uploads import UploadSet, configure_uploads, IMAGES, patch_request_class from flask_mail import Mail from flask_bootstrap import Bootstrap import os import logging app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy(app) migrate = Migrate(app, db) login = LoginManager(app) login.login_view = 'login' mail = Mail(app) bootstrap = Bootstrap(app) photos = UploadSet('photos', extensions='jpg') configure_uploads(app, photos) patch_request_class(app) # set maximum file size, default is 16MB from app import routes, models, errors if not app.debug: if app.config['MAIL_SERVER']: auth = None if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']: auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) secure = None if app.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
import os import pymongo from bson.objectid import ObjectId from flask_uploads import UploadSet, IMAGES, configure_uploads app = Flask(__name__) # Image and file upload configuration TOP_LEVEL_DIR = os.path.abspath(os.curdir) upload_dir = '/static/uploads/img/' app.config["UPLOADS_DEFAULT_DEST"] = TOP_LEVEL_DIR + upload_dir app.config["UPLOADED_IMAGES_DEST"] = TOP_LEVEL_DIR + upload_dir app.config["UPLOADED_IMAGES_URL"] = upload_dir # UploadSet for images images_upload_set=UploadSet('images', IMAGES) configure_uploads(app, images_upload_set) # Create the connection to MongoDB conn = pymongo.MongoClient(os.getenv("MONGO_URI")) # Define the Database used for easy reference and future updates RECIPE_DATABASE = 'online_cookbook' # Route to homepage @app.route("/") def index(): return render_template("index.html") # Route to recipes list
from flask import Flask, render_template, redirect, url_for from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate, MigrateCommand from flask_script import Manager from flask_uploads import UploadSet, configure_uploads, IMAGES from flask_wtf import FlaskForm from wtforms import StringField, IntegerField, TextAreaField from flask_wtf.file import FileField, FileAllowed app = Flask(__name__) photos = UploadSet('photos', IMAGES) app.config['UPLOADED_PHOTOS_DEST'] = 'images' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///trendy.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['DEBUG'] = True app.config['SECRET_KEY'] = 'mysecret' configure_uploads(app, photos) db = SQLAlchemy(app) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) class Product(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=True)
from flask import Flask, render_template, request from flask_uploads import UploadSet, configure_uploads, IMAGES, AUDIO, TEXT import os import shutil #os.chdir('C:\\Users\\Mchig\\Desktop\\DeepSpeach') #print (os.getcwd(), "F**K YOU ALL") app = Flask(__name__) photos = UploadSet('photos', TEXT ) app.config['UPLOADED_PHOTOS_DEST'] = os.path.dirname(os.path.realpath(__file__)) + '/test_Result' configure_uploads(app, photos) def openlight(): return "Open the Light Success" def closelight(): return "Close the Light Success" def Lock(): return "Lock the Key Success" def UnLock(): return "Unlock the Key Success" def OpenFile( ): FileDir = os.path.dirname(os.path.realpath(__file__)) + '/test_Result' FileName = os.path.join( FileDir, "test.txt") file = open( FileName, 'r' )
def configure_schematic_uploads(app): schematics = UploadSet("schematics", extensions=["schematic", "schem"]) configure_uploads(app, schematics) logger.info("Schematic uploads configured.") return schematics
from forms import data_cache, AdminRequestForm from random import randint from flask_login import login_required, login_user, current_user from flask_uploads import UploadSet, UploadNotAllowed, IMAGES, TEXT, DOCUMENTS, DATA import json import os RAW_FILES = TEXT + DOCUMENTS + DATA EXT = '.silt' main = Blueprint('main', __name__) auth = Blueprint('auth', __name__) web = Blueprint('web', __name__) public_photos = UploadSet( 'photos', IMAGES, default_dest=lambda app: os.environ.get('GENERAL_UPLOAD_DIRECTORY')) public_raw_files = UploadSet( 'rawFiles', RAW_FILES, default_dest=lambda app: os.environ.get('GENERAL_UPLOAD_DIRECTORY')) premium_photos = UploadSet( 'PremiumPhotos', IMAGES, default_dest=lambda app: os.environ.get('PREMIUM_UPLOAD_DIRECTORY')) premium_raw_files = UploadSet( 'PremiumRawFiles', RAW_FILES, default_dest=lambda app: os.environ.get('PREMIUM_UPLOAD_DIRECTORY')) known_clients = ('TuqOnPC', 'TuqOnMobile') all_course_ranks = 'tuq:all_course_rank'
import os import re from typing import Union from werkzeug.datastructures import FileStorage from flask_uploads import UploadSet, ALL # set name and allowed extensions CERTIFICATE_SET = UploadSet("certificates", ALL) def save_certificate(certificate: FileStorage, folder: str = None, name: str = None) -> str: return CERTIFICATE_SET.save(certificate, folder, name) def get_path(filename: str = None, folder: str = None) -> str: return CERTIFICATE_SET.path(filename, folder) # def find_image_any_format(filename: str, folder: str) -> Union[str, None]: # """ # Given a format-less filename, try to find the file by appending each of the allowed formats to the given # filename and check if the file exists # :param filename: formatless filename # :param folder: the relative folder in which to search # :return: the path of the image if exists, otherwise None # """ # for _format in IMAGES: # look for existing avatar and delete it # avatar = f"{filename}.{_format}" # avatar_path = IMAGE_SET.path(filename=avatar, folder=folder) # if os.path.isfile(avatar_path):
from flask import Flask, render_template, request, url_for, redirect from flask_uploads import UploadSet, configure_uploads, IMAGES, DATA, ALL from werkzeug import secure_filename import pandas as pd import pygal import io import os app = Flask(__name__) # Configurações para o Upload de Arquivos files = UploadSet('files', ALL) app.config['UPLOADED_FILES_DEST'] = 'static/dados' app.config['ALLOWED_EXTENSIONS'] = ['CSV'] configure_uploads(app, files) def allowed_extension(filename): if not '.' in filename: return False ext = filename.rsplit('.', 1)[1] if ext.upper() in app.config['ALLOWED_EXTENSIONS']: return True else: return False # Rota Índice @app.route('/') def index(): return render_template('index.html')
from app_oauth import require_oauth from authlib.integrations.flask_oauth2 import current_token from forms import AlbumForm from models import db, Album, User, Sound, SoundTag import json from utils.various import add_user_log, get_hashed_filename from datas_helpers import to_json_relationship, to_json_account, to_json_album from sqlalchemy import and_ from flask_uploads import UploadSet from utils.defaults import Reel2bitsDefaults import os import sqlalchemy.exc bp_api_albums = Blueprint("bp_api_albums", __name__) artworkalbums = UploadSet("artworkalbums", Reel2bitsDefaults.artwork_extensions_allowed) @bp_api_albums.route("/api/albums", methods=["POST"]) @require_oauth("write") def new(): """ Create a new album. --- tags: - Albums security: - OAuth2: - write responses: 200: