【问题标题】:Share sqlalchemy models between flask and other apps在烧瓶和其他应用程序之间共享 sqlalchemy 模型
【发布时间】: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 folderconfig.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 替换。如有任何混淆,请见谅。

【问题讨论】:

    标签: python flask sqlalchemy flask-sqlalchemy


    【解决方案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 等多模块包的作者 担心彼此的模块名称。

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 2011-05-07
          • 2012-06-02
          • 1970-01-01
          • 2015-12-14
          • 1970-01-01
          • 2015-07-05
          • 1970-01-01
          相关资源
          最近更新 更多