class TestConfigNoAppBound:
"""The application is not bound to a specific app.
"""
def setup(self):
self.env = Environment()
def test_no_app_available(self):
"""Without an application bound, we can't do much."""
assert_raises(RuntimeError, getattr, self.env, 'url')
assert_raises(RuntimeError, setattr, self.env, 'debug', True)
assert_raises(RuntimeError, self.env.config.get, 'debug')
def test_global_defaults(self):
"""We may set defaults even without an application, however."""
self.env.config.setdefault('FOO', 'BAR')
with Flask(__name__).test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_app_specific_defaults(self):
"""The defaults for url and directory are read from the app object.
"""
app = Flask(__name__, static_path='/foo')
self.env.init_app(app)
with app.test_request_context():
assert self.env.url.endswith('static')
assert self.env.directory.endswith('foo')
# Can be overridden
self.env.directory = 'new_media_dir'
assert self.env.directory == 'new_media_dir'
def test_multiple_separate_apps(self):
"""Each app has it's own separate configuration.
"""
app1 = Flask(__name__)
self.env.init_app(app1)
# With no app yet available...
assert_raises(RuntimeError, getattr, self.env, 'url')
# ...set a default
self.env.config.setdefault('FOO', 'BAR')
# When an app is available, the default is used
with app1.test_request_context():
assert self.env.config['FOO'] == 'BAR'
# If the default is overridden for this application, it
# is still valid for other apps.
self.env.config['FOO'] = '42'
assert self.env.config['FOO'] == '42'
app2 = Flask(__name__)
with app2.test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_key_error(self):
"""KeyError is raised if a config value doesn't exist.
"""
with Flask(__name__).test_request_context():
assert_raises(KeyError, self.env.config.get, 'YADDAYADDA')
class TestConfigNoAppBound:
"""The application is not bound to a specific app.
"""
def setup(self):
self.env = Environment()
def test_no_app_available(self):
"""Without an application bound, we can't do much."""
assert_raises(RuntimeError, setattr, self.env, 'debug', True)
assert_raises(RuntimeError, self.env.config.get, 'debug')
def test_global_defaults(self):
"""We may set defaults even without an application, however."""
self.env.config.setdefault('FOO', 'BAR')
with Flask(__name__).test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_multiple_separate_apps(self):
"""Each app has it's own separate configuration.
"""
app1 = Flask(__name__)
self.env.init_app(app1)
# With no app yet available...
assert_raises(RuntimeError, getattr, self.env, 'url')
# ...set a default
self.env.config.setdefault('FOO', 'BAR')
# When an app is available, the default is used
with app1.test_request_context():
assert self.env.config['FOO'] == 'BAR'
# If the default is overridden for this application, it
# is still valid for other apps.
self.env.config['FOO'] = '42'
assert self.env.config['FOO'] == '42'
app2 = Flask(__name__)
with app2.test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_key_error(self):
"""KeyError is raised if a config value doesn't exist.
"""
with Flask(__name__).test_request_context():
assert_raises(KeyError, self.env.config.__getitem__, 'YADDAYADDA')
# The get() helper, on the other hand, simply returns None
assert self.env.config.get('YADDAYADDA') == None
class TestEnv:
def setup(self):
self.app = Flask(__name__)
self.env = Environment(self.app)
self.env.debug = True
self.app.config.update({
'ASSETS_DIRECTORY': '',
'ASSETS_URL': '/foo',
})
self.env.register('test', 'file1', 'file2')
def test_tag_available(self):
"""Jinja tag has been made available.
"""
t = self.app.jinja_env.from_string('{% assets "test" %}{{ASSET_URL}};{% endassets %}');
assert t.render() == '/foo/file1;/foo/file2;'
def setup(self):
self.app = Flask(__name__)
self.env = Environment(self.app)
self.env.debug = True
self.app.config.update({
'ASSETS_DIRECTORY': '',
'ASSETS_URL': '/foo',
})
self.env.register('test', 'file1', 'file2')
class TestUrlAndDirectoryWithInitApp(object):
"""[Regression] Make sure the automatic "directory" and "url"
values also work if the application is initialized via "init_app()".
"""
def setup(self):
self.app = Flask(__name__, static_path='/initapp_static')
self.env = Environment()
self.env.init_app(self.app)
def test(self):
"""Make sure the "url" and "directory" config values are
read from the Flask app.
"""
with self.app.test_request_context():
assert not 'url' in self.env.config
assert Bundle('foo').urls(self.env) == ['/initapp_static/foo']
assert not 'directory' in self.env.config
root = self.app.root_path
assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo']
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)
Website server for geekup.in
"""
from flask import Flask
from flaskext.assets import Environment, Bundle
from flaskext.mail import Mail
from coaster import configureapp
from os import environ
# First, make an app and config it
app = Flask(__name__, instance_relative_config=True)
configureapp(app, 'GEEKUP_ENV')
mail = Mail()
mail.init_app(app)
assets = Environment(app)
# Second, setup assets
js = Bundle('js/libs/jquery-1.6.4.js',
'js/libs/jquery.form.js',
'js/scripts.js',
filters='jsmin',
output='js/packed.js')
assets.register('js_all', js)
# Third, after config, import the models and views
import geekup.models
import geekup.views
from radiocrepe.web.auth import web_auth, configure_auth
from radiocrepe.web.queue import web_queue
from radiocrepe.web.hub import web_hub
from radiocrepe.web.live import web_live
from radiocrepe.web.user import web_user
app = Flask(__name__)
app.register_blueprint(web_auth)
app.register_blueprint(web_queue)
app.register_blueprint(web_hub)
app.register_blueprint(web_live)
app.register_blueprint(web_user)
assets = Environment(app)
lib_bundle = Bundle('js/jquery.js', 'js/jquery.qtip.js', 'js/underscore.js',
'js/backbone.js', 'js/handlebars.js',
filters='jsmin', output='js/gen/libs.packed.js')
rc_bundle = Bundle('js/queue.js', 'js/user_profile.js', 'js/notifications.js',
filters='jsmin', output='js/gen/radiocrepe.packed.js')
assets.register('js_libs', lib_bundle)
assets.register('js_app', rc_bundle)
@app.route('/song/<uid>/')
@with_hub_db
def song(db, storage, registry, uid):
import os
from redis import Redis
from flask import Flask, request, g
from flaskext.assets import Environment, Bundle
from flaskext.login import (LoginManager, current_user, login_required,
login_user, logout_user, AnonymousUser,
confirm_login, fresh_login_required)
app = Flask(__name__)
app.config.from_object('gcm.config.%s' % os.environ.get('GCM_CONFIG', 'production'))
assets = Environment(app)
assets.register('gcm', Bundle(
'lib/modernizer-2.0.6.js',
'lib/jquery-1.6.1.js',
'jquery-ui/jquery-ui-1.8.14.custom.js',
'lib/underscore.js',
'lib/backbone.js',
'js/auth.js',
'js/tumblr.js',
'js/instagram.js',
'js/twitter.js',
'js/gcm.js',
# filters='jsmin',
output='gen/gcm.js'))
assets.register('admin', Bundle(
from flask import Flask
from flaskext.assets import Environment, Bundle
from baseframe import baseframe, baseframe_js, baseframe_css
# the flask app
app = Flask(__name__, instance_relative_config=True)
app.register_blueprint(baseframe)
assets = Environment(app)
js = Bundle(baseframe_js, 'js/leaflet.js')
css = Bundle(Bundle(baseframe_css, 'css/pyconindia.css', 'css/monitor.css',
filters='cssmin', output='css/pyconindia-packed.css'),
'css/leaflet.css')
assets.register('js_all', js)
assets.register('css_all', css)
# Import models and views, and register routes here
from flask import render_template, redirect, url_for
@app.route('/')
def index():
return render_template('index.html', active=1)
# delete the rule for favicon
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)
# 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 = ()
)
# Gestión centralizada de errores
sentry.init_app(app)
logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)
setup_logging(SentryHandler(sentry.client))
# Registra filtros de plantillas
register_filters(app)
# Oauth
init_oauth(app)
# Blueprints
app.register_blueprint(index)
app.register_blueprint(page)
app.register_blueprint(user)
app.register_blueprint(files)
app.register_blueprint(control)
app.register_blueprint(api)
# Web Assets
if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen")
assets = Environment(app)
assets.debug = app.debug
register_filter(JsSlimmer)
register_filter(CssSlimmer)
assets.register('js_all', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/files.js', filters='rjsmin', output='gen/packed.js'))
assets.register('css_all', Bundle('css/main.css', filters=('css_slimmer',), output='gen/packed.css'))
assets.register('css_ie7', Bundle('css/ie7.css', filters=('css_slimmer',), output='gen/ie7.css'))
assets.register('js_admin', Bundle('js/jquery.js', 'js/admin.js', filters='rjsmin', output='gen/admin_packed.js'))
assets.register('css_admin', Bundle('css/admin.css', filters=('css_slimmer',), output='gen/admin_packed.css'))
# 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"]
# sino se coge el que mas convenga dependiendo del que tenga establecido en su navegador o el idioma por defecto
elif request.accept_languages.values()!=[]:
g.lang = request.accept_languages.best_match(app.config["ALL_LANGS"],app.config["LANGS"][0])
# y sino se pone el idioma por defecto
else:
g.lang = app.config["LANGS"][0]
# 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)
# Actualizador 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)
profiler.init_app(app, feedbackdb)
# Carga la traducción alternativa
fallback_lang = support.Translations.load(os.path.join(app.root_path, 'translations'), ["en"])
@app.before_request
def before_request():
# 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)
# quita todas las / finales de una URL
if request.path != '/' and request.path.endswith('/'):
return redirect(u(request.url).replace(u(request.path), u(request.path)[:-1]),301)
# ignora peticiones sin blueprint
if request.blueprint is None:
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[7:-1] if "https" not in request.url_root else request.url_root[8:-1]
# título de la página por defecto
g.title = g.domain
# contador de archivos totales
g.count_files = lastcount[0]
'''
# TODO: Buscar una forma mejor de hacer esto
@app.after_request
def after_request(response):
if response.mimetype == "text/html":
response.data = html_slimmer(response.data)
return response
'''
# 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)
message=_("error_"+error+"_message")
description=_("error_"+error+"_description")
g.title=error+" "+message if message!="error_"+error+"_message" else e.message.replace("<p>","").replace("</p>","")
g.count_files = lastcount[0]
return render_template('error.html',
zone="errorhandler",
error=error,
description=description if description!="error_"+error+"_description" else e.description.replace("<p>","").replace("</p>","")
), e.code
return app
from flask import Flask, session, g, render_template
from flaskext.assets import Environment, Bundle
from jousse_blog.views import general
import websiteconfig as config
import os, sys
app = Flask(__name__)
app.debug = config.DEBUG
app.secret_key = config.SECRET_KEY
assets = Environment(app)
assets.directory = os.path.join(os.path.abspath(os.path.dirname(__file__)),'.','static')
js = Bundle('javascripts/jquery.js', 'javascripts/cufon-yui.js',
'javascripts/cufon.fonts.js',
'javascripts/scripts.js',
filters='jsmin', output='javascripts/packed.js')
css = Bundle('stylesheets/build.css',
filters='cssmin', output='stylesheets/packed.css')
assets.register('js_all', js)
assets.register('css_all', css)
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
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 setup(self):
self.app = Flask(__name__, static_path='/initapp_static')
self.env = Environment()
self.env.init_app(self.app)
# encoding=utf-8
import os
import time
from redis import Redis
from flask import Flask, request, g
from flaskext.assets import Environment, Bundle
app = Flask(__name__)
app.config.from_object('gummiognina.config.%s' % os.environ.get('GUMMIOGNINA_CONFIG', 'production'))
assets = Environment(app)
assets.register('js', Bundle(
'lib/modernizer-2.0.6.js',
'lib/jquery-1.6.1.js',
'lib/jquery.appear.js',
'lib/underscore.js',
'lib/backbone.js',
'js/gummiognina.js',
# filters='jsmin',
output='gen/gummiognina.js'))
#if not app.debug:
# from .loggers import configure_logging
# configure_logging(app)
import os
from flask import Flask, render_template
from flaskext.assets import Environment, Bundle
import feedparser
app = Flask(__name__)
assets = Environment(app)
app.debug = True
app.config['LESS_PATH'] = '/usr/local/bin/lessc'
js = Bundle('scripts/jquery-1.7.1.min.js',
filters='jsmin',
output='scripts/gen.js')
assets.register('all-js', js)
@app.route('/')
def hello():
return render_template('index.html')
if __name__ == '__main__':
port = int(os.environ.get("PORT", "5000"))
app.run(host='0.0.0.0', port=port)
def setup(self):
self.env = Environment()
#!/usr/bin/env python
import sys
from os import path
sys.path.insert(0, path.join(path.dirname(__file__), '../src'))
from flask import Flask, render_template, url_for
from flaskext.assets import Environment, Bundle
app = Flask(__name__)
assets = Environment(app)
assets.register('main',
'style1.css', 'style2.css',
output='cached.css', filters='cssmin')
@app.route('/')
def index():
return render_template('index.html')
app.run(debug=True)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Website server for rootconf.
"""
from flask import Flask
from flaskext.assets import Environment, Bundle
from baseframe import baseframe, baseframe_js, baseframe_css
from os import environ
from coaster import configureapp
# First, make an app and config it
app = Flask(__name__, instance_relative_config=True)
configureapp(app, "ROOTCONF_ENV")
app.register_blueprint(baseframe)
assets = Environment(app)
js = Bundle(baseframe_js, "js/leaflet.js")
css = Bundle(baseframe_css, "css/rootconf.css", "css/monitor.css")
assets.register("js_all", js)
assets.register("css_all", css)
import rootconf.views
if environ.get("ROOTCONF_ENV") == "production":
import rootconf.loghandler
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''.strip()))
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
app.logger.info("Emailing on error is ENABLED")
else:
app.logger.info("Emailing on error is DISABLED")
# Assets
from flaskext.assets import Environment
assets = Environment(app)
# Ensure output directory exists
assets_output_dir = os.path.join(FLASK_APP_DIR, 'static', 'gen')
if not os.path.exists(assets_output_dir):
os.mkdir(assets_output_dir)
# Email
from flaskext.mail import Mail
mail = Mail(app)
# Memcache
from werkzeug.contrib.cache import MemcachedCache
app.cache = MemcachedCache(app.config['MEMCACHED_SERVERS'])
def cache_fetch(key, value_function, timeout=None):
'''Mimicking Rails.cache.fetch'''
global app
