def setUp(self):
app.config['TESTING'] = True
app.config['MONGOALCHEMY_DATABASE'] = 'testing'
app.config[
'MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://*****:*****@ds115931.mlab.com:15931/testing'
self.app = app.test_client()
db = MongoAlchemy(app)
def setUp(self):
self.db_name = 'Hydrob_DB'
self.app.config['MONGODBALCHEMY_DATABASE'] = self.db_name
self.app.config[
'MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://db:27017'
self.app.config['TESTING'] = True
db = MongoAlchemy(self.app)
self.db = db
def create_app():
# 创建flask应用
app = Flask(__name__)
# 初始化bootstrap
Bootstrap(app)
# 初始化mysql数据库连接
app.config['SQLALCHEMY_DATABASE_URI'] = mysql_db_url
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
mysql_db = SQLAlchemy(app)
# 初始化mongo数据库连接
app.config['MONGOALCHEMY_CONNECTION_STRING'] = mongo_db_url
app.config['MONGOALCHEMY_DATABASE'] = 'flask_blog'
mongo_db = MongoAlchemy(app)
return app
def initialize_database(self, app: Flask) -> Any:
db = None
if self.type is DatabaseType.SQL:
app.config['SQLALCHEMY_DATABASE_URI'] = self.url
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['pool_size'] = self.pool_size
db = SQLAlchemy(app)
setattr(self, 'Model', db.Model)
elif self.type is DatabaseType.MONGODB:
app.config['MONGOALCHEMY_DATABASE'] = self.url.split('/')[-1]
app.config['MONGOALCHEMY_CONNECTION_STRING'] = self.url
db = MongoAlchemy(app)
setattr(self, 'Model', db.Document)
setattr(self.Model, 'db', db)
setattr(self.Model, 'url', self.url)
setattr(self.Model, 'db_type', self.type)
return db
import os
print('----------------------------------------------')
print('API Service Hostname:',os.environ.get('DOCKER_MONGO_HOSTNAME'))
print('----------------------------------------------')
app = Flask(__name__)
app.config['MONGOALCHEMY_SERVER'] = os.environ.get('DOCKER_MONGO_HOSTNAME')
# app.config['MONGOALCHEMY_SERVER'] = "localhost"
app.config['MONGOALCHEMY_DATABASE'] = "mongodb"
api = Api(app)
db = MongoAlchemy(app)
# exit(111)
'''
Document Structure
'''
class Car (db.Document):
title = db.StringField()
drive_type = db.StringField()
transmission = db.StringField()
engine_size = db.FloatField(min_value=0)
year = db.IntField(min_value=0)
cylinders = db.IntField(min_value=0)
from flask import Flask, render_template, redirect, url_for, request, flash, session
from flask_mongoalchemy import MongoAlchemy
import datetime
import re
app = Flask(__name__)
#app.config["SQLALCHEMY_DATABASE_URI"]='sqlite:///User_Login.sqlite3'
app.config['MONGOALCHEMY_DATABASE'] = 'library'
app.config['SECRET_KEY'] = 'Je123'
db1 = MongoAlchemy(app)
class Book(db1.Document):
name = db1.StringField()
author = db1.StringField()
quantity = db1.IntField()
section = db1.StringField()
serialno = db1.ListField(db1.IntField(), db_field='Books')
issued_on = db1.DateTimeField()
to_be_returned = db1.DateTimeField()
issued_by = db1.StringField()
class User_Login(db1.Document):
name = db1.StringField()
username = db1.StringField()
password = db1.StringField()
number = db1.IntField()
email = db1.StringField()
books = db1.ListField(db1.IntField(), db_field='Books')
# /usr/bin/python
"""
Add docstring here
"""
import os
from flask import Flask
from flask_cors import CORS
from flask_mongoalchemy import MongoAlchemy
app = Flask('kate3')
CORS(app)
app.config['MONGOALCHEMY_CONNECTION_STRING'] = \
os.getenv('KATE3_MONGOALCHEMY_CONNECTION_STRING', '')
app.config['MONGOALCHEMY_SERVER'] = \
os.getenv('KATE3_MONGOALCHEMY_SERVER', '')
app.config['MONGOALCHEMY_PORT'] = \
os.getenv('KATE3_MONGOALCHEMY_PORT', 0)
app.config['MONGOALCHEMY_DATABASE'] = \
os.getenv('KATE3_MONGOALCHEMY_DATABASE', '')
persist_db = MongoAlchemy(app)
os.path.abspath("/home/shashi/Desktop/Anveshan_FYP/SE/Anveshan_Crawler"))
sys.path.append(
os.path.abspath("/home/shashi/Desktop/Anveshan_FYP/SE/Anveshan"))
from constants import MONGODB_LINK
app = Flask(__name__)
app.secret_key = "secret"
app.config["MONGOALCHEMY_DATABASE"] = "AnveshanUser"
app.config.update({
'SESSION_COOKIE_SECURE': True,
'REMEMBER_COOKIE_SECURE': True
})
#cors
cors = CORS(app, origin="*")
login_manager = LoginManager(app)
anveshan_user_db = MongoAlchemy(app)
#socketio
#socketio = SocketIO(app, cors_allowed_origins="*",)
socketio = SocketIO()
app.config['SESSION_TYPE'] = 'filesystem'
socketio.init_app(app, cors_allowed_origins="*", message_queue="redis://")
from routes import routes, socket_routes
if __name__ == "__main__":
socketio.run(app, host="0.0.0.0", port=5001)
#app.run()
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_mongoalchemy import MongoAlchemy
from flask_cqlalchemy import CQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_migrate import Migrate
app = Flask(__name__)
app.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245'
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:mysql@db-mysql:3306/rumi'
app.config['MONGOALCHEMY_DATABASE'] = 'rumi'
app.config['MONGOALCHEMY_SERVER'] = 'db-mongo'
app.config['MONGOALCHEMY_PORT'] = '27017'
app.config['MONGOALCHEMY_SAFE_SESSION'] = 'true'
app.config['CASSANDRA_HOSTS'] = ['db-cassandra']
app.config['CASSANDRA_KEYSPACE'] = "rumi"
db = SQLAlchemy(app)
db2 = MongoAlchemy(app)
db3 = CQLAlchemy(app)
migrate = Migrate(app, db)
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'
login_manager.login_message_category = 'info'
from rumi_jokes import routes
# 扩展放入这里 from flask_sqlalchemy import SQLAlchemy from flask_bootstrap import Bootstrap from flask_mongoalchemy import MongoAlchemy mongo = MongoAlchemy() bootstrap = Bootstrap() db = SQLAlchemy()
def connect_db(app):
# Init DB Mongo
db = MongoAlchemy(app)
return db
from flask import Flask
application = Flask(__name__)
application.config.from_object('config.default')
# create db connection
from flask_sqlalchemy import SQLAlchemy
from flask_mongoalchemy import MongoAlchemy
sql_db = SQLAlchemy(application)
nonsql_db = MongoAlchemy(application)
def __init_db():
from models.user_data_sql import __init_user_sql_db
__init_user_sql_db()
#!/usr/bin/env python
import os
from flask import Flask, jsonify, request
from flask_cors import CORS, cross_origin
from flask_mongoalchemy import MongoAlchemy
from flask_autodoc import Autodoc
from keanu.routes.login import login_api
from keanu.routes.items import item_api
flask_app = Flask(__name__)
flask_app.config['MONGOALCHEMY_CONNECTION_STRING'] = os.getenv(
'DBURI', 'mongodb://localhost/kanaoreeves')
flask_app.config['MONGOALCHEMY_DATABASE'] = 'kanaoreeves'
flask_db = MongoAlchemy(flask_app)
CORS(flask_app)
flask_app.register_blueprint(login_api)
flask_app.register_blueprint(item_api)
auto = Autodoc(flask_app)
@flask_app.route('/spec', methods=['GET'])
def spec():
"""
Spec for root endpoints
:return:
"""
return auto.html()
from datetime import timedelta
from logging.handlers import RotatingFileHandler
from flask import Flask, session
from flask_login import LoginManager
from flask_mongoalchemy import MongoAlchemy
from flask_pymongo import PyMongo
from flask_sqlalchemy import SQLAlchemy
from autobench.jinja.custom_filters import _split, _datetime_format
# setup autobench
myapp = Flask(__name__)
myapp.config.from_object('config')
# db = SQLAlchemy(myapp)
mongo_alchemy = MongoAlchemy(myapp)
print 'mongo_alchemy timezone:', mongo_alchemy.session.timezone
lm = LoginManager()
lm.init_app(myapp)
lm.login_view = '_login'
# setup logging
file_handler = RotatingFileHandler('autobench.log', 'a',
1 * 1024 * 1024, 10)
file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: '
'%(message)s [in %(pathname)s:'
'%(lineno)d]'))
myapp.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
myapp.logger.addHandler(file_handler)
import os
from flask import Flask
from flask_socketio import SocketIO
from assets import assets
from forms import ScheduleTestForm
from flask_mongoalchemy import MongoAlchemy
from config import config
basedir = os.path.dirname(os.path.abspath(__file__))
# Flask extensions
db = MongoAlchemy()
socketio = SocketIO()
# Import Socket.IO events so that they are registered with Flask-SocketIO
from . import events
# Import models so that they are registered with MongoAlchemy
from . import models
def create_app(config_name=None):
"""Entry point to flask-script"""
app = Flask(__name__)
app.clients = {}
if config_name is None:
config_name = os.environ['REGRUN_CONFIG']
app.config.from_object(config[config_name]())
from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
from flask_mongoalchemy import MongoAlchemy
from flask_moment import Moment
app = Flask(__name__)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@sql3.db4free.net/valdekdb'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['MONGOALCHEMY_DATABASE'] = 'usersdb'
app.config[
'MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://*****:*****@ds121673.mlab.com:21673/usersdb'
moment = Moment(app)
sqldb = SQLAlchemy(app)
nosqldb = MongoAlchemy(app)
from views import *
from controllers import *
from models import User
if __name__ == '__main__':
app.run(debug=True)
from flask_mongoalchemy import MongoAlchemy, BaseQuery
from flask import Flask
crawler = Flask(__name__)
crawler.secret_key = 'continents9794'
crawler.config['MONGOALCHEMY_DATABASE'] = 'website-scraper'
crawler.config[
'MONGOALCHEMY_CONNECTION_STRING'] = 'mongodb://*****:*****@ds023495.mlab.com:23495/website-scraper'
db = MongoAlchemy(crawler)
class db_query(BaseQuery):
def text_query(self, url):
return self.filter(self.type.sites == url).fields('text')
def images_query(self, url):
return self.filter(self.type.sites == url).fields('images')
def links_query(self, url):
return self.filter(self.type.sites == url).fields('links')
def indent_query(self, url):
return self.filter(self.type.sites == url).fields('indent')
class images_db(db.Document):
query_class = db_query
sites = db.StringField()
images = db.ListField(db.StringField())
# 导入 sqlAlchemy python orm 模块
from flask_sqlalchemy import SQLAlchemy
# 导入 sqlAlchemy mongo orm 模块
from flask_mongoalchemy import MongoAlchemy
# 导入 falsk_migrate
from flask_migrate import Migrate
# 导入flask restfull api
from flask_restful import Api
# 导入配置文件全局环境变量
from devops_blog.config import flask_env_config
import os
# 初始化mysql数据库连接
mysql_db = SQLAlchemy()
# 初始化mongo数据库连接
mongo_db = MongoAlchemy()
migrate = Migrate()
# 定义一个创建app应用并且初始化的方法
def create_app(flask_env='default'):
# 创建flask应用
app = Flask(__name__)
app.config.from_object(flask_env_config[flask_env])
# 初始化bootstrap
Bootstrap(app)
# 初始化mysql数据库连接
mysql_db.init_app(app)
# 初始化mongo数据库连接
mongo_db.init_app(app)
# 初始化mysql据库migrate
