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