def create_app(config_name): app= Flask(__name__) app.config.from_object(config_by_name[config_name] ) UPLOAD_FOLDER = r'D:\aqua\apps\static\downloads' ALLOWED_EXTENSIONS= set(['txt','json','csv','xlsx']) app.config['UPLOADS_DEFAULT_DEST'] = UPLOAD_FOLDER app.config['UPLOAD_FOLDER'] ='downloads' docs = UploadSet('docs',DOCUMENTS) configure_uploads(app,docs) patch_request_class(app) celery.conf.update(CeleryConfig) mail.init_app(app) ''' db.init_app(app) toolbar.init_app(app) pagedown.init_app(app) ''' login_manager.init_app(app) moment.init_app(app) bootstrap.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) configure_uploads(app, photos) patch_request_class(app) # 限制文件上传大小 bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) pagedown.init_app(app) # oauth.init_app(app) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify sslify = SSLify(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .api_1_0 import api as api_1_0_blueprint app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) global photos photos = UploadSet('photos', IMAGES) app.config['UPLOADED_PHOTOS_DEST'] = 'app/static/' configure_uploads(app, photos) bootstrap.init_app(app) db.init_app(app) mail.init_app(app) moment.init_app(app) login_manager.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .employees import employees as employees_blueprint app.register_blueprint(employees_blueprint, url_prefix='/employees') from .reports import reports as reports_blueprint app.register_blueprint(reports_blueprint, url_prefix='/reports') from .loans import loans as loans_blueprint app.register_blueprint(loans_blueprint, url_prefix='/loans') return app
def register_extensions(app): csrf.init_app(app) session.init_app(app, app.config["STORE"]) db.init_app(app) cas.init_app(app, '/cas') prints = UploadSet(name='prints', extensions=['stl', 'obj']) configure_uploads(app, (prints)) bootstrap.init_app(app)
def create_app(sqlalchemy_uri=None): from flask import Flask, request_started, request, request_finished, g from flask_bootstrap import Bootstrap from flask_dogpile_cache import DogpileCache import os app = Flask(__name__) app.config.from_object('APITaxi_front.default_settings') if 'APITAXI_CONFIG_FILE' in os.environ: app.config.from_envvar('APITAXI_CONFIG_FILE') if not 'ENV' in app.config: app.logger.error('ENV is needed in the configuration') return None if app.config['ENV'] not in ('PROD', 'STAGING', 'DEV'): app.logger.error("""Here are the possible values for conf['ENV']: ('PROD', 'STAGING', 'DEV') your's is: {}""".format(app.config['env'])) return None #Load configuration from environment variables for k in app.config.keys(): if not k in os.environ: continue app.config[k] = os.environ[k] if sqlalchemy_uri: app.config['SQLALCHEMY_DATABASE_URI'] = sqlalchemy_uri from APITaxi_models import db db.init_app(app) from . import backoffice backoffice.init_app(app) from . import documentation documentation.init_app(app) Bootstrap(app) from APITaxi_utils.version import check_version, add_version_header request_started.connect(check_version, app) request_finished.connect(add_version_header, app) from flask_uploads import configure_uploads from .backoffice.extensions import images configure_uploads(app, (images)) from APITaxi_utils.login_manager import init_app as init_login_manager from .backoffice.forms.login import LoginForm from .extensions import user_datastore init_login_manager(app, user_datastore, LoginForm) from . import demo demo.create_app(app) from APITaxi_models import security user_datastore.init_app(db, security.User, security.CachedUser, security.Role) cache = DogpileCache() cache.init_app(app) return app
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 create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) configure_uploads(app, files) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['CORS_HEADERS'] = 'Content-Type' config[config_name].init_app(app) db.init_app(app) cors.init_app(app) configure_uploads(app, userFiles) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .api import api as api_blueprint app.register_blueprint(api_blueprint) return app
def test_file_allowed_uploadset(app, form): pytest.importorskip('flask_uploads') from flask_uploads import UploadSet, configure_uploads app.config['UPLOADS_DEFAULT_DEST'] = 'uploads' txt = UploadSet('txt', extensions=('txt',)) configure_uploads(app, (txt,)) form.file.kwargs['validators'] = [FileAllowed(txt)] f = form() assert f.validate() f = form(file=FileStorage(filename='test.txt')) assert f.validate() f = form(file=FileStorage(filename='test.png')) assert not f.validate() assert f.file.errors[0] == 'File does not have an approved extension.'
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) configure_logging() app.jinja_env.globals.update(slugify=slugify) app.jinja_env.globals.update(truncate=truncate) app.jinja_env.globals.update(url=ads.url) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) configure_uploads(app, (ads, imgs, landings)) mail.init_app(app) babel.init_app(app) afla_manager.init_app(app) from .models import Post whoosh_index(app, Post) from .aflafrettir import aflafrettir as afla_blueprint from .auth import auth as auth_blueprint from .admin import admin as admin_blueprint from .rss import feed as feed_blueprint app.register_blueprint(afla_blueprint) app.register_blueprint(auth_blueprint, url_prefix='/auth') app.register_blueprint(admin_blueprint, url_prefix='/admin') app.register_blueprint(feed_blueprint, url_prefix='/feed') from helpers.image import start_image_deletion_thread #pylint: disable-msg=W0612 @app.before_first_request def before_first_request(): start_image_deletion_thread() return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) moment.init_app(app) login_manager.init_app(app) login_manager.login_view = 'auth.login' db.init_app(app) from .main import main from .auth import auth from .manager import manager app.register_blueprint(main) app.register_blueprint(auth) app.register_blueprint(manager) configure_uploads(app, photos) patch_request_class(app) from .models import Message, User, Post, Praise, Comment, Collection app.add_template_global(Message, 'Message') app.add_template_global(User, 'User') app.add_template_global(Post, 'Post') app.add_template_global(Comment, 'Comment') return app
def create_app(config_name): app = Flask(__name__) # Creating the app configurations app.config.from_object(config_options[config_name]) config_options[config_name].init_app(app) # Initializing flask extensions bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) mail.init_app(app) simple.init_app(app) # Registering the blueprint from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint,url_prefix = '/auth') # setting config from .request import configure_request configure_request(app) #........ # configure UploadSet configure_uploads(app,photos) return app
def create_app(settings=None): """ Create flask application """ app = Flask(__name__) app.secret_key = 'plante website' app.register_blueprint(simple_page) if settings: app.config.update(settings) DATA_BASE.init_app(app) api.init_app(app) compress = Compress() compress.init_app(app) configure_uploads(app, uploaded_image) handler = RotatingFileHandler('ueki.log', maxBytes=100000, backupCount=1) handler.setLevel(DEBUG) app.logger.addHandler(handler) logger = getLogger('werkzeug') logger.addHandler(handler) return app
def create(): con = db.connect() cursor = con.cursor(db.getDictCursor()) cursor.execute("SELECT * FROM categories") categories = cursor.fetchall() cursor.execute("SELECT * FROM types") types = cursor.fetchall() form = ProductForm(request.form, csrf_enabled=False) if request.method == 'POST' and form.validate_on_submit(): sku = request.form['sku'] or 'NULL' name = request.form['name'] or 'NULL' description = request.form['description'] or 'NULL' category_id = request.form['category_id'] type_id = request.form['type_id'] normal_price = request.form['normal_price'] or 0 point = request.form['point'] or 0 weight = request.form['weight'] or 0 extra_fee = request.form['extra_fee'] or 0 created_by = session['user_id'] or 'NULL' medias = request.files.getlist("medias[]") is_disabled = 'is_disabled' in request.form file_url = "" sizes = ["S", "M", "L", "XL", "XXL"] type = "image" if is_disabled == True: is_disabled = 1 else: is_disabled = 0 photos = UploadSet('photos', IMAGES) configure_uploads(app, photos) con = db.connect() cursor = con.cursor(db.getDictCursor()) try: cursor.execute( "INSERT INTO \ products( \ category_id, type_id, sku, name,\ description, normal_price, point, weight, extra_fee, \ is_disabled, created_by \ ) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", (category_id, type_id, sku, name, description, normal_price, point, weight, extra_fee, is_disabled, created_by)) product_id = cursor.lastrowid for size in sizes: cursor.execute( "INSERT INTO product_sizes(product_id, size) VALUES(%s, %s)", (product_id, size)) for i, media in enumerate(medias): sorting = str(request.form['sorting_' + str(i + 1)]) if allowed_file(media.filename): filename = photos.save(media) path = photos.url(filename) cursor.execute( "INSERT INTO product_media(product_id, path, sorting, type) VALUES(%s, %s, %s, %s)", (product_id, path, sorting, type)) con.commit() flash('Operation success') return redirect(url_for('product.create')) except cursor.InternalError as e: code, message = e.args con.rollback() flash(message) return redirect(url_for('product.create')) finally: con.close() return render_template('back/product/create.html', form=form, categories=categories, types=types)
def create_app(sqlalchemy_uri=None): from .extensions import redis_store, redis_store_haillog, user_datastore app = Flask(__name__) app.config.from_object('APITaxi.default_settings') if 'APITAXI_CONFIG_FILE' in os.environ: app.config.from_envvar('APITAXI_CONFIG_FILE') if not 'ENV' in app.config: app.logger.error('ENV is needed in the configuration') return None if app.config['ENV'] not in ('PROD', 'STAGING', 'DEV'): app.logger.error("""Here are the possible values for conf['ENV']: ('PROD', 'STAGING', 'DEV') your's is: {}""".format(app.config['env'])) return None #Load configuration from environment variables for k in app.config.keys(): if not k in os.environ: continue app.config[k] = os.environ[k] if sqlalchemy_uri: app.config['SQLALCHEMY_DATABASE_URI'] = sqlalchemy_uri from APITaxi_models import db db.init_app(app) redis_store.init_app(app) redis_store.connection_pool.get_connection(0).can_read() redis_store_haillog.init_app(app) redis_store_haillog.connection_pool.get_connection(0).can_read() from . import api api.init_app(app) from APITaxi_utils.version import check_version, add_version_header request_started.connect(check_version, app) request_finished.connect(add_version_header, app) from flask_uploads import configure_uploads from .api.extensions import documents configure_uploads(app, (documents,)) from APITaxi_utils.login_manager import init_app as init_login_manager init_login_manager(app, user_datastore, None) from . import tasks tasks.init_app(app) from APITaxi_models import security user_datastore.init_app(db, security.User, security.CachedUser, security.Role) cache = DogpileCache() cache.init_app(app) @app.before_first_request def warm_up_redis(): from APITaxi.commands.warm_up_redis import warm_up_redis_func warm_up_redis_func(app, db, security.User, redis_store) from APITaxi_models.hail import HailLog def delete_redis_keys(response): from flask import g if not hasattr(g, 'keys_to_delete'): return response redis_store.delete(*g.keys_to_delete) return response app.after_request_funcs.setdefault(None, []).append( HailLog.after_request(redis_store_haillog) ) app.after_request_funcs.setdefault(None, []).append( delete_redis_keys ) return app
def app_init(): setup_logging() app = Flask(__name__) app.wsgi_app = ProxyFix(app.wsgi_app, num_proxies=1) app.config.from_object(FlaskConfig) if app.config['LOCAL']: CORS(app) if not app.config['LOCAL']: app.wsgi_app = ReverseProxied(app.wsgi_app) for bp in blueprints: app.register_blueprint(bp) configure_uploads(app, images) patch_request_class(app) db.init_app(app) # Flask-Security setup class UserDatastore(PeeweeUserDatastore): def login_user_silent(self, user): login_user(user) user.login_count -= 1 self.put(user) def get_user(self, identifier): if isinstance(identifier, int): try: return self.user_model.get( self.user_model.id == identifier) except self.user_model.DoesNotExist: pass for attr in get_identity_attributes(): column = getattr(self.user_model, attr) try: return self.user_model.get( fn.Lower(column) == fn.Lower(identifier)) except self.user_model.DoesNotExist: pass init_social(app, db.database) user_datastore = UserDatastore(db, User, Role, UserRole) security = Security(app, user_datastore) security.login_manager.login_view = 'auth.login' @security.login_manager.unauthorized_handler def unauthorized(): return 'Unauthorized', HTTPStatus.UNAUTHORIZED @user_logged_out.connect_via(app) def on_logout(*args, **kwargs): user = kwargs['user'] if user.has_role('superuser'): return user_datastore.add_role_to_user(user, 'anonymous') user_datastore.remove_role_from_user(user, 'user') user_datastore.login_user_silent(user) @app.before_request def login_implicitly(): if isinstance(current_user._get_current_object(), AnonymousUser): u = user_datastore.create_user(roles=['anonymous']) user_datastore.login_user_silent(u) g.user = current_user @app.context_processor def inject_user(): try: return {'user': g.user} except AttributeError: return {'user': None} if not DEV: @app.errorhandler(500) def error_handler(error): if isinstance(error, SocialAuthBaseException): return redirect('/socialerror') # Flask-Admin setup class SecureModelView(ModelView): def is_accessible(self): return current_user.is_active and \ current_user.is_authenticated and \ current_user.has_role('superuser') def _handle_view(self, name, **kwargs): if not self.is_accessible(): if current_user.is_authenticated: abort(403) return redirect(url_for('auth.admin_login', next=request.url)) class AuthenticatedMenuLink(MenuLink): def is_accessible(self): return current_user.is_authenticated admin = Admin(app, name='pushmoney', template_mode='bootstrap3') admin.add_view(SecureModelView(Shop)) admin.add_view(SecureModelView(Category)) admin.add_view(SecureModelView(Product)) admin.add_view(SecureModelView(User)) admin.add_view(SecureModelView(PushWallet)) admin.add_view(SecureModelView(PushCampaign)) admin.add_view(SecureModelView(OrderHistory)) admin.add_view(SecureModelView(WebhookEvent)) admin.add_view(SecureModelView(Recipient)) admin.add_view(SecureModelView(UserImage)) admin.add_view(SecureModelView(CustomizationSetting)) admin.add_link( AuthenticatedMenuLink(name='Logout', endpoint='security.logout')) @security.context_processor def security_context_processor(): return dict(admin_base_template=admin.base_template, admin_view=admin.index_view, h=admin_helpers, get_url=url_for) @app.before_first_request def create_admin(): if User.get_or_none(email='admin'): db.close_db(None) return anonymous_role, _ = Role.get_or_create(name='anonymous') super_role, _ = Role.get_or_create(name='superuser') user_role, _ = Role.get_or_create(name='user') user_datastore.create_user(first_name='Admin', email='admin', password=hash_password(ADMIN_PASS), confirmed_at=datetime.utcnow(), roles=[user_role, super_role]) db.close_db(None) endpoints = sorted([ str(rule) for rule in app.url_map.iter_rules() if 'admin' not in str(rule) ]) info('\n'.join(endpoints)) return app
def build_app(): ''' Method for creating and configuring a flask app instance ''' app = Flask(__name__, instance_relative_config=True) app.register_blueprint(build_admin_bp(), url_prefix='/admin') # Load the default configuration app.config.from_object('nscmr.config.default') # Load the configuration from the instance folder app.config.from_pyfile('config.py') # Load the configuration specified by the APP_CONFIG_FILE environment var app.config.from_envvar('APP_CONFIG_FILE') # config extensions ############### # Flask-Login # ############### login_manager = LoginManager() login_manager.init_app(app) @login_manager.user_loader def load_user(user_id): return User.get_by_id(user_id, to_obj=True) ################### # Flask-Principal # ################### Principal(app) @identity_loaded.connect_via(app) def on_identity_loaded(sender, identity): identity.user = current_user if hasattr(current_user, 'id'): identity.provides.add(UserNeed(current_user.id)) if hasattr(current_user, 'roles') and \ getattr(current_user, 'roles') is not None: for role in current_user.roles: identity.provides.add(RoleNeed(role)) ############# # Flask-WTF # ############# CsrfProtect(app) ################# # Flask-Uploads # ################# configure_uploads(app, (category_images, product_images)) ################ # Flask-Assets # ################ assets = Environment(app) assets.load_path = [ os.path.join(app.root_path, 'static/sass'), os.path.join(app.root_path, 'static/js'), os.path.join(app.root_path, 'bower_components'), ] assets.register( 'js_base', Bundle( 'jquery/dist/jquery.min.js', 'bootstrap/dist/js/bootstrap.min.js', 'duvet.js'), output='js/base.js') assets.register( 'angular', Bundle( 'angular/angular.js', 'angular-i18n/angular-locale_pt-br.js', 'angular-ui-mask/dist/mask.js'), output='js/angular-bundle.js') assets.register( 'css_all', Bundle( 'bootstrap/dist/css/bootstrap.min.css', 'font-awesome/css/font-awesome.min.css', Bundle( 'style.scss', filters='scss', output='css/style.css')), output='css/all.css') ################# # Flask session # ################# Session(app) # end config extensions return app
def configure_up(app): configure_uploads(app, (quiz_archive, video_file, lecture_file)) root = app.instance_path print(app.instance_path)
Bootstrap(app) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join( basedir, 'data.sqlite') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # lokacija slika app.config['UPLOADS_DEFAULT_DEST'] = os.path.join(basedir, 'static/images') return app app = create_app() slike = UploadSet('pizzas', IMAGES) configure_uploads(app, slike) patch_request_class(app) db = SQLAlchemy(app) # default slika placeholderSrc = '../static/images/pizzas/placeholder.png' class LoginForm(FlaskForm): username = StringField( 'Username', validators=[ DataRequired(), Email(message="Username has to be in the form of email") ])
def create_app(config_path=None): app = CustomFlask( import_name=__name__, use_flask_uuid=True, use_debug_toolbar=True, ) # Configuration files app.config.from_pyfile( os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'default_config.py')) app.config.from_pyfile(os.path.join( os.path.dirname(os.path.realpath(__file__)), '..', 'consul_config.py'), silent=True) app.config.from_pyfile(os.path.join( os.path.dirname(os.path.realpath(__file__)), '..', 'custom_config.py'), silent=True) if config_path: app.config.from_pyfile(config_path) app.init_loggers( file_config=app.config.get('LOG_FILE'), email_config=app.config.get('LOG_EMAIL'), sentry_config=app.config.get('LOG_SENTRY'), ) # Database from metabrainz import db db.init_db_engine(app.config["SQLALCHEMY_DATABASE_URI"]) from metabrainz import model model.db.init_app(app) # Redis (cache) from brainzutils import cache cache.init(**app.config['REDIS']) # MusicBrainz OAuth from metabrainz.users import login_manager, musicbrainz_login login_manager.init_app(app) musicbrainz_login.init(app.config['MUSICBRAINZ_BASE_URL'], app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Templates from metabrainz.utils import reformat_datetime app.jinja_env.filters['datetime'] = reformat_datetime app.jinja_env.filters['nl2br'] = lambda val: val.replace('\n', '<br />' ) if val else '' # Error handling from metabrainz.errors import init_error_handlers init_error_handlers(app) add_robots(app) from metabrainz import babel babel.init_app(app) from flask_uploads import configure_uploads from metabrainz.admin.forms import LOGO_UPLOAD_SET configure_uploads(app, upload_sets=[ LOGO_UPLOAD_SET, ]) # Blueprints _register_blueprints(app) # ADMIN SECTION from flask_admin import Admin from metabrainz.admin.views import HomeView admin = Admin(app, index_view=HomeView(name='Pending users'), template_mode='bootstrap3') # Models from metabrainz.model.user import UserAdminView from metabrainz.model.payment import PaymentAdminView from metabrainz.model.tier import TierAdminView admin.add_view( UserAdminView(model.db.session, category='Users', endpoint="user_model")) admin.add_view( PaymentAdminView(model.db.session, endpoint="donation_model")) admin.add_view(TierAdminView(model.db.session, endpoint="tier_model")) # Custom stuff from metabrainz.admin.views import CommercialUsersView from metabrainz.admin.views import UsersView from metabrainz.admin.views import TokensView from metabrainz.admin.views import StatsView admin.add_view( CommercialUsersView(name='Commercial users', category='Users')) admin.add_view(UsersView(name='Search', category='Users')) admin.add_view(TokensView(name='Access tokens', category='Users')) admin.add_view(StatsView(name='Statistics')) return app
from model import (connect_to_db, db, User, Business, UserBiz, CheckIn, Review, LikeReview, Friend, Invite, Referral, UserPromo, Promo) from datetime import datetime from helper import friend_request, lost_pword import re # import constants as c from sqlalchemy import or_, desc from bubble import bubble_data_refs, bubble_data_promos from friend_network import make_nodes_and_paths, see_friends app = Flask(__name__) pics = UploadSet('pics', IMAGES) app.config['UPLOADED_PICS_DEST'] = 'static/img' configure_uploads(app, pics) # Required to use Flask sessions and the debug toolbar app.secret_key = "SHHHHHHIIIITTTT" # Normally, if you use an undefined variable in Jinja2, it fails # silently. This is horrible. Fix this so that, instead, it raises an # error. app.jinja_env.undefined = StrictUndefined @app.template_filter() def datetimeformat(value, format='%H:%M / %d-%m-%Y'): """Custom Jinja filter to format dates consistently.""" return value.strftime(format)
student_policy = "sn:student2 cn:student2 uid:student2 3of3" #objectClass:inetOrgPerson objectClass:organizationalPerson sn:student2 cn:student2 uid:student2 userPassword:student2 ou:idp o:computer mail:[email protected] title:student app = Flask(__name__) bootstrap = Bootstrap(app) app.config['SECRET_KEY'] = 'I have a dream' app.config['UPLOADED_PHOTOS_DEST'] = os.getcwd() + '\\upload_dir' app.config['UPLOADED_DECPRV_DEST'] = os.getcwd() + '\\dec_dir' app.config['UPLOADED_BACKUP_DEST'] = os.getcwd() + '\\backup_dir' fileext = {'xml', 'txt'} app.config['UPLOADED_PHOTOS_ALLOW'] = fileext app.config['UPLOADED_DECPRV_ALLOW'] = ['', 'cpabe'] #tuple('jpg jpe jpeg png gif svg bmp'.split()) photos = UploadSet('photos', fileext) decprv = UploadSet('decprv') backup = UploadSet('backup') configure_uploads(app, [photos, decprv, backup]) patch_request_class(app) # set maximum file size, default is 16MB class UploadForm(FlaskForm): photo = FileField(validators=[ FileAllowed(photos, u'Image Only!'), FileRequired(u'Choose a file!') ]) submit1 = SubmitField(u'Upload') #FileAllowed(['jpg','png','gif'])] class UploadForm_dec1(FlaskForm): prv = FileField(validators=[FileRequired(u'Choose a file!')]) submit1 = SubmitField(u'Upload')
from flask import Flask, request, Response, make_response, send_file, send_from_directory, redirect from flask_uploads import (UploadSet, SCRIPTS, configure_uploads) import rocksdb import time import struct import datetime import subprocess import sys import os app = Flask(__name__) APP_ROOT = os.path.dirname(os.path.abspath(__file__)) UPLOAD_FOLDER = os.path.join(APP_ROOT, 'uploads/scripts') app.config['UPLOADED_SCRIPTS_DEST'] = UPLOAD_FOLDER scripts = UploadSet('scripts', SCRIPTS) configure_uploads(app, scripts) @app.route('/api/v1/scripts/<script_id>', methods=['GET']) def run_script(script_id): rdb = rocksdb.DB("sample.db", rocksdb.Options(create_if_missing=True)) key = script_id.encode(encoding='UTF-8', errors='strict') file_name = rdb.get(key) app.logger.error(file_name) cmd = 'python ./%s' % file_name app.logger.error(cmd) res = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) return res @app.route('/api/v1/scripts', methods=['POST'])
app = Flask(__name__) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'login' # login_manager.login_message = 'please login!' login_manager.session_protection = 'strong' logger = monitor_logger.get_logger(__name__) app.config['ALLOWED_EXTENSIONS'] = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']) app.config['UPLOAD_PATH'] = 'upload' app.config['UPLOADS_DEFAULT_DEST'] = app.config['UPLOAD_PATH'] app.config['UPLOADS_DEFAULT_URL'] = 'http://127.0.0.1:9000/' uploaded_photos = UploadSet() configure_uploads(app, uploaded_photos) api = Api(app) api.add_resource(monitor_api.MonitorApi, '/api/<id>') app.register_blueprint(monitor_resource) app.register_blueprint(admin) app.register_blueprint(admin, url_prefix='/v1') # http://www.pythondoc.com/flask-login/index.html#request-loader # http://docs.jinkan.org/docs/flask/index.html # http://flask-login.readthedocs.io/en/latest/#login-example class User(flask_login.UserMixin): pass
return render_template('mycamera.html') @application.route('/enrolluser') def enrolluser(): return render_template('enrolluser.html') @application.route('/trackuser') def trackuser(): return render_template('trackuser.html') photos = UploadSet('photos', IMAGES) application.config['UPLOADED_PHOTOS_DEST'] = 'static/img' configure_uploads(application, photos) @application.route('/trackuser', methods=['POST']) def do_trackuser(): fc = facerec() print("doing Track user") dbs = dbops() name = request.form['name'] print(name) email = request.form['email'] print(email) mobile = request.form['mobile'] print(mobile) address = request.form['address'] print(address)
from libs.image_helper import IMAGE_SET from resources.github_login import GithubLogin, GithubAuthorize app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URI") app.config.from_object( "default_config") # load default configs from default_config.py app.config.from_envvar( "APPLICATION_SETTINGS" #which is in the .env file ) # override with config.py (APPLICATION_SETTINGS points to config.py) patch_request_class(app, 10 * 1024 * 1024) # restrict max upload image size to 10MB configure_uploads(app, IMAGE_SET) # this is to link up the app with flask uploads api = Api(app) @app.before_first_request def create_tables(): db.create_all() @app.errorhandler(ValidationError) def handle_marshmallow_validation(err): # as except ValidationError as err return jsonify(err.messages), 400 jwt = JWTManager(app)
def update(id): data = get_data(id) sizes = [] con = db.connect() cursor = con.cursor(db.getDictCursor()) cursor.execute("SELECT * FROM categories") categories = cursor.fetchall() cursor.execute("SELECT * FROM types") types = cursor.fetchall() cursor.execute("SELECT * FROM product_sizes WHERE product_id=%s", (id)) product_sizes = cursor.fetchall() for ps in product_sizes: sizes.append(ps['size']) cursor.execute("SELECT * FROM product_media WHERE product_id=%s", (id)) product_media = cursor.fetchall() form = ProductForm(obj=data, csrf_enabled=False) if request.method == 'POST' and form.validate_on_submit(): sku = request.form['sku'] or 'NULL' name = request.form['name'] or 'NULL' description = request.form['description'] or 'NULL' category_id = request.form['category_id'] type_id = request.form['type_id'] normal_price = request.form['normal_price'] or 0 point = request.form['point'] or 0 weight = request.form['weight'] or 0 extra_fee = request.form['extra_fee'] or 0 updated_by = session['user_id'] or 'NULL' medias = request.files.getlist("medias[]") post_sizes = request.form.getlist("sizes[]") is_disabled = 'is_disabled' in request.form file_url = "" type = "image" if is_disabled == True: is_disabled = 1 else: is_disabled = 0 photos = UploadSet('photos', IMAGES) configure_uploads(app, photos) con = db.connect() cursor = con.cursor(db.getDictCursor()) try: cursor.execute( "UPDATE \ products SET category_id=%s, type_id=%s, sku=%s, \ name=%s, description=%s, normal_price=%s, point=%s, \ weight=%s, extra_fee=%s, is_disabled=%s, updated_by=%s \ WHERE id=%s", (category_id, type_id, sku, name, description, normal_price, point, weight, extra_fee, is_disabled, updated_by, id)) cursor.execute("DELETE FROM product_sizes WHERE product_id=%s", (id)) for ps in post_sizes: cursor.execute( "INSERT INTO product_sizes(product_id, size) VALUES(%s, %s)", (id, ps)) for i, media in enumerate(medias): sorting = str(request.form['sorting_' + str(i + 1)]) media_id = str(request.form['id_' + str(i + 1)]) if allowed_file(media.filename): filename = photos.save(media) path = photos.url(filename) if media_id == "": cursor.execute( "INSERT INTO product_media(product_id, path, sorting, type) VALUES(%s, %s, %s, %s)", (id, path, sorting, type)) else: cursor.execute( "UPDATE product_media SET path=%s WHERE id=%s", (path, media_id)) con.commit() flash('Operation success') return redirect(url_for('product.update', id=id)) except cursor.InternalError as e: code, message = e.args con.rollback() flash(message) return redirect(url_for('product.update', id=id)) finally: con.close() return render_template('back/product/update.html', form=form, data=data, categories=categories, sizes=sizes, types=types, product_sizes=product_sizes, product_media=product_media)
def configure(): configure_uploads(app, uploaded_logos)
from apps import app, db from apps.home import home_bp as home from apps.home.forms import LoginForm, RegistForm, PwdForm, InfoForm, AlbumInfoForm, AlbumSelectForm, PhotoAddForm, \ ArticleInfoForm, ArticleWriteForm from apps.models import User, Album, Photo, AlbumTag, AlbumFavor, ArticleTag, Article, ArticleFavor from apps.utils import secure_filename_with_uuid, create_thumbnail, create_show, check_filestorages_extension, \ ALLOWED_IMAGE_EXTENSIONS # 创建 UploadSet 类的实例 photosSet = UploadSet(name='photos', extensions=IMAGES) imgsSet = UploadSet(name='imgs', extensions=IMAGES) filesSet = UploadSet(name='files', extensions=AUDIO + ARCHIVES + DOCUMENTS) # 配置FlaskUpLoad 和 app configure_uploads(app, photosSet) configure_uploads(app, imgsSet) configure_uploads(app, filesSet) def user_login_req(f): @wraps(f) def decorated_function(*args, **kwargs): if "user_name" not in session: return redirect(url_for("home.user_login", next=request.url)) return f(*args, **kwargs) return decorated_function @home.route('/')
import os import sqlite3 import sys from config import BaseConfig from flask import Flask, request, session, g, redirect, url_for, \ abort, render_template, flash from flask_sqlalchemy import SQLAlchemy from flask_bcrypt import Bcrypt from flask_migrate import Migrate from flask_cors import CORS from flask_uploads import UploadSet, IMAGES, configure_uploads # Create application instance. app = Flask(__name__, static_folder="static", static_url_path='', template_folder="./static/") # Load config from config module. app.config.from_object(BaseConfig) CORS(app) # Configure photo uploads via Flask-Uploads PhotoSet = UploadSet('photos', IMAGES) configure_uploads(app, PhotoSet) db = SQLAlchemy(app) migrate = Migrate(app, db) bcrypt = Bcrypt(app)
mail = Mail(app) app.secret_key = APP_SECRET_KEY s = URLSafeTimedSerializer(URL_SAFE_SECRET) # APP_ROOT = os.path.dirname(os.path.abspath(__file__)) login_manager = LoginManager() ## sets up our login for the app login_manager.init_app(app) login_manager.login_view = 'login' # Sets variable images to uploader images = UploadSet('images', IMAGES) configure_uploads(app, images) socketio = SocketIO(app) @login_manager.user_loader def load_user(userid): try: return models.User.get(models.User.id == userid) except models.DoesNotExist: return None @app.before_request def before_request(): # Connect to the database before each request
regularExpression="^("+keyCode+")\s([0-9]{"+OTPNumbers+"})$" matched=re.findall(regularExpression, message.lower()) #matched=matched.trim() if(matched): responseToBooth='{"number":"'+phoneNumber+'","message":"' +matched[0][1]+'"}' #print() client = mqtt.Client() client.on_connect = on_connect client.on_publish = on_publish client.connect("iot.eclipse.org", 1883, 60) client.loop_start() #client.publish(publishingTotopicName, responseToBooth) client.loop_stop() return responseToBooth else: return "Not Ok" app.config['UPLOADED_PHOTOS_DEST'] = 'static/img' configure_uploads(app, photos) @app.route('/upload', methods=['GET', 'POST']) def upload(): if request.method == 'POST' and 'photo' in request.files: filename = photos.save(request.files['photo']) return filename return render_template('upload.html') if __name__ == '__main__': port = int(os.environ.get("PORT", 5000)) app.run(host='0.0.0.0', port=port,debug=True)
app = Flask(__name__) cors = CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' load_dotenv(".env", verbose=True) app.config.from_object( "default_config") # load default configs from default_config.py app.config.from_envvar( "APPLICATION_SETTINGS" ) # override with config.py (APPLICATION_SETTINGS points to config.py) stripe.api_key = os.environ.get("SK_TEST_KEY") patch_request_class(app, 10 * 1024 * 1024) # restrict max upload image size to 10MB configure_uploads(app, IMAGE_SET) api = Api(app) jwt = JWTManager(app) migrate = Migrate(app, db) socketio = SocketIO(app, cors_allowed_origins="*", ping_timeout=10, ping_interval=5) db.init_app(app) ma.init_app(app) @app.before_first_request def create_tables(): db.create_all()
def init_upload_config(app): # 配置上传目录 app.config['UPLOADS_DEFAULT_DEST'] = UPLOAD_ROOT_PATH # 生成文件的访问的url地址 # app.config['UPLOADS_DEFAULT_URL'] = '' configure_uploads(app=app, upload_set=images)
from flask import Flask, render_template, request from flask_uploads import UploadSet, configure_uploads, IMAGES, UploadNotAllowed, TEXT app = Flask(__name__) photos = UploadSet('photos', IMAGES + TEXT + ('py', 'pyc', 'cpp')) docs = UploadSet('docs', TEXT) app.config['UPLOADED_PHOTOS_DEST'] = 'pictures' app.config['UPLOADED_PHOTOS_ALLOW'] = ['txt', 'py'] #app.config['UPLOADED_PHOTOS_DENY'] = ['jpg'] app.config['UPLOADS_DEFAULT_DEST'] = 'other' configure_uploads(app, (photos, docs)) @app.route('/upload', methods=['GET', 'POST']) def upload(): if request.method == 'POST' and 'thefile' in request.files: try: doc_filename = docs.save(request.files['thefile']) #return '<h1>'+photos.path(image_filename)+'</h1>' return '<h1>'+docs.url(doc_filename)+'</h1>' except UploadNotAllowed: return '<h1>File is not allowed!' return render_template('upload.html') if __name__ == '__main__': app.run(debug=True)
from flask_uploads import configure_uploads, UploadSet, patch_request_class import os import score curr_path = os.path.abspath(os.path.dirname(__file__)) if not os.path.exists(os.path.join(curr_path, 'temp/')): os.makedirs(os.path.join(curr_path, 'temp/')) app = Flask(__name__) app.secret_key = 'development key' app.config['UPLOADED_RESUME_DEST'] = os.path.join(curr_path, 'temp/') DOCUMENTS = ('txt', 'pdf', 'docx', 'doc') resumes = UploadSet('resume', DOCUMENTS) configure_uploads(app, resumes) patch_request_class(app) class MyForm(FlaskForm): resume = FileField('resume', validators=[ FileAllowed( resumes, "Only PDF, TXT, DOC, DOCX Files Allowed"), Required("Resume is Required") ]) description = TextAreaField( 'description', validators=[InputRequired("Job Description is required")])
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.migrate import Migrate from flaskext.markdown import Markdown from flask_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 author import views
def configure(app): thumbnails_dir = os.path.join(app.static_folder, 'thumbnails') if not os.path.isdir(thumbnails_dir): os.mkdir(thumbnails_dir) configure_uploads(app, thumbnails)
from flask_sqlalchemy import SQLAlchemy from flask_uploads import UploadSet, ALL, configure_uploads from sqlalchemy import func logging.basicConfig( level=logging.DEBUG) # comment out to turn off info messages app = Flask(__name__) # Upload folder destination UPLOADED_ALL_DEST = 'static/uploads/' app.config['UPLOADED_ALL_DEST'] = UPLOADED_ALL_DEST files = UploadSet('files', extensions=ALL, default_dest=lambda x: UPLOADED_ALL_DEST) configure_uploads(app, (files, )) # must configure environment variables # https://devcenter.heroku.com/articles/config-vars # $ export SECRET_KEY='randomly_generated_string_using_python_function__secrets.token_urlsafe()' app.secret_key = os.environ.get('SECRET_KEY') # $ export DATABASE_URL='[DB_TYPE]+[DB_CONNECTOR]://[USERNAME]:[PASSWORD]@[HOST]:[PORT]/[DB_NAME]' app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', '') db = SQLAlchemy(app) db.drop_all()
# ML Packages For Vectorization of Text For Feature Extraction from sklearn.feature_extraction.text import CountVectorizer from sklearn.feature_extraction.text import TfidfVectorizer app = Flask(__name__) Bootstrap(app) db = SQLAlchemy(app) # Configuration for File Uploads files = UploadSet('files',ALL) app.config['UPLOADED_FILES_DEST'] = 'static/uploadsDB' configure_uploads(app,files) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///static/uploadsDB/filestorage.db' # Saving Data To Database Storage class FileContents(db.Model): id = db.Column(db.Integer,primary_key=True) name = db.Column(db.String(300)) modeldata = db.Column(db.String(300)) data = db.Column(db.LargeBinary) @app.route('/') def index(): return render_template('index.html') # Route for our Processing and Details Page
import os from flask import render_template, request, url_for, send_from_directory, flash from apps import app # IMAGES 允许上传的扩展名 from flask_uploads import UploadSet, IMAGES, configure_uploads, TEXT, UploadNotAllowed # 第二步:产生UploadSet类对象的实例,用来管理上传集合 # Upload Sets 管理上传集合 photosSet = UploadSet( 'photos', IMAGES) # 'photos'必须是 app.config['UPLOADED_PHOTOS_DEST']中的 PHOTOS 的小写格式 # 第三步:绑定 app 与UploadSet对象实例 configure_uploads(app, photosSet) @app.route('/index', methods=["GET", "POST"]) def index(): if request.method == "POST": fs = request.files["image_upload"] # print(fs.filename) if fs.filename != "": # 服务器资源地址 # file_path = os.path.join(app.config["ABS_UPLOAD_FOLDER"], fs.filename) # print(file_path) # fs.save(file_path) # 这个保存使用了FileStorage 的使用方法保存文件 # 第四步:使用UploadSet 的save方法保存文件 # (self, storage, folder=None, name=None): # 保存到uploads的根目录 返回的是当前文件的名字 the file will be saved and its name (including the folder) will be returned.
from flask import Response, render_template, redirect, url_for, request, session, json, jsonify, g, current_app from flask_security import login_required, current_user from flask_uploads import UploadSet, configure_uploads, ARCHIVES, secure_filename from ..utils import add_study, update_study, delete_study, activate_study, load_active_study, add_default_project from ..network_editor.utils import correct_network_geojson from .utils import add_network, share_network, move_network, \ load_weap_area, weap_to_network, get_templates, repair_template, update_templates, get_network_for_export # import blueprint definition from . import home from openagua import app templates = UploadSet('templates', ARCHIVES) configure_uploads(app, templates) #@home.before_app_first_request #def _check_hydra_server(): #'''This checks to see if the user's Hydra URL is valid and, if so, #ensures the session ID is up-to-date. ''' #g.hydrauser = load_hydrauser() #if not g.hydrauser: #session['hydra_url'] = current_app.config['HYDRA_URL'] #try: #requests.get(session['hydra_url']) #session['valid_hydra_url'] = True #if g.hydrauser: #g.conn = make_connection(login=True) #except: #session['valid_hydra_url'] = False
from flask import Flask, abort, request, jsonify, g, url_for from flask_sqlalchemy import SQLAlchemy from passlib.apps import custom_app_context as pwd_context from itsdangerous import (TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired) from flask_httpauth import HTTPBasicAuth from flask_uploads import UploadSet, configure_uploads, DATA, DOCUMENTS app = Flask(__name__) app.config['SECRET_KEY'] = 'python and java' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['datafile_location'] = "./tmp" datafiles = UploadSet('datafiles', DATA + DOCUMENTS, default_dest=lambda a: a.config['datafile_location']) configure_uploads(app, datafiles) db = SQLAlchemy(app) auth = HTTPBasicAuth() class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), index=True) password_hash = db.Column(db.String(64)) def hash_password(self, password): self.password_hash = pwd_context.encrypt(password) def verify_password(self, password): return pwd_context.verify(password, self.password_hash)
MAIL_SERVER = 'smtp.gmail.com', MAIL_PORT = 587, MAIL_USE_TLS = True, MAIL_USE_SSL = False, MAIL_USERNAME = '******', MAIL_PASSWORD = '******', )) mail = Mail(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 user import views from blog import views from author import views from home import views #from util import validators
def creat_app(spare_config=None): # 自定义实例文件夹/resource,此处为绝对路径,可以通过其他参数改为相对路径 # 和模板文件夹/template,此处为相对路径 # ################################# static_folder,好像通过这个参数可以让外部访问这个文件夹 app = Flask( __name__, instance_path='/resource', template_folder='../template', # 默认的static目录是'/factory/static',这里改成'/static' static_folder=os.path.join(os.getcwd(), 'static') # static_url_path = '/static' ) # 如果creat_app()没有接收到参数,使用默认的config文件 if spare_config is None: from .config import config app.config.from_object(config.Config) # 否则,使用参数中的config文件 else: app.config.from_pyfile(spare_config) # 引入蓝图 from resource import test_hello, test_user app.register_blueprint(test_hello.app) app.register_blueprint(test_user.app) from resource.token import update app.register_blueprint(update.app) from resource.user import oauth, login, name, avatar, phone, role, create app.register_blueprint(oauth.app) app.register_blueprint(login.app) app.register_blueprint(name.app) app.register_blueprint(avatar.app) app.register_blueprint(phone.app) app.register_blueprint(role.app) app.register_blueprint(create.app) from resource.user import collection as user_collection from resource.user import id as user_id app.register_blueprint(user_collection.app) app.register_blueprint(user_id.app) from resource.article import collection as article_collection from resource.article import id as article_id from resource.article import save_all as article_save_all from resource.article import cover as article_cover from resource.article import tag as article_tag app.register_blueprint(article_collection.app) app.register_blueprint(article_id.app) app.register_blueprint(article_save_all.app) app.register_blueprint(article_cover.app) app.register_blueprint(article_tag.app) from resource.illustration import upload as illustration_upload app.register_blueprint(illustration_upload.app) # 创建一个flask-mail实例 app.mail_instance = Mail(app) # 创建flask-uploads实例 from flask_uploads import IMAGES, ALL, configure_uploads, UploadSet app.illustration_upload = UploadSet('illustration', IMAGES) app.cover_upload = UploadSet('cover', IMAGES) configure_uploads(app, [app.illustration_upload, app.cover_upload]) return app
from redis import Redis import rq # class MySQLAlchemy(SQLAlchemy): # def create_session(self, options): # options['autoflush'] = False # return SignallingSession(self, **options) app = Flask(__name__) app.config.from_object(Config) login = LoginManager(app) db = SQLAlchemy(app) migrate = Migrate(app=app, db=db) bootstrap = Bootstrap(app) login.login_view = 'login' text = UploadSet("downloads", TEXT) configure_uploads(app, text) moment = Moment(app) babel = Babel(app) redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('lightreader-tasks', connection=redis) from app import models, routes import create_db @babel.localeselector def get_locale(): return request.accept_languages.best_match(app.config['LANGUAGES'])
def create_app(config_filename="config.development.Config", app_name=None, register_blueprints=True): # App configuration app = Flask(app_name or __name__) app_settings = os.getenv("APP_SETTINGS", config_filename) print(f" * Loading config: '{app_settings}'") try: cfg = import_string(app_settings)() except ImportError: print(" *** Cannot import config ***") cfg = import_string("config.config.BaseConfig") print(" *** Default config loaded, expect problems ***") if hasattr(cfg, "post_load"): print(" *** Doing some magic") cfg.post_load() app.config.from_object(cfg) app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1) Bootstrap(app) app.jinja_env.add_extension("jinja2.ext.with_") app.jinja_env.add_extension("jinja2.ext.do") app.jinja_env.globals.update(is_admin=is_admin) if HAS_SENTRY: sentry_sdk.init( app.config["SENTRY_DSN"], integrations=[SentryFlaskIntegration(), SentryCeleryIntegration()], release=f"{VERSION} ({GIT_VERSION})", ) print(" * Sentry Flask/Celery support activated") print(" * Sentry DSN: %s" % app.config["SENTRY_DSN"]) if app.debug: app.jinja_env.auto_reload = True logging.basicConfig(level=logging.DEBUG) # Logging if not app.debug: formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]") file_handler = RotatingFileHandler("%s/errors_app.log" % os.getcwd(), "a", 1000000, 1) file_handler.setLevel(logging.INFO) file_handler.setFormatter(formatter) app.logger.addHandler(file_handler) dbLogger = logging.getLogger("reel2bits.sqltime") dbLogger.setLevel(logging.DEBUG) CORS(app, origins=["*"]) if app.debug: logging.getLogger("flask_cors.extension").level = logging.DEBUG mail = Mail(app) # noqa: F841 migrate = Migrate(app, db) # noqa: F841 lgtm [py/unused-local-variable] babel = Babel(app) # noqa: F841 app.babel = babel template = { "swagger": "2.0", "info": {"title": "reel2bits API", "description": "API instance", "version": VERSION}, "host": app.config["AP_DOMAIN"], "basePath": "/", "schemes": ["https"], "securityDefinitions": { "OAuth2": { "type": "oauth2", "flows": { "authorizationCode": { "authorizationUrl": f"https://{app.config['AP_DOMAIN']}/oauth/authorize", "tokenUrl": f"https://{app.config['AP_DOMAIN']}/oauth/token", "scopes": { "read": "Grants read access", "write": "Grants write access", "admin": "Grants admin operations", }, } }, } }, "consumes": ["application/json", "application/jrd+json"], "produces": ["application/json", "application/jrd+json"], } db.init_app(app) # ActivityPub backend back = Reel2BitsBackend() ap.use_backend(back) # Oauth config_oauth(app) # Setup Flask-Security security = Security(app, user_datastore) # noqa: F841 lgtm [py/unused-local-variable] @FlaskSecuritySignals.password_reset.connect_via(app) @FlaskSecuritySignals.password_changed.connect_via(app) def log_password_reset(sender, user): if not user: return add_user_log(user.id, user.id, "user", "info", "Your password has been changed !") @FlaskSecuritySignals.reset_password_instructions_sent.connect_via(app) def log_reset_password_instr(sender, user, token): if not user: return add_user_log(user.id, user.id, "user", "info", "Password reset instructions sent.") @FlaskSecuritySignals.user_registered.connect_via(app) def create_actor_for_registered_user(app, user, confirm_token): if not user: return actor = create_actor(user) actor.user = user actor.user_id = user.id db.session.add(actor) db.session.commit() @security.mail_context_processor def mail_ctx_proc(): _config = Config.query.first() if not _config: print("ERROR: cannot get instance Config from database") instance = {"name": None, "url": None} if _config: instance["name"] = _config.app_name instance["url"] = app.config["REEL2BITS_URL"] return dict(instance=instance) @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings identity = getattr(g, "identity", None) if identity is not None and identity.id: return identity.user.locale # otherwise try to guess the language from the user accept # header the browser transmits. We support fr/en in this # example. The best match wins. return request.accept_languages.best_match(AVAILABLE_LOCALES) @babel.timezoneselector def get_timezone(): identity = getattr(g, "identity", None) if identity is not None and identity.id: return identity.user.timezone @app.before_request def before_request(): _config = Config.query.first() if not _config: flash(gettext("Config not found"), "error") cfg = { "REEL2BITS_VERSION_VER": VERSION, "REEL2BITS_VERSION_GIT": GIT_VERSION, "app_name": _config.app_name, "app_description": _config.app_description, } if GIT_VERSION: cfg["REEL2BITS_VERSION"] = "{0}-{1}".format(VERSION, GIT_VERSION) else: cfg["REEL2BITS_VERSION"] = VERSION g.cfg = cfg @app.errorhandler(InvalidUsage) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response @event.listens_for(Engine, "before_cursor_execute") def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): if not False: return conn.info.setdefault("query_start_time", []).append(time.time()) dbLogger.debug("Start Query: %s", statement) @event.listens_for(Engine, "after_cursor_execute") def after_cursor_execute(conn, cursor, statement, parameters, context, executemany): if not False: return total = time.time() - conn.info["query_start_time"].pop(-1) dbLogger.debug("Query Complete!") dbLogger.debug("Total Time: %f", total) # Tracks files upload set sounds = UploadSet("sounds", AUDIO) configure_uploads(app, sounds) # Album artwork upload set artworkalbums = UploadSet("artworkalbums", Reel2bitsDefaults.artwork_extensions_allowed) configure_uploads(app, artworkalbums) # Track artwork upload set artworksounds = UploadSet("artworksounds", Reel2bitsDefaults.artwork_extensions_allowed) configure_uploads(app, artworksounds) # User avatars avatars = UploadSet("avatars", Reel2bitsDefaults.avatar_extensions_allowed) configure_uploads(app, avatars) # Total max size upload for the whole app patch_request_class(app, app.config["UPLOAD_TRACK_MAX_SIZE"]) app.flake_id = FlakeId() if register_blueprints: from controllers.main import bp_main app.register_blueprint(bp_main) from controllers.admin import bp_admin app.register_blueprint(bp_admin) # ActivityPub from controllers.api.v1.well_known import bp_wellknown app.register_blueprint(bp_wellknown) from controllers.api.v1.nodeinfo import bp_nodeinfo app.register_blueprint(bp_nodeinfo) from controllers.api.v1.ap import bp_ap # Feeds from controllers.feeds import bp_feeds app.register_blueprint(bp_feeds) # API app.register_blueprint(bp_ap) from controllers.api.v1.auth import bp_api_v1_auth app.register_blueprint(bp_api_v1_auth) from controllers.api.v1.accounts import bp_api_v1_accounts app.register_blueprint(bp_api_v1_accounts) from controllers.api.v1.timelines import bp_api_v1_timelines app.register_blueprint(bp_api_v1_timelines) from controllers.api.v1.notifications import bp_api_v1_notifications app.register_blueprint(bp_api_v1_notifications) from controllers.api.tracks import bp_api_tracks app.register_blueprint(bp_api_tracks) from controllers.api.albums import bp_api_albums app.register_blueprint(bp_api_albums) from controllers.api.account import bp_api_account app.register_blueprint(bp_api_account) from controllers.api.reel2bits import bp_api_reel2bits app.register_blueprint(bp_api_reel2bits) # Pleroma API from controllers.api.pleroma_admin import bp_api_pleroma_admin app.register_blueprint(bp_api_pleroma_admin) # OEmbed from controllers.api.oembed import bp_api_oembed app.register_blueprint(bp_api_oembed) # Iframe from controllers.api.embed import bp_api_embed app.register_blueprint(bp_api_embed) swagger = Swagger(app, template=template) # noqa: F841 lgtm [py/unused-local-variable] # SPA catchalls for meta tags from controllers.spa import bp_spa app.register_blueprint(bp_spa) @app.route("/uploads/<string:thing>/<path:stuff>", methods=["GET"]) @cross_origin(origins="*", methods=["GET", "HEAD", "OPTIONS"], expose_headers="content-length", send_wildcard=True) def get_uploads_stuff(thing, stuff): if app.testing or app.debug: directory = safe_join(app.config["UPLOADS_DEFAULT_DEST"], thing) app.logger.debug(f"serving {stuff} from {directory}") return send_from_directory(directory, stuff, as_attachment=True) else: app.logger.debug(f"X-Accel-Redirect serving {stuff}") resp = Response("") resp.headers["Content-Disposition"] = f"attachment; filename={stuff}" resp.headers["X-Accel-Redirect"] = f"/_protected/media/{thing}/{stuff}" resp.headers["Content-Type"] = "" # empty it so Nginx will guess it correctly return resp def render_tags(tags): """ Given a dict like {'tag': 'meta', 'hello': 'world'} return a html ready tag like <meta hello="world" /> """ for tag in tags: yield "<{tag} {attrs} />".format( tag=tag.pop("tag"), attrs=" ".join(['{}="{}"'.format(a, html.escape(str(v))) for a, v in sorted(tag.items()) if v]), ) @app.errorhandler(404) def page_not_found(msg): excluded = ["/api", "/.well-known", "/feeds", "/oauth/authorize"] if any([request.path.startswith(m) for m in excluded]): return jsonify({"error": "page not found"}), 404 html = get_spa_html(app.config["REEL2BITS_SPA_HTML"]) head, tail = html.split("</head>", 1) request_tags = get_request_head_tags(request) default_tags = get_default_head_tags(request.path) unique_attributes = ["name", "property"] final_tags = request_tags skip = [] for t in final_tags: for attr in unique_attributes: if attr in t: skip.append(t[attr]) for t in default_tags: existing = False for attr in unique_attributes: if t.get(attr) in skip: existing = True break if not existing: final_tags.append(t) head += "\n" + "\n".join(render_tags(final_tags)) + "\n</head>" return head + tail @app.errorhandler(403) def err_forbidden(msg): if request.path.startswith("/api/"): return jsonify({"error": "access forbidden"}), 403 pcfg = { "title": gettext("Whoops, something failed."), "error": 403, "message": gettext("Access forbidden"), "e": msg, } return render_template("error_page.jinja2", pcfg=pcfg), 403 @app.errorhandler(410) def err_gone(msg): if request.path.startswith("/api/"): return jsonify({"error": "gone"}), 410 pcfg = {"title": gettext("Whoops, something failed."), "error": 410, "message": gettext("Gone"), "e": msg} return render_template("error_page.jinja2", pcfg=pcfg), 410 if not app.debug: @app.errorhandler(500) def err_failed(msg): if request.path.startswith("/api/"): return jsonify({"error": "server error"}), 500 pcfg = { "title": gettext("Whoops, something failed."), "error": 500, "message": gettext("Something is broken"), "e": msg, } return render_template("error_page.jinja2", pcfg=pcfg), 500 @app.after_request def set_x_powered_by(response): response.headers["X-Powered-By"] = "reel2bits" return response # Register CLI commands app.cli.add_command(commands.db_datas) app.cli.add_command(commands.users) app.cli.add_command(commands.roles) app.cli.add_command(commands.tracks) app.cli.add_command(commands.system) return app
def configure(self, *sets, **options): self.app.config.update(options) configure_uploads(self.app, sets) return self.app.upload_set_config
from common import config from src.definitions import INPUT_APK_DIR app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = config.MYSQL_URL app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) app.secret_key = os.urandom(24) login_manager = LoginManager(app) app.config['UPLOADED_APKS_DEST'] = INPUT_APK_DIR apks = UploadSet('apks', ('apk',)) configure_uploads(app, (apks,)) app.config['CELERY_BROKER_URL'] = config.RABBITMQ_URL app.config['CELERY_ROUTES'] = { 'static_analysis_task': {'queue': 'static_queue'}, 'dynamic_analysis_task': {'queue': 'dynamic_queue'}} app.config['CELERYD_PREFETCH_MULTIPLIER'] = 1 app.config['CELERY_ACKS_LATE'] = True gevent.monkey.patch_all() socketio = SocketIO(app, message_queue=config.RABBITMQ_URL) def make_celery(app):
import random import string from flask import render_template, flash, redirect, url_for, request, abort, send_file import flask_uploads import model from model import db from shelf import app documents = flask_uploads.UploadSet( 'documents', flask_uploads.DOCUMENTS + flask_uploads.TEXT + ('pdf', 'ppt') ) flask_uploads.configure_uploads(app, documents) class Document(object): """ Class to mediate storing and retrieving documents to and from database. """ doc_id_chars = string.letters + string.digits def __init__(self, fs_name, friendly_name): self.fs_name = fs_name self.friendly_name = friendly_name self.doc_id = None @classmethod
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'] = os.path.join(sc_dir(), 'tmp') app.config['UPLOADED_IMAGEFILES_DEST'] = os.path.join(sc_dir(), STATIC_DIR) app.config['EARTHQUAKES'] = os.path.join(sc_dir(), 'data') 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 start(): sc = SC() # don't start the web server if we're letting an extension do it if 'web_server' not in sc.dict['extensions']: app.run(host='0.0.0.0', port=sc.dict['web_port'], threaded=True)
import datetime import json import Ecommerce.forms as forms import Ecommerce.models as models from peewee import SelectQuery import translators as tran app.secret_key = 'secret-key' # Your sceret key # app.config['UPLOADED_<Name of Upload Set In Uppercase>_DEST'] app.config['UPLOADED_IMAGES_DEST'] = 'images/uploads/products' configure_uploads(app, (forms.images,)) login_manager = LoginManager() # create a login manager login_manager.init_app(app) # initialize login manager with flask app login_manager.login_view = 'login' # view used for login app.config['MAIL_SERVER']='' # Your mail server app.config['MAIL_PORT'] = 587 # Your mail server port app.config['MAIL_USERNAME'] = '' # your mail server username app.config['MAIL_PASSWORD'] = '' # your mail server password app.config['MAIL_USE_TLS'] = True app.config['MAIL_USE_SSL'] = False mail = Mail(app)
from app import app from flask_uploads import UploadSet, configure_uploads, patch_request_class IMAGES = tuple('jpg jpe jpeg png gif'.split()) profilepictures = UploadSet('profilepictures', IMAGES) entityphotos = UploadSet('entityphotos', IMAGES) pdftopos = UploadSet('pdftopos', ('pdf',)) configure_uploads(app, ( profilepictures, entityphotos, pdftopos )) patch_request_class(app, app.config['UPLOADS_MAX_FILESIZE'])
from yestudio import app, db from yestudio.models import Entries from yestudio.forms import AddForm from flask import render_template, request, redirect, flash from flask_uploads import UploadSet, configure_uploads # uploads uploaded_photos = UploadSet('photos') configure_uploads(app, uploaded_photos) @app.route('/') def index(): return render_template('layout.html', entries=Entries.query.all()) @app.route('/add', methods=['GET', 'POST']) def add(): add_form = AddForm() if request.method == 'POST': csrf, title, photo, cat, href = [field.data for field in add_form] if not add_form.validate(): flash(add_form.errors) else: filename = uploaded_photos.save(photo) entry = Entries(title=title, photo=filename, cat=cat, href=href) db.session.add(entry) db.session.commit()
def review_images_factory(testing=False, app=None): if testing: return review_images_test if app: configure_uploads(app, (review_images,)) return review_images
from ocr import ocr_detect from flask import Flask, render_template, request from flask_uploads import UploadSet, configure_uploads, IMAGES app = Flask(__name__) photos = UploadSet('photos', IMAGES) app.config['UPLOADED_PHOTOS_DEST'] = './static/img' configure_uploads(app, photos) @app.route('/', methods=['GET', 'POST']) def ac(): re = "Hey please redirect to /upload" return re @app.route('/home', methods=['GET', 'POST']) def home(): welcome = "Hey People!" return welcome @app.route('/upload', methods=['GET', 'POST']) def upload(): if request.method == 'POST' and 'photo' in request.files: filename = photos.save(request.files['photo']) print(list(request.files.lists())) res = ocr_detect('./static/img/' + filename)
from flask import Flask from flask_sqlalchemy import SQLAlchemy from config import Config from flask_login import LoginManager from flask_uploads import UploadSet, IMAGES, configure_uploads import os webapp = Flask(__name__) webapp.config.from_object(Config) db = SQLAlchemy(webapp) login_manager = LoginManager(webapp) image_uploadset = UploadSet('images', IMAGES) configure_uploads(webapp, (image_uploadset, )) from app import main from app import user from app import image directory1 = os.path.join(os.getcwd(), 'images', 'faces') #directory2 = os.path.join(os.getcwd(),'images','thumbnails') directory3 = os.path.join(os.getcwd(), 'images', 'originals') if not os.path.exists(directory1): os.makedirs(directory1) # if not os.path.exists(directory2): # os.makedirs(directory2) if not os.path.exists(directory3): os.makedirs(directory3)
from flask_uploads import UploadSet, configure_uploads, IMAGES from flask_admin import Admin from flask_babelex import Babel import config app = Flask(__name__) app.config.from_object(os.environ['APP_CONFIG']) app.jinja_env.add_extension('jinja2.ext.loopcontrols') db = SQLAlchemy(app) ebooks = UploadSet('ebooks', ('pdf',)) book_images = UploadSet('bookimages', IMAGES) configure_uploads(app, (ebooks, book_images)) babel = Babel(app) from models import * import views from views.admin_views import * from forms import UserLoginForm admin = Admin(app, name='okubir', template_mode='bootstrap3', base_template='admin/base_mod.html') admin.add_view(UserView(User, db.session, u"Kullanıcılar")) admin.add_view(BookView(Book, db.session, u"Kitaplar")) admin.add_view(AuthorView(Author, db.session, u"Yazarlar")) admin.add_view(PublisherView(Publisher, db.session, u"Yayınevleri")) admin.add_view(SummaryView(Summary, db.session, u"Özetler")) admin.add_view(CommonView(InterestArea, db.session, u"İlgi alanları"))
def create_app(script_info=None): from logging.config import dictConfig # Set up logging at DEBUG level ... # From here: http://flask.pocoo.org/docs/dev/logging/ dictConfig({ 'version': 1, 'formatters': {'default': { 'format': '[%(asctime)s] %(levelname)s in %(module)s: %(message)s', }}, 'handlers': {'wsgi': { 'class': 'logging.StreamHandler', 'stream': 'ext://flask.logging.wsgi_errors_stream', 'formatter': 'default' }}, 'root': { 'level': 'DEBUG', 'handlers': ['wsgi'] } }) # instantiate the app app = Flask( __name__, template_folder="../client/templates", static_folder="../client/static", ) # set config app_settings = os.getenv( "APP_SETTINGS", "coffeeshop.server.config.DevelopmentConfig" ) app.config.from_object(app_settings) # set up extensions bcrypt.init_app(app) toolbar.init_app(app) bootstrap.init_app(app) db.init_app(app) migrate.init_app(app, db) # register blueprints from coffeeshop.server.user.views import user_blueprint from coffeeshop.server.main.views import main_blueprint from coffeeshop.server.shop.views import coffee_blueprint app.register_blueprint(user_blueprint) app.register_blueprint(main_blueprint) app.register_blueprint(coffee_blueprint) # flask security from coffeeshop.server.models import User, Role from coffeeshop.server.user.forms import ExtendedRegisterForm datastore = SQLAlchemyUserDatastore(db, User, Role) security_ctx = security.init_app( app, datastore, register_form=ExtendedRegisterForm # extend the register ) # jinja2 filters from .filters import env_override app.jinja_env.filters['env_override'] = env_override # error handlers @app.errorhandler(401) def unauthorized_page(error): return render_template("errors/401.html"), 401 @app.errorhandler(403) def forbidden_page(error): return render_template("errors/403.html"), 403 @app.errorhandler(404) def page_not_found(error): return render_template("errors/404.html"), 404 @app.errorhandler(500) def server_error_page(error): return render_template("errors/500.html"), 500 # shell context for flask cli @app.shell_context_processor def ctx(): return {"app": app, "db": db} # flask-uploads configure_uploads(app, (photos, )) patch_request_class(app, None) # GNU Terry Pratchett @app.after_request def gnu_terry_pratchett(resp): resp.headers.add("X-Clacks-Overhead", "GNU Terry Pratchett") return resp return app