python导入与flask安全性冲突

我经常遇到这种“导入冲突”，我试图找到最适合Python的方法来解决它。我的应用程序的

\uuuu init\uuuu

实例化了

db

，在我的

user.models

文件中，

db

被广泛引用。但是，要使用Flask安全性，我需要初始化

user\u数据存储

，它需要my

db

和my

user

模型。这些文件无法相互导入。我需要

方法中的
User
，但我还需要
User
模型中的
db

我尝试过各种安排（除了将我的许多相互关联的模型移动到
\uuuu init\uuuu
文件中），但下面是最简单的设置和回溯。
我也跟着去了，但我还没完全明白

\uuuu init\uuuuu.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flaskext.markdown import Markdown
from flask_uploads import UploadSet, configure_uploads, IMAGES
from flask_security import Security, SQLAlchemyUserDatastore, utils
from flask_mail import Mail
import private

app = Flask(__name__)
app.config.from_object('settings')
db = SQLAlchemy(app)
mail = Mail(app)

# migrations
migrate = Migrate(app, db)

# markdown
md = Markdown(app, extensions=['fenced_code', 'tables'])

# images
uploaded_images = UploadSet('images', IMAGES)
configure_uploads(app, uploaded_images)

# CONFLICT 
from user.models import User, Role    
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)


from roster import views
from sentence import views
from blog import views
from user import views

@app.before_first_request
def before_first_request():

    # Create the Roles "admin" and "end-user" -- unless they already exist
    user_datastore.find_or_create_role(name='admin', description='Administrator')
    user_datastore.find_or_create_role(name='end-user', description='End user')

    # Create two Users for testing purposes -- unless they already exists.
    # In each case, use Flask-Security utility function to encrypt the password.
    encrypted_password = utils.encrypt_password(private.STARTING_ADMIN_PASS)
    if not user_datastore.get_user('example@gmail.com'):
        user_datastore.create_user(email='example@gmail.com', password=encrypted_password)

    db.session.commit()

    user_datastore.add_role_to_user('example@gmail.com', 'admin')
    db.session.commit()

用户.型号

# THE OTHER HALF OF THE CONFLICT
from my_app import db
from blog.models import Post
from sentence.models import Sentence
from roster.models import Roster
from datetime import datetime
import datetime
from flask_security import UserMixin, RoleMixin

# Helper table for a many-to-many relationship
roles_users = db.Table('roles_users',
        db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
        db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))

class Role(db.Model, RoleMixin):
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(80), unique=True)
    description = db.Column(db.String(255))

class User(db.Model, UserMixin):
    # general variables
    id = db.Column(db.Integer, primary_key=True)
    first_name = db.Column(db.String(155))
    last_name = db.Column(db.String(155))
    email = db.Column(db.String(255), unique=True)
    password = db.Column(db.String(255))
    active = db.Column(db.Boolean())
    confirmed_at = db.Column(db.DateTime())

    # relations
    roles = db.relationship('Role', secondary=roles_users,
                            backref=db.backref('users', lazy='dynamic'))
    posts = db.relationship('Post', backref='user', lazy='dynamic')
    sentences = db.relationship('Sentence', backref='user', lazy='dynamic')

    def __init__(self, name, email):
        # create a roster
        roster = Roster("default", self.email)
        db.session.add(roster)
        db.session.commit()

    def __repr__(self):
        return '<User %r>' % self.username

    # __str__ is required by Flask-Admin (not using?), so we can have human-readable values for the Role when editing a User.
    # If we were using Python 2.7, this would be __unicode__ instead.
    def __str__(self):
        return self.name

    # __hash__ is required to avoid the exception TypeError: unhashable type: 'Role' when saving a User
    def __hash__(self):
        return hash(self.name)

冲突的另一半
从我的应用程序导入数据库
从blog.models导入帖子
从句子模型导入句子
从花名册。模型导入花名册
从日期时间导入日期时间
导入日期时间
来自flask_安全导入UserMixin，RoleMixin
#多对多关系的帮助器表
roles\u users=db.Table（'roles\u users'，
db.Column（'user\u id'，db.Integer（），db.ForeignKey（'user.id'）），
db.Column（'role\u id'，db.Integer（），db.ForeignKey（'role.id'））
班级角色（db.Model，RoleMixin）：
id=db.Column（db.Integer（），主键=True）
name=db.Column（db.String（80），unique=True）
description=db.Column（db.String（255））
类用户（db.Model，UserMixin）：
#一般变量
id=db.Column（db.Integer，主键=True）
first_name=db.Column（db.String（155））
last_name=db.Column（db.String（155））
email=db.Column（db.String（255），unique=True）
密码=db.Column（db.String（255））
active=db.Column（db.Boolean（））
已确认\u at=db.Column（db.DateTime（））
#关系
roles=db.relationship（'Role'，secondary=roles\u用户，
backref=db.backref（'users'，lazy='dynamic'））
posts=db.relationship（'Post'，backref='user'，lazy='dynamic'）
句子=db.relationship（'句子'，backref='user'，lazy='dynamic'）
定义初始化（自我、姓名、电子邮件）：
#创建花名册
花名册=花名册（“默认”，self.email）
db.session.add（名册）
db.session.commit（）
定义报告（自我）：
返回“%self.username”
#__str__是Flask Admin所必需的（不使用？），因此在编辑用户时，我们可以为角色提供人类可读的值。
#如果我们使用的是Python2.7，那么这将是unicode。
定义（自我）：
返回self.name
#\uuuu散列\uuuuu是避免异常类型错误所必需的：保存用户时，类型为“角色”
定义散列（自我）：
返回散列（self.name）

回溯

Traceback (most recent call last):
  File "manage.py", line 8, in <module>
    from my_app import app
  File "/home/ubuntu/workspace/my_app/__init__.py", line 9, in <module>
    from user.models import User, Role
  File "/home/ubuntu/workspace/my_app/user/models.py", line 1, in <module>
    from my_app import db
ImportError: cannot import name 'db'

回溯（最近一次呼叫最后一次）：
文件“manage.py”，第8行，在
从我的应用程序导入应用程序
文件“/home/ubuntu/workspace/my_-app/_-init__.py”，第9行，在
从user.models导入用户、角色
文件“/home/ubuntu/workspace/my_app/user/models.py”，第1行，在
从我的应用程序导入数据库
ImportError:无法导入名称“db”

我通常做的是用使用过的扩展创建一个

扩展.py

，并使用应用程序工厂对其进行初始化

extensions.py

from flask_security import Security
from flask_sqlalchemy import SQLAlchemy

security = Security()
db = SQLAlchemy()

然后在

\uuuu init\uuuuu.py

中进行初始化

def register_extensions(app):
    db.init_app(app)
    security.init_app(app, ...)

---

因此，您可以在其他类中导入db、安全性和其他扩展，并且没有导入错误。有关更多信息和解释，请查看Flask文档，了解我通常使用的扩展名创建一个

扩展名.py

，并使用应用程序工厂对其进行初始化

extensions.py

from flask_security import Security
from flask_sqlalchemy import SQLAlchemy

security = Security()
db = SQLAlchemy()

然后在

\uuuu init\uuuuu.py

中进行初始化

def register_extensions(app):
    db.init_app(app)
    security.init_app(app, ...)

因此，您可以在其他类中导入db、安全性和其他扩展，并且没有导入错误。有关更多信息和说明，请查看有关的烧瓶文档