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('/')
