def init_users_db(app):
app.config['MONGO1_HOST'] = 'ec2-54-167-222-78.compute-1.amazonaws.com'
app.config['MONGO1_PORT'] = 27017
app.config['MONGO1_DBNAME'] = 'users'
mongo = PyMongo(app, config_prefix='MONGO1')
return mongo
msg.html = render_template(template + '.html', **kwargs)
return mail.send(msg)
def permission_required(permission):
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if not current_user.can(permission):
abort(403)
return f(*args, **kwargs)
return decorated_function
return decorator
def admin_required(f):
return permission_required(models.Permission.ADMINISTER)(f)
configfile = 'config/config.cfg'
cfg = ConfigParser.ConfigParser()
cfg.read(configfile)
gpg = gnupg.GPG(homedir=cfg.get('GPG', 'directory'))
redis = redisdb.StrictRedis(host=cfg.get('REDIS', 'host'),
port=cfg.get('REDIS', 'port'),
db=cfg.get('REDIS', 'db'))
mongo = PyMongo()
mail = Mail()
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
fapp = Flask(__name__)
fapp.config.from_object('dbconfig')
celery = make_celery(fapp)
mongo = PyMongo(fapp)
class JobExecution(object):
_jobinfo = None
_job = None
_mongo = None
_log = []
def __init__(self, mongo, jobinfo):
self._mongo = mongo
self._jobinfo = jobinfo
job_class = get_jobclass_by_name(self._jobinfo["type"])
con = job_class.connector_type()
refresh_connector_config(self._mongo, con)
def init():
"""Init app environment
Set environment variable 'INI' to 'testing' or 'production' to start
the app in production or testing mode.
"""
ini = os.environ.get('INI')
if ini == 'production':
config_file = 'production.cfg'
formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
handler = logging.handlers.RotatingFileHandler('cwr.log',
maxBytes=1000000,
backupCount=2)
handler.setLevel(logging.INFO)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
elif ini == 'testing':
config_file = 'testing.cfg'
else:
raise ValueError("Error! environment variable 'INI' must be set to "
"'production' or 'testing'")
app.config.from_pyfile(config_file)
app = Flask('cwr')
init()
ds = PyMongo(app) # Data store
PAGE_LIMIT = 20
from flask.ext.pymongo import PyMongo
from flask import Flask, request, session, g, redirect, url_for, \
abort, render_template, flash
import json
# configuration
DEBUG = True
SECRET_KEY = 'development key'
USERNAME = '******'
PASSWORD = '******'
# create our little application :)
app = Flask(__name__)
app.config['MONGO_DBNAME'] = 'items'
mongo = PyMongo(app, config_prefix='MONGO')
app.config.from_object(__name__)
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
@app.before_request
def before_request():
pass
@app.route('/')
def show_entries():
a = mongo.db.tblist_items.distinct("id")
project = mongo.db.tblist_items.find()
return render_template('index.html', entries=project)
def create_app(cfg_file='prod-config.yaml', testing=False, debug=False):
usage = "usage: %prog"
description = "Anella app"
version = "%anella 0.1"
output.OUTPUT.info("Initialising...")
opt_parser = optparse.OptionParser(usage=usage,
version=version,
description=description)
opt_parser.add_option(
"-c",
"--cfg",
metavar="FILE",
action="store",
type="string",
help="specify the full path to an alternate config FILE",
dest="cfg_file",
default=cfg_file)
opt_parser.add_option("--debug",
action="store_true",
help="Debug mode",
dest="debug",
default=debug)
(options, args) = opt_parser.parse_args()
load_config(configfile=options.cfg_file, )
app = Flask('anella', static_url_path='', static_folder='public')
app.config['HOST'] = get_cfg('app__host')
app.config['PORT'] = get_cfg('app__port')
app.config['MONGODB_SETTINGS'] = {
'db': get_cfg('database__database_name'),
'host': get_cfg('database__host'),
'port': get_cfg('database__port'),
}
# PyMongo
app.config['MONGO_DBNAME'] = get_cfg('database__database_name')
app.config['MONGO_HOST'] = get_cfg('database__host')
app.config['MONGO_PORT'] = get_cfg('database__port')
# MongoEngine
app.config['MONGODB_DATABASE'] = get_cfg('database__database_name')
app.config['MONGODB_HOST'] = get_cfg('database__host')
app.config['MONGODB_PORT'] = get_cfg('database__port')
app.config['TESTING'] = True
app.config['SECRET_KEY'] = 'flask+mongoengine=<3'
app.config['SESSION_COOKIE_NAME'] = 'anella'
#app.config['MAX_CONTENT_LENGTH'] = 4096 * 1024 * 1024
if options.debug:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.debug = True
app.config['DEBUG_TB_PANELS'] = (
'flask.ext.debugtoolbar.panels.versions.VersionDebugPanel',
'flask.ext.debugtoolbar.panels.timer.TimerDebugPanel',
'flask.ext.debugtoolbar.panels.headers.HeaderDebugPanel',
'flask.ext.debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask.ext.debugtoolbar.panels.template.TemplateDebugPanel',
'flask.ext.debugtoolbar.panels.logger.LoggingPanel',
'flask.ext.mongoengine.panels.MongoDebugPanel')
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# app.config['RESTFUL_JSON']=dict(cls=MongoengineEncoder)
LOGGER.info(pformat(app.config))
mongo = PyMongo(app)
# db = MongoEngine(app)
# Is this necessary?
conn = connect(get_cfg('database__database_name'),
host=get_cfg('database__host'),
port=get_cfg('database__port'))
LOGGER.info(pformat(conn))
add_rules(app)
api = Api(app)
add_resources(api)
app.session_interface = MongoSessionInterface(
db=app.config['MONGO_DBNAME'],
host=app.config['MONGO_HOST'],
port=app.config['MONGO_PORT'])
# db = MongoEngine(app)
# set_db(db)
if testing:
app.config['TESTING'] = True
return app
#!/usr/bin/env python
from flask import Flask
from flask import request, Blueprint
from flask.ext.pymongo import PyMongo
from mdb import mongo_dbs, minicd_inner, minicd_dbname
from ubi_feeds import ubi_take, ubi_save
app = Flask(__name__)
app.config['MONGO_MINICD_DBNAME'] = minicd_dbname
mongo_dbs[minicd_inner] = PyMongo(app, config_prefix='MONGO_MINICD')
app.register_blueprint(ubi_take)
app.register_blueprint(ubi_save)
@app.errorhandler(404)
def page_not_found(error):
print(request.url)
print('\n')
print(request.get_data())
print('\n')
return 'page not found', 404
def run_flask(host, port):
app.run(host=host, port=port, debug=False)
def __init__(self, app):
self.mongo = PyMongo(app)
self.excluded_paths = config.excluded_paths
self.excluded_ips = config.excluded_ips
self.excluded_clients = config.excluded_clients
self.filter = {}
# Import flask and template operators
from flask import Flask, render_template
# Import SQLAlchemy
from flask.ext.pymongo import PyMongo
# Define the WSGI application object
app = Flask(__name__)
# Configurations
app.config.from_object('config')
# Define the database object which is imported
# by modules and controllers
db = PyMongo(app)
# Sample HTTP error handling
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
# Import a module / component using its blueprint handler variable (mod_auth)
from app.controllers import routes as routes
# Register blueprint(s)
app.register_blueprint(routes)
# app.register_blueprint(xyz_module)
# ..
from docker import Client
from subprocess import call
from bson.json_util import dumps
cli_doc = Client(base_url='unix://var/run/docker.sock')
cli = soundcloud_cli.Soundc()
app = Flask(__name__)
app.secret_key = '/x01/as/os/$#q\wert!/qx0' # Change this!
app.config['config_prefix'] = 'MONGO'
app.config['MONGO_HOST'] = 'songathon.xyz'
#users exitst now using users_test for testing
#drop all dbs
app.config['MONGO_DBNAME'] = 'users_test'
app.config['MONGO_PORT'] = 27017
mongo = PyMongo(app, config_prefix='MONGO')
app.config['config_prefix'] = 'MONGO2'
app.config['MONGO2_HOST'] = 'songathon.xyz'
app.config['MONGO2_DBNAME'] = 'ports'
app.config['MONGO2_PORT'] = 27017
mongo_port = PyMongo(app, config_prefix='MONGO2')
socketio = SocketIO(app, async_mode=async_mode)
thread = None
@socketio.on('my event', namespace='/test')
def test_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response', {
def get_mongo():
global mongo
if not mongo:
mongo = PyMongo(app)
return mongo
from flask import Flask, jsonify, abort, make_response, request, url_for, render_template, redirect
from flask.ext.pymongo import PyMongo
from api.signup import signup_api
from api.forms import LoginForm
app = Flask(__name__)
app.register_blueprint(signup_api)
#app.config.from_object('config')
mongo = PyMongo(app, config_prefix='Mongo')
@app.errorhandler(404)
def not_found(error):
return make_response(jsonify({'error':'Not found'}),404)
@app.route('/')
def hello():
return "Hello world!"
#@app.route('/home')
#def home():
# online_users = mongo.db.users.find({'online': True})
# return "Hello bye bye {}!".format(online_users)
@app.route('/login', methods=['GET','POST'])
def login():
form = LoginForm()
user = {'nickname':'mkmde'}
if form.validate_on_submit():
return redirect('/index')
return render_template('login.html',title='Sign IN', user=user, form=form)
def init_app(self, app):
# mongod must be running or this will raise an exception
try:
self.driver = PyMongo(app)
except Exception, e:
raise ConnectionException(e)
from flask.ext.mongoalchemy import MongoAlchemy
# Object creation
app = Flask(__name__)
app.config.from_object(__name__)
app.secret_key = '<some secret key>'
CORS(app)
app.config['MONGOALCHEMY_DATABASE'] = 'app'
app.config['MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://localhost:27017/'
connection = MongoClient("mongodb://localhost:27017/")
db = MongoAlchemy()
mongo = PyMongo(app) #必须配置参数MONGO_URI 否者会报错
# Initialize Database
def create_mongodatabase():
try:
dbnames = connection.database_names()
if 'app' not in dbnames:
db_api = connection.app.apirelease
db_api.insert({
"buildtime": "2017-01-01 10:00:00",
"links": "/api/v1/users",
"methods": "get, post, put, delete",
"version": "v1"
})
db_api.insert({
def __init__(self):
self.mongo = PyMongo(app)
#coding=utf-8
# Import flask and template operators
from flask import Flask, render_template
from flask.ext.pymongo import PyMongo
from flask.ext.login import LoginManager
from flask.ext.assets import Environment
from app.assets import common_js, common_css
from app.models import User
from bson.objectid import ObjectId
# Define the WSGI application object
app = Flask(__name__)
app.config['metrics_DBNAME'] = 'metrics'
mongo = PyMongo(app, config_prefix='metrics')
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth.login"
login_manager.login_message = "Por favor faça login para ver a página"
assets = Environment(app)
assets.register('js_all', common_js)
assets.register('css_all', common_css)
# Configurations
app.config.from_object('config')
@login_manager.user_loader
def load_user(userid):
user = mongo.db.users.find_one({"_id": ObjectId(userid)})
if user is None:
def __init__(self, app):
self.app = app
self.mongo = PyMongo(app)
from flask import Flask
from flask.ext.pymongo import PyMongo
app = Flask(__name__)
app.config.from_object('guacamole.config')
app.config.from_envvar('CONFIG', silent=True)
db_client = PyMongo(app)
from guacamole import routes
app = Flask(__name__)
#Build the variables that use the assigned environment variables
HOST = os.environ['OPENSHIFT_NOSQL_DB_HOST']
PORT = int(os.environ['OPENSHIFT_NOSQL_DB_PORT'])
DB_USER = os.environ['OPENSHIFT_NOSQL_DB_USERNAME']
DB_PWD = os.environ['OPENSHIFT_NOSQL_DB_PASSWORD']
DB_NAME = 'govdata' #data base name
app.config['MDB_HOST'] = HOST
app.config['MDB_PORT'] = PORT
app.config['MDB_USERNAME'] = DB_USER
app.config['MDB_PASSWORD'] = DB_PWD
app.config['MDB_DBNAME'] = DB_NAME
mdb = PyMongo(app, config_prefix='MDB') #Create instance of PyMongo object
@app.template_filter("frmdate")
def frmDate(s):
d = s.strftime("%m/%d/%Y")
return d
@app.route("/")
@app.route("/index")
def index():
title = "fatalQuery"
return render_template("index.html", title = title)
@app.route("/view", methods=["GET","POST"])
def view():
year = request.form['year']
#!/usr/bin/python
# -*- coding:utf-8 -*-
import re
from flask import Flask, Markup, escape
from flask.ext.pymongo import PyMongo
from jinja2.filters import evalcontextfilter
from app_middleware import HTTPMethodOverrideMiddleware
app = Flask(__name__)
app.config['MONGO_HISTORY_DBNAME'] = 'dbHistory'
app.config['MONGO_HISTORY_HOST'] = '127.0.0.1'
app.config['MONGO_HISTORY_PORT'] = 27017
mongo = PyMongo(app,config_prefix='MONGO_HISTORY')
#app.jinja_env.autoescape = False
_paragraph_re = re.compile(r'(?:\r\n|\r|\n){2,}')
def create_app():
from history import historyApp
app.register_blueprint(historyApp)
# method overwrite
app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)
return app
@app.template_filter()
@evalcontextfilter
def connect_db():
"""Connects to the specific database."""
mongo = PyMongo(app)
return mongo
def init(app):
with app.app_context():
mongo = PyMongo(app).db
global db
db = mongo
return db
# Tech stack modules
from flask import Flask
from flask import request
from flask import render_template
from flask.ext.pymongo import PyMongo
# Local SentenceCraft modules
from SentenceCraftApp.Word import Word
from SentenceCraftApp.WordCollection import WordCollection
from SentenceCraftApp.Sentence import Sentence
from SentenceCraftApp.SentenceCollection import SentenceCollection
from SentenceCraftApp import SentenceCraftConfig as config
APP = Flask("app")
MONGO = PyMongo(APP)
# Set up the dictionary of keys to lexeme collections
# This will be a map of UUID strings to 2-tuples. The first element will
# be the lexeme collection, the second will be the timestamp in seconds at
# which it was created.
# This is an example of a Singleton design pattern; each server instance will
# keep track of only one list of keys.
LC_MAP = {}
'''
API functions that are not special Flask functions (without an @ directive).
'''
def check_out():
'''
import os
from flask import Flask, request, jsonify
import flask_restful as restful
from flask.ext.pymongo import PyMongo
from flask import make_response, render_template
from bson.json_util import dumps
import json
import urllib
MONGO_URL = os.environ.get('MONGO_URL')
if not MONGO_URL:
MONGO_URL = "mongodb://*****:*****@1996") + "@ds061076.mlab.com:61076/feed-db"
app = Flask(__name__)
app.config['MONGO_URI'] = MONGO_URL
mongo = PyMongo(app, config_prefix="MONGO")
@app.route('/', methods=['GET'])
def form():
# database status
root = flask_rest_service.resources.Root()
root_test = flask_rest_service.resources.Root.get(root)
return render_template('form.html', db_status=root_test)
@app.route('/all', methods=['GET'])
def retrieve_all_meanings():
test = flask_rest_service.resources.ReadingList()
test_read = flask_rest_service.resources.ReadingList.get(test)
# test_read[0]['_id'] = 'null'
def setup_mongo_db(app):
app.mongo = PyMongo(app)
def init_app(self, app):
try:
self.driver = PyMongo(app, config_prefix='LEGAL_ARCHIVE')
except Exception as e:
raise ConnectionException(e)
from flask import Flask, make_response
from flask.ext import restful
from flask.ext.pymongo import PyMongo
import app.decisiontrees.resources as resources
from app import constants
application = Flask(__name__, static_folder=constants.STATIC_FOLDER)
application.config['MONGO_DBNAME'] = constants.DB_NAME
application.mongo = PyMongo(application)
api = restful.Api(application)
@application.route("/")
def index():
return make_response(open('static/index.html').read())
api.add_resource(resources.DecisionTreeTask,
'/api/decisiontrees/<string:task_id>')
api.add_resource(resources.DecisionTreeWeakLearner,
'/api/decisiontrees/<string:task_id>/trees/<int:tree_id>')
api.add_resource(resources.DecisionTreeTaskList, '/api/decisiontrees/')
MONGO_REPLICA_SET = config.get('MONGODB', 'replicaset')
GRIDFS_HOST = config.get('GRIDFS', 'host')
GRIDFS_PORT = config.getint('GRIDFS', 'port')
virtualrest.config['CONNECT'] = False
virtualrest.config['MONGO_HOST'] = MONGO_HOST
virtualrest.config['MONGO_PORT'] = MONGO_PORT
virtualrest.config['MONGO_DBNAME'] = MONGO_DBNAME
virtualrest.config['MONGO_USERNAME'] = MONGO_USER
virtualrest.config['MONGO_PASSWORD'] = MONGO_PASSWD
virtualrest.config['MONGO_REPLICA_SET'] = MONGO_REPLICA_SET
virtualrest.jinja_env.trim_blocks = True
virtualrest.jinja_env.lstrip_blocks = True
mongodb = PyMongo(virtualrest)
# Users rights
rights = ['all', 'main_config', 'translations', 'languages', 'objects']
# Code is Language Code - ISO 639-1 (EN, FR, ES, PT, etc)
# Locale is Counyry Code - ISO 3166-1 (US,CA, AR, etc)
# Code + Locale = en-us / en-ca / en-uk / pt-br / etc
Language_JSON = {"name": "", "code": "", "locale": "", "variant": ""}
Object_JSON = {"id": "", "views": 0, "votes": 0, "translations": []}
Translation_JSON = {
"isocode": "",
"START_TAB": {
"TAB_TITLE": "Tab Start",
"TITLE": "Tab Start Title",
from flask.ext.mongoalchemy import MongoAlchemy
# Object creation
app = Flask(__name__)
app.config.from_object(__name__)
app.secret_key = '<some secret key>'
CORS(app)
app.config['MONGOALCHEMY_DATABASE'] = 'app'
app.config['MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://localhost:27017/'
connection = MongoClient("mongodb://localhost:27017/")
db = MongoAlchemy()
mongo = PyMongo(app)
# Initialize Database
def create_mongodatabase():
try:
dbnames = connection.database_names()
if 'app' not in dbnames:
db_api = connection.app.apirelease
db_api.insert({
"buildtime": "2017-01-01 10:00:00",
"links": "/api/v1/users",
"methods": "get, post, put, delete",
"version": "v1"
})
db_api.insert({
def init_journeys_db(app):
app.config['MONGO2_HOST'] = 'ec2-54-167-222-78.compute-1.amazonaws.com'
app.config['MONGO2_PORT'] = 27017
app.config['MONGO2_DBNAME'] = 'journeys'
mongo = PyMongo(app, config_prefix='MONGO2')
return mongo
