app.config["MEMCACHED_PORT"])
],
key_prefix=app.config["MEMCACHED_KEY_PREFIX"])
elif app.config["CACHE_TYPE"].lower() == "simple":
from werkzeug.contrib.cache import SimpleCache
flask_cache = SimpleCache()
else:
from werkzeug.contrib.cache import NullCache
flask_cache = NullCache()
if app.config["PROXY_SETUP"]:
app.wsgi_app = ProxyFix(app.wsgi_app)
if app.config["OPENID_ENABLED"]:
from flask.ext.openid import OpenID
oid = OpenID(app, safe_roots=[])
from login import login
app.register_blueprint(login)
from dumpdirs import dumpdirs
app.register_blueprint(dumpdirs, url_prefix="/dumpdirs")
from reports import reports
app.register_blueprint(reports, url_prefix="/reports")
from problems import problems
app.register_blueprint(problems, url_prefix="/problems")
from stats import stats
app.register_blueprint(stats, url_prefix="/stats")
from summary import summary
app.register_blueprint(summary, url_prefix="/summary")
flask_framework = Flask(__name__)
flask_framework.config.from_object('config')
orm_db = SQLAlchemy(flask_framework)
resp = Response
login_manager = LoginManager()
login_manager.init_app(flask_framework)
login_manager.login_view = 'login'
login_manager.login_message = lazy_gettext(
'Please log in to access this page.')
# OpenID service
openID_service = OpenID(flask_framework, os.path.join(basedir, 'tmp'))
mail = Mail(flask_framework)
babel = Babel(flask_framework)
''' Flask - Principal '''
from flask.ext.principal import Principal, Permission, RoleNeed
# load the extension
principals = Principal(flask_framework)
# Create a permission with a single Need, in this case a RoleNeed.
comptroller_permission = Permission(RoleNeed('COMPT'))
administrator_permission = Permission(RoleNeed('ADMIN'))
''' Exexcution Profiles '''
if not flask_framework.debug and MAIL_SERVER != '':
import logging
from .decorators import login_required, guest_or_login_required, with_lock
from .decorators import global_lock
# Make flask use the old session foo from <=flask-0.9
from flask_oldsessions import OldSecureCookieSessionInterface
from flask.ext.autoindex import AutoIndex
from sage.env import SAGE_SRC, SAGE_DOC
SRC = os.path.join(SAGE_SRC, 'sage')
from flask.ext.openid import OpenID
from flask.ext.babel import Babel, gettext, ngettext, lazy_gettext, get_locale
from sagenb.misc.misc import SAGENB_ROOT, DATA, translations_path, N_, nN_, unicode_str
from json import dumps
from sagenb.notebook.cell import number_of_rows
from sagenb.notebook.template import (css_escape, clean_name,
prettify_time_ago, TEMPLATE_PATH)
oid = OpenID()
class SageNBFlask(Flask):
static_path = ''
def __init__(self, *args, **kwds):
self.startup_token = kwds.pop('startup_token', None)
Flask.__init__(self, *args, **kwds)
self.session_interface = OldSecureCookieSessionInterface()
self.config['SESSION_COOKIE_HTTPONLY'] = False
self.root_path = SAGENB_ROOT
self.add_static_path('/css', os.path.join(DATA, "sage", "css"))
OPENID_ENDPOINT = 'http://*****:*****@APP.route('/')
def home():
userdata = None
if 'loggedin' in flask.session:
userdata = flask.session['user']
return flask.render_template('index.html', userdata=userdata)
@APP.route('/logout')
def logout():
flask.session = {}
return flask.redirect('/')
meta_argument,
)
app = flask.Flask(__name__)
app.config.from_object('datagrepper.default_config')
app.config.from_envvar('DATAGREPPER_CONFIG')
# Set up session secret key
app.secret_key = app.config['SECRET_KEY']
# Set up datagrepper database
db = SQLAlchemy(app)
from datagrepper.models import Job, STRSTATUS
# Set up OpenID
oid = OpenID(app)
# Read in the datanommer DB URL from /etc/fedmsg.d/ (or a local fedmsg.d/)
fedmsg_config = fedmsg.config.load_config()
fedmsg.meta.make_processors(**fedmsg_config)
# Initialize a datanommer session.
dm.init(fedmsg_config['datanommer.sqlalchemy.url'])
# Initialize the cache.
cache = dogpile.cache.make_region().configure(
app.config.get('DATAGREPPER_CACHE_BACKEND', 'dogpile.cache.memory'),
**app.config.get('DATAGREPPER_CACHE_KWARGS', {}))
import datagrepper.widgets
import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID
from config import BASE_DIR, BASE_URL, URLS_PER_PAGE
from .base_62 import saturate, dehydrate
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
openid = OpenID(app, os.path.join(BASE_DIR, 'tmp'))
from app import views, models
from flask import Blueprint, render_template, abort, g, request, Response, jsonify
from jinja2 import TemplateNotFound
from flask.ext.openid import OpenID
from functools import wraps
import json
oid = OpenID('openid') #
class BackendBlueprint(Blueprint):
def client_required(self, f):
@wraps(f)
def decorated_function(*args, **kwargs):
print "Check if client"
if not g.backend_client:
print "No client!"
response = Response(json.dumps({
"error": {
"type":
"DGDB_API_Exception",
"message":
"The client was invalid. Contact your code monkey."
}
}),
mimetype="application/json",
status=404)
return response
return f(*args, **kwargs)
return decorated_function
# -*- coding: utf-8 -*-
import app as core
from flask import (
Blueprint, request, current_app, g, render_template,
redirect, flash, session, abort, url_for)
from provider import BitTrailsProvider
from models import AccessToken, User
from auth.signals import services_registered
from flask.ext.openid import OpenID
app = Blueprint('oauth_provider', __name__, template_folder='templates')
PROVIDER = BitTrailsProvider(current_app)
PROVIDER.init_blueprint(app)
oid = OpenID(current_app)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/callback')
def callback():
return str(request.__dict__)
@app.route('/login', methods=['GET', 'POST'])
@oid.loginhandler
def login():
"""Does the login via OpenID. Has to call into `oid.try_login`
to start the OpenID machinery.
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID
from config import basedir
app = Flask(__name__)
app.config.from_object("config")
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
# Flask-Login 需要知道哪个视图允许用户登录
lm.login_view = 'login'
# Flask-OpenID 扩展需要一个存储文件的临时文件夹的路径
oid = OpenID(app, os.path.join(basedir, "tmp"))
from app import views, models
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler("tmp/M-blog.log", "a", 1 * 1024 * 1024,
10)
file_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
app.logger.setLevel()
import docker
from flask import Flask, render_template, session, g, \
redirect, url_for, request
from flask.ext.bootstrap import Bootstrap
from werkzeug import secure_filename
import psutil
import tempfile
from dirlist_app import dirlist
from flask.ext.openid import OpenID
import sqlite3dbm
app = Flask(__name__)
app.secret_key = "arglebargle"
oid = OpenID(app, os.path.join(os.path.dirname(__file__), 'openid_store'))
UPLOAD_FOLDER = tempfile.mkdtemp()
MOUNTPOINT = '/blah'
ALLOWED_EXTENSIONS = set(['py'])
DATABASE = '/tmp/database.sqlite3'
app.config['BOOTSTRAP_USE_MINIFIED'] = True
app.config['BOOTSTRAP_USE_CDN'] = True
app.config['BOOTSTRAP_FONTAWESOME'] = True
app.config['SECRET_KEY'] = app.secret_key
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
CONTAINER_STORAGE = "/tmp/containers.json"
SERVICES_HOST = '127.0.0.1'
BASE_IMAGE = 'ytproject/yt-devel'
from flask.ext.openid import OpenID
import anitya.lib
import anitya.mail_logging
__version__ = '0.10.1'
# Create the application.
APP = flask.Flask(__name__)
APP.config.from_object('anitya.default_config')
if 'ANITYA_WEB_CONFIG' in os.environ: # pragma: no cover
APP.config.from_envvar('ANITYA_WEB_CONFIG')
# Set up OpenID
APP.oid = OpenID(APP)
# Set up the logging
logging_config = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'simple': {
'format': '[%(name)s %(levelname)s] %(message)s',
},
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'simple',
'stream': 'ext://sys.stdout',
async_mode = 'eventlet'
eventlet.monkey_patch()
except ImportError:
try:
from gevent import monkey
async_mode = 'gevent'
except ImportError:
async_mode = 'threading'
app = Flask(__name__)
app.config.from_object('settings')
socketio = SocketIO(app, async_mode=async_mode)
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, os.path.realpath('tmp'))
from app import views, models
# TODO(hop): need fix logging
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('tmp/sm.log', 'a', 1 * 1024 * 1024, 10)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.openid import OpenID
from flask.ext.login import LoginManager
scrim_app = Flask(__name__)
scrim_app.config.from_pyfile('../config.py')
lm = LoginManager()
db = SQLAlchemy(scrim_app)
oid = OpenID(scrim_app)
lm.init_app(scrim_app)
from scrim import views, models
from models import User, Team, Scrim
@scrim_app.context_processor
def utility_processor():
def convert_days(bit_string):
days_of_week = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
aval = [
day for day, bit in zip(days_of_week, bit_string) if bit == '1'
]
return aval
def get_time_zone_label(time_zone):
from consts import TIME_ZONES_DICT
for item in TIME_ZONES_DICT:
if item['time_zone'] == time_zone:
import ConfigParser, os
import boto.ec2
import boto.sdb
from werkzeug.debug import tbtools
import cluster_monitor
import argparse
import logging
import prices
from instance_types import cpus_per_instance
import batch_submit
import json
import base64
oid = OpenID(None, "/tmp/clusterui-openid")
terminal_manager = term.TerminalManager()
from werkzeug.local import LocalProxy
def _get_current_config():
return flask.current_app.config
config = LocalProxy(_get_current_config)
def convert_to_boolean(name, value):
value = value.lower()
if value == 'true':
return True
if value == 'false':
return False
# coding:utf-8
from flask import g, flash, session, Flask, redirect, url_for, render_template, request
from flask.ext.login import logout_user, login_user, LoginManager, current_user
from flask.ext.openid import OpenID
app = Flask(__name__)
#app.config.from_object('config')
lm = LoginManager()
lm.init_app(app)
oid = OpenID(app, './tmp')
import User
import os
import latex
from Forms import LoginForm
@app.route('/')
@app.route('/index')
def hello():
args = {}
args['location'] = 'home'
return render_template('index.html', args=args)
@app.route('/generate_md', methods=['GET', 'POST'])
def generate_md():
if request.method=='GET':
return "<center><h1>HELLO</h1></md>"
else:
script = '''<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML"></script>'''
return script + "<body>" + markdown.markdown(request.form['data']) + "</body>"
from flask import Flask, session, g, render_template
from flask.ext.openid import OpenID
app = Flask(__name__)
app.config.from_object('websiteconfig')
from flask_website.openid_auth import DatabaseOpenIDStore
oid = OpenID(app, store_factory=DatabaseOpenIDStore)
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
@app.before_request
def load_current_user():
g.user = User.query.filter_by(openid=session['openid']).first() \
if 'openid' in session else None
@app.teardown_request
def remove_db_session(exception):
db_session.remove()
app.add_url_rule('/docs/', endpoint='docs.index', build_only=True)
app.add_url_rule('/docs/<path:page>/', endpoint='docs.show', build_only=True)
app.add_url_rule('/docs/flask-docs.pdf', endpoint='docs.pdf', build_only=True)
app.add_url_rule('/docs/flask-docs.zip', endpoint='docs.zip', build_only=True)
from flask import Flask, render_template, request, g, session, flash, \
redirect, url_for, abort
from flask.ext.openid import OpenID
import ujson as json
from openid.extensions import pape
import JumpScale.baselib.hrd
# setup flask
app = Flask(__name__)
app.config['SECRET_KEY'] = 'sdsdsd'
# setup flask-openid
oid = OpenID(app, safe_roots=[], extension_responses=[pape.Response])
userhrdtemplate = """
login=
email=
name=
alias=,
company=,
skype=,
mobile=,
jabber=,
openid=,
"""
grouphrdtemplate = """
members=,
import anitya.forms
import anitya.lib
import anitya.lib.plugins
import anitya.mail_logging
__version__ = '0.8.0'
# Create the application.
APP = flask.Flask(__name__)
APP.config.from_object('anitya.default_config')
if 'ANITYA_WEB_CONFIG' in os.environ: # pragma: no cover
APP.config.from_envvar('ANITYA_WEB_CONFIG')
# Set up OpenID
OID = OpenID(APP)
# Set up the logging
if not APP.debug:
APP.logger.addHandler(
anitya.mail_logging.get_mail_handler(
smtp_server=APP.config.get('SMTP_SERVER', '127.0.0.1'),
mail_admin=APP.config.get('MAIL_ADMIN',
'*****@*****.**')))
# Log to stderr as well
STDERR_LOG = logging.StreamHandler(sys.stderr)
STDERR_LOG.setLevel(logging.INFO)
APP.logger.addHandler(STDERR_LOG)
ANITYALOG = logging.getLogger('anitya')
ANITYALOG.addHandler(STDERR_LOG)
import time
from flask import (g, flash, redirect, render_template, request, Response,
session, url_for)
from flask.ext.openid import OpenID
from cya_server import app, settings
from cya_server.models import (client_version, container_requests, hosts,
shared_storage, users)
oid = OpenID(app, settings.OPENID_STORE, safe_roots=[])
@app.before_request
def lookup_current_user():
g.user = None
if 'openid' in session:
openid = session['openid']
g.user = users.get_user_by_openid(openid)
@app.route('/login', methods=['GET', 'POST'])
@oid.loginhandler
def login():
if g.user is not None:
return redirect(oid.get_next_url())
if request.method == 'POST':
openid = request.form.get('openid')
if openid:
return oid.try_login(openid, ask_for=['email', 'nickname'])
return render_template('login.html',
import datanommer.models
# Create the application.
app = flask.Flask(__name__)
log = app.logger
app.url_map.converters['not_reserved'] = fmn.web.converters.NotReserved
# set up FAS
app.config.from_object('fmn.web.default_config')
if 'FMN_WEB_CONFIG' in os.environ: # pragma: no cover
app.config.from_envvar('FMN_WEB_CONFIG')
# Set up OpenID in stateless mode
oid = OpenID(app,
safe_roots=[],
store_factory=lambda: None,
url_root_as_trust_root=True)
# Inject a simple jinja2 test -- it is surprising jinja2 does not have this.
app.jinja_env.tests['equalto'] = lambda x, y: x == y
# Also, allow 'continue' and 'break' statements in jinja loops
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
fedmsg_config = fedmsg.config.load_config()
db_url = fedmsg_config.get('fmn.sqlalchemy.uri')
if not db_url:
raise ValueError("fmn.sqlalchemy.uri must be present")
fedmsg.meta.make_processors(**fedmsg_config)
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.openid import OpenID
from flask_mail import Mail
app = Flask(__name__)
app.config.from_envvar('CONFIG')
oid = OpenID(app, '/tmp')
db = SQLAlchemy(app)
mail = Mail(app)
import views
from flask.ext.restful import Api from flask.ext.celery import Celery from flask.ext.debugtoolbar import DebugToolbarExtension from flask.ext.cache import Cache from flask_assets import Environment, Bundle from flask.ext.admin import Admin from flask_mail import Mail from flask_youku import Youku from flask_gzip import GZip # Create the Flask-Bcrypt's instance bcrypt = Bcrypt() # Create the Flask-OpenID's instance openid = OpenID() # Create the Flask-Principal's instance principals = Principal() # Create the Flask-Restful's instance restful_api = Api() # Create the Flask-Celery-Helper's instance flask_celery = Celery() # Create the Flask-DebugToolbar's instance debug_toolbar = DebugToolbarExtension() # Create the Flask-Cache's instance cache = Cache()
# -*- coding: utf8 -*-
from functools import wraps
from flask import Flask, Blueprint, Markup, session, g, flash, redirect, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.openid import OpenID
from flask.ext.misaka import markdown
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
oid = OpenID(app, '/var/tmp')
app.jinja_env.filters['markdown'] = markdown
app.jinja_env.filters['markup'] = Markup
@app.before_request
def lookup_current_user():
g.user = None
if 'user_id' in session:
user_id = session['user_id']
g.user = User.query.get(user_id)
if not g.user:
session.clear('user_id')
def login_required(func):
@wraps(func)
def wrapper(*args, **kwargs):
if not g.user:
flash('You must login to visit this page!')
from flask.ext.babel import lazy_gettext
from flask.ext.login import LoginManager, current_user
from flask.ext.openid import OpenID
from werkzeug.routing import RequestRedirect
chat = Blueprint('chat', __name__)
db = SQLAlchemy()
# define Login manager
lm = LoginManager()
lm.login_view = 'login'
lm.login_message = lazy_gettext('Please log in to access this page.')
# add OpenID login
oid = OpenID(fs_store_path=os.path.join(basedir, 'tmp'))
class CustomAdminIndexView(MyAdminIndexView):
@expose('/')
def index(self):
if current_user.is_authenticated():
if not current_user.is_admin():
return redirect(url_for('chat.login'))
else:
return redirect(url_for('chat.login'))
return super(CustomAdminIndexView, self).index()
def is_accessible(self):
if current_user.is_authenticated():
return current_user.is_admin()
import flask
from flask.ext.openid import OpenID
from flask.ext.pymongo import PyMongo
import wtforms as wtf
import logging
import uuid
import os
app = flask.Flask(__name__)
app.config.from_pyfile('config.py')
# Set up session secret key
app.secret_key = app.config['SESSION_SECRET_KEY']
# Set up OpenID
oid = OpenID(app, app.config['OPENID_STORE'])
# Set up MongoDB
mongo = PyMongo(app)
# Set up logging
if not app.debug:
file_handler = logging.FileHandler(app.config['LOGFILE'])
file_handler.setLevel(logging.DEBUG)
app.logger.addHandler(file_handler)
def generate_uuid():
while True:
the_uuid = str(uuid.uuid4())
if not mongo.db.registrations.find_one({'_id': the_uuid}):
import wtforms as wtf
import logging
import uuid
import os
app = flask.Flask(__name__)
app.config.from_pyfile('config.py')
# Set up babel for translations
babel = Babel(app)
# Set up session secret key
app.secret_key = app.config['SESSION_SECRET_KEY']
# Set up OpenID
oid = OpenID(app, fs_store_path=app.config['OPENID_STORE'], safe_roots=[])
# Set up MongoDB
mongo = PyMongo(app)
# Set up logging
if not app.debug:
file_handler = logging.FileHandler(app.config['LOGFILE'])
file_handler.setLevel(logging.DEBUG)
app.logger.addHandler(file_handler)
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(LANGUAGES.keys())
instance_relative_config=True,
instance_path=os.environ['WANDER_PATH'])
app.config.from_object('wander.app.defaultconfig')
app.config.from_pyfile('config.py', silent=True)
app.config.from_pyfile('config.cfg', silent=True)
app.config.from_envvar('WANDER_CONFIG', silent=True)
app.logger.addHandler(handler)
Bootstrap(app)
admin = Admin(app, name="Wander Admin")
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, os.path.join(app.config['TMP_DIR'], 'tmp'))
def start_jobs():
import wander.worker
wander.worker.start()
def init_db():
import first_time
if os.environ.has_key('WANDER_WIPE'):
first_time.purge()
try:
first_time.create()
except DatabaseAlreadyControlledError:
pass
from flask.ext.admin import Admin
from flask.ext.httpauth import HTTPBasicAuth
from flask_debugtoolbar import DebugToolbarExtension
auth = HTTPBasicAuth()
app = Flask(__name__)
# set a 'SECRET_KEY' to enable the Flask session cookies
app.config['SECRET_KEY'] = 'sdsdsd'
from flask.ext.openid import OpenID
j.system.fs.createDir("/var/flash/openid")
oid = OpenID(app, '/var/flash/openid', safe_roots=[])
admin = Admin(app)
users = {"admin": "admin"}
@app.before_request
def lookup_current_user():
g.user = None
if 'openid' in session:
openid = session['openid']
g.user = User.query.filter_by(openid=openid).first()
@app.route('/login', methods=['GET', 'POST'])
from config import basedir, ADMINS, MAIL_SERVER, MAIL_PORT, MAIL_USERNAME, MAIL_PASSWORD
from momentjs import momentjs
from error_log_email import TlsSMTPHandler
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
# set up time formatting
app.jinja_env.globals['momentjs'] = momentjs
# set up log in system
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
oid = OpenID(app, os.path.join(basedir, 'tmp'))
# set up email capabilities
mail = Mail(app)
# set up logging
if not app.debug and MAIL_SERVER != '':
import logging
from logging.handlers import SMTPHandler
credentials = None
if MAIL_USERNAME or MAIL_PASSWORD:
credentials = (MAIL_USERNAME, MAIL_PASSWORD)
mail_handler = TlsSMTPHandler((MAIL_SERVER, 587),
'*****@*****.**', ADMINS,
'MissionConnect Error!', credentials)
mail_handler.setLevel(logging.ERROR)
#encoding=utf-8
#! ./env/bin/python
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
# login
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID
from config import basedir
app = Flask(__name__)
app.config.from_object('config')
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
# basedir 在哪里？
oid = OpenID(app, os.path.join(basedir, 'tmp'))
db = SQLAlchemy(app)
# app/views.py
from app import views, models
