def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # blueprints from app.main import main as main_blueprint from app.blog import blog as blog_blueprint from app.admin import admin as admin_blueprint from app.projects import projects as projects_blueprint app.register_blueprint(main_blueprint) app.register_blueprint(blog_blueprint, url_prefix='/blog') app.register_blueprint(admin_blueprint) app.register_blueprint(projects_blueprint, url_prefix='/projects') # initializations csrf.init_app(app) db.init_app(app) login_manager.init_app(app) migrate.init_app(app, db) mail.init_app(app) md = Markdown(app) md.register_extension(CodeHiliteExtension) app.jinja_env.filters['timesince'] = timesince_filter return app
def new_app(app, serialize=False): logging.basicConfig(level=logging.DEBUG) md = Markdown(app, extensions=['tables']) md.register_extension(ProverExtension) register_modules(app, [admin, classes, frontend, lessons, prover]) app.secret_key = os.urandom(24) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' app.config['COQD_HOST'] = 'localhost' app.config['COQD_PORT'] = 8003 if serialize: app.config['serialize'] = serialize # XXX:dc: kind of a hack but I want to keep the db and the app seperate db.init_app(app) db.app = app return app
# -*- coding: utf-8 -*- """ Flask Main Entry Point """ import os from flask import Flask # Init Flask app = Flask(__name__) app.config.from_object(__name__) app.debug = True # Init Markdown from flaskext.markdown import Markdown md = Markdown(app) # Extensions from extensions.abk import Abbrevation md.register_extension(Abbrevation) from extensions.comment import Comment md.register_extension(Comment) from extensions.linebreak import LineBreak md.register_extension(LineBreak) with app.app_context(): # noinspection PyUnresolvedReferences from processors import * # noinspection PyUnresolvedReferences from handlers import *
def create_app(config_name): """An application factory, as explained here: http://flask.pocoo.org/docs/patterns/appfactories/ @param config_name: The configuration object to use. """ app = Flask(__name__) app.config.from_object(config[config_name] or config[os.getenv('BG_CONFIG')]) app.config.from_envvar('BG_SETTINGS', silent=True) config[config_name].init_app(app) db.init_app(app) # Setup Flask-Security user_datastore = SQLAlchemyUserDatastore(db, User, Role) from app.users.forms import ExtendedRegisterForm security.init_app(app, user_datastore, register_form=ExtendedRegisterForm) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) migrate.init_app(app, db) md = Markdown(app, output_format='html5', extensions=['fenced_code', 'tables', 'abbr', 'footnotes']) pages.init_app(app) csrf.init_app(app) register_adminviews(app) app.jinja_env.filters['alert_class'] = alert_class_filter # WTForms helpers from .utils import add_helpers add_helpers(app) if not app.debug: import logging from logging.handlers import SMTPHandler mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'], fromaddr=app.config['ADMINS_FROM_EMAIL'], toaddrs=app.config['ADMINS_EMAIL'], subject='Application Error Occurred') mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) register_blueprints(app) register_commands(app) # Create the bg_interface directory if it does not exist directory = os.path.join(os.path.dirname(BASE_DIR), 'bg_interface') if not os.path.exists(directory): os.makedirs(directory) with app.app_context(): db.create_all() if not User.query.first(): # Create a default admin user if there is no user in the database user_datastore.create_role(name='admin') user_datastore.create_user(name='Administration Account', email='*****@*****.**', password=encrypt_password('password'), roles=['admin']) db.session.commit() app.logger.info('Created admin user [email protected]') return app
def create_app(config_name): """ Application factory """ # Flask init app = Flask(__name__) # most of the work done right here. Thanks, Flask! app.config.from_object('settings') # load my settings which pull from .env ''' FLASK EXTENTIONS ''' db.init_app(app) # load my database extension from .models import User, Role user_datastore = SQLAlchemyUserDatastore(db, User, Role) # load my security extension security.init_app(app, user_datastore, confirm_register_form=ExtendedRegisterForm) mail.init_app(app) # load my mail extensioin # load my writing tool extension md = Markdown(app, extensions=['fenced_code', 'tables']) migrate.init_app(app, db) # load my database updater tool moment.init_app(app) # time formatting jwt.init_app(app) #### # ASSETS ### assets.init_app(app) js = Bundle('vendor/bootstrap/js/bootstrap.bundle.min.js', 'vendor/jquery-easing/jquery.easing.min.js', 'js/sb-admin-2.min.js', filters='jsmin', output='js/packed.js') sass = Bundle('scss/custom.scss', filters='scss', output='css/custom.css') all_css = Bundle( sass, # add more CSS files here filters='cssmin', output="css/packed.css") # EXTENSIONS THAT SOMETIMES CRASH # TODO: don't be lazy, Mr. A, get rid of this try-except try: assets.register('js_all', js) assets.register('all_css', all_css) admin.init_app(app) ckeditor.init_app(app) from .models import Post, Buzz # importing models carefully as needed to avoid circular import issues from .models.main import UserAdmin, RoleAdmin # not db tables admin.add_view(UserAdmin(User, db.session)) admin.add_view(RoleAdmin(Role, db.session)) admin.add_view(RoleAdmin(Post, db.session)) admin.add_view(RoleAdmin(Buzz, db.session)) # Add new models here so you can manage data from Flask-Admin's convenient tools except Exception as e: app.logger.error(f'Failed activating extensions: {e}') # TODO: Setup sentry.io! # sentry_sdk.init(dsn="", integrations=[FlaskIntegration()]) # activate the flaskinni blueprint (blog, user settings, and other basic routes) from .main import main as main_blueprint app.register_blueprint(main_blueprint) # activate API blueprint: https://stackoverflow.com/questions/38448618/using-flask-restful-as-a-blueprint-in-large-application jwt.init_app(app) # bolt on our Javascript Web Token tool from .api import api_blueprint restful = Api(api_blueprint, prefix="/api/v1") from .api import add_resources add_resources(restful) app.register_blueprint( api_blueprint ) # registering the blueprint effectively runs init_app on the restful extension # Callback function to check if a JWT exists in the redis blocklist @jwt.token_in_blocklist_loader def check_if_token_is_revoked(jwt_header, jwt_payload): jti = jwt_payload["jti"] return models.RevokedTokenModel.is_jti_blocklisted(jti) # --- NEW BLUEPRINTS GO BELOW THIS LINE --- # custom error handlers, these call the functions at the top of the file app.register_error_handler(500, crash_page) app.register_error_handler(404, page_not_found) app.register_error_handler(403, page_forbidden) # Executes before the first request is processed. @app.before_first_request def before_first_request(): """ What do we do before we respond to the first request """ # Create any database tables that don't exist yet. db.create_all() # Create the Roles "admin" and "end-user" -- unless they already exist user_datastore.find_or_create_role(name='admin', description='Administrator') user_datastore.find_or_create_role(name='end-user', description='End user') # Create two Users for testing purposes -- unless they already exists. # In each case, use Flask-Security utility function to encrypt the password. encrypted_password = utils.encrypt_password( app.config['STARTING_ADMIN_PASS']) for email in app.config['STARTING_ADMINS']: if not user_datastore.get_user(email): user_datastore.create_user(email=email, password=encrypted_password) # Commit any database changes; the User and Roles must exist before we can add a Role to the User db.session.commit() for email in app.config['STARTING_ADMINS']: user_datastore.add_role_to_user(email, 'admin') confirmed_admin = user_datastore.get_user(email) confirmed_admin.confirmed_at = datetime.utcnow() db.session.commit() @app.before_request def before_request(): """ What we do before every single handled request """ if current_user.is_authenticated: first_time = True if not current_user.last_seen else False current_user.last_seen = datetime.utcnow() db.session.commit() return app
from flask import Flask from flask_hcaptcha import hCaptcha from flask_migrate import Migrate from flask_sqlalchemy import SQLAlchemy from flaskext.markdown import Markdown from config import config from document import DocumentManager app = Flask(__name__) app.config.from_mapping(config) hcaptcha = hCaptcha(app) db = SQLAlchemy(app) migrate = Migrate(app, db) md = Markdown(app, output_format='html4') document_manager = DocumentManager(app, "documents/documents.json")
from flask import Flask, render_template, abort, url_for, request, flash, session, redirect from flaskext.markdown import Markdown from mdx_github_gists import GitHubGistExtension from mdx_strike import StrikeExtension from mdx_quote import QuoteExtension from mdx_code_multiline import MultilineCodeExtension from werkzeug.contrib.atom import AtomFeed import post import user import pagination import settings from helper_functions import * import csv app = Flask('IncidentDB') md = Markdown(app) md.register_extension(GitHubGistExtension) md.register_extension(StrikeExtension) md.register_extension(QuoteExtension) md.register_extension(MultilineCodeExtension) app.config.from_object('config') @app.route('/', defaults={'page': 1}) @app.route('/page-<int:page>') def index(page): skip = (page - 1) * int(app.config['PER_PAGE']) posts = postClass.get_posts(int(app.config['PER_PAGE']), skip) count = postClass.get_total_count() pag = pagination.Pagination(page, app.config['PER_PAGE'], count) return render_template('index.html',
dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(dir_path) from config import SECRET_KEY, PERMANENT_SESSION_LIFETIME, SQLALCHEMY_DATABASE_URI, SQLALCHEMY_TRACK_MODIFICATIONS,\ SESSION_PROTECTION, LOGIN_VIEW app = Flask(__name__) # 配置数据库 app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI app.config[ 'SQLALCHEMY_TRACK_MODIFICATIONS'] = SQLALCHEMY_TRACK_MODIFICATIONS # 不写这句总是警告 db = SQLAlchemy() db.init_app(app) # 应用中间件初始化 #init markdown Markdown(app, output_format='html5') # 配置session app.secret_key = SECRET_KEY # secret_key需要24个字符的字符串 app.config['PERMANENT_SESSION_LIFETIME'] = PERMANENT_SESSION_LIFETIME # init flask_login login_manager = LoginManager() login_manager.session_protection = SESSION_PROTECTION login_manager.login_view = LOGIN_VIEW login_manager.init_app(app) # 注册auth蓝图 from main import main as main_blueprint app.register_blueprint(main_blueprint) from auth import auth as auth_blueprint
#import aplikacji from app import app from flask import render_template, redirect, url_for from flaskext.markdown import Markdown from app.forms import ProductForm from app.scraper import scraper import pandas as pd import os Markdown(app, extensions=['tables']) app.config['SECRET_KEY'] = "ToJestBrdzoTajnyKLucz" #routing dla strony głównej @app.route('/') @app.route('/index') def index(): return render_template("main.html") @app.route('/about') def about(): with open("README.md", "r", encoding="UTF-8") as fp: text = fp.read() return render_template("about.html", text=text) @app.route('/extract', methods=['GET', 'POST']) def extract(): form = ProductForm() if form.validate_on_submit(): product_id = form.product_id.data scraper(product_id)
app.config.from_object('config') # Include docs folder in templates my_loader = jinja2.ChoiceLoader([ app.jinja_loader, jinja2.FileSystemLoader(['sni/templates/', 'sni/templates/blog/', 'sni/templates/docs/', 'sni/templates/podcast/']), ]) app.jinja_loader = my_loader db = SQLAlchemy(app) migrate = Migrate(app, db) Markdown(app, extensions=['footnotes']) pages = FlatPages(app) manager = Manager(app) manager.add_command('db', MigrateCommand) cache = Cache(app,config={'CACHE_TYPE': 'simple'}) from models import DonationAddress @app.context_processor def utility_processor(): def donation_address(): address = DonationAddress.query.order_by(DonationAddress.lastseen).first() address.lastseen = datetime.now() db.session.commit()
from flask_sqlalchemy import SQLAlchemy from flaskext.markdown import Markdown from flask_principal import Principal, Permission, RoleNeed from flask_login import LoginManager, current_user app = Flask(__name__) app.config.from_pyfile('../doc/flamejam.cfg.default') if os.environ.get('CONFIG_TYPE') == "production": app.config.from_pyfile('/etc/flamejam/flamejam.cfg', silent=True) else: app.config.from_pyfile('../flamejam.cfg', silent=True) mail = Mail(app) db = SQLAlchemy(app) markdown_object = Markdown(app, safe_mode="escape") login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "login" principals = Principal(app) admin_permission = Permission(RoleNeed('admin')) from flamejam.utils import get_current_jam import flamejam.filters import flamejam.views.account import flamejam.views.admin import flamejam.views.ajax import flamejam.views.game import flamejam.views.index
from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_mail import Mail from flask_pagedown import PageDown from flask_featureflags import FeatureFlag from flaskext.markdown import Markdown db = SQLAlchemy() migrate = Migrate() login = LoginManager() login.login_view = 'fellow.login' login.login_message = 'Please log in to access this page.' mail = Mail() pagedown = PageDown() markdown = Markdown() feature_flags = FeatureFlag() log = logging.getLogger(__name__) def create_app(config_class=Config): app = Flask(__name__) app.logger.info(f'Starting application') app.config.from_object(config_class) app.wsgi_app = SassMiddleware( app.wsgi_app, { 'lada': { 'sass_path': 'static/sass', 'css_path': 'static/css', 'wsgi_path': '/static/css',
import re import bleach from flask_heroku import Heroku from jinja2 import evalcontextfilter, Markup, escape from flask import Flask from flask_login import LoginManager from flask_mail import Mail from flaskext.markdown import Markdown app = Flask(__name__, instance_relative_config=True) app.config.from_pyfile('settings.py') mail = Mail(app) heroku = Heroku(app) markdown = Markdown(app, extensions=['nl2br']) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "login" login_manager.login_message_category = "warning" _paragraph_re = re.compile(r'(?:\r\n|\r|\n){2,}') @app.template_filter() def restrict_markdown(value): allowed_tags = ['a', 'b', 'em', 'i', 'li', 'ol', 'strong', 'ul', 'br'] output = Markup( bleach.linkify(bleach.clean(value, tags=allowed_tags, strip=True))) return output
def create_app(test_config=None): ### TUYAUTERIE ### # create and configure the app # c'est la doc qui dit qu'il vaut mieux utiliser la forme split app = Flask(__name__.split('.')[0], instance_relative_config=True) app.config.from_mapping( SECRET_KEY='dev', TOOLBAR=os.environ.get('TOOLBAR'), TITRE='Des Nombres Premiers à chaque mise à jour !', DEBUG_TB_TEMPLATE_EDITOR_ENABLED=True, #EXPLAIN_TEMPLATE_LOADING=True ) if test_config is None: # load the instance config, if it exists, when not testing # contient essentiellement la "SECRET_KEY" app.config.from_pyfile('config.py', silent=True) else: # load the test config if passed in app.config.from_mapping(test_config) # si la variable d'environnement "SECRET_KEY" existe alors c'est la bonne (bonne pratique docker) if os.environ.get('SECRET_KEY'): app.config.from_mapping(SECRET_KEY=os.environ['SECRET_KEY'], ) # autoescape sur .j2 from jinja2 import select_autoescape app.jinja_env.autoescape = select_autoescape(default_for_string=True, disabled_extensions=('txt', ), default=True) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass # la toolbar if app.config['TOOLBAR']: from flask_debugtoolbar import DebugToolbarExtension #toolbar = DebugToolbarExtension(app) DebugToolbarExtension(app) if app.debug: # lorsqu'il y a la toolbar, le logger n'envoie plus les debug app.logger.propagate = True @app.route('/robots.txt') @app.route('/humans.txt') @app.route('/favicon.ico') @app.route('/sitemap.xml') def static_from_root(): return send_from_directory(app.static_folder, request.path[1:]) # session côté serveur redis = os.environ.get('REDIS') if os.environ.get('REDIS') else False app.config.update( SESSION_TYPE='redis' if redis else 'filesystem', SESSION_COOKIE_HTTPONLY=True, SESSION_COOKIE_SAMESITE='Lax', #SESSION_COOKIE_SECURE=True, # impose HTTPS SESSION_USE_SIGNER=True, SESSION_FILE_DIR=os.path.join(app.instance_path, 'flask_session'), PERMANENT_SESSION_LIFETIME=2 * 24 * 3600 + 3600 # 49 heures ) if redis: from redis import Redis hp = redis.split(':') h = hp[0] p = 6379 if len(hp) == 1 else int(hp[1]) app.config['SESSION_REDIS'] = Redis(host=h, port=p) Session(app) # Markdown from flaskext.markdown import Markdown Markdown(app) # sécuriser les FORM HTML # from flask_wtf.csrf import CSRFProtect # CSRFProtect(app) ### Mon appli ### from primes import primes app.register_blueprint(primes.bp) app.add_url_rule('/', endpoint='homepage') return app
from flask import Flask from .config import Config from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_mail import Mail from flask_pymongo import PyMongo from flask_session import Session from flaskext.markdown import Markdown from mdx_gfm import GithubFlavoredMarkdownExtension app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy(app) pmongo = PyMongo(app) md = Markdown(app, extensions=[GithubFlavoredMarkdownExtension()]) login = LoginManager(app) login.login_view = 'login' mail = Mail(app) Session(app) from app import routes, routes_twitter, routes_toxic, routes_black, models, errors, stratified
from flask import Flask import os import config from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flaskext.markdown import Markdown app = Flask(__name__) app.config.from_object('config') app.secret_key = config.SECRET_KEY app.config['UPLOAD_FOLDER'] = config.UPLOAD_FOLDER app.config['MAX_CONTENT_LENGTH'] = config.MAX_FILE_SIZE # Flask-SQLAlchemy db = SQLAlchemy(app) # Flask-Login lm = LoginManager() lm.init_app(app) # Flask-Markdown md = Markdown(app) from app import views, models
from flask import Flask, render_template, flash, request, redirect, Response, abort, url_for from flaskext.markdown import Markdown from datetime import datetime from TwitterApi import TwitterClient from RedditApi import RedditClient app = Flask(__name__) md = Markdown(app, extensions=['fenced_code']) @app.template_filter('datetime') def format_datetime(value): date = datetime.fromtimestamp(value) return date.strftime("%d %B, %Y %H:%M:%S") @app.route('/', methods=['GET', 'POST']) def index(): twitter = TwitterClient() loc = None if request.method == 'POST' and request.form.get('location'): radius = request.form.get('radius') loc = request.form.get('location') tweets = twitter.search_tweets(loc, radius) else: tweets = twitter.search_tweets() reddit = RedditClient() posts = reddit.get_hot_posts() return render_template('index.html', tweets=tweets, reddit=posts, area=loc)
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.migrate import Migrate from flaskext.markdown import Markdown from flask_uploads import UploadSet, configure_uploads, IMAGES app = Flask(__name__) app.config.from_object('settings') db = SQLAlchemy(app) # migrations migrate = Migrate(app, db) # markdown md = Markdown(app, extensions=['fenced_code', 'tables']) # images uploaded_images = UploadSet('images', IMAGES) configure_uploads(app, uploaded_images) from blog import views from author import views
def create_app(ini_file=DEFAULT_INI_FILE): app = Flask(__name__, static_url_path='/static') INIConfig(app) app.config.from_inifile(ini_file) app.secret_key = app.config['common']['secret_key'] if app.config.get('sentry', {}).get('dsn') is not None: sentry.init_app(app, dsn=app.config['sentry']['dsn'], logging=True, level=logging.ERROR) sentry_enabled = True else: sentry_enabled = False app.session_cookie_name = 'flask_session' Bootstrap(app) oidc = OIDConnect(app, **app.config['oidc']) Mozillians(app) Markdown(app) for bp in blueprints: app.register_blueprint(bp) bp.app = app service_book = os.environ.get('SERVICEBOOK', None) if service_book is None: service_book = app.config['common']['service_book'] app.db = Client(service_book, cache=False) if 'service_book_api' in app.config['common']: api_key = app.config['common']['service_book_api'] api_key = base64.b64encode(api_key.encode('utf8')).decode('utf8') app.db.session.headers['Authorization'] = 'APIKey ' + api_key app.search = Search(service_book) app.register_error_handler(401, unauthorized_view) nav.init_app(app) app.add_url_rule(app.static_url_path + '/<path:filename>', endpoint='static', view_func=app.send_static_file) @app.before_first_request def _init_auth(): oidc.set_auth() @app.before_request def before_req(): g.debug = _DEBUG g.db = app.db g.search = app.search g.user = get_user(app) if g.user is not None: team_id = g.user.get('team_id') secondary_team_id = g.user.get('secondary_team_id') # cache teams = [ team.id for team in g.db.get_entries('team') if team.name in ('OPS', 'QA', 'Dev') ] g.user_in_mozteam = (team_id in teams or secondary_team_id in teams or g.user.get('editor')) else: g.user_in_mozteam = False @app.after_request def after_req(response): response.headers["Cache-Control"] = "no-cache" response.headers["Pragma"] = "no-cache" return response @app.template_filter('humanize') def _humanize(last_modified): age = time.time() - (last_modified / 1000.) return humanize.naturaltime(age) @app.template_filter('translate') def translate_string(s): return APP_TRANSLATIONS.get(s, s) @app.template_filter('capitalize') def capitalize_string(s): return s[0].capitalize() + s[1:] @app.template_filter('completion') def completion(s): return testing_completion(s) @app.template_filter('fullname') def fullname(s): return _fullname(s) @app.template_filter('display_entry') def display_entry(entry, table): return _de(table, entry) @app.errorhandler(404) def _404(err): return render_template('_404.html'), 404 @app.errorhandler(500) def _500(error): if sentry_enabled: data = { 'event_id': g.sentry_event_id, 'public_dsn': sentry.client.get_public_dsn('https') } else: data = {} return render_template('_500.html', **data), 500 @app.route('/fonts/<path:filename>') def fonts(filename): return send_from_directory(_FONTS, filename) logging.config.fileConfig(ini_file) return app
password=app.config.get("PASSWORD")) #db.row_factory = sqlite3.Row return db app = Flask(__name__) app.register_blueprint(filters.blueprint) class EscapeHtml(Extension): def extendMarkdown(self, md, md_globals): del md.preprocessors['html_block'] del md.inlinePatterns['html'] md = Markdown(app, extensions=[EscapeHtml()]) # Load config app.config.from_pyfile('config.py') class ConfigProxy: def __init__(self, name): self.name = name @property def per_host(self): dict = app.config.get(self.name) if dict is None: return None return dict.get(request.host)
r'(?:www\.|[\-;:&=\+\$,\w]+@)[A-Za-z0-9\.\-]+)((?:/[\+~%/\.\w\-_]*)?\??' r'(?:[\-\+=&;%@\.\w_]*)#?(?:[\.!/\\\w]*))?)') class URLify(Preprocessor): def run(self, lines): return [urlfinder.sub(r'<\1>', line) for line in lines] class URLifyExtension(Extension): def extendMarkdown(self, md, md_globals): md.preprocessors.add('urlify', URLify(md), '_end') from flaskext.markdown import Markdown Markdown(app, safe_mode='escape', extensions=[URLifyExtension()]) # ======================================================== from . import views from . import database CACHE_SIZE = 5000 userIdCache = {} tlGroupIdCache = {} def format_js_date(din): return din.strftime("%Y/%m/%d %H:%M")
by_uid["sponsors"] = { sponsor["UID"]: sponsor for sponsors_at_level in site_data["sponsors"] for sponsor in sponsors_at_level["sponsors"] } print("Data Successfully Loaded") return extra_files # ------------- SERVER CODE --------------------> app = Flask(__name__) app.config.from_object(__name__) freezer = Freezer(app) markdown = Markdown(app) # MAIN PAGES def _data(): data = {"config": site_data["config"]} return data @app.route("/") def index(): return redirect("/index.html") # TOP LEVEL PAGES
def create_app(config_name): app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config.from_mapping(CLOUDINARY_URL=os.environ.get('CLOUDINARY_URL') or 'Pegue a sua Key', ) #Bootstrap(app) db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) Markdown(app) migrate = Migrate(app, db) #minify(app=app, html=True, js=True, cssless=True) #wtf_tinymce.init_app(app) login_manager.login_message = "Veuillez vous connecté" login_manager.login_view = "auth.login" login_manager.login_message_category = 'danger' #SimpleMDE(app) #md= Markdown(app, extensions=['fenced_code']) from app import models @app.errorhandler(403) def forbidden(error): rec = {'titre': 'Erreur 403', 'page': 'Forbidden'} return render_template('errors/403.html', title='Forbidden', rec=rec), 403 @app.errorhandler(404) def page_not_found(error): rec = {'titre': 'Erreur 404', 'page': 'Page non trouvée'} return render_template('errors/404.html', title='Page non trouvée', rec=rec), 404 @app.errorhandler(500) def internal_server_error(error): rec = {'titre': 'Erreur 505', 'page': 'Erreur serveur'} return render_template('errors/500.html', title='Erreur serveur'), 500 #Login from .authentification import auth as auth_blueprint app.register_blueprint(auth_blueprint) #Utilisateur from .user import user as user_blueprint app.register_blueprint(user_blueprint) #Main from .main import main as main_blueprint app.register_blueprint(main_blueprint) #Types des categorie from .types import types as types_blueprint app.register_blueprint(types_blueprint) #Categorie from .categorie import categorie as categorie_blueprint app.register_blueprint(categorie_blueprint) #Produit from .produit import produit as produit_blueprint app.register_blueprint(produit_blueprint) #Les internautes from .plateforme import plate as plate_blueprint app.register_blueprint(plate_blueprint) #Les trucking from .trucking import trucking as trucking_blueprint app.register_blueprint(trucking_blueprint) #Les commandes from .commande import commande as commande_blueprint app.register_blueprint(commande_blueprint) #Les commandes from .api import apis as api_blueprint app.register_blueprint(api_blueprint) return app
from ml_models import webapp_interface def create_app(): """ create app factory :return: """ _app = Flask(__name__) return _app APP = create_app() # bind flask-markdown extension to the app Markdown(APP) # load the markdown file content for /methodology route APP.config['md_content'] = Webapp.markdown_reader() # api base url setup APP.config['api_prefix'] = '/api/v1/prediction/' # setup Cache ext. APP.config['CACHE_TYPE'] = 'simple' # register the cache instance and bind it to the app APP.cache = Cache(APP) # language detection module allowed languages # Slovak, Slovenian, Croatian allowed because langdetect module, # when submitting Czech text without the diacritics detects one of these APP.config['acceptable_detected_language_codes'] = ['cs', 'sk', 'sl', 'hr']
from flask_wtf.csrf import CSRFProtect from model import * import config app = Flask(__name__) # csrf = CSRFProtect() # csrf.init_app(app) # DB 설정 app.config.from_object(config) db.init_app(app) migrate = Migrate(app,db) # markdown Markdown(app, extensions=['nl2br', 'fenced_code']) # filter from filter import format_datetime app.jinja_env.filters['datetime'] = format_datetime from views import main, review, comment, auth app.register_blueprint(main.bp) app.register_blueprint(review.bp) app.register_blueprint(comment.bp) app.register_blueprint(auth.bp)
app.config["CACHE_DEFAULT_TIMEOUT"] = 60 app.config["CACHE_KEY_PREFIX"] = "flask_caching_" app.config["S3_BUCKET"] = environ.get("S3_BUCKET_NAME", "i.ruqqus.com").lstrip().rstrip() app.config["REDIS_POOL_SIZE"] = int(environ.get("REDIS_POOL_SIZE", 10)) redispool = ConnectionPool(max_connections=app.config["REDIS_POOL_SIZE"], host=app.config["CACHE_REDIS_URL"][8:] ) if app.config["CACHE_TYPE"] == "redis" else None app.config["CACHE_OPTIONS"] = { 'connection_pool': redispool } if app.config["CACHE_TYPE"] == "redis" else {} Markdown(app) cache = Cache(app) Compress(app) class CorsMatch(str): def __eq__(self, other): if isinstance(other, str): if other in [ 'https://ruqqus.com', f'https://{app.config["SERVER_NAME"]}' ]: return True elif other.endswith(".ruqqus.com"): return True
class ReverseProxied(object): def __init__(self, app): self.app = app def __call__(self, environ, start_response): scheme = environ.get('HTTP_X_FORWARDED_PROTO') if scheme: environ['wsgi.url_scheme'] = scheme return self.app(environ, start_response) app = Flask(__name__) app.wsgi_app = ReverseProxied(app.wsgi_app) app.config.from_object(__name__) md = Markdown(app, extensions=['mdx_math', 'mdx_truly_sane_lists', 'extra'], output_format='html5') pages = FlatPages(app) freezer = Freezer(app) # app.jinja_env.lstrip_blocks = True # app.jinja_env.trim_blocks = True #Page definitions title = "Rafael Marinho" subtitle = md("Currently PhD at <a href=http://xlim.fr>XLIM</a> and Professor at <a href=http://ufpb.br>UFPB</a>.") icons = [ { 'href': 'http://twitter.com/rsmarinhoo',
#from flaskext.markdown import Markdown from flaskext.markdown import Markdown from mdx_github_gists import GitHubGistExtension from mdx_strike import StrikeExtension from mdx_quote import QuoteExtension from mdx_code_multiline import MultilineCodeExtension from werkzeug.contrib.atom import AtomFeed import post import user import pagination import settings from helper_functions import * app = Flask('FlaskBlog') md = Markdown(app) md.register_extension(GitHubGistExtension) md.register_extension(StrikeExtension) md.register_extension(QuoteExtension) md.register_extension(MultilineCodeExtension) app.config.from_object('config') @app.route('/', defaults={'page': 1}) @app.route('/page-<int:page>') def index(page): skip = (page - 1) * int(app.config['PER_PAGE']) posts = postClass.get_posts(int(app.config['PER_PAGE']), skip) count = postClass.get_total_count() pag = pagination.Pagination(page, app.config['PER_PAGE'], count) return render_template('index.html', posts=posts['data'], pagination=pag, meta_title=app.config['BLOG_TITLE'])
def create_app(configfile=None): app = Flask(__name__) app.config.from_object('web.config.Config') Markdown(app) # JSON app.json_encoder = CustomJSONEncoder app.json_decoder = CustomJSONDecoder # Typography Jinja2 Filter app.jinja_env.filters['typogrify'] = typogrify_filters.typogrify # Static Assets Config (Javascript and SCSS) env = assets.Environment(app) env.load_path = [ os.path.join(app.config['STATIC_PATH'], 'bower'), os.path.join(app.config['STATIC_PATH'], 'scss'), os.path.join(app.config['STATIC_PATH'], 'javascript') ] env.register('js_all', assets.Bundle('jquery/dist/jquery.min.js', 'leaflet/dist/leaflet.js', assets.Bundle('iconic.min.js'), assets.Bundle('app.js'), output='app.js')) sass = get_filter('scss') sass.load_paths = env.load_path env.register('css_all', assets.Bundle('app.scss', filters=(sass,), depends=(os.path.join(app.config['STATIC_PATH'], 'scss/**/*.scss')), output='app.css')) # i18n Config babel = Babel(app) @app.url_defaults def set_language_code(endpoint, values): if 'lang_code' in values or not g.get('lang_code', None): return if app.url_map.is_endpoint_expecting(endpoint, 'lang_code'): values['lang_code'] = g.lang_code @app.url_value_preprocessor def get_lang_code(endpoint, values): if values is not None: g.lang_code = values.pop('lang_code', None) @app.before_request def ensure_lang_support(): lang_code = g.get('lang_code', None) if lang_code and lang_code not in app.config['LANGUAGES'].keys(): return abort(404) @babel.localeselector def get_locale(): return g.get('lang_code', app.config['BABEL_DEFAULT_LOCALE']) @babel.timezoneselector def get_timezone(): return app.config['BABEL_DEFAULT_TIMEZONE'] @app.context_processor def utility_processor(): def get_talk(slug): return filters.get_talk(slug) return dict(get_talk=get_talk) # Register the Blueprints app.register_blueprint(view_pages, url_prefix='/<lang_code>') app.register_blueprint(view_schedule, url_prefix='/<lang_code>/schedule') # Register the filters app.jinja_env.filters['format_datetime'] = filters.format_datetime app.jinja_env.filters['format_date'] = filters.format_date app.jinja_env.filters['format_time'] = filters.format_time return app
import os from flask import Flask, render_template, abort, url_for, request, flash, session, redirect from flaskext.markdown import Markdown from mdx_github_gists import GitHubGistExtension from mdx_strike import StrikeExtension from mdx_quote import QuoteExtension from werkzeug.contrib.atom import AtomFeed import post import user import pagination import settings from helper_functions import * app = Flask(__name__) md = Markdown(app) md.register_extension(GitHubGistExtension) md.register_extension(StrikeExtension) md.register_extension(QuoteExtension) app.config.from_object('config') @app.route('/', defaults={'page': 1}) @app.route('/page-<int:page>') def index(page): skip = (page - 1) * int(app.config['PER_PAGE']) posts = postClass.get_posts(int(app.config['PER_PAGE']), skip) count = postClass.get_total_count() pag = pagination.Pagination(page, app.config['PER_PAGE'], count) return render_template('index.html', posts=posts['data'], pagination=pag, meta_title=app.config['BLOG_TITLE'])
from flask_flatpages import FlatPages from flask_frozen import Freezer from flaskext.markdown import Markdown # Configuration DEBUG = True FLATPAGES_AUTO_RELOAD = DEBUG FLATPAGES_EXTENSION = '.md' app = Flask(__name__) app.config.from_object(__name__) pages = FlatPages(app) freezer = Freezer(app) markdown_manager = Markdown( app, extensions=['fenced_code'], output_format='html5', ) posts = [page for page in list(pages) if not page.path.startswith('r/')] reviews = [page for page in list(pages) if page.path.startswith('r/')] review_tags = set([tag for page in list(reviews) for tag in page.meta['tags']]) # Functionalities # @app.context_processor # def clever_function(u): # return 'hello' # Routes @app.route('/')