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:
