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_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_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_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 _configuploadset(name, constraint): uset = UploadSet(name, constraint) uset._config = UploadConfiguration( conf.UPLOADS_DEFAULT_DEST, conf.UPLOADED_FILES_URL, ) return uset
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_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_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_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_selfserve(self): f, p = UploadSet('files'), UploadSet('photos') setconfig = self.configure(f, p, UPLOADED_FILES_DEST='/var/files', UPLOADED_PHOTOS_DEST='/mnt/photos') fconf, pconf = setconfig['files'], setconfig['photos'] assert fconf == Config('/var/files', None) assert pconf == Config('/mnt/photos', None)
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.modules
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_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_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_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_manual(self): f, p = UploadSet('files'), UploadSet('photos') setconfig = self.configure( f, p, UPLOADED_FILES_DEST='/var/files', UPLOADED_FILES_URL='http://localhost:6001/', UPLOADED_PHOTOS_DEST='/mnt/photos', UPLOADED_PHOTOS_URL='http://localhost:6002/') fconf, pconf = setconfig['files'], setconfig['photos'] assert fconf == Config('/var/files', 'http://localhost:6001/') assert pconf == Config('/mnt/photos', 'http://localhost:6002/')
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.modules
def test_defaults(self): f, p = UploadSet('files'), UploadSet('photos') setconfig = self.configure( f, p, UPLOADS_DEFAULT_DEST='/var/uploads', UPLOADS_DEFAULT_URL='http://localhost:6000/') fconf, pconf = setconfig['files'], setconfig['photos'] assert fconf == Config('/var/uploads/files', 'http://localhost:6000/files/') assert pconf == Config('/var/uploads/photos', 'http://localhost:6000/photos/')
def upload(): images = UploadSet('images', IMAGES) logging.info(request) if request.method == 'POST' and 'image_1' and 'image_2' in request.files: filename_1 = images.save(app.config['UPLOAD'], request.files['image_1']) filename_2 = images.save(app.config['UPLOAD'], request.files['image_2']) rec = Photo(filename=filename, user=g.user.id) rec.store() flash("Photo saved.") return "OK", 204 return "Failed", 404
def test_defaultdest_callable(self): f = UploadSet('files', default_dest=lambda app: os.path.join( app.config['INSTANCE'], 'files')) p = UploadSet('photos') setconfig = self.configure( f, p, INSTANCE='/home/me/webapps/thisapp', UPLOADED_PHOTOS_DEST='/mnt/photos', UPLOADED_PHOTOS_URL='http://localhost:6002/') fconf, pconf = setconfig['files'], setconfig['photos'] assert fconf == Config('/home/me/webapps/thisapp/files', None) assert pconf == Config('/mnt/photos', 'http://localhost:6002/')
def upload_photo(file_data, path, filename): """Uploads a photo to storage.""" photo_set = UploadSet('photos', IMAGES) if photo_set: # Create the thumbnail and preview thumb = create_thumbnail(file_data.stream, THUMB_SIZE) preview = create_thumbnail(file_data.stream, PREVIEW_SIZE) # Save the full size picture and the thumbnail and preview try: photo_set.save(file_data, path, filename) save_image(thumb, path, 'thumb_' + filename) save_image(preview, path, 'preview_' + filename) except Exception, ex: raise ex
def configure_media_uploads(app=None): """ ABOUT This configures the uploading and hosting of our image files. UploadSet is pretty flexible, but we don't do a whole lot to customize this. """ uploaded_photos = UploadSet('photos', IMAGES) configure_uploads(app, uploaded_photos) app.uploaded_photos = uploaded_photos
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')
class Config(object): DEBUG = False TESTING = False CSRF_ENABLED = True SECRET_KEY = os.environ.get('FLASK_SECRET_KEY', 'this-really-needs-to-be-changed') SQLALCHEMY_DATABASE_URI = os.environ.get( 'DATABASE_URL', 'postgresql:///salud_dev?client_encoding=utf8') # Parámetro que indica si el parser de argumentos debe devolver la totalidad de los errores encontrados en una # petición a la API (True), o sólo el primer error (False). BUNDLE_ERRORS = True # Directorio donde guardaremos el archivo #UPLOAD_FOLDER = '/tmp' #ALLOWED_IMG_EXTENSIONS = set(['png']) UPLOADED_PHOTOS_DEST = '/tmp/imagenes' MAX_CONT_IMG_LENGTH = 6 * 1024 * 1024 uploaded_photos = UploadSet('photos', IMAGES) # Claves, pública y privada, de autenticación de la aplicación en Dropbox. DROPBOX_APP_KEY = 'i7u47ht1t730nar' DROPBOX_APP_SECRET = os.environ.get('DROPBOX_APP_SECRET', '')
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.migrate import Migrate from flaskext.markdown import Markdown from flaskext.uploads import UploadSet, configure_uploads, IMAGES app = Flask(__name__) app.config.from_object('settings') db = SQLAlchemy(app) # migrations migrate = Migrate(app, db) # markdown md = Markdown(app, extensions=['fenced_code', 'tables']) # images uploaded_images = UploadSet('images', IMAGES) configure_uploads(app, uploaded_images) from blog import views from user import views
from datetime import datetime from sys import exit from flask import Flask, render_template from flask.ext.mongoengine import MongoEngine from flaskext.uploads import UploadSet, configure_uploads, patch_request_class from flask.ext.assets import Environment, Bundle from mongoengine.connection import ConnectionError # Configure Flask app app = Flask(__name__) app.config.from_object('settings') # Configure uploads vcf_uploads = UploadSet(name = 'vcf', extensions = tuple(app.config['UPLOAD_FORMAT_EXTENSIONS'])) configure_uploads(app, vcf_uploads) patch_request_class(app, app.config['UPLOADED_VCF_MAX_SIZE']) # 128MB max upload size # Attempt connection to MongoDB instance try: db = MongoEngine(app) except ConnectionError, e: print str(e) print "----" print "Are you sure your MongoDB instance is running?" print "If on another server or port, look at settings.py." exit(1) from autozygosity import views, models, helpers, modules # Configure Jinja2 filters
UploadConfiguration) from flask.ext.pymongo import PyMongo import hashlib import subprocess import json import os import zipfile from functools import wraps app = create_app() UPLOAD_DEST = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'static/data') uploaded_files = UploadSet('tracks', ARCHIVES, default_dest=lambda app: app.instance_path) configure_uploads(app, uploaded_files) uploaded_files._config = UploadConfiguration(UPLOAD_DEST) configure_uploads(app, uploaded_files) mongo = PyMongo(app) def check_auth(username, password): """This function is called to check if a username / password combination is valid. """ users = app.config.get('USERS') passkey = app.config.get('SECRET')[0] if username in users and passkey == password: return username
app = Flask(__name__) app.config.from_object(setting) app.debug = True toolbar = DebugToolbarExtension(app) mail = Mail(app) babel = Babel(app) cache = Cache(app) #db = SQLAlchemy(app) principals = Principal(app) login_manager = LoginManager() login_manager.setup_app(app) userimage = UploadSet('userimage', IMAGES) configure_uploads(app, (userimage)) # setting # fix issue of unicode reload(sys) sys.setdefaultencoding("utf-8") # fix issue of forerign_keys problem for SQLite #db.session.execute('PRAGMA foreign_keys=ON;') class SQLiteForeignKeysListener(PoolListener): def connect(self, dbapi_con, con_record): db_cursor = dbapi_con.execute('pragma foreign_keys=ON') class StrictSQLAlchemy(SQLAlchemy):
def test_default_selfserve(self): f, p = UploadSet('files'), UploadSet('photos') setconfig = self.configure(f, p, UPLOADS_DEFAULT_DEST='/var/uploads') fconf, pconf = setconfig['files'], setconfig['photos'] assert fconf == Config('/var/uploads/files', None) assert pconf == Config('/var/uploads/photos', None)
from flask.ext.sqlalchemy import SQLAlchemy from flaskext.uploads import UploadSet, ALL __all__ = ['db'] db = SQLAlchemy() UploadSet.image_path = lambda self, dirname, filename: self.path('%s/%s' % (dirname, filename)) iscsi_images_store = UploadSet('iscsiImage', extensions=ALL, default_dest=lambda app: app.config.get('ISCSI_IMAGES_STORE', '/dev/null') ) iscsi_images_store.resolve_conflict = lambda target_folder, basename: basename pxe_images_store = UploadSet('pxeImage', extensions=ALL, default_dest=lambda app: app.config.get('PXE_IMAGES_STORE', '/dev/null') ) pxe_images_store.resolve_conflict = lambda target_folder, basename: basename kernels_store = UploadSet('kernel', extensions=ALL, default_dest=lambda app: app.config.get('KERNELS_STORE', '/dev/null') ) kernels_store.resolve_conflict = lambda target_folder, basename: basename
from image import * import const ROOT_PATH = os.path.dirname(__file__) ABS_PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) DEBUG = True SECRET_KEY = 'ZL=_K8RJ:e{+6WwdlnX~tR6a|`BoYBi>' UPLOADS_DEFAULT_DEST = ABS_PROJECT_ROOT + "/static" UPLOADS_DEFAULT_URL = 'http://127.0.0.1:5000/static' app = Flask(__name__) app.config.from_object(__name__) app.config.from_envvar('YOUTHING_SETTINGS', silent=True) uploads = UploadSet('uploads', IMAGES) configure_uploads(app, uploads) @app.route("/") def index(): entries = Entry().query(None, 0, const.PAGE_SIZE * 2) categories = Category().query(None, 0, const.MAX_CATEGORY_SIZE) return render_template("index.html", entries=entries, categories=categories, page=2, cat="")
BooleanField, file, FileField, Form, PasswordField, RadioField, SubmitField, TextAreaField, TextField, ValidationError, validators, ) import models savefiles = UploadSet('savefiles', ('user', 'zip')) class RegistrationForm(Form): username = TextField('Username', [ validators.Required(), validators.Length( min=3, max=30, message='Username must be %(min)d - %(max)d chars'), validators.Regexp( '^[A-Za-z0-9\-_]+$', message= 'Username may only contain letters, numbers, dashes and underscores' ) ]) email = TextField('Email', [ validators.Required(),
ADMIN_USERNAME = '******' ADMIN_PASSWORD = '******' COUCHDB_SERVER = 'http://localhost:5984/' COUCHDB_DATABASE = 'flask-photolog' # application app = Flask(__name__) app.config.from_object(__name__) app.config.from_envvar('PHOTOLOG_SETTINGS', silent=True) # uploads uploaded_photos = UploadSet('photos', IMAGES) configure_uploads(app, uploaded_photos) # documents manager = CouchDBManager() def unique_id(): return hex(uuid.uuid4().time)[2:-1] class Post(Document): doc_type = 'post' title = TextField() filename = TextField()
def create_app(app_name, config_obj, with_api=True): """ Generates and configures the main shop application. All additional """ # Launching application app = Flask(app_name) # So the engine would recognize the root package # Load Configuration app.config.from_object(config_obj) # Loading assets assets = Environment(app) assets.from_yaml('assets.yaml') app.assets = assets # Initialize Mail app.mail = Mail(app) # Initializing login manager login_manager = LoginManager() login_manager.login_view = app.config.get('LOGIN_VIEW', 'main.index') # login_manager.login_message = 'You need to be logged in to access this page' login_manager.session_protection = 'strong' login_manager.setup_app(app) app.login_manager = login_manager # Initializing principal manager app.principal = Principal(app) # Initializing bcrypt password encryption bcrypt = Bcrypt(app) app.bcrypt = bcrypt # Initializing Database db = SQLAlchemy(app) app.db = db # Initializing Migrate migrate = Migrate(app, db, "from fitted.models import *") app.migrate = migrate photos = UploadSet('photos', IMAGES) archives = UploadSet('archives', ARCHIVES) configure_uploads(app, (photos, archives)) patch_request_class(app, 2 * 1024 * 1024) # Patches to 2MB file uploads max. app.photos = photos app.archives = archives # Integrate Elasticsearch es_config = app.config.get("ES_CONFIG", []) app.es = Elasticsearch(es_config) # Integrate sms with Twilio app.sms = TwilioRestClient(app.config.get("TWILIO_API_SID"), app.config.get("TWILIO_API_TOKEN")) # Redis store for session management # The process running Flask needs write access to this directory: # store = RedisStore(redis.StrictRedis()) # # this will replace the app's session handling # KVSessionExtension(store, app) # configure sentry # if not app.config.get("DEBUG", False): # sentry = Sentry(app) # app.sentry = sentry # inject celery into the app app.celery = make_celery(app) # injecting mongodb support # app.mongo = PyMongo(app) # flask s3 integration app.s3 = FlaskS3(app) # Facebook & Twitter Integration app.facebook = oauth.remote_app('facebook', app_key='FACEBOOK') oauth.init_app(app) # Initializing the restful API if with_api: api = restful.Api(app, prefix='/api/v1') app.api = api # Initialize Logging if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler( "/var/log/fitted/%s.log" % app.config.get("LOGFILE_NAME", app_name), maxBytes=500 * 1024) file_handler.setLevel(logging.WARNING) from logging import Formatter file_handler.setFormatter( Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) app.logger.addHandler(file_handler) #include an api_registry to the application app.api_registry = [] #a simple list holding the values to be registered return app
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
# GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from flask import Flask, request, redirect, make_response from flaskext.uploads import UploadSet, ALL, configure_uploads from time import time from os import listdir, path from mimetypes import guess_type PATH = '/home/cryptoparty' app = Flask(__name__) messages = UploadSet('messages', ALL, default_dest=lambda _: PATH) configure_uploads(app, (messages, )) @app.route('/', methods=['GET']) def form(): return """\ <html> <head> <title>InsecureDrop</title> </head> <body> <h1>InsecureDrop</h1> Upload a new file:<br /> <form method="POST" enctype="multipart/form-data"> <input type="file" name="message" />
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 flaskext.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_module(cache.cache, url_prefix='/cache') bson.ObjId = bson.objectid.ObjectId # handy reference to otherwise long name
from flask import Flask from flask.ext.mail import Mail from flask.ext.wtf.csrf import CsrfProtect from flaskext.uploads import UploadSet from sponsortracker import data app = Flask(__name__, template_folder='templates', static_folder='static') app.config.from_object("sponsortracker.settings") csrf = CsrfProtect(app) mail = Mail(app) preview_uploader = UploadSet("previews", data.ASSET_FORMATS_EXT)