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"])