def register_bundles(app): assets = Environment(app) assets.debug = app.config.get('ASSETS_DEBUG', False) ## # CSS css_global = Bundle( 'css/shared/normalize.scss', 'css/global.scss', filters='scss, cssmin', output='gen/global.css') assets.register('css_global', css_global) css_home = Bundle( 'css/home.scss', filters='scss, cssmin', #otheCssBundled output='gen/home.css') assets.register('css_home', css_home) ## # Javascript js_global = Bundle('js/jquery-1.9.1.js', 'js/global.js','js/someUtil.js') js_global = Bundle( Bundle(js_global), #otherJsBundled, output='gen/script.js' ) assets.register('js_global', js_global)
def init_webassets(flask_app, config): """ Initialize Flask-Assets extension. """ assets = Environment(flask_app) assets.debug = flask_app.debug dart_root = 'dart/web' if flask_app.debug else 'dart/build/web' assets.register("less", Bundle( "less/bootstrap/bootstrap.less", "less/font-awesome/font-awesome.less", filters="less", output="combined/bootstrap.css", depends="less/*.less" )) assets.register('dart', Bundle( dart_root + '/main.dart' )) assets.register("javascript", Bundle( 'js/d3.js', 'js/markdown.js', dart_root + '/packages/web_components/dart_support.js', dart_root + '/packages/browser/dart.js', output='combined/combined.js' ))
def assets_env(app): env = Environment(app) env.url = "/static" # App Engine doesn't support automatic rebuilding. env.auto_build = False # This file needs to be shipped with your code. env.manifest = ('file:' + os.path.join(root_dir, 'webassets.manifest')) env.versions = 'hash:32' # create static bundles env.register('new_js', 'js/hiro.js', filters='yui_js', output="javascript/hiro.%(version)s.js") env.register('hoc_js', 'js/hoc.js', filters='yui_js', output="javascript/hoc.%(version)s.js") env.register('new_css', 'css/hiro.css', filters='cssmin', output="stylesheets/hiro.%(version)s.css") env.register('hoc_css', 'css/hoc.css', filters='cssmin', output="stylesheets/hoc.%(version)s.css") env.debug = app.config['DEBUG'] return env
def init_webassets(flask_app, config): """ Initialize Flask-Assets extension. """ assets = Environment(flask_app) assets.debug = flask_app.debug dart_root = 'dart/web' if flask_app.debug else 'dart/build/web' assets.register("less", Bundle( "less/bootstrap/bootstrap.less", "less/font-awesome/font-awesome.less", filters="less", output="combined/bootstrap.css", depends="less/*.less" )) assets.register('dart', Bundle( dart_root + '/main.dart' )) assets.register("javascript", Bundle( 'js/d3.js', 'js/markdown.js', dart_root + '/packages/web_components/dart_support.js', dart_root + '/packages/browser/dart.js', output='combined/combined.js' ))
def init_app(app): webassets = Environment(app) webassets.register('apollo_css', apollo_css) webassets.register('apollo_js', apollo_js) webassets.manifest = 'cache' if not app.debug else False webassets.cache = not app.debug webassets.debug = app.debug
def register_web_ui(mgr): global manager, assets manager = mgr assets_cache = os.path.join(manager.config_base, '.webassets-cache') if not os.path.isdir(assets_cache): os.mkdir(assets_cache) assets = Environment(webui_app) assets.directory = assets_cache for p in _get_plugin_paths(): assets.append_path(p, url="%s/plugin" % webui_app.url_path) assets.cache = assets_cache assets.url = '%s/cache' % webui_app.url_path if 'debug' in manager.args: assets.debug = True load_assets() load_ui_plugins() register_app(webui_app.url_path, webui_app) register_home('%s/' % webui_app.url_path)
def register_web_ui(mgr): global manager, assets manager = mgr assets_cache = os.path.join(manager.config_base, '.webassets-cache') if not os.path.isdir(assets_cache): os.mkdir(assets_cache) assets = Environment(webui_app) assets.directory = assets_cache for p in _get_plugin_paths(): assets.append_path(p, url="%s/plugin" % webui_app.url_path) assets.cache = assets_cache assets.url = '%s/cache' % webui_app.url_path if 'debug' in manager.args: assets.debug = True load_assets() load_ui_plugins() register_app(webui_app.url_path, webui_app) register_home('%s/' % webui_app.url_path)
def init_app(app): webassets = Environment(app) webassets.register("apollo_css", apollo_css) webassets.register("apollo_js", apollo_js) webassets.manifest = "cache" if not app.debug else False webassets.cache = not app.debug webassets.debug = app.debug
def init_app(app): assets = Environment(app) assets.debug = app.config.get('DEBUG', False) assets.directory = app.static_folder assets.url = app.static_url_path assets.directory = app.static_folder assets.append_path(assets_directory) assets.append_path(app.static_folder)
def init_app(app): webassets = Environment(app) webassets.register('css_all', css_all) webassets.register('js_vendor', js_vendor) webassets.register('js_ie', js_ie) webassets.register('js_main', js_main) webassets.manifest = 'cache' if not app.debug else False webassets.cache = not app.debug webassets.debug = app.debug
def create_app(config='dev'): """ Flask application factory :param str config: type of app to build, either "prod" or "dev" """ # Create flask application app = Flask(__name__) app.config.from_object('settings') app.config['ENV'] = config app.jinja_env.trim_blocks = True # Debug toolbar (when debug=true) debug_toolbar = DebugToolbarExtension(app) app.config['DEBUG_TB_PROFILER_ENABLED'] = True app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False # Register Blueprints app.register_blueprint(views_base.base) app.register_blueprint(views_blog.blog) # Flask-Assets; bundles all css/js files in minifed file assets = Environment(app) css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css', filters='cssmin', output='gen/style.css') js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js', 'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js') assets.register('css_all', css_all) assets.register('js_all', js_all) if app.config['DEBUG']: assets.debug = True app.config['ASSETS_DEBUG'] = True # Set up Flask-User babel = Babel(app) db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Init the cache cache.init_app(app) Moment(app) # moment.js Misaka(app, autolink=True, # Misaka Markdown fenced_code=True, lax_html=True, strikethrough=True, superscript=True, tables=True, wrap=True) # Init Admin page admin = Admin(app, index_view=AdminMain(endpoint='admin')) admin.add_view(PostAdminView()) admin.add_view(NewPostView()) admin.add_view(ModelView(Comment, db.session)) static_path = os.path.join(BASE_DIR, 'app', 'static') admin.add_view(FileAdminView(static_path, '/static/', name='Static Files')) # Initialize DB db.init_app(app) return app
def bundle(app): assets = Environment(app) assets.debug = True theme_bundle(assets) base_bundle(assets) app_bundle(assets) return assets
def setup_assets(app): assets = Environment(app) assets.debug = app.debug static_base = os.path.join(app.root_path, 'static') bootstrap_files = [os.path.relpath(path, static_base) for path in glob(os.path.join(static_base, 'js/lib/bootstrap-*.js'))] bootstrap = Bundle(*bootstrap_files) js = Bundle('js/lib/jquery-2.0.2.js', 'js/lib/underscore.js', bootstrap, 'js/dict8or.js', filters='rjsmin', output='assets/bundle.%(version)s.js') css = Bundle('less/lib/bootstrap.less', 'less/core.less', filters=('less', 'cssrewrite', 'cssmin'), output='assets/bundle.%(version)s.css') assets.register('js_all', js) assets.register('css_all', css)
def setup_bundles(app): assets_env = Environment(app) assets_env.url = '/statics' assets_env.manifest = 'file:Compiled/static-manifest-version' assets_env.cache = False assets_env.auto_build = False assets_env.debug = app.config.get('DEVELOPMENT') == True # load and register bundles config_path = app.instance_path + '/config/asset_bundles.yaml' bundles = YAMLLoader(config_path).load_bundles() for name, bundle in bundles.iteritems(): assets_env.register(name, bundle) app.assets_env = assets_env
def init_app(app): assets = Environment(app) assets.debug = app.config.get('DEBUG', False) assets.directory = app.static_folder assets.url = app.static_url_path assets.directory = app.static_folder assets.append_path(assets_directory) assets.append_path(app.static_folder) assets.register("h5bp_css", h5bp_css) assets.register("h5bp_shiv", h5bp_shiv) assets.register("h5bp_head_js", h5bp_head_js) if assets.debug: assets.register("h5bp_body_js", h5bp_body_js_devel) else: assets.register("h5bp_body_js", h5bp_body_js_production)
def register_assets(app): assets = Environment(app) ALL_ASSETS = { 'core_js': Bundle('js/lib/jquery.js', 'js/lib/jquery.highlight.js', 'js/lib/jquery.mobile.js', 'js/lib/underscore.js', 'js/lib/backbone.js', 'js/lib/inifiniScroll.js', 'js/lib/moment.js', 'js/model/modelsForEvents.js', 'js/utils.js', 'js/view/PageView.js', 'js/view/ListView.js', 'js/add_favorites.js', 'js/routes.js', filters='rjsmin', output='core_%(version)s.js'), 'home_js': Bundle('js/home.js', filters='rjsmin', output='home_%(version)s.js'), 'goingon_js': Bundle('js/goingon.js', filters='rjsmin', output='goingon_%(version)s.js'), 'events_js': Bundle('js/events.js', filters='rjsmin', output='events_%(version)s.js'), 'favorites_js': Bundle('js/favorites.js', filters='rjsmin', output='favorites_%(version)ss.js'), 'history_js': Bundle('js/history.js', filters='rjsmin', output='history_%(version)s.js'), 'search_js': Bundle('js/search.js', filters='rjsmin', output='search_%(version)s.js'), 'statistics_js': Bundle('js/statistics.js', filters='rjsmin', output='statistics_%(version)s.js'), 'maps_js': Bundle('js/lib/gmaps.js', 'js/maps.js', filters='rjsmin', output='maps_%(version)s.js'), 'style_css': Bundle('style/jquery.mobile.css', 'style/icons.css', 'style/core.css', filters='cssmin', output='style/style_%(version)s.css') } assets.debug = app.config["DEBUG"] for bundle_id, bundle in ALL_ASSETS.iteritems(): assets.register(bundle_id, bundle) return assets
def setup_app(app): """Initialize Assets extension.""" app.config.setdefault("LESS_RUN_IN_DEBUG", False) assets = Environment(app) assets.url = app.static_url_path + "/" assets.directory = app.static_folder commands = (("LESS_BIN", "lessc"), ("CLEANCSS_BIN", "cleancss")) import subprocess for key, cmd in commands: try: command = app.config.get(key, cmd) subprocess.call([command, "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) except OSError: app.logger.error("Executable `{0}` was not found. You can specify " "it via {1}." .format(cmd, key)) app.config["ASSETS_DEBUG"] = True assets.debug = True def _jinja2_new_bundle(tag, collection, name=None, filters=None): if len(collection): name = "invenio" if name is None else name sig = hash(",".join(collection) + "|" + str(filters)) kwargs = { "output": "{0}/{1}-{2}.{0}".format(tag, name, sig), "filters": filters, "extra": {"rel": "stylesheet"} } # If LESS_RUN_IN_DEBUG is set to False, then the filters are # removed and each less file will be parsed by the less JavaScript # library. if assets.debug and not app.config.get("LESS_RUN_IN_DEBUG", True): kwargs["extra"]["rel"] = "stylesheet/less" kwargs["filters"] = None return Bundle(*collection, **kwargs) app.jinja_env.extend(new_bundle=_jinja2_new_bundle, default_bundle_name='90-invenio') app.jinja_env.add_extension(CollectionExtension) return app
def register_assets(app): assets = Environment(app) ALL_ASSETS = { "core_js": Bundle( "js/lib/jquery.js", "js/lib/jquery.highlight.js", "js/lib/jquery.mobile.js", "js/lib/underscore.js", "js/lib/backbone.js", "js/lib/inifiniScroll.js", "js/lib/moment.js", "js/model/modelsForEvents.js", "js/utils.js", "js/view/PageView.js", "js/view/ListView.js", "js/add_favorites.js", "js/routes.js", filters="rjsmin", output="core_%(version)s.js", ), "home_js": Bundle("js/home.js", filters="rjsmin", output="home_%(version)s.js"), "goingon_js": Bundle("js/goingon.js", filters="rjsmin", output="goingon_%(version)s.js"), "events_js": Bundle("js/events.js", filters="rjsmin", output="events_%(version)s.js"), "favorites_js": Bundle("js/favorites.js", filters="rjsmin", output="favorites_%(version)ss.js"), "history_js": Bundle("js/history.js", filters="rjsmin", output="history_%(version)s.js"), "search_js": Bundle("js/search.js", filters="rjsmin", output="search_%(version)s.js"), "maps_js": Bundle("js/lib/gmaps.js", "js/maps.js", filters="rjsmin", output="maps_%(version)s.js"), "style_css": Bundle( "style/jquery.mobile.css", "style/icons.css", "style/core.css", filters="cssmin", output="style/style_%(version)s.css", ), } assets.debug = app.config["DEBUG"] for bundle_id, bundle in ALL_ASSETS.iteritems(): assets.register(bundle_id, bundle) return assets
def register(app): assets = Environment(app) assets.debug = False css_overrides = Bundle("css/jquery-ui.css", "css/google_open_sans.css", "css/app.css", "css/timepicker.css", "css/select2.css", output="gen/overrides.css") assets.register("css_overrides", css_overrides) boards_js = Bundle("js/select2.js", "js/socket.io.js", "js/jquery-ui.js", "js/timepicker.js", "js/raty/jquery.raty.js", output="gen/boards_js.js") assets.register("boards_js", boards_js)
def build_assets(app): """ build assets with webassets """ js = Bundle( *js_assets, filters='rjsmin', output='gen/packed.js' ) css = Bundle( *css_assets, filters=(custom_cssmin, 'cssrewrite'), output='gen/packed.css' ) assets = Environment(app) assets.debug = True # FIXME # assets.debug = True assets.register('js_all', js) assets.register('css_all', css)
def register_assets(app, debug=False): """We add the app's root path to assets search path. However, the output directory is relative to `app.static_folder`. """ assets = Environment(app) assets.debug = debug assets.auto_build = True assets.manifest = 'file' assets.append_path(app.root_path) site_js = Bundle( 'static/app.js', filters=('uglifyjs',), output='js/bundle.js' ) assets.register('site_js', site_js) site_css = Bundle( 'static/style.css', filters=('cssmin',), output='css/bundle.css' ) assets.register('site_css', site_css)
def init_app(app): # Initialize webassets, the asset pipeline assets = Environment(app) assets.debug = app.config['DEBUG'] cur_path = os.path.dirname(os.path.abspath(__file__)) assets_load_path = os.path.join(cur_path, 'static') if ('WEBASSETS_PATH' in app.config): assets_load_path = app.config['WEBASSETS_PATH'] logger.debug('Using asset directory specified in config.') logger.debug('Using asset directory of: {0}.'.format(assets_load_path)) # Output path for compiled assets assets.directory = os.path.join(cur_path, 'static') assets.url = '/static/' assets.from_yaml(os.path.join(cur_path, 'assets.yml')) assets.config['closure_compressor_optimization'] = 'SIMPLE_OPTIMIZATIONS' assets.config['closure_extra_args'] = ['--language_in', 'ECMASCRIPT5'] assets.append_path(assets_load_path) return assets
trackId = track[0].id submissions = Submission.query.filter(Submission.trackId==trackId).all(); resp = make_response(render_template('tracks_listing.html', user=g.user,show=len(track)<=0, submissions=submissions)) return resp # static asset versioning and packaging assets = Environment(app) js = Bundle('jquery-1.11.0.js', 'bootstrap-3.1.1/dist/js/bootstrap.js', 'bootstrap-selectpicker/bootstrap-select.js', 'typeahead.bundle.js', 'lodash.min.js', 'can.jquery.js', 'modal.js', filters='rjsmin', output='build/tuxtrax-%(version)s.js') css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css') assets.debug = constants.DEBUG assets.versions = "hash" assets.register('js_base', js) assets.register('css_base', css) @app.route('/dev') def index(): tags = [tag.name for tag in Tag.query.all()] resp = make_response(render_template('index.html', user=g.user, showhidden=False, tags=tags)) resp.set_cookie('submission_ver', str(submission_dataset_ver())) return resp
# load config app.config.update( DEBUG=debug, SHOW_GA=show_ga, SECRET_KEY=os.environ.get('SECRET_KEY', ''), # GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''), # GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''), # GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''), SQLALCHEMY_TRACK_MODIFICATIONS=True, SQLALCHEMY_DATABASE_URI=os.environ.get( 'SQLALCHEMY_DATABASE_URI', 'postgres://*****:*****@localhost/beer'), ) db = SQLAlchemy(app) # setup assetbundle assets = Environment(app) assets.debug = False # app.debug # (debug=True f***s up jsx) bundles = PythonLoader('web.assetbundles').load_bundles() for name, bundle in bundles.iteritems(): assets.register(name, bundle) # add various views from web import views from web import api app.db_session = db.session
@app.before_first_request def setup_logging(): if not app.debug: app.logger.addHandler(logging.StreamHandler()) app.logger.setLevel(logging.INFO) # Getting the supported languages from SUMO LANGUAGES = requests.get( (app.config['SUMO_URL'] + 'offline/get-languages')).json() LANGUAGES = json.dumps(LANGUAGES['languages']) # Sets up the assets assets = Environment(app) assets.auto_build = app.debug assets.debug = app.debug # we don't need this as manifest.appcache will change assets.url_expire = False css = Bundle('css/develop/gaia.css', 'css/develop/doc.css', 'css/develop/installer.css', 'css/develop/nav.css', 'css/develop/app.css', filters='cssmin', output='css/app.min.css') assets.register('css_all', css) scripts = ['js/develop/app.js'] for root, subdir, fnames in os.walk('static/js/develop'): for filename in fnames:
from dexter.app import app # setup assets from flask.ext.assets import Environment, Bundle assets = Environment(app) assets.url_expire = False assets.debug = app.config['ENV'] == 'development' assets.directory = '%s/public' % app.config.root_path assets.load_path = ['assets'] assets.url = '/public' assets.register('css', Bundle( 'css/bootstrap-3.2.0.min.css', 'css/bootstrap-theme-3.2.0.min.css', 'css/font-awesome-4.3.0.min.css', 'css/datepicker3.css', 'css/bootstrap-datetimepicker.min.css', 'css/daterangepicker-bs3.css', 'css/select2-3.4.8.css', 'css/select2-bootstrap-3.4.8.css', 'css/dropzone-3.10.2.css', Bundle( 'css/*.scss', filters='pyscss', output='css/app.%(version)s.css'), output='css/all.%(version)s.css')) assets.register('mine-css', Bundle( 'css/bootstrap-3.2.0.min.css',
def init(app): """Initialize CSS and JavaScript asset bundles """ js_libs = Bundle("js/libs/jquery-1.6.2.min.js", "js/libs/jquery.dropkick-1.0.0.js", "js/libs/json2.js", "js/libs/underscore.js", "js/libs/backbone.js", "js/libs/swfobject.js", "js/libs/spin-1.2.2.js", filters="jsmin", output="libs.js") js_common = Bundle("js/app/tools.js", "js/app/common.js", filters="jsmin", output="common.js") js_home = Bundle("js/app/stats.js", "js/app/home.js", filters="jsmin", output="home.js") js_profile = Bundle("js/app/profile.js", filters="jsmin", output="profile.js") css_less = Bundle("css/style.less", filters="less", output="style.css", debug=False) css_main = Bundle(Bundle("css/lib/screen.css", "css/lib/dropkick.css"), css_less, filters="cssmin", output="main.css") css_ie8 = Bundle("css/ie8.css", filters="cssmin", output="ie8.css") # Admin Assets js_admin_libs = Bundle("js/libs/jquery-1.6.2.min.js", "js/libs/jquery-ui-1.8.16.min.js", "js/libs/json2.js", "js/libs/underscore.js", "js/libs/backbone.js", filters="jsmin", output="admin_libs.js") js_admin_common = Bundle("js/app/admin_tools.js", "js/app/admin.js", filters="jsmin", output="admin_common.js") css_admin_less = Bundle("css/admin.less", filters="less", output="admin.css", debug=False) css_admin_main = Bundle("css/lib/screen.css", "css/lib/smoothness/jquery-ui-1.8.16.css", css_admin_less, filters="cssmin", output="admin_main.css") assets = Environment(app) assets.debug = app.config['ENVIRONMENT'] in ['development', 'staging'] assets.register('js_libs', js_libs) assets.register('js_common', js_common) assets.register('js_home', js_home) assets.register('js_profile', js_profile) assets.register("css_main", css_main) assets.register("css_ie8", css_ie8) assets.register("js_admin_libs", js_admin_libs) assets.register("js_admin_common", js_admin_common) assets.register("css_admin_main", css_admin_main)
def init(app): assets = Environment(app) if app.config.get('CARAVELA_ENV') == 'production': assets.debug=False assets.auto_build=False #else: # assets.debug = True assets.url = app.static_url_path assets.register('common.js', Bundle( 'lib/jquery-1.9.1.min.js', 'lib/bootstrap.js', 'lib/modernizr-2.6.1.min.js', 'lib/underscore-min.js', 'lib/less-1.3.0.min.js', 'lib/jquery-ui-1.10.1.custom.min.js', 'lib/jquery.mousewheel.js', 'lib/handlebars-1.0.0.js', 'lib/ember-1.0.0.js', 'lib/ember-data.js', 'lib/ember-table.js', 'lib/d3.v3.min.js', 'lib/vega.js', 'lib/d3.geo.projection.min.js', 'lib/codemirror.js', 'lib/mode/javascript/javascript.js', 'js/app.js', 'js/routes/*.js', 'js/controllers/*.js', 'js/models/*.js', 'js/views/*.js', #filters='rjsmin', output='assets/common.js' )) sass = Bundle( '**/*.sass', filters='compass', output='assets/sass.css' ) assets.register('sass.css', sass) assets.register('common.css', Bundle( sass, 'css/bootstrap.min.css', 'lib/codemirror.css', 'css/persona-buttons.css', 'css/style.css', output='assets/common.css' )) assets.config.update(dict( jst_compiler = "Em.Handlebars.compile", jst_namespace= "Em.TEMPLATES" )) assets.register('app.handlebars', Bundle( 'templates/*.handlebars', 'templates/**/*.handlebars', filters='jst', output='assets/app.handlebars' ))
if 'PC_FAKE_OID' in os.environ: session['openid'] = os.environ['PC_FAKE_OID'] # static asset versioning and packaging assets = Environment(app) js = Bundle('jquery-1.11.0.js', 'bootstrap-3.1.1/dist/js/bootstrap.js', 'bootstrap-selectpicker/bootstrap-select.js', 'typeahead.bundle.js', 'lodash.min.js', 'can.jquery.js', filters='rjsmin', output='build/tuxtrax-%(version)s.js') css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css') try: os.environ["DEBUG"] except KeyError: debug = False else: debug = True assets.debug = debug assets.versions = "hash" assets.register('js_base', js) assets.register('css_base', css)
def create_app(config=None, debug=False): ''' Inicializa la aplicación Flask. Carga los siguientes módulos: - index: página de inicio - page: páginas estáticas - user: gestión del usuario - files: búsqueda y obtención de ficheros - status: servicio de monitorización de la aplicación Y además, inicializa los siguientes servicios: - Configuración: carga valores por defecto y modifica con el @param config - Web Assets: compilación y compresión de recursos estáticos - i18n: detección de idioma en la URL y catálogos de mensajes - Cache y auth: Declarados en el módulo services - Files: Clases para acceso a datos ''' app = Flask(__name__) app.config.from_object(defaults) app.debug = debug app.session_interface = NoSessionInterface() # Configuración if config: app.config.from_object(config) # Runtime config app.config["DOWNLOADER_FILES"] = { k: os.path.join(os.path.abspath(os.path.join(app.root_path,"../downloads")), v) for k, v in app.config["DOWNLOADER_FILES"].iteritems() } # Gestión centralizada de errores if app.config["SENTRY_DSN"]: sentry.init_app(app) logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO) # Configuración dependiente de la versión del código revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision") if os.path.exists(revision_filename_path): f = open(revision_filename_path, "r") data = f.read() f.close() revisions = tuple( tuple(i.strip() for i in line.split("#")[0].split()) for line in data.strip().split("\n") if line.strip() and not line.strip().startswith("#")) revision_hash = md5(data).hexdigest() app.config.update( CACHE_KEY_PREFIX = "%s%s/" % ( app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "", revision_hash ), REVISION_HASH = revision_hash, REVISION = revisions ) else: app.config.update( REVISION_HASH = None, REVISION = () ) # Registra valores/funciones para plantillas app.jinja_env.globals["u"] = u # Blueprints print "Registering blueprints." app.register_blueprint(index) register_files_converters(app) app.register_blueprint(news) app.register_blueprint(files) for blueprint in downloader_blueprints: app.register_blueprint(blueprint) # Registra filtros de plantillas register_filters(app) # Web Assets print "Web assets." if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen") assets = Environment(app) app.assets = assets assets.debug = app.debug assets.versions = "timestamp" register_filter(JsSlimmer) register_filter(CssSlimmer) assets.register('css_torrents', Bundle('main.css', 'jquery.treeview.css', filters='pyscss', output='gen/main.css', debug=False), '960_24_col.css', filters='css_slimmer', output='gen/torrents.css') assets.register('js_torrents', Bundle('modernizr.js', 'jquery.js', 'jquery.treeview.js', 'jquery.cookie.js', 'jquery.colorbox-min.js', 'torrents.js', 'cookies.js', filters='rjsmin', output='gen/torrents.js'), ) print "Initializing services." # CSRF protection csrf.init_app(app) # Traducciones babel.init_app(app) @babel.localeselector def get_locale(): return "en" # Cache cache.init_app(app) # Mail mail.init_app(app) print "Database accesses:" # Acceso a bases de datos filesdb.init_app(app) print "* files" torrentsdb.init_app(app, searchd) print "* torrents" pagesdb.init_app(app) print "* pages" #feedbackdb.init_app(app) #print "* feedback" configdb.init_app(app) print "* config" entitiesdb.init_app(app) print "* entities" for service_name, params in app.config["DATA_SOURCE_SHARING"].iteritems(): eval(service_name).share_connections(**{key:eval(value) for key, value in params.iteritems()}) configdb.register_action("flush_cache", cache.clear, _unique=True) print "Blacklists." # Blacklists if app.debug: blacklists.debug=True blacklist_data = torrentsdb.get_blacklists() blacklists.load_data(blacklist_data) blacklists.clone_into(blacklists_adult, lambda x:x!="misconduct") def refresh_blacklists(): ''' Refresh blacklists. ''' blacklists.load_data(torrentsdb.get_blacklists()) configdb.register_action("refresh_blacklists", refresh_blacklists) def update_downloader_properties(): ''' Downloader updated. ''' local_cache["downloader_properties"] = get_downloader_properties() configdb.register_action("update_downloader", update_downloader_properties) with app.app_context(): local_cache["downloader_properties"] = get_downloader_properties() # IPs españolas spanish_ips.load(os.path.join(os.path.dirname(app.root_path),app.config["SPANISH_IPS_FILENAME"])) @app.before_first_request def init_process(): if not eventmanager.is_alive(): # Fallback inicio del eventManager eventmanager.start() print "Event manager." # Profiler # profiler.init_app(app, feedbackdb) # Servicio de búsqueda eventmanager.once(searchd.init_app, hargs=(app, filesdb, entitiesdb, profiler)) # Refresco de conexiones eventmanager.once(filesdb.load_servers_conn) eventmanager.interval(app.config["FOOCONN_UPDATE_INTERVAL"], filesdb.load_servers_conn) # Refresco de configuración eventmanager.once(configdb.pull) eventmanager.interval(app.config["CONFIG_UPDATE_INTERVAL"], configdb.pull) # Categorias categories_cache.init_app(app.config["TORRENTS_CATEGORIES"], app.config["SUBCATEGORIES_MIN_OCCURS"]) categories_cache.update_subcategories(torrentsdb.get_subcategories()) def refresh_subcategories(): ''' Refresh subcategories. ''' categories_cache.update_subcategories(torrentsdb.get_subcategories()) configdb.register_action("refresh_subcategories", refresh_subcategories) eventmanager.interval(app.config["CATEGORIES_REFRESH_INTERVAL"], refresh_subcategories) @app.before_request def before_request(): g.cache_code = "" g.last_modified = None # No preprocesamos la peticiones a static if request.path.startswith("/static/"): g.must_cache = False return g.blacklisted_content = False init_g(current_app) if not g.domain: return multidomain.redirect_to_domain(g.domains_family[0], 301) # ignora peticiones sin blueprint if request.blueprint is None and request.path.endswith("/"): if "?" in request.url: root = request.url_root[:-1] path = request.path.rstrip("/") query = request.url if not isinstance(query, unicode): query = query.decode("utf-8") query = query[query.find(u"?"):] return redirect(root+path+query, 301) return redirect(request.url.rstrip("/"), 301) @app.after_request def after_request(response): if request.user_agent.browser == "msie": response.headers["X-UA-Compatible"] = "IE-edge" if g.must_cache: response.headers["X-Cache-Control"] = "max-age=%d"%g.must_cache if g.cache_code: response.headers["X-Cache-Code"] = g.cache_code if g.last_modified: response.headers["Last-Modified"] = utils.formatdate(time.mktime(max(g.last_modified, current_app.config["APP_LAST_MODIFIED"]).timetuple()), False, True) return response # Páginas de error errors = { 404: ("Page not found", "The requested address does not exists."), 410: ("File not available", "The file you are trying to access has been removed."), 500: ("An error happened", "We had some problems displaying this page. Maybe later we can show it to you."), 503: ("Service unavailable", "This page is temporarily unavailable. Please try again later.") } @allerrors(app, 400, 401, 403, 404, 405, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 500, 501, 502, 503) def all_errors(e): error = e.code if hasattr(e,"code") else 500 title, description = errors[error if error in errors else 500] init_g(current_app) if not g.domain: return multidomain.redirect_to_domain(g.domains_family[0], 301) g.title.append(title) return render_template('error.html', code=str(error), title=title, description=description), error print "App ready." return app
'bootstrap-selectpicker/bootstrap-select.js', 'typeahead.bundle.js', 'lodash.min.js', 'can.jquery.js', filters='rjsmin', output='build/tuxtrax-%(version)s.js') css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css') try: os.environ["DEBUG"] except KeyError: debug = False else: debug = True assets.debug = debug assets.versions = "hash" assets.register('js_base', js) assets.register('css_base', css)
app = flask.Flask(__name__) app.root_path = os.path.join(os.path.dirname(__file__), '..') # Load webassets bundles from a config file. BUNDLES_FILENAME = 'bundles.yaml' bundles = webassets.loaders.YAMLLoader(BUNDLES_FILENAME).load_bundles() # Merge files in debug mode, but don't apply filters. assets = Environment(app) # assets.cache = False # assets.updater = 'always' if DEBUG: assets.debug = 'merge' for name, bundle in bundles.iteritems(): # Register bundles, so we can include them in templates. assets.register(name, bundle) # Disable debug mode for JST filters. JSTFilter = webassets.filter.jst.JSTFilter if any([isinstance(f, JSTFilter) for f in bundle.filters]): bundle.debug = False # Import views. from views import * from quotes import *
from flask.ext.assets import Environment from flask.ext.assets import Bundle import psycopg2.extras import json import os # Define the WSGI application object app = Flask(__name__) # Configurations app.config.from_object('config') # Define the assets environment assets = Environment(app) assets.debug = app.config["DEBUG"] # Setup the secret key app.secret_key = app.config["SECRET_KEY"] # add CSRF protection (http://flask-wtf.readthedocs.org/en/latest/csrf.html) app.WTF_CSRF_TIME_LIMIT = 86400 csrf_protection = CsrfProtect(app) # import handlers import db import application.handlers.admin import application.handlers.public import application.handlers.welcome import application.handlers.dashboard
# load config app.config.update( DEBUG=os.environ.get('DEBUG', False), SECRET_KEY=os.environ.get('SECRET_KEY', ''), GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''), GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''), GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''), SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI', ''), ) db = SQLAlchemy(app) # setup assetbundle assets = Environment(app) assets.debug = True if app.debug == 'True' else False bundles = PythonLoader('newbeercellar.assetbundles').load_bundles() for name, bundle in bundles.iteritems(): assets.register(name, bundle) # setup login stuff login_manager = LoginManager() login_manager.init_app(app) googlelogin = GoogleLogin(app, login_manager) # add various views from newbeercellar import login from newbeercellar import views from newbeercellar import api app.db_session = db.session
js_bundle = Bundle('js/vendor/jquery.autocomplete.js', 'js/vendor/jquery.min.js', 'js/vendor/jquery-ui.min.js', 'js/custom/dom_ajax.js', 'js/vendor/foundation.min.js', 'js/vendor/jquery.sidr.min.js', 'js/vendor/sweet-alert.min.js', 'js/vendor/knockout-3.2.0.js', 'js/vendor/perfect-scrollbar.js', output='gen/all.js') css_bundle = Bundle('css/custom/style.css', 'css/vendor/font-awesome.css', 'css/vendor/foundation.css', 'css/vendor/sidr.dark.css', 'css/vendor/sweet-alert.css', 'css/vendor/perfect-scrollbar.css', output='gen/all.css') assets.register('js_all', js_bundle) assets.register('css_all', css_bundle) assets.debug = True app.config['ASSETS_DEBUG'] = True app.config.from_pyfile('configs/production.py') app.jinja_env.add_extension(HamlishTagExtension) app.jinja_env.hamlish_enable_div_shortcut = True db = SQLAlchemy(app) from oddsportal import views
from flask.ext.migrate import Migrate, MigrateCommand from flask.ext.script import Manager from flask.ext.sqlalchemy import SQLAlchemy from webassets.loaders import PythonLoader import project.asset_bundles app = Flask(__name__) app.config.from_object('project.config') db = SQLAlchemy(app) migrate = Migrate(app, db) import routes # from models import * assets = Environment(app) assets.versions = "hash:32" assets.auto_build = app.config["SERVER_ENV"] == 'development' assets.debug = False bundles = PythonLoader(project.asset_bundles).load_bundles() for name, bundle in bundles.iteritems(): assets.register(name, bundle) manager = Manager(app) manager.add_command('db', MigrateCommand) manager.add_command('assets', ManageAssets) if __name__ == '__main__': manager.run()
original_send = mail.send def send_email_with_subaccount(message): message.extra_headers = { 'X-MC-Subaccount': app.config['MANDRILL_TRANSACTIONAL_SUBACCOUNT'], 'X-MC-Template': app.config['MANDRILL_TRANSACTIONAL_TEMPLATE'], 'X-MC-GoogleAnalytics': 'pmg.org.za', } original_send(message) app.extensions.get('mail').send = send_email_with_subaccount # setup assets from flask.ext.assets import Environment, Bundle assets = Environment(app) assets.url_expire = False assets.debug = app.debug # source files assets.load_path = ['%s/static' % app.config.root_path] from webassets.filter.pyscss import PyScss assets.register('css', Bundle( 'font-awesome-4.2.0/css/font-awesome.min.css', 'chosen/chosen.min.css', Bundle( 'resources/css/style.scss', 'resources/css/committees.scss', 'resources/css/bill-progress.scss', filters=PyScss(load_paths=assets.load_path), output='stylesheets/styles.%(version)s.css'),
# static asset versioning and packaging assets = Environment(app) js = Bundle('jquery-1.11.0.js', 'bootstrap-3.1.1/dist/js/bootstrap.js', 'bootstrap-selectpicker/bootstrap-select.js', 'typeahead.bundle.js', 'lodash.min.js', 'can.jquery.js', 'modal.js', filters='rjsmin', output='build/tuxtrax-%(version)s.js') css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css') assets.debug = constants.DEBUG assets.versions = "hash" assets.register('js_base', js) assets.register('css_base', css) @app.route('/dev') def index(): tags = [tag.name for tag in Tag.query.all()] resp = make_response( render_template('index.html', user=g.user, showhidden=False, tags=tags)) resp.set_cookie('submission_ver', str(submission_dataset_ver())) return resp
def create_app(config=None, debug=False): ''' Inicializa la aplicación Flask. Carga los siguientes módulos: - index: página de inicio - page: páginas estáticas - user: gestión del usuario - files: búsqueda y obtención de ficheros - status: servicio de monitorización de la aplicación Y además, inicializa los siguientes servicios: - Configuración: carga valores por defecto y modifica con el @param config - Web Assets: compilación y compresión de recursos estáticos - i18n: detección de idioma en la URL y catálogos de mensajes - Cache y auth: Declarados en el módulo services - Files y users: Clases para acceso a datos ''' app = Flask(__name__) app.config.from_object(defaults) app.debug = debug # Configuración if config: app.config.from_object(config) # Gestión centralizada de errores logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO) if app.config["SENTRY_DSN"]: sentry.init_app(app) # Configuración dependiente de la versión del código revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision") if os.path.exists(revision_filename_path): f = open(revision_filename_path, "r") data = f.read() f.close() revisions = tuple( tuple(i.strip() for i in line.split("#")[0].split()) for line in data.strip().split("\n") if line.strip() and not line.strip().startswith("#")) revision_hash = md5(data).hexdigest() app.config.update( CACHE_KEY_PREFIX = "%s%s/" % ( app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "", revision_hash ), REVISION_HASH = revision_hash, REVISION = revisions ) else: app.config.update( REVISION_HASH = None, REVISION = () ) # Registra filtros de plantillas register_filters(app) # Registra valores/funciones para plantillas app.jinja_env.globals["u"] = u # Oauth init_oauth(app) # Blueprints app.register_blueprint(index) app.register_blueprint(page) app.register_blueprint(user) app.register_blueprint(files) app.register_blueprint(api) add_labs(app) # Labs (blueprints y alternativas en pruebas) # Web Assets if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen") assets = Environment(app) assets.debug = app.debug assets.url=app.static_url_path register_filter(JsSlimmer) register_filter(CssSlimmer) assets.register('css_all', 'css/jquery-ui.css', Bundle('css/main.css', filters='pyscss', output='gen/main.css', debug=False), filters='css_slimmer', output='gen/foofind.css') assets.register('css_ie', 'css/ie.css', filters='css_slimmer', output='gen/ie.css') assets.register('css_ie7', 'css/ie7.css', filters='css_slimmer', output='gen/ie7.css') assets.register('css_search', 'css/jquery-ui.css', Bundle('css/search.css', filters='pyscss', output='gen/s.css', debug=False), filters='css_slimmer', output='gen/search.css') assets.register('css_labs', 'css/jquery-ui.css', Bundle('css/labs.css', filters='pyscss', output='gen/l.css', debug=False), filters='css_slimmer', output='gen/labs.css') assets.register('css_admin', Bundle('css/admin.css', filters='css_slimmer', output='gen/admin.css')) assets.register('js_all', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/jquery.ui.selectmenu.js', 'js/files.js', filters='rjsmin', output='gen/foofind.js'), ) assets.register('js_ie', Bundle('js/html5shiv.js', 'js/jquery-extra-selectors.js', 'js/selectivizr.js', filters='rjsmin', output='gen/ie.js')) assets.register('js_labs', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/labs.js', filters='rjsmin', output='gen/labs.js')) assets.register('js_admin', Bundle('js/jquery.js', 'js/admin.js', filters='rjsmin', output='gen/admin.js')) # Detección de idioma @app.url_defaults def add_language_code(endpoint, values): ''' Añade el código de idioma a una URL que lo incluye. ''' if 'lang' in values or not g.lang: return if app.url_map.is_endpoint_expecting(endpoint, 'lang'): values['lang'] = g.lang pull_lang_code_languages = tuple( (code,localedata.load(code)["languages"][code].capitalize(), code in app.config["BETA_LANGS"]) for code in app.config["ALL_LANGS"]) @app.url_value_preprocessor def pull_lang_code(endpoint, values): ''' Carga el código de idioma en la variable global. ''' # obtiene el idioma de la URL g.url_lang = None if values is not None: g.url_lang = values.pop('lang', None) # si esta lista de idiomas permitidos if g.url_lang and g.url_lang in app.config["ALL_LANGS"]: g.lang = g.url_lang # si el usuario esta logueado y tiene establecido el idioma se asigna ese elif "user" in session and "lang" in session["user"]: g.lang = session["user"]["lang"] # si no esta logueado y ha elegido un idioma elif "lang" in session: g.lang = session["lang"] else: accept = request.accept_languages.values() # si viene, se coge el que mas convenga dependiendo del que tenga establecido en su navegador o el idioma por defecto locale = Locale.negotiate((option.replace("-","_") for option in accept), app.config["ALL_LANGS"]) if accept else None if locale: g.lang = locale.language else: g.lang = app.config["LANGS"][0] # valor por defecto si todo falla # se carga la lista de idiomas como se dice en cada idioma g.languages = pull_lang_code_languages g.beta_lang = g.lang in app.config["BETA_LANGS"] # Traducciones babel.init_app(app) @babel.localeselector def get_locale(): ''' Devuelve el código del idioma activo. ''' try: return g.lang except: return "en" # Cache cache.init_app(app) # Autenticación auth.setup_app(app) auth.login_view="user.login" auth.login_message="login_required" @auth.user_loader def load_user(userid): user = User(userid) if not user.has_data: data = usersdb.find_userid(userid) if data is None: return None user.set_data(data) return user # Mail mail.init_app(app) # Acceso a bases de datos filesdb.init_app(app) usersdb.init_app(app) pagesdb.init_app(app) feedbackdb.init_app(app) configdb.init_app(app) # Servicio de búsqueda @app.before_first_request def init_search(): searchd_servers = [(server["_id"], str(server["sp"]), int(server["spp"])) for server in filesdb.get_servers() if "sp" in server] stats = {server[0]:filesdb.get_server_stats(server[0]) for server in searchd_servers} searchd.init_app(app, searchd_servers, stats) init_search_stats() # Taming taming.init_app(app) # Refresco del contador de ficheros lastcount = [filesdb.count_files()] def countupdater(): lastcount[0] = long(filesdb.count_files()) eventmanager.interval(app.config["COUNT_UPDATE_INTERVAL"], countupdater) # Refresco de conexiones eventmanager.interval(app.config["FOOCONN_UPDATE_INTERVAL"], filesdb.load_servers_conn) # Refresco de configuración configdb.pull() eventmanager.interval(app.config["CONFIG_UPDATE_INTERVAL"], configdb.pull) # Profiler profiler.init_app(app, feedbackdb) # Carga la traducción alternativa fallback_lang = support.Translations.load(os.path.join(app.root_path, 'translations'), ["en"]) # Unittesting unit.init_app(app) # Inicializa init_labs(app) if app.config["UNITTEST_INTERVAL"]: eventmanager.timeout(20, unit.run_tests) eventmanager.interval(app.config["UNITTEST_INTERVAL"], unit.run_tests) # Inicio del eventManager eventmanager.start() @app.before_request def before_request(): # No preprocesamos la peticiones a static if request.path.startswith("/static"): return # si el idioma de la URL es inválido, devuelve página no encontrada if g.url_lang and not g.url_lang in app.config["ALL_LANGS"]: abort(404) # ignora peticiones sin blueprint if request.blueprint is None: if request.path.endswith("/"): if "?" in request.url: return redirect(request.url_root[:-1] + request.path + request.url[request.url.find("?"):], 301) return redirect(request.url[:-1], 301) return # si no es el idioma alternativo, lo añade por si no se encuentra el mensaje if g.lang!="en": get_translations().add_fallback(fallback_lang) # dominio de la web g.domain = request.url_root[8:-1] if request.url_root.startswith("https") else request.url_root[7:-1] # tÃtulo de la página por defecto g.title = g.domain # contador de archivos totales g.count_files = lastcount[0] # Páginas de error @app.errorhandler(400) @app.errorhandler(401) @app.errorhandler(403) @app.errorhandler(404) @app.errorhandler(405) @app.errorhandler(408) @app.errorhandler(409) @app.errorhandler(410) @app.errorhandler(411) @app.errorhandler(412) @app.errorhandler(413) @app.errorhandler(414) @app.errorhandler(415) @app.errorhandler(416) @app.errorhandler(417) @app.errorhandler(418) @app.errorhandler(500) @app.errorhandler(501) @app.errorhandler(502) @app.errorhandler(503) def all_errors(e): error = str(e.code) if hasattr(e,"code") else "500" message_msgid = "error_%s_message" % error message_msgstr = _(message_msgid) if message_msgstr == message_msgid: message_msgstr = _("error_500_message") description_msgid = "error_%s_description" % error description_msgstr = _(description_msgid) if description_msgstr == description_msgid and hasattr(e,"description"): message_msgstr = _("error_500_description") try: g.title = "%s %s" % (error, message_msgstr) g.count_files = lastcount[0] return render_template('error.html', zone="errorhandler", error=error, description=description_msgstr), int(error) except Exception as ex: #si el error ha llegado sin contexto se encarga el servidor de él logging.warn(ex) return make_response("",error) return app
'db1': app.config['SQLALCHEMY_DATABASE_URI'], } root_path = os.path.abspath("%s/.." % os.path.dirname(__file__)) tmp_path = "%s/tmp" % root_path os.environ['BOTO_ENDPOINTS'] = os.path.abspath( "%s/config/boto_endpoints.json" % root_path) ################### # ASSETS SETTINGS # ################### assets = Environment(app) loader = YAMLLoader("%s/assets/assets.yml" % root_path) bundles = loader.load_bundles() assets.register(bundles) assets.set_directory("%s/public" % root_path) assets.load_path.append('./assets/') assets.url = '/' assets.manifest = "json:%s/public/gen/webassets-manifest.json" % root_path development_mode = not environment.equals('production') assets.cache = development_mode assets.auto_build = development_mode assets.debug = development_mode # MD Feb-2015 Allow created files to be group writeable. This will fix some problems with files created in the /tmp # directory that are accessed both by Celery and duesty scripts. The /tmp directory should have set "chmod g+s tmp" os.umask(0o002)
def create_invenio_flask_app(**kwargs_config): """ Prepare WSGI Invenio application based on Flask. Invenio consists of a new Flask application with legacy support for the old WSGI legacy application and the old Python legacy scripts (URLs to *.py files). An incoming request is processed in the following manner: * The Flask application first routes request via its URL routing system (see LegacyAppMiddleware.__call__()). * One route in the Flask system, will match Python legacy scripts (see static_handler_with_legacy_publisher()). * If the Flask application aborts the request with a 404 error, the request is passed on to the WSGI legacy application (see page_not_found()). E.g. either the Flask application did not find a route, or a view aborted the request with a 404 error. """ def decorate_build(f): @wraps(f) def decorator(*args, **kwargs): scheme_url = { 'http': current_app.config['CFG_SITE_URL'], 'https': current_app.config['CFG_SITE_SECURE_URL'] } force_external = kwargs.get('force_external', True) url_scheme = getattr(f.im_self, 'url_scheme', 'http') kwargs['force_external'] = False url = f(*args, **kwargs) if force_external: url = scheme_url.get(url_scheme) + url return url return decorator class InvenioFlask(Flask): def create_url_adapter(self, request): url_adapter = super(InvenioFlask, self).create_url_adapter(request) if url_adapter is not None and hasattr(url_adapter, 'build'): url_adapter.build = decorate_build(url_adapter.build) return url_adapter ## The Flask application instance _app = InvenioFlask( __name__, ## Static files are usually handled directly by the webserver (e.g. Apache) ## However in case WSGI is required to handle static files too (such ## as when running simple server), then this flag can be ## turned on (it is done automatically by wsgi_handler_test). ## We assume anything under '/' which is static to be server directly ## by the webserver from CFG_WEBDIR. In order to generate independent ## url for static files use func:`url_for('static', filename='test')`. static_url_path='', static_folder=CFG_WEBDIR) ## Update application config from parameters. _app.config.update(kwargs_config) if 'SQLALCHEMY_DATABASE_URI' not in _app.config: from sqlalchemy.engine.url import URL # Global variables from invenio.dbquery import CFG_DATABASE_HOST, CFG_DATABASE_PORT,\ CFG_DATABASE_NAME, CFG_DATABASE_USER, CFG_DATABASE_PASS, \ CFG_DATABASE_TYPE _app.config['SQLALCHEMY_DATABASE_URI'] = URL( CFG_DATABASE_TYPE, username=CFG_DATABASE_USER, password=CFG_DATABASE_PASS, host=CFG_DATABASE_HOST, database=CFG_DATABASE_NAME, port=CFG_DATABASE_PORT, ) ## Let's initialize database. from invenio.sqlalchemyutils import db db.init_app(_app) ## First check that you have all rights to logs from invenio.bibtask import check_running_process_user check_running_process_user() from invenio.pluginutils import PluginContainer from invenio.session_flask import InvenioSessionInterface from invenio.webuser_flask import InvenioLoginManager, current_user, UserInfo from invenio.messages import wash_language, gettext_set_language, \ language_list_long, is_language_rtl from invenio.urlutils import create_url, get_canonical_and_alternates_urls from invenio.cache import cache from invenio.jinja2utils import CollectionExtension, \ LangExtension, hack_jinja2_utf8decoding, \ extend_application_template_filters from flask.ext.assets import Environment, Bundle from invenio.webinterface_handler_flask_utils import unicodifier, InvenioRequest from flaskext.gravatar import Gravatar from werkzeug.wrappers import BaseResponse from werkzeug.exceptions import HTTPException from invenio.flask_sslify import SSLify from invenio.webinterface_handler_wsgi import application as legacy_application from invenio.webinterface_handler_wsgi import is_mp_legacy_publisher_path, \ mp_legacy_publisher # See note on Jinja2 string decoding using ASCII codec instead of UTF8 in # function documentation hack_jinja2_utf8decoding() # Handle both url with and without trailing slashe by Flask. # @blueprint.route('/test') # @blueprint.route('/test/') -> not necessary when strict_slashes == False _app.url_map.strict_slashes = False # SECRET_KEY is needed by Flask Debug Toolbar SECRET_KEY = _app.config.get('SECRET_KEY') or CFG_SITE_SECRET_KEY if not SECRET_KEY or SECRET_KEY == '': fill_secret_key = """ Set variable CFG_SITE_SECRET_KEY with random string in invenio-local.conf. You can use following commands: $ %s $ %s """ % (CFG_BINDIR + os.sep + 'inveniocfg --create-secret-key', CFG_BINDIR + os.sep + 'inveniocfg --update-config-py') try: raise Exception(fill_secret_key) except Exception: register_exception(alert_admin=True, subject="Missing CFG_SITE_SECRET_KEY") raise Exception(fill_secret_key) _app.config["SECRET_KEY"] = SECRET_KEY # Enable Flask Debug Toolbar early to also catch HTTPS redirects if 'debug-toolbar' in getattr(config, 'CFG_DEVEL_TOOLS', []): _app.config["DEBUG_TB_ENABLED"] = True _app.config[ "DEBUG_TB_INTERCEPT_REDIRECTS"] = 'intercept-redirects' in getattr( config, 'CFG_DEVEL_TOOLS', []) from flask_debugtoolbar import DebugToolbarExtension class InvenioDebugToolbarExtension(DebugToolbarExtension): def _show_toolbar(self): user_info = UserInfo(session.get('user_id')) # Enable debug toolbar only for super admin. if not user_info.is_super_admin: return False return super(InvenioDebugToolbarExtension, self)._show_toolbar() InvenioDebugToolbarExtension(_app) # Set email backend for Flask-Email plugin from invenio.mailutils import initialize_email_backend initialize_email_backend(_app) if CFG_HAS_HTTPS_SUPPORT: # Makes request always run over HTTPS. _sslify = SSLify(_app) if not CFG_FULL_HTTPS: @_sslify.criteria_handler def criteria(): """Extends criteria when to stay on HTTP site.""" _force_https = False if request.blueprint in current_app.blueprints: _force_https = current_app.blueprints[request.blueprint].\ _force_https view_func = current_app.view_functions.get(request.endpoint) if view_func is not None and hasattr(view_func, '_force_https'): _force_https = view_func._force_https return not (_force_https or session.need_https()) class LegacyAppMiddleware(object): def __init__(self, app): self.app = app def __call__(self, environ, start_response): if remote_debugger: remote_debugger.start() with self.app.request_context(environ): g.start_response = start_response try: response = self.app.full_dispatch_request() except Exception as e: register_exception(req=request, alert_admin=True) response = self.app.handle_exception(e) return response(environ, start_response) _app.wsgi_app = LegacyAppMiddleware(_app) @_app.errorhandler(404) def page_not_found(error): try: response = legacy_application(request.environ, g.start_response) if not isinstance(response, BaseResponse): response = current_app.make_response(str(response)) return response except HTTPException: return render_template("404.html"), 404 @_app.errorhandler(401) def do_login_first(error=401): """Displays login page when user is not authorised.""" if request.is_xhr: return _("Authorization failure"), 401 flash(_("Authorization failure"), 'error') from invenio.webaccount_blueprint import login return login(referer=request.url), 401 @_app.endpoint('static') @_app.route(_app.static_url_path + '/<path:filename>', methods=['POST', 'PUT']) def static_handler_with_legacy_publisher(*args, **kwargs): """ Adds support for legacy publisher. NOTE: It changes order of url page lookup. First, the invenio_handler will be called and on 404 error the mp_legacy_publisher is called. """ possible_module, possible_handler = is_mp_legacy_publisher_path( request.environ['PATH_INFO']) if possible_module is not None: legacy_publisher = lambda req: \ mp_legacy_publisher(req, possible_module, possible_handler) return legacy_application(request.environ, g.start_response, handler=legacy_publisher) # Static file serving for devserver # --------------------------------- # Apache normally serve all static files, but if we are using the # devserver we need to serve static files here. Werkzeugs default # behaviour is to return a '405 Method not allowed' for POST requests # to static files. However, if we abort all POST requests with 405, the # legacy_application (see page_not_found()) will not be given a chance # to serve static files as it only get's invokved when we abort with a # 404. Hence, on POST requests, we first check if the static file exists, # and if it does we return we abort the request with a 405. if not CFG_FLASK_SERVE_STATIC_FILES: abort(404) else: static_file_response = _app.send_static_file(*args, **kwargs) if request.method in ['POST', 'PUT']: abort(405) else: return static_file_response if CFG_FLASK_CACHE_TYPE not in [None, 'null']: _app.jinja_options = dict(_app.jinja_options, auto_reload=False, cache_size=-1, bytecode_cache=MemcachedBytecodeCache( cache, prefix="jinja::", timeout=3600)) ## Let's customize the template loader to first look into ## /opt/invenio/etc-local/templates and then into ## /opt/invenio/etc/templates _app.jinja_loader = FileSystemLoader([ join(CFG_ETCDIR + '-local', 'templates'), join(CFG_ETCDIR, 'templates') ]) ## Let's attach our session handling (which is bridging with the native ## Invenio session handling _app.session_interface = InvenioSessionInterface() ## Set custom request class _app.request_class = InvenioRequest ## Let's load the whole invenio.config into Flask :-) ... _app.config.from_object(config) ## ... and map certain common parameters _app.config['SESSION_COOKIE_NAME'] = CFG_WEBSESSION_COOKIE_NAME _app.config['PERMANENT_SESSION_LIFETIME'] = \ CFG_WEBSESSION_EXPIRY_LIMIT_REMEMBER * CFG_WEBSESSION_ONE_DAY _app.config['USE_X_SENDFILE'] = CFG_BIBDOCFILE_USE_XSENDFILE _app.config['DEBUG'] = CFG_DEVEL_SITE > 0 _app.debug = CFG_DEVEL_SITE > 0 language_list_long = language_list_long() language_labordoc_list = [ ln for ln in language_list_long if ln[0] in ['en', 'es', 'fr'] ] _app.config['CFG_LANGUAGE_LIST_LONG'] = [ (lang, longname.decode('utf-8')) for (lang, longname) in language_list_long ] _app.config['CFG_LANGUAGE_LABORDOC_LIST'] = [ (lang, longname.decode('utf-8')) for (lang, longname) in language_labordoc_list ] ## Invenio is all using str objects. Let's change them to unicode _app.config.update(unicodifier(dict(_app.config))) ## Cache _app.config['CACHE_TYPE'] = CFG_FLASK_CACHE_TYPE # FIXME problem in Flask-Cache==0.11.1 cache.app = _app cache.init_app(_app) if CFG_FLASK_CACHE_TYPE == 'redis': def with_try_except_block(f): def decorator(*args, **kwargs): try: return f(*args, **kwargs) except Exception: register_exception(alert_admin=True) pass return decorator ## When the redis is down, we would like to keep the site running. cache.cache._client.execute_command = with_try_except_block( cache.cache._client.execute_command) # FIXME problem in Flask-Cache==0.11.1 cache.app = current_app _flask_log_handler = RotatingFileHandler( os.path.join(CFG_LOGDIR, 'flask.log')) _flask_log_handler.setFormatter( Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) _app.logger.addHandler(_flask_log_handler) # Let's create login manager. _login_manager = InvenioLoginManager(_app) _login_manager.login_view = 'webaccount.login' _login_manager.anonymous_user = UserInfo _login_manager.unauthorized_handler(do_login_first) # Let's create main menu. class Menu(object): def __init__(self, id='', title='', url='', order=None, children=None, display=lambda: True): self.id = id self.title = title self.url = url self.children = children or {} self.order = order or 100 self.display = display # Let's create assets environment. _assets = Environment(_app) _assets.debug = 'assets-debug' in getattr(config, 'CFG_DEVEL_TOOLS', []) _assets.directory = config.CFG_WEBDIR def _jinja2_new_bundle(tag, collection, name=None): if not _assets.debug: files = [ f for f in collection if os.path.isfile(os.path.join(_assets.directory, f)) ] if len(files) != len(collection): ## Turn on debuging to generate 404 request on missing files. _assets.debug = True current_app.logger.error( 'Missing files: ' + ','.join(set(collection) - set(files))) if len(collection): return Bundle(output="%s/%s-%s.%s" % (tag, 'invenio' if name is None else name, hash('|'.join(collection)), tag), *collection) _app.jinja_env.extend(new_bundle=_jinja2_new_bundle, default_bundle_name='90-invenio') _app.jinja_env.add_extension(CollectionExtension) _app.jinja_env.add_extension(LangExtension) _app.jinja_env.add_extension('jinja2.ext.do') # Let's extend application with custom template filters. extend_application_template_filters(_app) # Let's create Gravatar bridge. _gravatar = Gravatar(_app, size=100, rating='g', default='retro', force_default=False, force_lower=False) del _gravatar # Let's set the user language from invenio.webinterface_handler_flask_utils import guess_language _app.before_request(guess_language) # Let's extend application with more custom templete filters from invenio.jinja2utils import inject_utils _app.context_processor(inject_utils) @_login_manager.user_loader def _load_user(uid): """ Function should not raise an exception if uid is not valid or User was not found in database. """ return UserInfo(int(uid)) @_app.before_request def reset_template_context_processor(): g._template_context_processor = [] @_app.context_processor def _inject_template_context(): context = {} if not hasattr(g, '_template_context_processor'): reset_template_context_processor() for func in g._template_context_processor: context.update(func()) return context def _invenio_blueprint_plugin_builder(plugin): """ Handy function to bridge pluginutils with (Invenio) blueprints. """ if plugin.__name__ in CFG_FLASK_DISABLED_BLUEPRINTS or \ plugin.__name__.split('.')[-1] in CFG_FLASK_DISABLED_BLUEPRINTS: _app.logger.info( '%s is excluded by CFG_FLASK_DISABLED_BLUEPRINTS' % plugin_name) return from invenio.webinterface_handler_flask_utils import InvenioBlueprint if 'blueprint' in dir(plugin): candidate = getattr(plugin, 'blueprint') if isinstance(candidate, InvenioBlueprint): return candidate _app.logger.error('%s is not a valid blueprint plugin' % plugin_name) ## Let's load all the blueprints that are composing this Invenio instance _BLUEPRINTS = [ m for m in map( _invenio_blueprint_plugin_builder, autodiscover_modules(['invenio'], related_name_re='.+_blueprint.py', ignore_exceptions=True)) if m is not None ] _app.config['breadcrumbs_map'] = {} _app.config['menubuilder_map'] = {} ## Let's attach all the blueprints from invenio.webinterface_handler_flask_utils import _ for plugin in _BLUEPRINTS: _app.register_blueprint(plugin) if plugin.config: ## Let's include the configuration parameters of the config file. ## E.g. if the blueprint specify the config string ## 'invenio.webmessage_config' any uppercase variable defined in ## the module invenio.webmessage_config is loaded into the system. _app.config.from_object(plugin.config) if plugin.breadcrumbs: _app.config['breadcrumbs_map'][plugin.name] = plugin.breadcrumbs _app.config['breadcrumbs_map'].update(plugin.breadcrumbs_map) ## Let's build global menu. Each blueprint can plug its own menu items. if plugin.menubuilder: _app.config['menubuilder_map'].update( (m[0], Menu(*m)) for m in plugin.menubuilder) _app.config['menubuilder_map'].update(plugin.menubuilder_map) _app.config['menubuilder_map'].update({ 'main.admin': Menu('main.admin', _('Administration'), 'help.admin', 9998, [], lambda: current_user.is_admin if current_user else False), 'main.help': Menu('main.help', _('Help'), 'help', 9999) }) menu = { 'main': Menu('main', '', ''), 'personalize': Menu('personalize', '', '') } for key, item in _app.config['menubuilder_map'].iteritems(): start = menu if '.' not in key: if key in menu: menu[key] = item.children.update(menu[key].children) else: menu[key] = item continue keys = key.split('.') for k in keys[:-1]: try: start = start[k].children except: start[k] = Menu() start = start[k].children if keys[-1] in start: item.children.update(start[keys[-1]].children) start[keys[-1]] = item _app.config['menubuilder_map'] = menu # Flask-Admin from invenio.adminutils import register_admin register_admin(_app) try: ## When deploying Invenio, one can prepare a module called ## webinterface_handler_local.py to be deployed under ## CFG_PYLIBDIR/invenio directory, and containing a function called ## customize_app which should accept a Flask application. ## This function has a chance to modify the application as needed ## including changing the URL routing map. # pylint: disable=E0611 from invenio.webinterface_handler_local import customize_app # pylint: enable=E0611 customize_app(_app) except ImportError: ## No customization needed. pass return _app
def register_assets(app): assets = Environment(app) ALL_ASSETS = { 'core_js': Bundle('js/lib/jquery.js', 'js/lib/jquery.highlight.js', 'js/lib/jquery.mobile.js', 'js/lib/underscore.js', 'js/lib/backbone.js', 'js/lib/inifiniScroll.js', 'js/lib/moment.js', 'js/model/modelsForEvents.js', 'js/utils.js', 'js/view/PageView.js', 'js/view/ListView.js', 'js/add_favorites.js', 'js/routes.js', filters='rjsmin', output='core_%(version)s.js'), 'home_js': Bundle('js/home.js', filters='rjsmin', output='home_%(version)s.js'), 'goingon_js': Bundle('js/goingon.js', filters='rjsmin', output='goingon_%(version)s.js'), 'events_js': Bundle('js/events.js', filters='rjsmin', output='events_%(version)s.js'), 'favorites_js': Bundle('js/favorites.js', filters='rjsmin', output='favorites_%(version)ss.js'), 'history_js': Bundle('js/history.js', filters='rjsmin', output='history_%(version)s.js'), 'search_js': Bundle('js/search.js', filters='rjsmin', output='search_%(version)s.js'), 'statistics_js': Bundle('js/statistics.js', filters='rjsmin', output='statistics_%(version)s.js'), 'maps_js': Bundle('js/lib/gmaps.js', 'js/maps.js', filters='rjsmin', output='maps_%(version)s.js'), 'style_css': Bundle('style/jquery.mobile.css', 'style/icons.css', 'style/core.css', filters='cssmin', output='style/style_%(version)s.css') } assets.debug = app.config["DEBUG"] for bundle_id, bundle in ALL_ASSETS.iteritems(): assets.register(bundle_id, bundle) return assets
show_ga = not debug # load config app.config.update( DEBUG=debug, SHOW_GA=show_ga, SECRET_KEY=os.environ.get('SECRET_KEY', ''), # GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''), # GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''), # GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''), SQLALCHEMY_TRACK_MODIFICATIONS=True, SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgres://*****:*****@localhost/beer'), ) db = SQLAlchemy(app) # setup assetbundle assets = Environment(app) assets.debug = False # app.debug # (debug=True f***s up jsx) bundles = PythonLoader('web.assetbundles').load_bundles() for name, bundle in bundles.iteritems(): assets.register(name, bundle) # add various views from web import views from web import api app.db_session = db.session
from os.path import dirname, join, realpath, normpath from flask.ext.assets import Environment, Bundle from app import app environment = Environment(app) environment.versions = 'hash' manifest_path = normpath(realpath(join(dirname(__file__), '.static-manifest'))) environment.manifest = 'file:%s' % manifest_path environment.cache = False environment.debug = False css_main = Bundle('css/main.css', Bundle('less/main.less', filters='less'), filters='cssmin', output='css/main.%(version)s.css') js_head = Bundle( 'https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/modernizr.min.js', output='js/head.%(version)s.js') js_foot = Bundle( 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js', Bundle('js/scripts.js', filters='jsmin'), output='js/main.%(version)s.js')
from modules.models import ( page, proxy, result, statistics_memory, statistics_request, ) from modules.log import initialize initialize() application = Flask( __name__, static_folder=join(abspath(dirname(__file__)), 'resources'), ) application.config.from_pyfile('settings.py') assets = Environment(application) assets.cache = not application.config['DEBUG'] assets.debug = application.config['DEBUG'] assets.directory = application.static_folder assets.manifest = 'json:assets/versions.json' assets.url = application.static_url_path assets.url_expire = True assets.versions = 'hash' assets.register('javascripts', Bundle( 'vendor/jquery/dist/jquery.js', 'vendor/angular/angular.min.js', 'vendor/bootstrap/dist/js/bootstrap.js', 'vendor/highcharts/highcharts-all.js', 'javascripts/all.js', filters='rjsmin' if not application.config['DEBUG'] else None, output='assets/compressed.js', )) assets.register('stylesheets', Bundle(
from modules import models application = Flask(__name__, static_folder=join(abspath(dirname(__file__)), 'resources')) application.config.from_pyfile('settings/__init__.py') application.config.from_pyfile( 'settings/%(environment)s.py' % { 'environment': environ.get('environment', 'serve'), }, silent=True) assets = Environment(application) assets.cache = False assets.debug = application.config['DEBUG'] assets.directory = application.static_folder assets.manifest = 'json:assets/versions.json' assets.url = application.static_url_path assets.url_expire = True assets.versions = 'hash' assets.register( 'javascripts', Bundle( 'vendor/jquery/dist/jquery.js', 'vendor/bootstrap/dist/js/bootstrap.js', filters='rjsmin' if not application.config['DEBUG'] else None, output='assets/compressed.js', )) assets.register( 'stylesheets',
stream_handler.setLevel(logging.DEBUG) loggers = [app.logger, logging.getLogger('elasticsearch')] for logger in loggers: logger.setLevel(logging.WARNING) logger.addHandler(stream_handler) # When I'm ready to fix this with bower and stuff # look at http://adambard.com/blog/fresh-flask-setup/ assets = Environment(app) assets.directory = 'eheritage/static/' assets.url = '/static/' assets.debug = True js = Bundle('app.js', filters='jsmin', output='gen/packed.js') assets.register('js_all', js) # scss = Bundle('*.scss', filters='scss', output='gen/scss.css') # css = Bundle('style.css', # scss, # filters='pyscss,cssmin', output='gen/style.css') # assets.register('css_all', css) app.json_encoder = IterableAwareEncoder
# Create the Flask app. app = flask.Flask(__name__) app.root_path = os.path.join(os.path.dirname(__file__), '..') # Load webassets bundles from a config file. BUNDLES_FILENAME = 'bundles.yaml' bundles = webassets.loaders.YAMLLoader(BUNDLES_FILENAME).load_bundles() # Merge files in debug mode, but don't apply filters. assets = Environment(app) # assets.cache = False # assets.updater = 'always' if DEBUG: assets.debug = 'merge' for name, bundle in bundles.iteritems(): # Register bundles, so we can include them in templates. assets.register(name, bundle) # Disable debug mode for JST filters. JSTFilter = webassets.filter.jst.JSTFilter if any([isinstance(f, JSTFilter) for f in bundle.filters]): bundle.debug = False # Import views. from views import * from quotes import * if __name__ == '__main__':
from dexter.app import app # setup assets from flask.ext.assets import Environment, Bundle assets = Environment(app) assets.url_expire = False assets.debug = app.config['ENV'] == 'development' assets.directory = '%s/public' % app.config.root_path assets.load_path = ['assets'] assets.url = '/public' assets.register( 'css', Bundle('css/bootstrap-3.2.0.min.css', 'css/bootstrap-theme-3.2.0.min.css', 'css/font-awesome-4.3.0.min.css', 'css/datepicker3.css', 'css/bootstrap-datetimepicker.min.css', 'css/daterangepicker-bs3.css', 'css/select2-3.4.8.css', 'css/select2-bootstrap-3.4.8.css', 'css/dropzone-3.10.2.css', Bundle('css/*.scss', filters='pyscss', output='css/app.%(version)s.css'), output='css/all.%(version)s.css')) assets.register( 'mine-css', Bundle('css/bootstrap-3.2.0.min.css', 'css/bootstrap-theme-3.2.0.min.css',
import os from flask import Flask from flask import render_template from flask.ext.assets import Bundle from flask.ext.assets import Environment DEBUG = True app = Flask(__name__) app.debug = DEBUG assets = Environment(app) assets.debug = DEBUG assets.load_path = [ os.path.join(os.path.dirname(__file__), 'sass'), os.path.join(os.path.dirname(__file__), 'coffee'), os.path.join(os.path.dirname(__file__), 'bower_components'), ] assets.register( 'css', Bundle( '**/*.css', Bundle( '*.sass', filters="sass", output="sass.css" ), filters="cssmin",