def test_override_defaults(self, html):
ext, flags = 0, 0
md = Misaka(autolink=True)
result = md.render(TEST_MD, autolink=False)
html.assert_called_with(TEST_MD, extensions=ext, render_flags=flags)
self.assertIsInstance(result, Markup)
self.assertEqual(result, misaka.html(TEST_MD,
extensions=ext, render_flags=flags))
def test_set_defaults(self, html):
ext, flags = EXT_TABLES, HTML_SMARTYPANTS
md = Misaka(smartypants=True, tables=True)
result = md.render(TEST_MD)
html.assert_called_with(TEST_MD, extensions=ext, render_flags=flags)
self.assertIsInstance(result, Markup)
self.assertEqual(result, misaka.html(TEST_MD,
extensions=ext, render_flags=flags))
def init(app):
md = Misaka(autolink=True,
tables=True,
fenced_code=True,
no_intra_emphasis=True,
strikethrough=True,
escape=True,
wrap=True,
toc=True)
md.init_app(app)
app.secret_key = Config.secret_key
def create_app(config='dev'):
""" Flask application factory
:param str config: type of app to build, either "prod" or "dev"
"""
# Create flask application
app = Flask(__name__)
app.config.from_object('settings')
app.config['ENV'] = config
app.jinja_env.trim_blocks = True
# Debug toolbar (when debug=true)
debug_toolbar = DebugToolbarExtension(app)
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# Register Blueprints
app.register_blueprint(views_base.base)
app.register_blueprint(views_blog.blog)
# Flask-Assets; bundles all css/js files in minifed file
assets = Environment(app)
css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css',
filters='cssmin', output='gen/style.css')
js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js',
'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js')
assets.register('css_all', css_all)
assets.register('js_all', js_all)
if app.config['DEBUG']:
assets.debug = True
app.config['ASSETS_DEBUG'] = True
# Set up Flask-User
babel = Babel(app)
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app
# Init the cache
cache.init_app(app)
Moment(app) # moment.js
Misaka(app, autolink=True, # Misaka Markdown
fenced_code=True, lax_html=True, strikethrough=True,
superscript=True, tables=True, wrap=True)
# Init Admin page
admin = Admin(app, index_view=AdminMain(endpoint='admin'))
admin.add_view(PostAdminView())
admin.add_view(NewPostView())
admin.add_view(ModelView(Comment, db.session))
static_path = os.path.join(BASE_DIR, 'app', 'static')
admin.add_view(FileAdminView(static_path, '/static/', name='Static Files'))
# Initialize DB
db.init_app(app)
return app
def configure(app):
# Markdown(app)
Misaka(app,
fenced_code=True,
autolink=True,
no_intra_emphasis=True,
strikethrough=True,
superscript=True,
tables=True,
hard_wrap=True,
safelink=True)
CsrfProtect(app)
if app.config.get('GRAVATAR'):
from flask.ext.gravatar import Gravatar
Gravatar(app, **app.config.get('GRAVATAR'))
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
moment.init_app(app)
Misaka(app)
login_manager.init_app(app)
app.jinja_env.globals['momentjs'] = momentjs
from views.home import home as home_blueprint
app.register_blueprint(home_blueprint)
from views.post import post as post_blueprint
app.register_blueprint(post_blueprint)
from views.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
return app
def make_app(debug=False, **app_options):
global db, app, admin
app = Flask(__name__)
logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
logg.debug("creating flask app %s", __name__)
try:
import arguments.config
app.config.from_object(arguments.config)
except ImportError:
pass
if app_options:
app.config.update(app_options)
app.config["RESTFUL_JSON"] = {'ensure_ascii': False}
app.config["SECRET_KEY"] = "dev"
app.config["DEBUG"] = debug
logg.debug("app config is:\n%s", pformat(dict(app.config)))
if debug:
app.debug = True
from werkzeug.debug import DebuggedApplication
app.wsgi_app = DebuggedApplication(app.wsgi_app, True)
app.jinja_env.add_extension('arguments.helper.templating.PyJadeExtension')
# initialize extensions
# flask-sqlalchemy
db = SQLAlchemy(app)
import arguments.database.datamodel
# flask-admin
admin = Admin(app, name="Arguments", template_mode="bootstrap3")
# markdown via flask-misaka
# TODO: markdown options should be configurable
markdown_opts = dict(
autolink=True,
fenced_code=True,
no_intra_emphasis=True,
strikethrough=True,
tables=True,
safelink=True,
escape=True,
smartypants=True
)
Misaka(app, **markdown_opts)
# user management provided by flask_login
login_manager = LoginManager(app)
login_manager.login_view = 'ekklesia.login'
# XXX: for testing: just use first user from the DB as anon user
# login_manager.anonymous_user = lambda: User.query.first()
from arguments.database.datamodel import User
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
# i18n via flask-babelex
babel = Babel(app)
@babel.localeselector
def get_locale():
return session["locale"]
# OAuth2 using flask-dance
init_oauth_ext(app)
# ajax lib flask-sijax
path = os.path.join('.', os.path.dirname(__file__), 'static/js/sijax/')
app.config['SIJAX_STATIC_PATH'] = path
app.config['SIJAX_JSON_URI'] = '/static/js/sijax/json2.js'
flask_sijax.Sijax(app)
@app.before_request
def set_locale():
locale = session.get("locale")
if locale:
logg.debug("locale from session: %s", locale)
else:
locale = request.accept_languages.best_match(['de', 'en', 'fr'])
logg.debug("locale from request: %s", locale)
session["locale"] = locale
g.locale = locale
import arguments.views
import arguments.views.admin
# import arguments_rest.api
# needed when running behind a reverse proxy.
app.wsgi_app = ProxyFix(app.wsgi_app)
return app
''' Flask is instantiated here, as are the extensions we will be using
which include:
- Flask-Login
- Flask-Misaka
- Flask-Uploads
- Flask-Cache
'''
from flask import Flask
from flask.ext.cache import Cache
from flask.ext.uploads import UploadSet, IMAGES
from flask.ext.mongoengine import MongoEngine
from flask.ext.login import LoginManager
from flask.ext.misaka import Misaka
app = Flask(__name__)
db = MongoEngine()
app.config['MONGODB_DB'] = 'chris_blog'
app.config['MONGODB_HOST'] = 'localhost'
app.config['MONGODB_PORT'] = 27017
# extensions
login_manager = LoginManager()
md = Misaka(space_headers=True, no_intra_emphasis=True, fenced_code=True)
photos = UploadSet('photos', IMAGES)
cache = Cache()
from blog import views, forms
def test_init(self):
md = Misaka()
app2 = Flask(__name__)
md.init_app(app2)
self.assertIn("markdown", app2.jinja_env.filters)
from flask.ext.assets import Environment
from flask.ext.misaka import Misaka
from werkzeug.contrib.cache import SimpleCache
from bs4 import BeautifulSoup
import pygments, pygments.lexers, pygments.formatters
import misaka
app = Flask(__name__.split('.')[0])
app.config.from_object('config')
assets = Environment(app)
menu = Menu(app)
misaka_instance = Misaka(app)
cache = SimpleCache()
logger = logging.getLogger('app')
class MarkdownRenderer(misaka.HtmlRenderer):
def blockcode(self, text, lang):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % Markup.escape(text)
lexer = pygments.lexers.get_lexer_by_name(lang, stripall=True)
formatter = pygments.formatters.HtmlFormatter()
rendered = pygments.highlight(text, lexer, formatter)
return rendered
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('settings')
app.config.from_pyfile('settings.py')
# Setup debugtoolbar, if we're in debug mode.
if app.debug:
from flask.ext.debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
# Flask extensions
db = SQLAlchemy(app)
login_manager = LoginManager(app)
oid = OpenID(app)
workshopzips = UploadSet('workshopZips', 'zip')
modimages = UploadSet('modImages', IMAGES)
markdown = Misaka(app, escape=True, wrap=True)
sentry = Sentry(app)
# Setup steamodd
steam.api.key.set(app.config['STEAM_API_KEY'])
steam.api.socket_timeout.set(5)
# Setup Flask-Uploads
configure_uploads(app, [workshopzips, modimages])
# Views
import views
# Blueprints
from .tf2.views import tf2 as tf2_blueprint
from .users.views import users as users_blueprint
from functools import wraps
from flask import request, Response
from flask.ext.bcrypt import Bcrypt
from werkzeug.security import generate_password_hash, check_password_hash
from flask import session, redirect, url_for, escape, request
from werkzeug.utils import secure_filename
import os, json, re, random
app = Flask(__name__)
Misaka(app=app, escape = True,
no_images = True,
wrap = True,
autolink = True,
no_intra_emphasis = True,
space_headers = True,
fenced_code = True)
app.config.from_pyfile('config.py')
db = SQLAlchemy(app)
from config import *
from util import *
db.create_all()
db.session.commit()
@app.route('/')
from flask.ext.pagedown import PageDown
from config import config
from flask.ext.login import LoginManager
from flask.ext.misaka import Misaka
from flask.ext.cors import CORS
from admin import am
from .db import db
# for login
login_manager = LoginManager()
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
pagedown = PageDown()
md = Misaka()
cors = CORS()
def create_app(conf):
app = Flask(__name__)
app.config.from_object(conf)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
pagedown.init_app(app)
md.init_app(app)
cors.init_app(app)
login_manager.init_app(app)
#!/usr/bin/env python
import codecs
from flask import Flask
from flask import render_template
from flask.ext.misaka import Misaka
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.script import Server, Manager
from flask.ext.migrate import Migrate, MigrateCommand
md = Misaka()
app = Flask(__name__)
md.init_app(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///uwcalgo.db'
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('runserver', Server(debug=True))
class Solution(db.Model):
__tablename__ = 'solutions'
member_id = db.Column(db.Integer, db.ForeignKey('member.id'), primary_key=True)
problem_id = db.Column(db.Integer, db.ForeignKey('problem.id'), primary_key=True)
url = db.Column(db.String(200), nullable=True)
problem = db.relationship('Problem')
from flaskext.bcrypt import Bcrypt
bcrypt = Bcrypt()
# for the Gravatar service
from flaskext.gravatar import Gravatar
gravatar = Gravatar(size=35,
rating='g',
default='mm',
force_default=False,
force_lower=False)
from flask.ext.misaka import Misaka
md = Misaka(fenced_code=True,
superscript=True,
strikethrough=True,
hard_wrap=True,
autolink=True)
from flask.ext.cache import Cache
cache = Cache() # cache cache :)
def github_oauth(app):
from rauth.service import OAuth2Service
github = OAuth2Service(
name='github',
base_url='https://api.github.com/',
authorize_url='https://github.com/login/oauth/authorize',
access_token_url='https://github.com/login/oauth/access_token',
from flask import Flask
from flask.ext.misaka import Misaka
from flask.ext import login
from aggrerate.loginCode import flogin
app = Flask(__name__)
# The secret key is used when creating session cookies
app.secret_key = 'aggrerate_secret_key'
Misaka(app, smartypants=True)
login_manager = login.LoginManager()
login_manager.anonymous_user = flogin.getAnonymousUser
@login_manager.user_loader
def load_user(userid):
return flogin.User.get(userid)
login_manager.setup_app(app)
@app.context_processor
def utility_processor():
def current_user():
if login.current_user.is_authenticated():
return login.current_user
else:
return None
from data import *
from g import USER,_site_info,admin_url,static_url,admin_static
import json
from flask import Flask,render_template,session,request,session,\
url_for, redirect,Response,jsonify,g,Blueprint,flash,get_template_attribute,abort
from functools import wraps
from flask.ext.misaka import Misaka
from config import IMG_DET_SAVE
from werkzeug import secure_filename
from os import path
from admin import *
import itertools
dw = DataWrapper()
Misaka(app)
@app.before_request
def before_request():
g.user = USER
g.info = _site_info
g.admin_url = admin_url
g.static_url = static_url
g.admin_static = admin_static
@app.route('/')
@app.route('/page/<int:pid>')
def index(pid=1):
per_page = 2
p = dw.get_article_by_page(pid, per_page)
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.misaka import Misaka app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) misaka = Misaka(app) app.secret_key = '/xcbq^/x0c$/x9f/xd9/xe72/xb33uX/xfb/xd3x/x0f/xf3aH/xf9e/x06e' from app import views from app import models
import os
from flask import Flask, g, render_template
from flask.ext.misaka import Misaka
from lib import db, filters
from themes import themes
from flask.ext.cors import CORS
theme = os.environ.get('THEME', 'new')
blog = Flask(__name__,
static_folder=themes[theme]['static'],
template_folder=themes[theme]['templates'])
CORS(blog)
Misaka(blog, tables=True)
blog.config['FREEZER_RELATIVE_URLS'] = True
blog.config['MONGODB_DATABASE_URI'] = 'mongodb://localhost:27017'
blog.config['BASE_DIR'] = os.path.abspath(os.path.dirname(__file__))
blog.jinja_env.filters['human_readable_date'] = filters.human_readable_date
blog.jinja_env.filters['clean_date'] = filters.clean_date
blog.jinja_env.filters['urlencode'] = filters.urlencode
blog.jinja_env.filters['urldecode'] = filters.urldecode
blog.jinja_env.filters['md'] = filters.md
blog.secret_key = 'test'
@blog.errorhandler(404)
import os, time, random
from datetime import datetime
from threading import Thread
import eventlet
import bSerial
from settings import APP_ROOT
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
app.debug = True
app.config['DATA_FOLDER'] = 'data/'
#Markdown(app)
Misaka(app, fenced_code=True)
socketio = SocketIO(app)
#namespace = '/test'
namespace = ''
thread = None #second thread used by background_thread()
ser = None
#see: https://github.com/miguelgrinberg/Flask-SocketIO/issues/192
eventlet.monkey_patch()
#b = bSerial.bSerial(socketio)
def background_thread():
"""Example of how to send server generated events to clients."""
def init(app):
md = Misaka(autolink=True,tables=True,fenced_code=True,no_intra_emphasis=True,strikethrough=True,escape=True,wrap=True, toc=True)
md.init_app(app)
app.secret_key = Config.secret_key
from pybossa.util import Facebook facebook = Facebook() from pybossa.util import Twitter twitter = Twitter() from pybossa.util import Google google = Google() # Markdown support from flask.ext.misaka import Misaka misaka = Misaka() # Babel from flask.ext.babel import Babel babel = Babel() # Uploader uploader = None # Exporters json_exporter = None csv_exporter = None # CSRF protection from flask_wtf.csrf import CsrfProtect
sys.setdefaultencoding("utf-8")
# 导入扩展模块
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.misaka import Misaka
from flask.ext.mail import Mail
# 初始化blog应用，并从config中设定配置
blog = Flask(__name__)
blog.config.from_object('config')
# 初始化数据库
db = SQLAlchemy(blog)
# 设定登录管理
lm = LoginManager()
lm.setup_app(blog)
# 设定markdown
md = Misaka()
md.init_app(blog)
# 使用邮件服务器发送邮件
mail = Mail()
mail.init_app(blog)
# 导入模型Models和视图Views
from app import views, models
