在烧瓶和其他应用程序之间共享 sqlalchemy 模型

Posted 2023-02-23

【中文标题】在烧瓶和其他应用程序之间共享 sqlalchemy 模型

【英文标题】：Share sqlalchemy models between flask and other apps

【发布时间】：2016-01-12 14:30:02

【问题描述】：

我有一个正在运行的 Flask 应用程序，它是根据我们在网上和 Miguel Grinberg 的“Flask Web 开发”一书中找到的最佳实践组合设置的。

我们现在需要第二个 Python 应用程序，它不是 Web 应用程序，它需要访问与 Flask 应用程序相同的模型。我们当然想重用相同的模型，这样两个应用程序都可以从共享代码中受益。

我们已经删除了对 flask-sqlalchemy 扩展的依赖（我们之前使用过，当我们只有 Flask 应用程序时）。并换成了SQLalchemy Declarative extension described here，简单一点（Flask-SQLalchemy adds a few specific things to standard SQLAlchemy）

根据示例，我们在根目录中创建了一个 database.py 文件。在我们的例子中，与声明式扩展示例有两点不同：我将引擎和会话放在一个类中，因为我们所有的模型都使用 db.session，而不是 db_session，并且我将带有配置值的字典传递给 init()，这样我就可以使用不同的配置从 Flask 和另一个应用程序中重用这个 database.py。它看起来像这样：

from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base


class Database(object):

    def __init__(self, cfg):
        self.engine = create_engine(cfg['SQLALCHEMY_DATABASE_URI'], convert_unicode=True)
        self.session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=self.engine))

    class Model(object):
        pass

Base = declarative_base()

所以现在我们来解决实际问题。 Flask 创建一个包含配置选项的类字典对象，并将它们作为属性添加到应用程序实例中。它从站点根目录中的instance folder、config.py 和环境变量加载它们。我需要从 Flask 传递配置字典，所以我需要 Flask 来首先加载和组装配置，然后初始化数据库，并在应用程序文件的根目录中有一个（配置的）db 对象。但是，我们遵循Application factory pattern，因此我们可以针对不同的情况（测试、生产、开发）使用不同的配置。

这意味着我们的app/__init__.py 看起来像这样（简化）：

from flask import Flask
from database import Database
from flask.ext.mail import Mail
from flask_bcrypt import Bcrypt
from config import config

mail = Mail()
bcrypt = Bcrypt()


def create_app(config_name):

    app = Flask(__name__, instance_relative_config=True)

    if not config_name:
        config_name = 'default'
    app.config.from_object(config[config_name])
    app.config.from_pyfile('config.py')
    config[config_name].init_app(app)

    db = Database(app.config)

    mail.init_app(app)
    bcrypt.init_app(app)

    @app.teardown_appcontext
    def shutdown_session(exception=None):
        db.session.remove()

    from main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    return app

但是 db（模型从 .. 导入）现在需要在 create_app() 函数中，因为这是 Flask 加载配置的地方。如果我要在 create_app() 函数之外实例化 db 对象，它将可以从模型中导入，但未配置！

示例模型如下所示，如您所见，它需要应用根目录中的“db”：

from . base_models import areas
from sqlalchemy.orm import relationship, backref
from ..utils.helper_functions import newid
from .. import db


class Areas(db.Model, areas):
    """Area model class.
    """
    country = relationship("Countries", backref=backref('areas'))

    def __init__(self, *args, **kwargs):
        self.area_id = newid()
        super(Areas, self).__init__(*args, **kwargs)

    def __str__(self):
        return u"".format(self.area_name).encode('utf8')

    def __repr__(self):
        return u"<Area: ''>".format(self.area_name).encode('utf8')

所以我的问题是，我怎样才能拥有一个可以在外部配置的数据库实例（通过 Flask 或其他应用程序），并且仍然使用应用程序工厂模式？

编辑： 代码示例不正确，它有一个 Flask-SQLalchemy 的导入，被 from database import Database 替换。如有任何混淆，请见谅。

【参考方案1】：

Flask-SQLAlchemy 扩展，像大多数 Flask 扩展一样，应该在工厂之外创建，然后在工厂中使用init_app 进行初始化。这样您就可以在创建应用之前使用db 对象。

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    db.init_app(app)
    return app

您的 Flask 应用程序与任何设计合理的 Python 项目一样，应该是一个可安装的包。这很简单：确保您的项目布局合理，然后添加一个基本的setup.py 文件。

project/
    my_flask_package/
        __init__.py  # at the most basic, this contains create_app and db
    setup.py

from setuptools import setup, find_packages

setup(
    name='my_flask_package',
    version='1.0',
    packages=find_packages(),
    install_requires=['flask', 'flask-sqlalchemy'],
)

$ python setup.py sdist

现在您可以安装 Flask 应用程序及其数据库，以便在其他项目中使用。在您的第二个项目的 virtualenv 中安装并导入它，然后创建并推送一个应用程序以对其进行初始化。

$ pip install my_flask_package-1.0.tar.gz

from my_flask_package import db, create_app
create_app().app_context().push()
db.session.query(...)

如果您担心创建应用程序所涉及的开销，您可以向create_app 函数添加参数来控制初始化的内容。不过，在大多数情况下，这应该不是问题。

【参考方案2】：

我遇到了同样的问题。

如果您打开“SQLALCHEMY_ECHO”，您可能会看到新事务已启动，但缺少相应的 COMMIT/ROLLBACK。

就我的发现而言，它与您也创建的两个 SQLAlchemy 实例有关，一次在您的模型文件中，一次在您的 web.py 中。很可能是因为您与 web.py 的会话进行交互，并且如果您查询模型，则会发生一些上下文切换，这将接收 COMMIT。

我通过从模型中导入“db”解决了这个问题，然后通过调用 db.init_app(app) 来初始化它。根据日志，现在提交工作正常。

@app.teardown_appcontext 不是必需的，因为它是在 Flask-SQLAlchemy 的 SQLAlchemy 类 (https://github.com/mitsuhiko/flask-sqlalchemy/blob/master/flask_sqlalchemy/init.py) 中设置的

【参考方案3】：

您可以轻松分享。我将展示如何。考虑到这个 Flask 应用程序：

.
├── config.py
├── db
│   └── test.db
├── do_somenthing2.py ============> Here is run some script 2
├── do_something.py   ============> Here is run some script
├── machinelearning
│   ├── models
│   │   ├── restore.py
│   │   ├── train.py
│   │   └── utils.py
│   └── save
│       └── test.ckpt
├── runserver.py ============> Here is run your app
├── test.py
└── web
    ├── __init__.py
    ├── api
    │   ├── __init__.py
    │   ├── app.py  ============> Here is app = Flask(__name__)
    │   ├── client.py
    │   ├── models.py ==========> Here is db = SQLAlchemy(app)
    │   ├── sample.json
    │   └── utils.py
    └── frontend
        ├── __init__.py
        └── routes.py

runserver.py

import os

from config import DEBUG

from web.api.app import app
from web.api.client import *

if __name__ == "__main__":
    app.run(debug=DEBUG)

好的。现在您想使用相同的模型来做另一件事。例如：使用相同的模型训练机器、服务并保存在数据库 (ORM) 中。

您可以导入应用程序并使用 app.test_request_context()。像这样：

do_something.py

从 web.api.app 导入应用 从 web.api.models 导入数据库，用户

def do_something():
    q = db.session.query(User)\
        .filter(User.Name.ilike('Andre'))
    for i in q.all():
        print (i.Name)    

with app.test_request_context():
    do_something()

do_something2.py（真实示例）

from web.api.app import app
from web.api.models import *

def save(df):

    passengers = []

    records = df.to_dict('records')

    for row in records:
        p = Passenger(row)
        passengers.append(p)

    for p in passengers:
        db.session.add(p)

    db.session.commit()

from ml.models import train, restore

with app.test_request_context():
    print ('Trainning model. It will take a while... (~ 5 minutos)')
    train.run()
    print ('Saving model...')
    save(restore.run())
    print ('Saved!')

许多答案建议使用（从不同文件夹导入文件）：

import sys
sys.path.append('../')

但我不同意你有一个 Flask 应用程序和其他脚本，因为你会疯狂地解决相关引用。

安装 Flask 应用程序及其数据库以用于其他项目的方法是另一种选择。

您可以在此处找到有关packages and modules 的文档。

包是一种构建 Python 模块命名空间的方法，使用 “带点的模块名称”。例如，模块名称 A.B 指定一个 在名为 A 的包中名为 B 的子模块。就像使用模块一样 使不同模块的作者不必担心每个模块 其他的全局变量名，使用带点的模块名可以节省 NumPy 或 Pillow 等多模块包的作者 担心彼此的模块名称。