class TestPyMongo(object):
def teardown(self):
self.db.connection.drop_database("testdb")
def test_app_immediately_bound(self):
app = create_app()
self.db = PyMongo(app, database="testdb")
assert repr(self.db) == "<PyMongo connection=mongodb://localhost:27017>"
def test_app_delayed_bound(self):
app = create_app()
self.db = PyMongo(database="testdb")
assert repr(self.db) == "<PyMongo connection=None>"
self.db.init_app(app)
assert repr(self.db) == "<PyMongo connection=mongodb://localhost:27017>"
def test_ensured_indices(self):
app = create_app()
self.db = PyMongo(database="testdb")
Item = initialize_item_model(self.db)
Entity = initialize_entity_model(self.db)
self.db.init_app(app)
assert 'title_1' in Item.query.index_information()
assert 'count_-1' in Item.query.index_information()
assert 'title_1' in Entity.query.index_information()
def test_ensured_indices(self):
app = create_app()
self.db = PyMongo(database="testdb")
Item = initialize_item_model(self.db)
Entity = initialize_entity_model(self.db)
self.db.init_app(app)
assert 'title_1' in Item.query.index_information()
assert 'count_-1' in Item.query.index_information()
assert 'title_1' in Entity.query.index_information()
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'
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
class Mongo(Storage):
def __init__(self, app):
self.app = app
self.mongo = PyMongo(self.app)
def create_user(self, username, hashed_password, admin, token):
try:
return self.mongo.db.users.insert(
{'_id': username, 'password': hashed_password, 'admin': admin, 'token': token},
safe=True)
except DuplicateKeyError:
raise UserExists
def find_user_by_token(self, token):
return self.mongo.db.users.find_one({'token': token})
def find_user_by_username(self, username):
return self.mongo.db.users.find_one({'_id': username})
def key(self, key, *args):
prefix = key
postfix = args[0]
if type(postfix) in set([tuple, list, set]):
return type(postfix)(["%s\0%s" % (prefix, p) for p in postfix])
return "%s\0%s" % (prefix, postfix)
def read_manifest(self, uuid, default=None):
return self.mongo.db.manifests.find_one({'uuid': uuid}) or default
def read_manifests(self):
return dict([(manifest['_id'], manifest) for manifest in self.mongo.db.manifests.find()])
def write_manifest(self, uuid, manifest):
return self.mongo.db.manifests.update({'_id': uuid}, manifest, upsert=True)
def write_runlist(self, runlist_name, runlist):
return self.mongo.db.manifests.update({'_id': runlist_name}, runlist, upsert=True)
def read_runlists(self):
return dict([(runlist['_id'], runlist) for runlist in self.mongo.db.runlists.find()])
def read_runlist(self, runlist_name, default=None):
return self.mongo.db.runlists.find_one({'_id': runlist_name}) or default
def read_profile(self, profile_name, default=None):
return self.mongo.db.profiles.find_one({'_id': profile_name}) or default
def read_profiles(self):
rv = {}
for profile in self.mongo.db.profiles.find():
_id = profile.pop('_id')
rv[_id] = profile
return rv
def write_profile(self, profile_name, profile):
profile['_id'] = profile_name
return self.mongo.db.profiles.update({'_id': profile_name}, profile, upsert=True)
def read_hosts(self):
hosts = {}
try:
for record in self.mongo.db.hosts.find():
hosts[record['alias']] = record['hosts']
except RuntimeError:
pass
return hosts
def add_host(self, alias, host):
record = self.mongo.db.hosts.find_one({'alias': alias})
if record is None:
return self.mongo.db.hosts.insert({'alias': alias, 'hosts': [host]})
if host in record['hosts']:
return
record['hosts'].append(host)
return self.mongo.db.hosts.insert(record)
def save_app(self, uuid, fileobj):
self.mongo.save_file(self.key("apps", uuid), fileobj)
def remove_app(self, uuid):
self.mongo.remove_file(self.key("apps", uuid))
self.mongo.db.manifests.remove({'uuid': uuid})
def clean_manifests(self):
pass
def test_app_immediately_bound(self):
app = create_app()
self.db = PyMongo(app, database="testdb")
assert repr(self.db) == "<PyMongo connection=mongodb://localhost:27017>"
from flask import Flask, request, jsonify
from flask.ext.pymongo import PyMongo, pymongo
from bson.json_util import dumps
app = Flask(__name__)
app.config['MONGO_DBNAME'] = 'rasberry'
app.config[
'MONGO_URI'] = 'mongodb://*****:*****@ds231987.mlab.com:31987/rasberry'
mongo = PyMongo(app)
@app.route('/framework')
def getting():
friend_interest = mongo.db.friends_interest
all_interest = friend_interest.find()
finalans = ''
for i in all_interest:
finalans += 'Name: ' + i['Name'] + ' Interest: ' + i[
'Interest'] + '<br>'
return finalans
@app.route('/framework/<name>')
def getting_one(name):
friend_interest = mongo.db.friends_interest
all_interest = friend_interest.find_one({'Name': name})
finalans = ''
if all_interest:
finalans += 'Name: ' + all_interest[
import bson
import requests
import collections
from ipwhois import IPWhois
import whois
import re
#################
# Configuration #
#################
app = Flask(__name__)
app.config['MONGO_HOST'] = 'localhost'
app.config['MONGO_PORT'] = 27017
app.config['MONGO_DBNAME'] = 'threatnote'
mongo = PyMongo(app, config_prefix='MONGO')
###################
# Creating routes #
###################
@app.route('/', methods=['GET'])
def home():
try:
network = mongo.db.network.find()
return render_template('home.html', network=network)
except Exception as e:
return render_template('error.html', error=e)
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 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_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
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
from flask import Flask from flask.ext.pymongo import PyMongo webclient = Flask(__name__) mongo = PyMongo(webclient) from webclient import views
from flask import Flask, request, redirect, url_for, make_response, abort
from werkzeug import secure_filename
from pymongo import Connection
from bson.objectid import ObjectId
from gridfs import GridFS
from gridfs.errors import NoFile
from flask.ext.pymongo import PyMongo
ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'])
DB = Connection().gridfs_server_test
FS = GridFS(DB)
app = Flask(__name__)
moiniigo = PyMongo(app)
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
oid = FS.put(file,
content_type=file.content_type,
filename=filename)
import pymongo.errors
from flask.ext.pymongo import PyMongo
OperationFailure = pymongo.errors.OperationFailure
mongodb = PyMongo()
class MongoTalk(object):
def __init__(self, result):
self._fields = result
def __getattr__(self, attr):
try:
return self._fields[attr]
except KeyError:
return None
def __setattr__(self, attr, value):
if attr in ['id', '_fields']:
object.__setattr__(self, attr, value)
else:
self._fields[attr] = value
def save(self):
self._fields['_id'] = self.collection.save(self._fields)
def delete(self):
self.collection.remove({'_id': self._fields.get('_id', None)})
self.id = None
#!/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 init(app):
with app.app_context():
mongo = PyMongo(app).db
global db
db = mongo
return db
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):
try:
self.driver = PyMongo(app, config_prefix='LEGAL_ARCHIVE')
except Exception as e:
raise ConnectionException(e)
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', {
#!/usr/bin/python # coding=utf-8 from flask.ext.pymongo import PyMongo mongo = PyMongo()
def get_mongo():
global mongo
if not mongo:
mongo = PyMongo(app)
return mongo
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)
# ..
def test_app_delayed_bound(self):
app = create_app()
self.db = PyMongo(database="testdb")
assert repr(self.db) == "<PyMongo connection=None>"
self.db.init_app(app)
assert repr(self.db) == "<PyMongo connection=mongodb://localhost:27017>"
#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:
# Wanna make sure test db is used if /test/ in url
try:
if '/test/' in request.url:
Config.TESTING = True
escfg = Config.ES_TEST
except:
pass
# ElasticSearch
es = ES(("http", escfg['host'], escfg['port']))
es.__dict__['index_name'] = escfg['name']
app.es = es
app.config.from_object(Config)
mongo = PyMongo()
app.mongo = mongo
mongo.init_app(app)
# add regex for routing
app.url_map.converters['regex'] = RegexConverter
##################### GET SEARCH
@app.route( '/es', methods=['GET'])
def es():
return generic.es()
##################### PUT
@app.route( '/<regex("[\w]*[Ss]"):class_name>', methods=['PUT','PATCH'])
@app.route( '/test/<regex("[\w]*[Ss]"):class_name>', methods=['PUT','PATCH'])
def put(class_name):
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
def __init__(self, app):
self.app = app
self.mongo = PyMongo(self.app)
app = Flask(__name__)
#Build the varibles 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 = 'hp' #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.route("/")
@app.route("/index")
def index():
title = {
"first": "Tutorial 01-Flask-Pymongo extension",
"second": "Tutorial 02"
}
users = mdb.db.users.find({})
conn = "Connected successfully"
return render_template("index.html", title=title, users=users, conn=conn)
@app.route("/record", methods=["GET", "POST"])
