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
