@expose('/') def index(self): return redirect(url_for('dashboard.index')) admin = Admin(name='Apollo', index_view=AdminHome(name='Dashboard')) babel = Babel() cache = Cache() db = SQLAlchemy(session_options={'expire_on_commit': False}) mail = Mail() menu = Menu() migrate = Migrate() oauth = OAuth() red = FlaskRedis() security = Security() gravatar = Gravatar(size=25, default="identicon", use_ssl=True) sentry = Sentry(client_cls=ApolloRavenClient) csrf = CSRFProtect() debug_toolbar = DebugToolbarExtension() if fdt_available else None uploads = UploadSet('uploads', DEFAULTS) webpack = Webpack() docs = FlaskApiSpec() class Filter(object): """Enables filtering a queryset on one parameter. Several filters can (and should) be combined into a `class`FilterSet, which can be used to generate a form for receiving the necessary parameters for filtering. This base class doesn't do much, and will raise an exception if it's
from flask_compress import Compress from flask_caching import Cache from flask_babel import Babel, lazy_gettext as _l from config import Config db = SQLAlchemy() # flask-sqlalchemy migrate = Migrate() # flask-migrate login = LoginManager() # flask-login login.login_view = 'auth.login' login.login_message = _l('Please login to access this page.') mail = Mail() moment = Moment() gravatar = Gravatar(app=None, size=100, rating='g', default='robohash', force_default=False, force_lower=False, use_ssl=True, base_url=None) bootstrap = Bootstrap() # flask-bootstrap cache = Cache() # flask-caching compress = Compress() # flask-compress babel = Babel() # flask-babel def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) db.init_app(app) migrate.init_app(app, db)
from functools import wraps from werkzeug.security import generate_password_hash, check_password_hash from flask_sqlalchemy import SQLAlchemy from sqlalchemy.orm import relationship from flask_login import UserMixin, login_user, LoginManager, login_required, current_user, logout_user from forms import LoginForm, RegisterForm, CreatePostForm, CommentForm from flask_gravatar import Gravatar app = Flask(__name__) app.config['SECRET_KEY'] = '8BYkEfBA6O6donzWlSihBXox7C0sKR6b' ckeditor = CKEditor(app) Bootstrap(app) gravatar = Gravatar(app, size=100, rating='g', default='retro', force_default=False, force_lower=False, use_ssl=False, base_url=None) ##CONNECT TO DB app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) login_manager = LoginManager() login_manager.init_app(app) @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id))
class AdminLTE(object): """ Attributes: app (flask.Flask): Application object. manager (Manager): Manager for accessing AdminLTE features. """ def __init__(self, app=None): self.app = app self.manager = Manager() self.flash = Flash() self.gravatar = Gravatar(default='mp') if app is not None: self.init_app(app) def init_app(self, app): """Initializes the extension.""" if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['adminlte_full'] = self for name, value in DEFAULT_SETTINGS.items(): app.config.setdefault(name, value) # assets.init_app(app) self.gravatar.init_app(app) self.manager.user_getter(self.user_getter) self.manager.home_page = app.config['ADMINLTE_HOME_PAGE'] self.init_locale(app) self.register_blueprint(app) if not app.debug: app.register_error_handler(HTTPException, self.error_page) for name in filters.__all__: app.jinja_env.filters.setdefault(name, getattr(filters, name)) @app.context_processor def processors(): return dict( adminlte=self.manager, adminlte_user=self.manager.user, ThemeColor=ThemeColor, ThemeLayout=ThemeLayout, ) if not hasattr(app.jinja_env, 'install_gettext_callables'): app.jinja_env.add_extension('jinja2.ext.i18n') app.jinja_env.install_null_translations(True) def init_locale(self, app): """Initializes the manager to use locales.""" babel = app.extensions.get('babel') if babel is not None: self.manager.default_locale = str(babel.default_locale) self.manager.locale_getter(lambda: babel.locale_selector_func and babel.locale_selector_func()) else: self.manager.default_locale = app.config.get( 'ADMINLTE_DEFAULT_LOCALE') def error_page(self, err): """Page for all HTTP errors.""" template = f'adminlte_full/http_error_page.html' context = { 'status_code': err.code, 'status_message': err.name, 'details': err.get_description(), } return render_template(template, **context), err.code def register_blueprint(self, app): """Registers Blueprint.""" app.register_blueprint( Blueprint('adminlte_full', __name__, static_folder='static', template_folder=pkg_resources.resource_filename( 'adminlte_base', 'templates'), static_url_path='/adminlte_full')) def user_getter(self): """Returns the current user.""" return current_user, current_app.config['ADMINLTE_USER_MAPPING']
""" Flask Web """ from flask import Flask, render_template from flask_gravatar import Gravatar from webtools import Settings, get_activities, get_users settings = Settings() app = Flask(__name__) gravatar = Gravatar(app, size=128, rating='g', default='retro') @app.route("/") def index(): return render_template("index.html") @app.route("/charts/") def charts_view(): activities = get_activities(settings) date_range = [] # list of dates for x axis chart_series = {} # list of users with duration for y axis for date in activities: date_range.append(date) for point in activities[date]: if point['user'] not in chart_series: chart_series[point['user']] = [] chart_series[point['user']].append(point['duration']) return render_template("chart.html", date_range=date_range,
app = Flask(__name__) app.config["SECRET_KEY"] = os.getenv("FLASK_SECRET_KEY") ckeditor = CKEditor(app) Bootstrap(app) # CONNECT TO DB app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///blog.sqlite3" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False db = SQLAlchemy(app) # GAVATAR gravatar = Gravatar( app, size=100, rating="g", default="retro", force_default=False, force_lower=False, use_ssl=False, base_url=None, ) # CONFIGURE TABLES class User(UserMixin, db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(250), unique=True, nullable=False) password = db.Column(db.String(250), nullable=False) name = db.Column(db.String(250), nullable=False) posts = relationship("BlogPost", back_populates="author") comments = relationship("Comment", back_populates="author")
def test_constructor(self): Gravatar(self.app)
def index(): """Render and process the main browser window.""" # Register Gravatar module with the app only if required if config.SHOW_GRAVATAR_IMAGE: Gravatar(current_app, size=100, rating='g', default='retro', force_default=False, use_ssl=True, base_url=None) # Check the browser is a supported version # NOTE: If the checks here are updated, make sure the supported versions # at https://www.pgadmin.org/faq/#11 are updated to match! if config.CHECK_SUPPORTED_BROWSER: browser_name, browser_known, version = _get_supported_browser() if browser_name is not None: msg = render_template(MODULE_NAME + "/browser.html", version=version, browser=browser_name, known=browser_known) flash(msg, 'warning') # Get the current version info from the website, and flash a message if # the user is out of date, and the check is enabled. if config.UPGRADE_CHECK_ENABLED: last_check = get_setting('LastUpdateCheck', default='0') today = time.strftime('%Y%m%d') if int(last_check) < int(today): check_browser_upgrade() store_setting('LastUpdateCheck', today) auth_only_internal = False auth_source = [] session['allow_save_password'] = True if config.SERVER_MODE: if session['auth_source_manager']['current_source'] == INTERNAL: auth_only_internal = True auth_source = session['auth_source_manager']['source_friendly_name'] if not config.MASTER_PASSWORD_REQUIRED and 'pass_enc_key' in session: session['allow_save_password'] = False response = Response( render_template(MODULE_NAME + "/index.html", username=current_user.username, auth_source=auth_source, is_admin=current_user.has_role("Administrator"), logout_url=get_logout_url(), requirejs=True, basejs=True, mfa_enabled=is_mfa_enabled(), login_url=login_url, _=gettext, auth_only_internal=auth_only_internal)) # Set the language cookie after login, so next time the user will have that # same option at the login time. misc_preference = Preferences.module('misc') user_languages = misc_preference.preference('user_language') language = 'en' if user_languages: language = user_languages.get() or 'en' domain = dict() if config.COOKIE_DEFAULT_DOMAIN and\ config.COOKIE_DEFAULT_DOMAIN != 'localhost': domain['domain'] = config.COOKIE_DEFAULT_DOMAIN response.set_cookie("PGADMIN_LANGUAGE", value=language, path=config.COOKIE_DEFAULT_PATH, secure=config.SESSION_COOKIE_SECURE, httponly=config.SESSION_COOKIE_HTTPONLY, samesite=config.SESSION_COOKIE_SAMESITE, **domain) return response
template_mode="bootstrap3", index_view=HomeView()) # Debug toolbar debug_toolbar = DebugToolbarExtension() # CSRF protection csrf = CSRFProtect() # SQLAlchemy db = SQLAlchemy(session_options={"autoflush": False}) # Flask gravatar gravatar = Gravatar( size=100, rating="g", default="retro", force_default=False, use_ssl=True, base_url=None, ) # Flask migrate migrate = Migrate() # Flask-User user_manager = CustomUserManager(None, None, None) # Celery cel = FlaskCelery("opencve", include=["opencve.tasks"])
app.config["FLATPAGES_ROOT"] = "flatpages" app.config["FLATPAGES_EXTENSION"] = ".md" app.config.from_pyfile(os.environ["FLASK_CONFIG"]) r = redis.Redis.from_url(app.config["REDIS_URL"]) menu.Menu(app=app) github = GitHub(app) csrf = CSRFProtect(app) mail = Mail(app) pages = FlatPages(app) babel = Babel(app) gravatar = Gravatar(app, size=58, rating='g', default='mp', force_default=False, force_lower=False, use_ssl=True, base_url=None) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "users.login" from .sass import sass sass(app) if not app.debug and app.config["MAIL_UTILS_ERROR_SEND_TO"]: from .maillogger import build_handler app.logger.addHandler(build_handler(app))
# coding: utf-8 """ ext ~~~ Good place for pluggable extensions. :copyright: (c) 2015 by Roman Zaiev. :license: BSD, see LICENSE for more details. """ from flask_debugtoolbar import DebugToolbarExtension from flask_gravatar import Gravatar from flask_login import LoginManager from flask_sqlalchemy import SQLAlchemy from flask_assets import Environment db = SQLAlchemy() assets = Environment() login_manager = LoginManager() gravatar = Gravatar(size=50) toolbar = DebugToolbarExtension() # Almost any modern Flask extension has special init_app() # method for deferred app binding. But there are a couple of # popular extensions that no nothing about such use case. # Or, maybe, you have to use some app.config settings # gravatar = lambda app: Gravatar(app, size=50)
def configure(app): if app.config.get('GRAVATAR'): try: Gravatar(app, **app.config.get('GRAVATAR')) except TypeError: raise ImportError('You must install flask_gravatar')
def index(): """Render and process the main browser window.""" # Register Gravatar module with the app only if required if config.SHOW_GRAVATAR_IMAGE: Gravatar(current_app, size=100, rating='g', default='retro', force_default=False, use_ssl=True, base_url=None) # Check the browser is a support version # NOTE: If the checks here are updated, make sure the supported versions # at https://www.pgadmin.org/faq/#11 are updated to match! if config.CHECK_SUPPORTED_BROWSER: browser_name, browser_known, version = _get_supported_browser() if browser_name is not None: msg = render_template(MODULE_NAME + "/browser.html", version=version, browser=browser_name, known=browser_known) flash(msg, 'warning') # Get the current version info from the website, and flash a message if # the user is out of date, and the check is enabled. if config.UPGRADE_CHECK_ENABLED: check_browser_upgrade() auth_only_internal = False auth_source = [] if config.SERVER_MODE: if len(config.AUTHENTICATION_SOURCES) == 1\ and 'internal' in config.AUTHENTICATION_SOURCES: auth_only_internal = True auth_source = session['_auth_source_manager_obj'][ 'source_friendly_name'] response = Response( render_template(MODULE_NAME + "/index.html", username=current_user.username, auth_source=auth_source, is_admin=current_user.has_role("Administrator"), logout_url=_get_logout_url(), _=gettext, auth_only_internal=auth_only_internal)) # Set the language cookie after login, so next time the user will have that # same option at the login time. misc_preference = Preferences.module('misc') user_languages = misc_preference.preference('user_language') language = 'en' if user_languages: language = user_languages.get() or 'en' domain = dict() if config.COOKIE_DEFAULT_DOMAIN and\ config.COOKIE_DEFAULT_DOMAIN != 'localhost': domain['domain'] = config.COOKIE_DEFAULT_DOMAIN response.set_cookie("PGADMIN_LANGUAGE", value=language, path=config.COOKIE_DEFAULT_PATH, **domain) return response
def index(): """Render and process the main browser window.""" # Register Gravatar module with the app only if required if config.SHOW_GRAVATAR_IMAGE: Gravatar( current_app, size=100, rating='g', default='retro', force_default=False, use_ssl=True, base_url=None ) # Check the browser is a support version # NOTE: If the checks here are updated, make sure the supported versions # at https://www.pgadmin.org/faq/#11 are updated to match! if config.CHECK_SUPPORTED_BROWSER: browser = request.user_agent.browser version = request.user_agent.version and int( request.user_agent.version.split('.')[0]) browser_name = None browser_known = True if browser == 'chrome' and version < 72: browser_name = 'Chrome' elif browser == 'firefox' and version < 65: browser_name = 'Firefox' elif browser == 'edge' and version < 44: browser_name = 'Edge' elif browser == 'safari' and version < 12: browser_name = 'Safari' elif browser == 'msie': browser_name = 'Internet Explorer' elif browser != 'chrome' and browser != 'firefox' and \ browser != 'edge' and browser != 'safari': browser_name = browser browser_known = False if browser_name is not None: msg = render_template( MODULE_NAME + "/browser.html", version=version, browser=browser_name, known=browser_known ) flash(msg, 'warning') # Get the current version info from the website, and flash a message if # the user is out of date, and the check is enabled. if config.UPGRADE_CHECK_ENABLED: data = None url = '%s?version=%s' % (config.UPGRADE_CHECK_URL, config.APP_VERSION) current_app.logger.debug('Checking version data at: %s' % url) try: # Do not wait for more than 5 seconds. # It stuck on rendering the browser.html, while working in the # broken network. if os.path.exists(config.CA_FILE): response = urlreq.urlopen(url, data, 5, cafile=config.CA_FILE) else: response = urlreq.urlopen(url, data, 5) current_app.logger.debug( 'Version check HTTP response code: %d' % response.getcode() ) if response.getcode() == 200: data = json.loads(response.read().decode('utf-8')) current_app.logger.debug('Response data: %s' % data) except Exception: current_app.logger.exception('Exception when checking for update') if data is not None: if data[config.UPGRADE_CHECK_KEY]['version_int'] > \ config.APP_VERSION_INT: msg = render_template( MODULE_NAME + "/upgrade.html", current_version=config.APP_VERSION, upgrade_version=data[config.UPGRADE_CHECK_KEY]['version'], product_name=config.APP_NAME, download_url=data[config.UPGRADE_CHECK_KEY]['download_url'] ) flash(msg, 'warning') auth_only_internal = False auth_source = [] if config.SERVER_MODE: if len(config.AUTHENTICATION_SOURCES) == 1\ and 'internal' in config.AUTHENTICATION_SOURCES: auth_only_internal = True auth_source = session['_auth_source_manager_obj'][ 'source_friendly_name'] response = Response(render_template( MODULE_NAME + "/index.html", username=current_user.username, auth_source=auth_source, is_admin=current_user.has_role("Administrator"), logout_url=_get_logout_url(), _=gettext, auth_only_internal=auth_only_internal )) # Set the language cookie after login, so next time the user will have that # same option at the login time. misc_preference = Preferences.module('misc') user_languages = misc_preference.preference( 'user_language' ) language = 'en' if user_languages: language = user_languages.get() or 'en' domain = dict() if config.COOKIE_DEFAULT_DOMAIN and\ config.COOKIE_DEFAULT_DOMAIN != 'localhost': domain['domain'] = config.COOKIE_DEFAULT_DOMAIN response.set_cookie("PGADMIN_LANGUAGE", value=language, path=config.COOKIE_DEFAULT_PATH, **domain) return response
def test_init_app(self): gravatar = Gravatar() if hasattr(self.app, 'extensions'): del self.app.extensions gravatar.init_app(self.app)
from flask import Flask from flask_mail import Mail from flask_gravatar import Gravatar from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) app.config.from_object('auth.config') mail = Mail(app) gravatar = Gravatar(app, use_ssl=True) db = SQLAlchemy(app)
def test_parameters(self): gravatar = Gravatar(self.app, force_lower=True) assert gravatar('*****@*****.**') == gravatar('*****@*****.**', force_lower=None)
import os from redis import Redis import rq from flask_gravatar import Gravatar from flask_babelex import Babel app = Flask(__name__) db = MongoEngine() jsglue = JSGlue() login = LoginManager() login.login_view = 'auth.login' login.login_message = 'Veuillez vous connecter pour accéder à cette page' gravatar = Gravatar(size=100, rating='g', default='identicon', force_default=False, force_lower=False, use_ssl=False, base_url=None) redis = Redis() task_queue = rq.Queue('standard-tasks', connection=redis) babel = Babel() # photos = UploadSet('photos', IMAGES) class HomeView(AdminIndexView): @expose('/') def index(self): courriers_entrant = CourrierEntrant.objects.count()
def add_user_blueprint(app): """ to the app. """ monkey_patch_email() # https://pythonhosted.org/Flask-Security-Fork/customizing.html from flask_security.forms import RegisterForm, ConfirmRegisterForm from wtforms.fields import StringField from wtforms.validators import Required, Regexp, Length # https://flask-security-fork.readthedocs.io/en/latest/customizing.html#views # https://flask-security-fork.readthedocs.io/en/latest/quickstart.html#id1 from flask_security import Security monkey_patch_sqlstore(app) def unique_user_name(form, field): """ Make sure it is a unique user name. """ from wtforms import ValidationError from pygameweb.user.models import User user = (current_session.query(User).filter( User.name == field.data).first()) if user is not None: msg = f'{field.data} is already associated with an account.' raise ValidationError(msg) username_msg = 'Username must contain only letters numbers or underscore' username_validators = [ Required(), Regexp('^\w+$', message=username_msg), Length(min=5, max=25, message='Username must be betwen 5 & 25 characters'), unique_user_name, ] class ExtendedRegisterForm(RegisterForm): name = StringField('Username', username_validators) title = StringField('Title (eg. Real name)', [Required()]) class ExtendedConfirmRegisterForm(ConfirmRegisterForm): name = StringField('Username', username_validators) title = StringField('Title (eg. Real name)', [Required()]) monkey_patch_email_field(ExtendedRegisterForm) monkey_patch_email_field(ExtendedConfirmRegisterForm) security = Security(app, app.user_datastore, register_form=ExtendedRegisterForm, confirm_register_form=ExtendedConfirmRegisterForm) from pygameweb.cache import limiter limiter.limit("4/hour")(security.app.blueprints['security']) # https://pypi.python.org/pypi/Flask-Gravatar from flask_gravatar import Gravatar Gravatar(app, size=100, rating='g', default='retro', force_default=False, use_ssl=True, base_url=None) # http://flask-security-fork.readthedocs.io/en/latest/api.html#signals from flask_security import user_confirmed, user_registered @user_confirmed.connect_via(app) def when_the_user_is_confirmed(app, user): """ we can add a newbie role. """ # we add a newbie role, once the user confirms their email. default_role = app.user_datastore.find_role("newbie") app.user_datastore.add_role_to_user(user, default_role) # TODO: After a couple of hours we can add a 'member' role. # The idea with this magic spell would be to ward off spam a bit. member_role = app.user_datastore.find_role("members") app.user_datastore.add_role_to_user(user, member_role) current_session.commit() @user_registered.connect_via(app) def when_user_is_registered(app, user, confirm_token): """ we log their ip address so as to try and block spammers. """ remote_addr = request.remote_addr or None user.registered_ip = remote_addr current_session.add(user) current_session.commit() app.register_blueprint(user_blueprint)
import os from datetime import date, datetime from flask import Blueprint, g, redirect, render_template, request, url_for from flask_babel import gettext from flask_gravatar import Gravatar from main import app, flash_error, flash_success from main.decorators import auth_required from main.forms import AuthForm, ContactForm, ResetPasswordConfirmForm, ResetPasswordForm from main.models import Application, AuthModel, ContactModel, InitPasswordResetModel, PasswordResetModel gravatar = Gravatar(app) front = Blueprint('front', __name__, url_prefix='/<any(pl, en, ru, ""):lang_code>') @front.url_defaults def add_language_code(endpoint, values): values.setdefault('lang_code', g.lang_code) @front.url_value_preprocessor def pull_lang_code(endpoint, values): g.lang_code = values.pop('lang_code') @app.template_filter('age') def age(birth_date): birth_date = datetime.strptime(birth_date, '%Y-%m-%d') return int((date.today() - birth_date.date()).days / 365.2425)
def index(): """Render and process the main browser window.""" # Register Gravatar module with the app only if required if config.SHOW_GRAVATAR_IMAGE: Gravatar( current_app, size=100, rating='g', default='retro', force_default=False, use_ssl=True, base_url=None ) # Get the current version info from the website, and flash a message if # the user is out of date, and the check is enabled. if config.UPGRADE_CHECK_ENABLED: data = None url = '%s?version=%s' % (config.UPGRADE_CHECK_URL, config.APP_VERSION) current_app.logger.debug('Checking version data at: %s' % url) try: # Do not wait for more than 5 seconds. # It stuck on rendering the browser.html, while working in the # broken network. if os.path.exists(config.CA_FILE): response = urlreq.urlopen(url, data, 5, cafile=config.CA_FILE) else: response = urlreq.urlopen(url, data, 5) current_app.logger.debug( 'Version check HTTP response code: %d' % response.getcode() ) if response.getcode() == 200: data = json.loads(response.read().decode('utf-8')) current_app.logger.debug('Response data: %s' % data) except Exception: current_app.logger.exception('Exception when checking for update') if data is not None: if data[config.UPGRADE_CHECK_KEY]['version_int'] > \ config.APP_VERSION_INT: msg = render_template( MODULE_NAME + "/upgrade.html", current_version=config.APP_VERSION, upgrade_version=data[config.UPGRADE_CHECK_KEY]['version'], product_name=config.APP_NAME, download_url=data[config.UPGRADE_CHECK_KEY]['download_url'] ) flash(msg, 'warning') response = Response(render_template( MODULE_NAME + "/index.html", username=current_user.email, is_admin=current_user.has_role("Administrator"), _=gettext )) # Set the language cookie after login, so next time the user will have that # same option at the login time. misc_preference = Preferences.module('miscellaneous') user_languages = misc_preference.preference( 'user_language' ) language = 'en' if user_languages: language = user_languages.get() or 'en' domain = dict() if config.COOKIE_DEFAULT_DOMAIN and\ config.COOKIE_DEFAULT_DOMAIN != 'localhost': domain['domain'] = config.COOKIE_DEFAULT_DOMAIN response.set_cookie("PGADMIN_LANGUAGE", value=language, path=config.COOKIE_DEFAULT_PATH, **domain) return response
ckeditor = CKEditor(app) Bootstrap(app) login_manager = LoginManager() login_manager.init_app(app) ##CONNECT TO DB app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', "sqlite:///blog.db") app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) ##CONFIGURE TABLES gravatar = Gravatar( app, size=100, rating='g', default='retro', force_default=False, force_lower=False, ) class Users(UserMixin, db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(250), unique=True, nullable=False) password = db.Column(db.String(250), nullable=False) name = db.Column(db.String(250), nullable=False) user_blog_posts = db.relationship('BlogPost', backref='the_user') the_comments = db.relationship('Comments', backref='the_user_comment')
import os import click from flask import Flask from flask.cli import with_appcontext from flask_sqlalchemy import SQLAlchemy from flask_gravatar import Gravatar db = SQLAlchemy() gravatar = Gravatar() def create_app(test_config=None): """Create and configure an instance of the Flask application.""" app = Flask(__name__, instance_relative_config=True) # some deploy system set the database url in the environ db_url = os.environ.get("DATABASE_URL") if db_url is None: # default to a sqlite database in the instance folder db_url = "sqlite:///" + os.path.join(app.instance_path, "flaskr.sqlite") # ensure the instance folder exists os.makedirs(app.instance_path, exist_ok=True) app.config.from_mapping( # default secret that should be overridden in environ or config SECRET_KEY=os.environ.get("SECRET_KEY", "dev"), SQLALCHEMY_DATABASE_URI=db_url, SQLALCHEMY_TRACK_MODIFICATIONS=False,
from daimaduan.views.pastes import paste_app from daimaduan.views.tags import tag_app from daimaduan.views.bookmarks import bookmark_app app.register_blueprint(site_app) app.register_blueprint(user_app, url_prefix='/user') app.register_blueprint(paste_app, url_prefix='/paste') app.register_blueprint(tag_app, url_prefix='/tag') app.register_blueprint(bookmark_app, url_prefix='/bookmark') app.jinja_env.filters['time_passed'] = time_passed app.jinja_env.filters['time_used'] = time_used app.jinja_env.filters['ternary'] = ternary app.jinja_env.filters['datetimeformat'] = datetimeformat app.jinja_env.filters['markdown'] = md if app.config['USE_JINJA_CACHE']: app.jinja_env.bytecode_cache = MemcachedBytecodeCache(memcache.Client([app.config['MEMCACHED_URL']])) login_manager.init_app(app) assets.init_app(app) cdn.init_app(app) gravatar = Gravatar(app, size=100, rating='g', default='retro', force_default=False, force_lower=False, use_ssl=True, base_url='https://cn.gravatar.com/')