def create_app(config=None, blueprints=None): """ Create and initialise the application. """ app = Flask(__name__) app.config.from_pyfile("%s/config/default.py" % app.root_path) app.url_map.converters["regex"] = RegexConverter app.add_template_filter(slugify) if blueprints is None: blueprints = DEFAULT_BLUEPRINTS configure_blueprints(app, blueprints) return app
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].ASSET_PATH) init_app( application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, login_manager=login_manager ) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint url_prefix = application.config['URL_PREFIX'] application.register_blueprint(status_blueprint, url_prefix=url_prefix) application.register_blueprint(main_blueprint, url_prefix=url_prefix) login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() init_frontend_app(application, data_api_client, login_manager) application.add_template_filter(parse_document_upload_time) @application.context_processor def extra_template_variables(): return { 'generic_contact_email': application.config['GENERIC_CONTACT_EMAIL'], } return application
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH) init_app( application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, feature_flags=feature_flags, login_manager=login_manager ) # Should be incorporated into digitalmarketplace-utils as well csrf.init_app(application) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint application.register_blueprint(status_blueprint, url_prefix='/admin') application.register_blueprint(main_blueprint, url_prefix='/admin') login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() @application.before_request def remove_trailing_slash(): if request.path != '/' and request.path.endswith('/'): return redirect(request.path[:-1], code=301) application.add_template_filter(parse_document_upload_time) return application
def app_factory(extra_config=None): """Builds the flask application""" app = Flask(__name__) # App defaults app.config.update(dict( DEBUG=True, CLEANCSS_EXTRA_ARGS=['--skip-rebase'], FLATPAGES_ROOT='blog', FLATPAGES_EXTENSION='.md', FLATPAGES_MARKDOWN_EXTENSIONS=['codehilite', JavierExtensions()], FLATPAGES_AUTO_RELOAD=True)) # Extra config if extra_config: app.config.update(extra_config) # Blueprints app.register_blueprint(BLOG, url_prefix='/blog') app.register_blueprint(INDIVIDUAL) app.register_blueprint(FEEDS) # Other configuration app.context_processor(template_settings) app.add_template_filter(l10n_date) register_assets(app) register_pages(app) return app
def create_app(app_mode='DEBUG'): """ Create application, register blueprints, etc """ if app_mode == '': app_mode = os.environ.get('APP_MODE', 'DEBUG') # create an application app = Flask(__name__) app.config['SECRET_KEY'] = b'\x88~\x17h\xdc;,\x9f\x1do\x98\xcd\xaf|\x1c\x19\xec\xcf\xb1\x12\xd4\x8b\xcdQ' # set logging configure_logging(app_mode, app) if app_mode == 'DEBUG': # debugging in VSCode works only if following 2 lines are commented out #app.debug = True #app.config['DEBUG'] = True app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 # register blueprints app.register_blueprint(public_ui) app.register_blueprint(member_ui) app.register_blueprint(customer_ui) # register jinja exts app.add_template_filter(f=points, name='points') # configure uploads app.config['UPLOAD_FOLDER'] = os.path.join(BASE_DIR, 'uploads') # app started logging.info('Application started in %s mode', app_mode) return app
def create_app(): app = Flask(__name__, static_folder="../static", static_url_path="/static") from api import api as api_blueprint app.register_blueprint(api_blueprint, url_prefix='/api') app.register_blueprint(web, url_prefix='') app.debug = True app.add_template_filter(human_date) return app
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH) init_app( application, configs[config_name], data_api_client=data_api_client, feature_flags=feature_flags, login_manager=login_manager, ) from .main import main as main_blueprint from .status import status as status_blueprint application.register_blueprint(status_blueprint, url_prefix='/suppliers') application.register_blueprint(main_blueprint, url_prefix='/suppliers') login_manager.login_message_category = "must_login" main_blueprint.config = application.config.copy() csrf.init_app(application) @csrf.error_handler def csrf_handler(reason): if 'user_id' not in session: application.logger.info( u'csrf.session_expired: Redirecting user to log in page' ) return application.login_manager.unauthorized() application.logger.info( u'csrf.invalid_token: Aborting request, user_id: {user_id}', extra={'user_id': session['user_id']}) abort(400, reason) @application.before_request def remove_trailing_slash(): if request.path.endswith('/'): return redirect(request.path[:-1], code=301) @application.before_request def refresh_session(): session.permanent = True session.modified = True application.add_template_filter(question_references) application.add_template_filter(parse_document_upload_time) return application
def create_app(config): app = Flask(__name__) app.config.from_object(configs.get(config)) register_extensions(app) # 用于创建测试数据 Migrate(app, db) register_blueprints(app) # 注册自定义过滤器 app.add_template_filter(get_jobdelta) return app
def create_app(config_name): asset_path = os.environ.get('ASSET_PATH', configs[config_name].ASSET_PATH) application = Flask(__name__, static_folder='static/', static_url_path=asset_path) init_app( application, configs[config_name], data_api_client=data_api_client, login_manager=login_manager, ) from .main import main as main_blueprint from .status import status as status_blueprint url_prefix = application.config['URL_PREFIX'] application.register_blueprint(status_blueprint, url_prefix=url_prefix) application.register_blueprint(main_blueprint, url_prefix=url_prefix) login_manager.login_message_category = "must_login" main_blueprint.config = application.config.copy() application.add_template_filter(question_references) application.add_template_filter(parse_document_upload_time) init_frontend_app(application, data_api_client, login_manager) @application.context_processor def extra_template_variables(): return { 'marketplace_home': urlparse.urljoin('/', application.config['BASE_PREFIX']), 'generic_contact_email': application.config['GENERIC_CONTACT_EMAIL'], } def component_filter(x, thing, *args, **kwargs): from jinja2 import Markup # , escape from flask import current_app COMPONENTS = 'components' EXTENSION = '.html' t = current_app.jinja_env.get_template( COMPONENTS + '/' + thing + EXTENSION) return Markup(t.render(x=x, **kwargs)) application.jinja_env.filters['as'] = component_filter application.jinja_env.globals.update(render_component=render_component) return application
def create_app(method): my_app = Flask('test_filter') filters = make_filters(FILTERS, method) for name, function in filters.items(): my_app.add_template_filter(function, name) @my_app.route('/my_hex/<int:number>', endpoint='my_hex') @my_app.route('/my_bin/<int:number>', endpoint='my_bin') @my_app.route('/my_oct/<int:number>', endpoint='my_oct') def use_filter(number): filter_ = request.url_rule.endpoint template = '{{ filter_ }} {{ number|%s }}' % filter_ pytest.set_trace() return render_template_string(template, **locals()) return my_app
def create_app(config_name): application = Flask( __name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH ) application.config['NOTIFY_ENVIRONMENT'] = config_name application.config.from_object(configs[config_name]) init_app(application) csrf.init_app(application) @csrf.error_handler def csrf_handler(reason): if 'user_id' not in session: application.logger.info( u'csrf.session_expired: Redirecting user to log in page' ) return application.login_manager.unauthorized() application.logger.info( u'csrf.invalid_token: Aborting request, user_id: {user_id}', extra={'user_id': session['user_id']}) abort(400, reason) login_manager.init_app(application) admin_api_client.init_app(application) proxy_fix.init_app(application) from .main import main as main_blueprint application.permanent_session_lifetime = timedelta(hours=1) application.register_blueprint(main_blueprint, url_prefix='/admin') login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() @application.before_request def remove_trailing_slash(): if request.path != '/' and request.path.endswith('/'): return redirect(request.path[:-1], code=301) application.add_template_filter(datetimeformat) return application
class App(object): def __init__(self): self._indices = {} templateFolder = os.path.join( os.path.dirname(os.path.abspath(__file__)), 'templates') staticFolder = os.path.join( os.path.dirname(os.path.abspath(__file__)), 'static') self._app = Flask('pyaci Query App', static_folder=staticFolder, template_folder=templateFolder) self._app.add_template_test(isDn, 'Dn') self._app.add_template_filter(getParentDn, 'parentDn') def addIndex(self, index): # TODO: Handle duplicate index. self._indices[index.name] = index self._app.add_url_rule( '/{}/dn/<path:dn>'.format(index.name), view_func=DnView.as_view('dn_view_{}'.format(index.name), index, self), methods=['GET'] ) self._app.add_url_rule( '/{}/class/<className>'.format(index.name), view_func=ClassView.as_view('class_view_{}'.format(index.name), index, self), methods=['GET'] ) if index.name == 'audit': self._app.add_url_rule( '/{}/affected/<path:dn>'.format(index.name), view_func=AuditView.as_view( 'affected_view_{}'.format(index.name), index, self), methods=['GET'] ) def indices(self): return self._indices def run(self, debug=False): self._app.debug = debug self._app.run(host='0.0.0.0')
def create_app_by_config(config=None, profile=False): app = Flask(__name__) # 初始化环境配置 app.config.from_object("config.default") if config: try: app.config.from_object(config) except: raise ValueError("[%s] config is not exists" % config) from qsapp.views.qsmain_view import qsmain from qsapp.views.wechat_view import wechat app.register_blueprint(qsmain) app.register_blueprint(wechat) # 增加过滤器 for value in template_filters.__dict__.values(): if callable(value): app.add_template_filter(value) return app
def _crea_app(self, config=None): app = Flask(__name__, template_folder="plantillas" ) app.psdash = self app.config.from_envvar('PSDASH_CONFIG', silent=True) if config and isinstance(config, dict): app.config.update(config) self._cargar_direccciones_remotas_permitidas(app) # If the secret key is not read from the config just set it to something. if not app.secret_key: app.secret_key = 'whatisthissourcery' app.add_template_filter(fromtimestamp) from controlador_web import webapp prefix = app.config.get('PSDASH_URL_PREFIX') if prefix: prefix = '/' + prefix.strip('/') webapp.url_prefix = prefix app.register_blueprint(webapp) return app
def _create_app(self, config=None): app = Flask(__name__) app.psdash = self app.config.from_envvar('PSDASH_CONFIG', silent=True) if config and isinstance(config, dict): app.config.update(config) self._load_allowed_remote_addresses(app) # If the secret key is not read from the config just set it to something. if not app.secret_key: app.secret_key = 'whatisthissourcery' app.add_template_filter(fromtimestamp) from psdash.web import webapp prefix = app.config.get('PSDASH_URL_PREFIX') if prefix: prefix = '/' + prefix.strip('/') webapp.url_prefix = prefix app.register_blueprint(webapp) return app
# Blueprints from .tf2.views import tf2 as tf2_blueprint from .users.views import users as users_blueprint from .mods.views import mods as mods_blueprint # Admin from .users.models import User from .mods.models import ModAuthor from .admin.views import admin admin.init_app(app) # TF2 Schema from .tf2.models import TF2Item, TF2EquipRegion, TF2BodyGroup app.register_blueprint(users_blueprint) app.register_blueprint(mods_blueprint) app.register_blueprint(tf2_blueprint) # Assets from assets import assets # Jinja2 Filters from filters import format_thousands, pluralize, datetime_to_datestring app.add_template_filter(format_thousands) app.add_template_filter(pluralize) app.add_template_filter(datetime_to_datestring) # Load current app version into globals from functions import current_version app.config['VERSION'] = current_version()
def make_cache_key(*args, **kwargs): path = request.path args = str(hash(frozenset(request.args.items()))) return (path + args).encode('utf-8') def filelist_filter(info_hash): try: return json.loads(Search_Filelist.query.filter_by(info_hash=info_hash).first().file_list) except: return [{ 'path':Search_Hash.query.filter_by(info_hash=info_hash).first().name, 'length':Search_Hash.query.filter_by(info_hash=info_hash).first().length }] app.add_template_filter(filelist_filter,'filelist') def todate_filter(s): return datetime.datetime.fromtimestamp(int(s)).strftime('%Y-%m-%d') app.add_template_filter(todate_filter,'todate') def tothunder_filter(magnet): return base64.b64encode('AA'+magnet+'ZZ') app.add_template_filter(tothunder_filter,'tothunder') def sphinx_conn(): conn = pymysql.connect(host=DB_HOST, port=DB_PORT_SPHINX, user=DB_USER, password=DB_PASS, db=DB_NAME_SPHINX, charset=DB_CHARSET, cursorclass=pymysql.cursors.DictCursor) curr = conn.cursor()
#!/usr/bin/env python import json import argparse from flask import Flask, make_response, render_template import app_config from render_utils import make_context, smarty_filter, urlencode_filter import static from gentrification import make_ca_context app = Flask(__name__) app.add_template_filter(smarty_filter, name='smarty') app.add_template_filter(urlencode_filter, name='urlencode') # Filters def format_currency(value): value = int(value) return "${:,}".format(value) def format_comma(value): value = int(value) return "{:,}".format(value) app.jinja_env.filters['format_currency'] = format_currency app.jinja_env.filters['format_comma'] = format_comma # Example application views
# -*- coding: utf-8 -*- __author__ = 'venking' from flask import Flask from web import loginctrl from module.util import fromtimestamp app = Flask(__name__) app.register_blueprint(loginctrl,url_prefix='/login') app.add_template_filter(fromtimestamp) app.secret_key = 'zoupan19940907' # @app.route('/') # def index(): # return 'Index Page!' # # # @app.route('/hello') # def hello_world(): # return 'Hello World!' # # # @app.route('/user/<username>') # def show_user_profile(username): # # show the user profile for that user # flash('你好,%s'%(username)) # return 'User %s' % username # # # @app.route('/post/<int:post_id>')
app.add_url_rule('/atlases', 'get atlases', get_atlases) app.add_url_rule('/atlas', 'post atlas', post_atlas, methods=['POST']) app.add_url_rule('/atlas-hints/<id>', 'post atlas hints', post_atlas_hints, methods=['GET', 'POST']) app.add_url_rule('/atlas/<id>', 'get atlas', get_atlas) app.add_url_rule('/map/<id>', 'get map', get_map) app.add_url_rule('/maps', 'get maps', get_maps) app.add_url_rule('/atlases-list', 'get atlases list', get_atlases_list) app.add_url_rule('/maps-list', 'get maps list', get_maps_list) app.add_url_rule('/check-map-status/<id>', 'get map status', check_map_status, methods=['GET']) app.add_url_rule('/tile/<path:path>', 'tile', tile) app.add_url_rule('/tile/map/<id>/<path:path>', 'tilemap', tile_by_id) app.add_url_rule('/tile/atlas/<id>/<path:path>', 'tileatlas', tile_by_id) app.add_url_rule('/map-sandwich', 'map-sandwich', map_sandwich) app.add_url_rule('/map-sandwich/map/<id>', 'map-sandwich-map', map_sandwich) app.add_url_rule('/map-sandwich/atlas/<id>', 'map-sandwich-atlas', map_sandwich) app.add_url_rule('/faq', 'faq', faq) app.add_url_rule('/faq-public', 'faq-public', faq_public) app.add_url_rule('/docs', 'docs', docs) app.error_handler_spec[None][404] = page_not_found app.add_template_filter(sumiter) app.add_template_filter(datetimeformat) if __name__ == '__main__': app.debug = True app.run(host='0.0.0.0', port=8080)
import os from boto.s3.key import Key from boto.s3.connection import S3Connection from flask import Flask, request, render_template from pbkdf2 import crypt import forms import filters import models import settings app = Flask(__name__) app.config.update(SECRET_KEY=settings.FLASK_SECRET_KEY) app.add_template_filter(filters.nl2br) @app.route('/', methods=['GET', 'POST']) def create_page(): """ Main view to present the user with a form to create a signup page. """ form = forms.PageForm(request.form) error = None if request.method == 'POST' and form.validate(): # if password incorrect or not entered, show an error if not valid_password(form.password.data): error = "Must enter correct password." return render_template('main.html', form=form, error=error)
def create_app(config=None): """ config should be a python file """ from pathlib import Path from flask import (Flask, current_app, g, session, url_for, render_template) from flask_sqlalchemy import SQLAlchemy from flask_security import (Security, SQLAlchemyUserDatastore) from flask_wtf.csrf import CsrfProtect from flask_assets import (Environment, Bundle) from .app_setup import (init_db, setup_dirs) from .core import (db, load_blueprints, setup_logger) from .lib.template_filters import ( fmt_datetime, none_as_str, next_page_url, prev_page_url, get_page_url, get_images) from .models.user import (User, Role, user_datastore) from .Admin import (index, series, images, texts, contact) from .Public import (index, contact, texts) from .Security import user app = Flask(__name__.split('.')[0], instance_relative_config=True) app.config.from_object('config') app.config.from_pyfile('config.py') if config is not None: app.config.from_pyfile(config) setup_logger(app) app.logger.info('Started with config from: {}'.format(config)) else: setup_logger(app) app.logger.info('Started App') # Flask.sqlalchemy db.init_app(app) load_blueprints(app) # make sure db tables and required directories exist before_first_request_funcs = [setup_dirs(app), init_db(app)] #Security csrf = CsrfProtect() csrf.init_app(app) security = Security() security.init_app(app, user_datastore, register_blueprint=False) # Assets assets = Environment(app=app) assets.from_yaml('assets.yml') # template filters app.add_template_filter(fmt_datetime) app.add_template_filter(none_as_str) app.add_template_filter(next_page_url) app.add_template_filter(prev_page_url) app.add_template_filter(get_page_url) app.add_template_filter(get_images) return app
def create_app(): from config import configs application = Flask(__name__) application.config.from_object(configs[os.environ["NOTIFY_ENVIRONMENT"]]) init_app(application) statsd_client.init_app(application) logging.init_app(application, statsd_client) init_csrf(application) request_id.init_app(application) service_api_client.init_app(application) user_api_client.init_app(application) api_key_api_client.init_app(application) job_api_client.init_app(application) notification_api_client.init_app(application) status_api_client.init_app(application) invite_api_client.init_app(application) template_statistics_client.init_app(application) events_api_client.init_app(application) provider_client.init_app(application) organisations_client.init_app(application) login_manager.init_app(application) login_manager.login_view = "main.sign_in" login_manager.login_message_category = "default" login_manager.session_protection = None from app.main import main as main_blueprint application.register_blueprint(main_blueprint) from .status import status as status_blueprint application.register_blueprint(status_blueprint) proxy_fix.init_app(application) application.session_interface = ItsdangerousSessionInterface() application.add_template_filter(format_datetime) application.add_template_filter(format_datetime_24h) application.add_template_filter(format_datetime_normal) application.add_template_filter(format_datetime_short) application.add_template_filter(format_time) application.add_template_filter(syntax_highlight_json) application.add_template_filter(valid_phone_number) application.add_template_filter(linkable_name) application.add_template_filter(format_date) application.add_template_filter(format_date_normal) application.add_template_filter(format_date_short) application.add_template_filter(format_datetime_relative) application.add_template_filter(format_delta) application.add_template_filter(format_notification_status) application.add_template_filter(format_notification_status_as_time) application.add_template_filter(format_notification_status_as_field_status) application.add_template_filter(format_notification_status_as_url) application.after_request(useful_headers_after_request) application.after_request(save_service_after_request) application.before_request(load_service_before_request) @application.context_processor def _attach_current_service(): return {"current_service": current_service} register_errorhandlers(application) setup_event_handlers() return application
@app.route('/index') def index(): """docstring for index""" data = { 'name': 'ai', 'age': 18, 'my_dic': {'city': 'Beijing'}, 'my_list': [1, 2, 3, 4, 5], 'my_int': 0, } # return render_template('index.html', name='ai', age=18) # data前面的**表示按键-值对解析字典 return render_template('index.html', **data) # 自定义过滤器方法一 def list_split2(li): """自定义过滤器方法一 list_split2""" return li[::2] # 注册过滤器 app.add_template_filter(list_split2, 'lis2') # 自定义过滤器方法二 @app.template_filter('lis3') def list_split3(li): """自定义过滤器方法一 list_split2""" return li[::3]
def create_app(config={}): app = Flask(__name__, instance_relative_config=True) app.config.update(DEFAULT_CONFIG) app.config.from_pyfile('settings.py', silent=True) app.config.update(config) babel = Babel(app) @babel.localeselector def get_locale(): return getattr(g, 'language', 'en') assets_env.init_app(app) db.init_app(app) app.register_blueprint(admin) app.register_blueprint(auth) app.register_blueprint(meetings) app.add_template_filter(activity_map) app.add_template_filter(countries) app.add_template_filter(country_in) app.add_template_filter(region_in) app.add_template_filter(crop) app.add_template_filter(nl2br) app.add_template_filter(convert_to_dict, name='dict') app.add_template_filter(no_image_cache) app.add_template_filter(pluralize) app.add_template_filter(slugify) app.add_template_filter(sort_by_tuple_element) app.add_template_filter(clean_html) app.add_template_global(active) app.add_template_global(date_processor) app.add_template_global(inject_static_file) app.add_template_global(inject_badge_context) app.add_template_global(has_perm) app.add_template_global(Logo, name='get_logo') @app.context_processor def inject_context(): return { 'CustomField': { 'TEXT': CustomField.TEXT, 'IMAGE': CustomField.IMAGE, 'EMAIL': CustomField.EMAIL, 'CHECKBOX': CustomField.CHECKBOX, 'SELECT': CustomField.SELECT, 'COUNTRY': CustomField.COUNTRY, 'LANGUAGE': CustomField.LANGUAGE, 'CATEGORY': CustomField.CATEGORY, 'EVENT': CustomField.EVENT, }, 'Participant': { 'PARTICIPANT': Participant.PARTICIPANT, 'MEDIA': Participant.MEDIA, 'DEFAULT': Participant.DEFAULT, 'DEFAULT_MEDIA': Participant.DEFAULT_MEDIA, }, } login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'auth.login' login_manager.login_message_category = 'warning' mail.init_app(app) redis_store.init_app(app, strict=True) if app.config.get('SENTRY_DSN'): sentry.init_app(app) _configure_uploads(app) _configure_logging(app) app.config['REPRESENTING_TEMPLATES'] = ( path('meetings/participant/representing')) _translations = app.config['TRANSLATIONS'] if _DEFAULT_LANG not in _translations: _translations = [_DEFAULT_LANG] + _translations app.config['TRANSLATIONS'] = _translations @login_manager.user_loader def load_user(user_id): return User.query.get(user_id) @app.route('/') def index(): return redirect(url_for('meetings.home')) @app.errorhandler(413) def file_too_large(error): mb = 1024 * 1024 max_size = app.config.get('UPLOAD_SIZE', mb) / mb return render_template('_file_too_large.html', max_size=max_size, url=request.url), 413 return app
app = Flask(__name__) app.debug = app_config.DEBUG try: file_handler = logging.FileHandler('%s/public_app.log' % app_config.SERVER_LOG_PATH) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) except IOError: pass app.logger.setLevel(logging.INFO) app.register_blueprint(static.static, url_prefix='/%s' % app_config.PROJECT_SLUG) app.add_template_filter(smarty_filter, name='smarty') app.add_template_filter(urlencode_filter, name='urlencode') app.add_template_filter(format_commas_filter, name='format_commas') # Example of rendering index.html with public_app @app.route('/%s/' % app_config.PROJECT_SLUG, methods=['GET']) def index(): """ Example view rendering a simple page. """ context = make_context(asset_depth=1) context['users'] = SITE_USERS return make_response(render_template('admin/index.html', **context))
from mongokit import Connection import steam from models import Profile, Job, Match, User from filters import unix_strftime, prettyprint app = Flask(__name__) app.config.from_pyfile("settings.cfg") connection = Connection(app.config['MONGODB_HOST'], app.config['MONGODB_PORT']) cache = Cache(app) oid = OpenID(app) connection.register([Profile, Job, Match, User]) app.add_template_filter(unix_strftime) app.add_template_filter(prettyprint) # Setup steamodd steam.api.key.set(app.config['STEAM_API_KEY']) steam.api.socket_timeout.set(10) # Helpers @cache.cached(timeout=60*60, key_prefix="league_passes") def get_league_passes(): try: return [x for x in steam.items.schema(570, "en_US") if x.type == "League Pass"] except steam.api.APIError: return []
App Template for static publishing. """ import app_config import json import oauth import static from flask import Flask, make_response, render_template from render_utils import make_context, smarty_filter, urlencode_filter from werkzeug.debug import DebuggedApplication app = Flask(__name__) app.debug = app_config.DEBUG app.add_template_filter(smarty_filter, name="smarty") app.add_template_filter(urlencode_filter, name="urlencode") @app.route("/") @oauth.oauth_required def index(): """ Example view demonstrating rendering a simple HTML page. """ context = make_context() with open("data/featured.json") as f: context["featured"] = json.load(f) return make_response(render_template("index.html", **context))
# Setup steamodd steam.api.key.set(app.config['STEAM_API_KEY']) steam.api.socket_timeout.set(5) # Setup debugtoolbar if we're in debug mode. if app.debug: from flask.ext.debugtoolbar import DebugToolbarExtension toolbar = DebugToolbarExtension(app) # Set up jinja2 filters. from app.filters import escape_every_character,\ timestamp_to_datestring,\ datetime_to_datestring,\ seconds_to_time app.add_template_filter(escape_every_character) app.add_template_filter(timestamp_to_datestring) app.add_template_filter(datetime_to_datestring) app.add_template_filter(seconds_to_time) # Load current app version into globals from helpers import current_version app.config['VERSION'] = current_version() # Load views import views # Load blueprints from app.users.views import mod as users_module app.register_blueprint(users_module)
from kagami.config import Config from kagami.models import KagamiStatus from kagami.i18n import i18n def get_api(access_token: str, access_secret: str): tw_auth = tweepy.OAuthHandler(current_app.config['CK'], current_app.config['CS']) tw_auth.set_access_token(access_token, access_secret) return tweepy.API(tw_auth) app = Flask(__name__) app.config.from_object(Config) app.config['STRINGS'] = i18n() import kagami.handler import kagami.auth import kagami.status import kagami.user import kagami.user_config import kagami.direct_message import kagami.cookie app.add_template_filter(nl2br) app.jinja_env.globals.update(handler=kagami.handler) app.jinja_env.globals.update(int=int, str=str) app.jinja_env.globals.update(session=session) app.jinja_env.globals.update(KagamiStatus=KagamiStatus) Bootstrap(app) if app.config['ENABLE_HTTPS']: SSLify(app)