def test_config(self):
""" Tests configuration vars exist. """
FlaskS3(self.app)
defaults = ('S3_USE_HTTPS', 'USE_S3', 'USE_S3_DEBUG',
'S3_BUCKET_DOMAIN', 'S3_USE_CACHE_CONTROL')
for default in defaults:
self.assertIn(default, self.app.config)
def create_app():
app = Flask(__name__)
app.config.from_object('app.config')
# init flask-s3 to upload static file
s3 = FlaskS3()
s3.init_app(app)
app.config['FLASKS3_BUCKET_NAME'] = 'a2homework'
#flask_s3.create_all(app)
register_blueprint(app)
login_manager.init_app(app)
login_manager.login_view = 'web.login'
login_manager.login_message = 'Please login or register'
admin_t = db.Table('admin')
response = admin_t.scan(
FilterExpression=Attr('nickname').eq('admin')
)
items = response['Items']
if not len(items):
admin_t.put_item(
Item={
'nickname': 'admin',
'role': 'super',
'password': generate_password_hash('123456'),
'create_time': int(datetime.now().timestamp())
}
)
return app
def client_get(self, ufs):
FlaskS3(self.app)
client = self.app.test_client()
import six
if six.PY3:
return client.get('/%s' % ufs)
elif six.PY2:
return client.get('/{}'.format(ufs))
def test_jinja_url_for(self):
""" Tests that the jinja global gets assigned correctly. """
self.assertNotEqual(self.app.jinja_env.globals['url_for'],
flask_s3.url_for)
# then we initialise the extension
FlaskS3(self.app)
self.assertEquals(self.app.jinja_env.globals['url_for'],
flask_s3.url_for)
def init_flask_s3(app_):
with open(os.path.join(ROOT_DIR, '.aws/credentials')) as f:
config = ConfigParser()
config.read_file(f)
app_.config['AWS_ACCESS_KEY_ID'] = config['zappa-personal'][
'aws_access_key_id']
app_.config['AWS_SECRET_ACCESS_KEY'] = config['zappa-personal'][
'aws_secret_access_key']
FlaskS3(app_)
def test__write_files(self, key_mock):
""" Tests _write_files """
FlaskS3(self.app)
static_url_loc = '/foo/static'
static_folder = 'tests/'
assets = ['tests/bar.css', 'tests/foo.css']
exclude = ['/foo/static/foo.css', '/foo/static/foo/bar.css']
# we expect foo.css to be excluded and not uploaded
expected = [call(bucket=None, name=u'/foo/static/bar.css'),
call().set_metadata('Cache-Control', 'cache instruction'),
call().set_metadata('Expires', 'Thu, 31 Dec 2037 23:59:59 GMT'),
call().set_metadata('Content-Encoding', 'gzip'),
call().set_contents_from_filename('/home/z/bar.css')]
flask_s3._write_files(self.app, static_url_loc, static_folder, assets,
None, exclude)
self.assertLessEqual(expected, key_mock.mock_calls)
def start_app():
flask_app = Flask(__name__)
debug = env("DEBUG")
use_S3 = env("USE_S3")
if use_S3:
s3 = FlaskS3()
flask_app.config["FLASKS3_BUCKET_NAME"] = env("S3_BUCKET_NAME")
flask_app.config["FLASKS3_ACTIVE"] = use_S3
if env("USE_CDN"):
flask_app.config["FLASKS3_CDN_DOMAIN"] = env("CDN_DOMAIN")
s3.init_app(flask_app)
flask_app.debug = debug
content_security_policy = {'default-src': [SELF, env("CDN_DOMAIN")]}
if env("ENVIRONMENT") != "development":
Talisman(flask_app, content_security_policy=content_security_policy)
return flask_app
def create_app(env='dev', services=dict()):
"""
Creates a new flask app instance
"""
# Create the flask app
app = Flask(__name__)
# Do everything in the app context
with app.app_context():
from flask import current_app, g
g._env = env
# Load the config
current_app.config.from_object('magic.config.config_%s.Config' % env)
# Configure S3
s3 = FlaskS3(app)
g._s3 = s3
# Load all further resources and services
from . import views, models
# Resources
models.load_models()
views.load_views()
# Services
from .aws import configure_aws
configure_aws()
# Load debug toolbar if enabled
dev_toolbar = None
if app.config.get('DEBUG_TOOLBAR', True):
dev_toolbar = DebugToolbarExtension(app)
g._dev_toolbar = dev_toolbar
# Configure bootstrap
Bootstrap(app)
return app
def start_app():
app = Flask(__name__)
app.config['S3_BUCKET_NAME'] = 'readsy'
app.config['S3_CDN_DOMAIN'] = 'dwdhruapbuq08.cloudfront.net'
app.config['S3_USE_HTTPS'] = False
app.config['USE_S3_DEBUG'] = True # should be true
app.config['AWS_ACCESS_KEY_ID'] = os.environ['AWS_ACCESS_KEY_ID']
app.config['AWS_SECRET_ACCESS_KEY'] = os.environ['AWS_SECRET_ACCESS_KEY']
s3 = FlaskS3()
s3.init_app(app)
assets = Environment()
# use closure_js once i have java 7
js = Bundle('js/jquery.cookie.js', 'js/app.js', 'js/froala_editor.min.js', 'js/sharrre.min.js', filters='rjsmin', output='gen/packed.js')
css = Bundle('css/bootstrap.min.css', 'css/froala_editor.min.css', 'css/bootstrapcustom.css', 'css/sharre.css', filters='cssmin', output='gen/packed.css')
assets.register('js_all', js)
assets.register('css_all', css)
app.config['ASSETS_DEBUG'] = False
assets.init_app(app)
app.config['FLASK_ASSETS_USE_S3'] = True #should be true
return app
import sendgrid
import os
from flask import Flask
from config import Config
from flask_s3 import FlaskS3
app = Flask(__name__)
app.config.from_object(Config)
s3 = FlaskS3(app)
sg = sendgrid.SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))
from app import routes, errors
from glob import glob
import flask_s3
from flask import Flask
from flask_jwt_extended import JWTManager
from flask_s3 import FlaskS3
from importlib import import_module
from flask_login import LoginManager
s3 = FlaskS3()
login_manager = LoginManager()
def register_blueprints(app):
for module_name in glob("webapp/blueprints/*/"):
module = import_module(module_name.replace('/', '.') + 'routes')
app.register_blueprint(module.blueprint)
def register_extensions(app):
login_manager.init_app(app)
login_manager.session_protection = "strong"
aws_s3(app)
JWTManager(app)
def aws_s3(app):
try:
s3.init_app(app)
flask_s3.create_all(app, put_bucket_acl=False)
except Exception as e:
print('---> Something wrong with S3')
def client_get(self, ufs):
FlaskS3(self.app)
client = self.app.test_client()
return client.get('/%s' % ufs)
'''import main Flask. This starts when run.py calls from app import app'''
import os
from flask import Flask
from flask_compress import Compress
from flask_assets import Bundle, Environment
from flask_caching import Cache
from flask_s3 import FlaskS3
from flask_debugtoolbar import DebugToolbarExtension
from app.assets import css_assets, js_assets, js_api_assets
from app.utils.logger import logger
# Config
app = Flask(__name__)
compress = Compress()
flasks3 = FlaskS3()
cache = Cache()
toolbar = DebugToolbarExtension()
flask_config = os.environ['FLASK_CONFIG']
logger.info('** FLASK_CONFIG: {}'.format(flask_config))
app.config.from_object('app.config.{}'.format(flask_config))
compress.init_app(app)
flasks3.init_app(app)
cache.init_app(app)
toolbar.init_app(app)
if bool(int(os.getenv('CACHE_CLEAR', 0))):
cache.clear()
logger.info('** Cached cleared [CLEAR_CACHE] True')
def create_app(app_name, config_obj, with_api=True):
""" Generates and configures the main shop application. All additional """
# Launching application
app = Flask(app_name) # So the engine would recognize the root package
# Load Configuration
app.config.from_object(config_obj)
# Loading assets
assets = Environment(app)
assets.from_yaml('assets.yaml')
app.assets = assets
# Initialize Mail
app.mail = Mail(app)
# Initializing login manager
login_manager = LoginManager()
login_manager.login_view = app.config.get('LOGIN_VIEW', 'main.index')
# login_manager.login_message = 'You need to be logged in to access this page'
login_manager.session_protection = 'strong'
login_manager.setup_app(app)
app.login_manager = login_manager
# Initializing principal manager
app.principal = Principal(app)
# Initializing bcrypt password encryption
bcrypt = Bcrypt(app)
app.bcrypt = bcrypt
# Initializing Database
db = SQLAlchemy(app)
app.db = db
# Initializing Migrate
migrate = Migrate(app, db, "from fitted.models import *")
app.migrate = migrate
photos = UploadSet('photos', IMAGES)
archives = UploadSet('archives', ARCHIVES)
configure_uploads(app, (photos, archives))
patch_request_class(app,
2 * 1024 * 1024) # Patches to 2MB file uploads max.
app.photos = photos
app.archives = archives
# Integrate Elasticsearch
es_config = app.config.get("ES_CONFIG", [])
app.es = Elasticsearch(es_config)
# Integrate sms with Twilio
app.sms = TwilioRestClient(app.config.get("TWILIO_API_SID"),
app.config.get("TWILIO_API_TOKEN"))
# Redis store for session management
# The process running Flask needs write access to this directory:
# store = RedisStore(redis.StrictRedis())
# # this will replace the app's session handling
# KVSessionExtension(store, app)
# configure sentry
# if not app.config.get("DEBUG", False):
# sentry = Sentry(app)
# app.sentry = sentry
# inject celery into the app
app.celery = make_celery(app)
# injecting mongodb support
# app.mongo = PyMongo(app)
# flask s3 integration
app.s3 = FlaskS3(app)
# Facebook & Twitter Integration
app.facebook = oauth.remote_app('facebook', app_key='FACEBOOK')
oauth.init_app(app)
# Initializing the restful API
if with_api:
api = restful.Api(app, prefix='/api/v1')
app.api = api
# Initialize Logging
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler(
"/var/log/fitted/%s.log" %
app.config.get("LOGFILE_NAME", app_name),
maxBytes=500 * 1024)
file_handler.setLevel(logging.WARNING)
from logging import Formatter
file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(file_handler)
#include an api_registry to the application
app.api_registry = [] #a simple list holding the values to be registered
return app
#: Flask-SQLAlchemy extension instance
db = SQLAlchemy()
#: Flask-Security extension instance
security = Security()
#: Flask Mail Extension Instance
mail = Mail()
#: Flask-Cache Extension Instance
cache = Cache()
#: Flask-S3 Extension Instance (for Static Assets)
s3_assets = FlaskS3()
#: Image Filesystem
store = config[os.getenv('APP_ENV') or 'default'].get_store()
class LongboxedError(Exception):
"""Base application error class"""
def __init__(self, msg):
self.msg = msg
class LongboxedFormError(Exception):
"""Raise when an error processing a form occurs."""
def __init__(self, errors=None):
import requests
import boto3
from datetime import datetime
import decimal
from flask_cors import CORS
class DecimalEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, decimal.Decimal):
return int(o)
return super(DecimalEncoder, self).default(o)
webapp = Flask(__name__, static_url_path = '/static', static_folder = 'static')
webapp.config['FLASKS3_BUCKET_NAME'] = S3_BUCKET
s3 = FlaskS3(webapp)
CORS(webapp, resources=r'/*')
# oauth
sp_oauth = oauth2.SpotifyOAuth(SPOTIPY_CLIENT_ID, SPOTIPY_CLIENT_SECRET, SPOTIPY_REDIRECT_URI, scope=SCOPE, cache_path=CACHE)
sp_token = {}
# for home page user playlists
pl_names = []
pl_image_urls =[]
pl_ids = []
pl_descriptions = []
pl_track_ids = []
pl_track_names = []
pl_art_ids = []
pl_track_dicts = []
import werkzeug
from flask import Flask, render_template, flash, g, request, url_for, redirect
from flask_s3 import FlaskS3
from flaskext.babel import Babel, lazy_gettext as _
import forms
from countries import country_choices
app = Flask(__name__)
app.secret_key = os.environ.get("SECRET_KEY", "secret")
app.config["DEBUG"] = int(os.environ.get("BETA_DEBUG", 1)) != 0
bucket = os.environ.get("TSURU_S3_BUCKET")
app.config["S3_BUCKET_NAME"] = bucket
FlaskS3(app)
babel = Babel(app)
MONGO_URI = os.environ.get("MONGO_URI", "localhost:27017")
MONGO_USER = os.environ.get("MONGO_USER", "")
MONGO_PASSWORD = os.environ.get("MONGO_PASSWORD", "")
MONGO_DATABASE_NAME = os.environ.get("MONGO_DATABASE_NAME", "beta_test")
GITHUB_CLIENT_ID = os.environ.get("GITHUB_CLIENT_ID", "")
GITHUB_CLIENT_SECRET = os.environ.get("GITHUB_CLIENT_SECRET", "")
FACEBOOK_APP_ID = os.environ.get("FACEBOOK_APP_ID", "")
GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
GOOGLE_USER_IP = os.environ.get("GOOGLE_USER_IP")
GOOGLE_OAUTH_ENDPOINT = "https://www.googleapis.com/oauth2/v2"
SIGN_KEY = os.environ.get("SIGN_KEY")
application.config['MYSQL_DATABASE_USER'] = '******'
application.config['MYSQL_DATABASE_PASSWORD'] = '******'
application.config['MYSQL_DATABASE_DB'] = 'nanugi'
application.config['MYSQL_DATABASE_HOST'] = 'nanugi.cnwhswqzcfic.ap-northeast-2.rds.amazonaws.com'
application.config['FLASK3_BUCKET_NAME'] = 'elasticbeanstalk-ap-northeast-2-164387737785'
application.config.from_object(__name__)
application.config['ALLOWED_EXTENSIONS'] = ['jpg', 'jpeg', 'png']
application.config['FILE_CONTENT_TYPES'] = {
'jpg' : 'image/jpeg',
'jpeg' : 'image/jpeg',
'png' : 'image/png'
}
application.config['AWS_ACCESS_KEY_ID'] = 'AKIAJYUUY7OHL46KXSPA'
application.config['AWS_SECRET_ACCESS_KEY'] = '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'
s3 = FlaskS3(application)
mysql.init_app(application)
# load model as global from s3
bucket='sagemaker-test02'
data_key = 'model'
data_location = 's3://{}/{}'.format(bucket, data_key)
s3 = boto3.resource('s3', aws_access_key_id=application.config['AWS_ACCESS_KEY_ID'], aws_secret_access_key=application.config['AWS_SECRET_ACCESS_KEY'])
with BytesIO() as data:
s3.Bucket(bucket).download_fileobj("model/model_tdmvector.sav", data)
data.seek(0) # move back to the beginning after writing
loaded_tdm_model = joblib.load(data)
with BytesIO() as data:
s3.Bucket(bucket).download_fileobj("model/model_tfidf.sav", data)
data.seek(0) # move back to the beginning after writing
