Flask - 在应用程序上下文之外工作

Question

I am testing a Flask application and am receiving a "working outside of application context" error. My file directory is as follows:

api
    app.py
    __init__.py
    models
        __init__.py
        user.py
    resources
        __init__.py
        deals.py
        stores.py
    common
        __init__.py
        calculations.py
        decorators.py

My app.py file looks like the following:

import os
from flask import Flask, jsonify, url_for, redirect, request, g, current_app
from flask_pymongo import PyMongo
from flask_restful import Api, Resource
from flask_httpauth import HTTPTokenAuth
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.httpauth import HTTPBasicAuth

from resources.deals import Deals
from resources.stores import Stores

from models.user import User

USERDBFILE=os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)),'database'),'db.sqlite')

#Deals database
app = Flask(__name__)
app.config["MONGO_DBNAME"] = "database"
mongo = PyMongo(app,config_prefix='MONGO')
app.db = mongo

#User database
app.config['SECRET_KEY'] = 'SECRET KEY'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.dbuser = SQLAlchemy(app)

#App url
app.APP_URL = "http://127.0.0.1:5000"

#Setup authorization
auth = HTTPTokenAuth(scheme='Token')

#Setup the app
api = Api(app)
api.add_resource(Deals, '/deals', '/Deals/<string:type>/<string:id>',endpoint="dealType")
api.add_resource(Stores, '/stores', '/Stores/<string:type>/<string:id>',endpoint="type")

if __name__ == "__main__":
    if not os.path.exists(USERDBFILE):
        app.dbuser.create_all()
    app.run(debug=True)

My users.py file is as follows:

from flask import current_app
import os
from flask import Flask, abort, request, jsonify, g, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.httpauth import HTTPBasicAuth
from passlib.apps import custom_app_context as pwd_context
from itsdangerous import (TimedJSONWebSignatureSerializer
                          as Serializer, BadSignature, SignatureExpired)

class User(current_app.dbuser.Model):
    __tablename__ = 'user_api'
    id = current_app.dbuser.Column(current_app.dbuser.Integer,primary_key=True)
    date_created = current_app.dbuser.Column(current_app.dbuser.DateTime,default=current_app.dbuser.func.current_timestamp())
    date_modified = current_app.dbuser.Column(current_app.dbuser.DateTime,default=current_app.dbuser.func.current_timestamp(),
                                      onupdate=current_app.dbuser.func.current_timestamp())
    # User Name
    name = current_app.dbuser.Column(current_app.dbuser.String(128),nullable=False)
    # Identification Data: email & password
    email = current_app.dbuser.Column(current_app.dbuser.String(128),nullable=False,unique=True)
    password = current_app.dbuser.Column(current_app.dbuser.String(192),nullable=False)
    company = current_app.dbuser.Column(current_app.dbuser.String(128),nullable=False,unique=True)
    # Authorization Data: role & status
    role = current_app.dbuser.Column(current_app.dbuser.String(32),nullable=False,default='user')
    status = current_app.dbuser.Column(current_app.dbuser.Boolean,nullable=False,default=True)
    hourly_limit = current_app.dbuser.Column(current_app.dbuser.Integer,nullable=False,default=100)
    daily_limit = current_app.dbuser.Column(current_app.dbuser.Integer,nullable=False,default=2400)
    monthly_limit = current_app.dbuser.Column(current_app.dbuser.Integer,nullable=False,default=2400)
    admin = current_app.dbuser.Column(current_app.dbuser.Boolean,nullable=False,default=True)

    def hash_password(self, password):
        self.password_hash = pwd_context.encrypt(password)

    def verify_password(self, password):
        return pwd_context.verify(password, self.password_hash)

    def generate_auth_token(self, expiration=600):
        s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
        return s.dumps({'id': self.id})

    @staticmethod
    def verify_auth_token(token):
        s = Serializer(current_app.config['SECRET_KEY'])
        try:
            data = s.loads(token)
        except SignatureExpired:
            return None    # valid token, but expired
        except BadSignature:
            return None    # invalid token
        user = User.query.get(data['id'])
        return user

I run the file in the same directory as app.py using

python app.py

But it returns the following error:

File "app.py", line 13, in <module>
    from models.user import User
  File "/Users/toby/api/api/models/user.py", line 10, in <module>
    class User(current_app.dbuser.Model):
  File "/Users/toby/api/venv/lib/python3.4/site-packages/werkzeug/local.py", line 343, in __getattr__
    return getattr(self._get_current_object(), name)
  File "/Users/toby/api/venv/lib/python3.4/site-packages/werkzeug/local.py", line 302, in _get_current_object
    return self.__local()
  File "/Users/toby/api/venv/lib/python3.4/site-packages/flask/globals.py", line 34, in _find_app
    raise RuntimeError('working outside of application context')
RuntimeError: working outside of application context

If I move the contents of the user.py file into the app.py file and change the inheritance from current_app.dbuser.Model to app.dbuser.Model it seems to work fine. Does anyone know what I am doing wrong?

Answer 1

Flask-Sqlalchemy binds some sqlalchemy concepts like the session, the engine, and the declaritive base to the flask app. This is convenient because you only have one thing to instantiate at your uwsgi entry point (the app object) but a pain when testing- because you have to instantiate the app object.

EDIT- I am leaving the part about testing below, but I reread your question and realized you're not actually trying to test anything.

You don't have access to the 'current_app' object at import time (when you are trying to initialize your sqlalchemy models). Instead, you have to actually import the app object from your app file. This of course means you have to worry about circular dependencies...

I have a method called 'register_routes' that gets called after I initialize the app object that imports models and views files that require access to the app object at import time.

#at the bottom of app.py
def register_models(app):
    from models import User

register_models(app)

# in models.py
from app import app

class User(app.dbuser.Model):
   ...

EDIT- the below discusses this issue with respect to unit testing

Flask-Testing is a project that attempts to solve these problems, and is almost certainly appropriate for a beginner in this area- it provides a test class to inherit from that will set up your flask app before test cases and tear it down after. (As you come to understand the various globals and what they do you may want to move away from this... but it is very helpful for getting started!)

If you don't want to do that, you need to create an app and initialize an app context before doing anything with your flask-sqlalchemy models. This may just be

app = myapp.create()
with app.test_request_context():
    # do some testing...

You will probably want to refresh this in between methods, otherwise global state will leak between test cases.

Answer 2

Basically, flask uses quite a lot of global variables like current_app , request etc. which only exist when a flask app is instantiated and running and in various states.

You have used current_app in the definition of the User object which is evaluated as soon as the file is imported by Python. You need to ensure you only use values like this when an app is already running.

You could move the instantiation of the User class until after the app exists, but I think the root problem is why are you using current_app.dbuser.Boolean rather than say sqlalchemy.types.Boolean ?

I'm not a great expert on flask.ext.sqlalchemy , but my guess is you don't need to load those definitions of things like Column and Boolean from the particular instance of the app you have. Using the static definitions from sqlalchemy would prevent you from having a dependency from the User class to the app.