def login(self):
self._model.set_username(self.usr.text())
self._model.set_password(self.pwd.text())
self.connect_to_Mongo()
print(self._model.get_username())
print(self.mg)
try:
mgd.get_db()
self.switch_window.emit()
except Exception as e:
if e.code == 18:
QtWidgets.QMessageBox.critical(self, 'Auth Error',
'Could not authorize')
mgd.disconnect()
def test_connection__should_pass_alias__if_provided(app, config_extension):
"""Make sure a simple connection pass ALIAS setting variable."""
db = MongoEngine()
app.config.update(config_extension)
# Verify no extension for Mongoengine yet created for app
assert app.extensions == {}
assert current_mongoengine_instance() is None
# Create db connection. Should return None.
assert db.init_app(app) is None
# Verify db added to Flask extensions.
assert current_mongoengine_instance() == db
# Verify db settings passed to pymongo driver.
# ALIAS is used to find correct connection.
# As we do not use default alias, default call to mongoengine.get_connection
# should raise.
with pytest.raises(ConnectionFailure):
mongoengine.get_connection()
connection = mongoengine.get_connection("simple_conn")
mongo_engine_db = mongoengine.get_db("simple_conn")
assert isinstance(mongo_engine_db, Database)
assert isinstance(connection, MongoClient)
assert mongo_engine_db.name == "flask_mongoengine_test_db"
assert connection.HOST == "localhost"
assert connection.PORT == 27017
def __put(f, name):
fs = GridFS(get_db())
# 计算文件属性
extension = os.path.splitext(name)[1].lower()
mimetype = filelib.mime(f)
sha1 = filelib.sha1(f)
md5 = filelib.md5(f)
arg = {'mimetype': mimetype, 'sha1': sha1, 'md5': md5}
exist_fs = fs.find_one(arg)
if exist_fs:
return FileMeta(file_id=exist_fs._id,
length=exist_fs.length,
extension=exist_fs.extension,
**arg)
newfile = fs.new_file(content_type=mimetype,
name=name,
extension=extension,
**arg)
newfile.write(f)
newfile.close()
return FileMeta(file_id=newfile._id,
length=newfile.length,
extension=newfile.extension,
**arg)
def connection(config):
try:
conn = mongoengine.get_connection()
except mongoengine.connection.MongoEngineConnectionError:
conn = mongoengine.connect(**config)
yield conn
conn_db = mongoengine.get_db()
conn.drop_database(conn_db.name)
def test_fs(self):
fs = GridFS(get_db(alias="recall-db-alias"))
# with open('xxx.jpg', 'rb') as fd:
# id = fs.put(fd)
# print(id)
b = fs.get(ObjectId("5f39fd75e9974144d72231eb"))
b2 = fs.find_one({"md5": "c3c1ae262ddd527f0465dfb77a546b73"})
print(1)
def init(config_file: Optional[str] = None) -> None:
"""Initialize shared resources"""
global config
try:
config = Configuration.create_from_config_file(config_file)
try:
connect(config.mongodb.pop("name", "sales"),
**config.mongodb,
tz_aware=True)
get_db().collection_names()
except PyMongoError as e:
logger.critical("Failed to connect to MongoDB: %s", str(e))
raise e
logger.info("MongoDB connected")
except Exception as e:
raise
def __init__(self):
# Instead of making another connection to Mongo, we use the one defined
# in `app.py` extension `MongoSingleton` by calling the `MongoEngine`
# get_db() which should get the current app context database.
self.db = get_db('default')
# We create an index to avoid duplicates
# TODO(ANDREW): Find the Master Error that occurred today.
self.db.alloys.create_index([('name', ASCENDING)], unique=True)
def test_indexes(batch_files: List[BatchFile]) -> None:
explain = get_db().command(
"aggregate",
BatchFile._meta["collection"],
pipeline=BatchFile._get_oldest_and_newest_indexes_pipeline(2),
explain=True,
)
assert (explain["stages"][0]["$cursor"]["queryPlanner"]["winningPlan"]
["inputStage"]["stage"] == "IXSCAN")
# sort should not be executed
assert len(explain["stages"]) == 3
def test_connection__should_accept_host_as_list(app):
"""Make sure MONGODB_HOST can be a list hosts."""
db = MongoEngine()
app.config["MONGODB_SETTINGS"] = {
"ALIAS": "host_list",
"HOST": ["localhost:27017"],
"DB": "flask_mongoengine_list_test_db",
}
db.init_app(app)
connection = mongoengine.get_connection("host_list")
mongo_engine_db = mongoengine.get_db("host_list")
assert isinstance(mongo_engine_db, Database)
assert isinstance(connection, MongoClient)
assert mongo_engine_db.name == "flask_mongoengine_list_test_db"
assert connection.HOST == "localhost"
assert connection.PORT == 27017
def test_ingnored_mongodb_prefix_config(app):
"""Config starting by MONGODB_ but not used by flask-mongoengine
should be ignored.
"""
db = MongoEngine()
app.config[
"MONGODB_HOST"
] = "mongodb://localhost:27017/flask_mongoengine_test_db_prod"
# Invalid host, should trigger exception if used
app.config["MONGODB_TEST_HOST"] = "dummy://localhost:27017/test"
db.init_app(app)
connection = mongoengine.get_connection()
mongo_engine_db = mongoengine.get_db()
assert isinstance(mongo_engine_db, Database)
assert isinstance(connection, MongoClient)
assert mongo_engine_db.name == "flask_mongoengine_test_db_prod"
assert connection.HOST == "localhost"
assert connection.PORT == 27017
def get2(f: FileStorage):
fs = GridFS(get_db())
# 计算文件属性
mimetype = filelib.mime(f.stream)
sha1 = filelib.sha1(f.stream)
md5 = filelib.md5(f.stream)
arg = {'mimetype': mimetype, 'sha1': sha1, 'md5': md5}
exist_fs = fs.find_one(arg)
if exist_fs:
return exist_fs._id, {
'mimetype': exist_fs.mimetype,
'sha1': exist_fs.sha1,
'md5': exist_fs.md5
}
newfile = fs.new_file(content_type=mimetype, **arg)
newfile.write(f.stream) # f.stream.read()
newfile.close()
return newfile._id, arg
def test_connection__should_use_defaults__if_no_settings_provided(app):
"""Make sure a simple connection to a standalone MongoDB works."""
db = MongoEngine()
# Verify no extension for Mongoengine yet created for app
assert app.extensions == {}
assert current_mongoengine_instance() is None
# Create db connection. Should return None.
assert db.init_app(app) is None
# Verify db added to Flask extensions.
assert current_mongoengine_instance() == db
# Verify db settings passed to pymongo driver.
# Default mongoengine db is 'default', default Flask-Mongoengine db is 'test'.
connection = mongoengine.get_connection()
mongo_engine_db = mongoengine.get_db()
assert isinstance(mongo_engine_db, Database)
assert isinstance(connection, MongoClient)
assert mongo_engine_db.name == "test"
assert connection.HOST == "localhost"
assert connection.PORT == 27017
def save_status_to_mongo(status_data=None):
try:
mongodb_host = config('MONGODB_HOST')
mongodb_database = config('MONGODB_DATABASE')
mongodb_port = config('MONGODB_PORT')
mongodb_username = config('MONGODB_USERNAME')
mongodb_password = config('MONGODB_PASSWORD')
mongodb_auth_database = config('MONGODB_AUTH_DATABASE')
except UndefinedValueError:
print('----> ', status_data)
return
disconnect()
connect(mongodb_database,
host=mongodb_host,
port=int(mongodb_port),
username=mongodb_username,
password=mongodb_password,
authentication_source=mongodb_auth_database)
db = get_db()
coll = db.get_collection('EnrollmentStatusHistory')
coll.insert_one(status_data)
def test_connection__should_parse_host_uri__if_host_formatted_as_uri(
app, config_extension
):
"""Make sure a simple connection pass ALIAS setting variable."""
db = MongoEngine()
app.config.update(config_extension)
# Verify no extension for Mongoengine yet created for app
assert app.extensions == {}
assert current_mongoengine_instance() is None
# Create db connection. Should return None.
assert db.init_app(app) is None
# Verify db added to Flask extensions.
assert current_mongoengine_instance() == db
connection = mongoengine.get_connection()
mongo_engine_db = mongoengine.get_db()
assert isinstance(mongo_engine_db, Database)
assert isinstance(connection, MongoClient)
assert mongo_engine_db.name == "flask_mongoengine_test_db"
assert connection.HOST == "localhost"
assert connection.PORT == 27017
from capture.camera import Camera
from database import mongo_setup
from capture import camera
from database.data import Data
import mongoengine
from matplotlib import pyplot as plt
from utilities.encoder import encode, decode
import globals
if __name__ == '__main__':
#init db
mongo_setup.global_init()
#Take a picture from the webcam
MyCamera = camera.Camera()
MyCamera.capture()
#store web camera pic in database encoded
NewData = Data()
NewData.image = encode(MyCamera.getFrame())
NewData.save()
#retrieve a img from the database, decode and display
db = mongoengine.get_db(alias=globals.DB.ALIAS)
plt.imshow(decode(Data.objects[0].image))
plt.show()
def get(id):
if isinstance(id, str):
id = ObjectId(id)
return GridFS(get_db()).get(id)
def cleanup_db(sanic: Sanic) -> None:
managers.exposure_mongo.drop_database(get_db().name)
def _get_database(self):
"""获取数据库"""
return mongoengine.get_db()
def database(connection):
return mongoengine.get_db()
def get_db_find():
unsafe_search = request.args['search']
json_search = json.loads(unsafe_search)
db = me.get_db()
return db.movie.find({'name': json_search})
async def cleanup(client: TestClient) -> None:
managers.analytics_mongo.drop_database(get_db().name)
await managers.analytics_redis.flushdb()
pass
obj["Código"] = obj["Código"].replace(" ", "")
if obj["HT/HP por Periodo"] == "72/20":
obj["HT/HP por Periodo"] = 72
if obj["HT por semana"] == "-" or obj[
"HP por semana"] == "-" or obj["HT/HP por semana"] == "-":
obj["HT por semana"] = -1
obj["HP por semana"] = -1
obj["HT/HP por semana"] = -1
mat = Materia(mat_id=obj["Código"],
asignatura=obj["Asignatura"],
hrs_periodo=obj["HT/HP por Periodo"],
hrs_teoria_sem=obj["HT por semana"],
hrs_pract_sem=obj["HP por semana"],
hrs_total_sem=obj["HT/HP por semana"],
creditos=obj["Creditos"],
requeridas=obj["Requisitos"].split(" y "))
#print("checking {}".format(obj["Código"]))
if not Materia.objects(mat_id=obj["Código"]):
mat.save()
print("saved {}".format(obj["Código"]))
elems.append(
SimpleMateria(mat_id=obj["Código"],
asignatura=obj["Asignatura"]))
nn = name.split("/")[2][5:-4]
print("Checked {}".format(nn))
if not Plan.objects(carrera=nn):
Plan(carrera=nn, materias=elems).save()
print(get_db().list_collection_names())
mongo_uri = (
f'mongodb://{_username}:{_password}@{_host}:{_port}'
f'/?authSource=admin'
)
client = connect(
db=_db_name,
host=mongo_uri,
alias='default',
authentication_mechanism='SCRAM-SHA-1'
)
else:
init_db(app)
client = get_connection('default')
# This will get the correct database.
db = get_db('default')
print(f'MongoDB Client: \n{client}\n', file=stderr)
print(f'MongoDB Database: \n{db}\n', file=stderr)
random.seed(100000)
np.random.seed(3000)
# loading global alloy's
print(
'Seeding global alloys to <{}> database:'.format(db.name), file=sys.stderr
)
with app.app_context():
json_data = global_alloy_data
from sim_api.schemas import AlloySchema
data = AlloySchema(many=True).load(json_data['alloys'])
async def cleanup_db(sanic: Sanic) -> None:
managers.exposure_mongo.drop_database(get_db().name)
await managers.otp_redis.flushdb()
await managers.analytics_redis.flushdb()
import dropbox
from flask import Flask
from config import Config
from saver_class import DropboxSaver, LocalSaver
from mongoengine import connect, get_db
app = Flask(__name__)
app.config.from_object(Config)
connect(app.config['DB_NAME'])
db = get_db()
dbx = dropbox.Dropbox(app.config['DROPBOX_API'])
# obj_saver = DropboxSaver(dbx)
obj_saver = LocalSaver()
from views import *
if __name__ == "__main__":
app.run()
def setUp(self):
assert isinstance(app, Flask)
self.app = app.test_client()
self.db = get_db()
def cleanup_db(sanic: Sanic) -> None:
managers.app_configuration_mongo.drop_database(get_db().name)
def teardown():
me = get_db()
db_name = "test"
for collection in me.client.get_database(
db_name).list_collection_names():
me.client.get_database(db_name).drop_collection(collection)
def on_startup():
connect(host=SETTINGS.MONGO_URI)
mongoengine.get_db()
logger.info("Startup flow successful")
def setUpClass(cls):
print("Setting up")
cls.connection = mongoengine.connect(db=DB_NAME, host=DB_HOST)
cls.db = mongoengine.get_db()
