Python Flask-运行时错误：未找到应用程序。在视图函数中工作或推送应用程序上下文

我现在正在尝试创建一个应用程序，该应用程序使用RESTAPI处理HTTP请求。该应用程序将Flask用于web框架，将芹菜用于异步任务

下面是应用程序结构

app.py
celery_app.py
controller/
    controller.py
task/
    task.py

（1） app.py

from consts.consts import Consts
from kombu.utils.url import quote
from celery import Celery
from config.config import Config

config = Config()
db_uri = 'db+' + config.get_db_uri()

aws_access_key = quote(config.get_config(Consts.AWS, Consts.AWS_ACCESS_KEY))
aws_secret_key = quote(config.get_config(Consts.AWS, Consts.AWS_SECRET_KEY))
broker_url = "sqs://{aws_access_key}:{aws_secret_key}@".format(
    aws_access_key=aws_access_key, aws_secret_key=aws_secret_key
)

celery = Celery(
    broker=broker_url,
    backend=db_uri,
    include=['task']
)

from flask import Blueprint, request, json, render_template, jsonify
from mysql.connector import Error
from sqlalchemy import or_, and_
from consts.consts import StatusCode
from consts.consts import Consts
from model.model import db, FriendRequest
from outbound.request import Request
from util.logging import logger
from task.task import check_friend_status_from_db


controller_blueprint = Blueprint('controller_blueprint', __name__)
outbound_request = Request()


@controller_blueprint.route('/friend/status/<requested_from>/<requested_to>', methods=['GET'])
def check_friend_status(requested_from, requested_to):
    logger.info('Checking the friend status')
    try:
        status = check_friend_status_from_db.apply_async((requested_from, requested_to)).get()

        if status is None:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: StatusCode.NO_RELATION
            }
        else:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: status
            }
    except Error as e:
        logger.error("TypeError:", e)
        response = {
            Consts.STATUS_CODE: StatusCode.ERROR
        }
    json_response = jsonify(response)
    logger.info(json_response)
    return json_response

芹菜配置没有行

from flask import Flask
...

app = Flask(__name__)
...


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

（2） 芹菜.py

from consts.consts import Consts
from kombu.utils.url import quote
from celery import Celery
from config.config import Config

config = Config()
db_uri = 'db+' + config.get_db_uri()

aws_access_key = quote(config.get_config(Consts.AWS, Consts.AWS_ACCESS_KEY))
aws_secret_key = quote(config.get_config(Consts.AWS, Consts.AWS_SECRET_KEY))
broker_url = "sqs://{aws_access_key}:{aws_secret_key}@".format(
    aws_access_key=aws_access_key, aws_secret_key=aws_secret_key
)

celery = Celery(
    broker=broker_url,
    backend=db_uri,
    include=['task']
)

from flask import Blueprint, request, json, render_template, jsonify
from mysql.connector import Error
from sqlalchemy import or_, and_
from consts.consts import StatusCode
from consts.consts import Consts
from model.model import db, FriendRequest
from outbound.request import Request
from util.logging import logger
from task.task import check_friend_status_from_db


controller_blueprint = Blueprint('controller_blueprint', __name__)
outbound_request = Request()


@controller_blueprint.route('/friend/status/<requested_from>/<requested_to>', methods=['GET'])
def check_friend_status(requested_from, requested_to):
    logger.info('Checking the friend status')
    try:
        status = check_friend_status_from_db.apply_async((requested_from, requested_to)).get()

        if status is None:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: StatusCode.NO_RELATION
            }
        else:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: status
            }
    except Error as e:
        logger.error("TypeError:", e)
        response = {
            Consts.STATUS_CODE: StatusCode.ERROR
        }
    json_response = jsonify(response)
    logger.info(json_response)
    return json_response

（3） 任务/task.py

from consts.consts import Consts
from kombu.utils.url import quote
from celery import Celery
from config.config import Config

config = Config()
db_uri = 'db+' + config.get_db_uri()

aws_access_key = quote(config.get_config(Consts.AWS, Consts.AWS_ACCESS_KEY))
aws_secret_key = quote(config.get_config(Consts.AWS, Consts.AWS_SECRET_KEY))
broker_url = "sqs://{aws_access_key}:{aws_secret_key}@".format(
    aws_access_key=aws_access_key, aws_secret_key=aws_secret_key
)

celery = Celery(
    broker=broker_url,
    backend=db_uri,
    include=['task']
)

from flask import Blueprint, request, json, render_template, jsonify
from mysql.connector import Error
from sqlalchemy import or_, and_
from consts.consts import StatusCode
from consts.consts import Consts
from model.model import db, FriendRequest
from outbound.request import Request
from util.logging import logger
from task.task import check_friend_status_from_db


controller_blueprint = Blueprint('controller_blueprint', __name__)
outbound_request = Request()


@controller_blueprint.route('/friend/status/<requested_from>/<requested_to>', methods=['GET'])
def check_friend_status(requested_from, requested_to):
    logger.info('Checking the friend status')
    try:
        status = check_friend_status_from_db.apply_async((requested_from, requested_to)).get()

        if status is None:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: StatusCode.NO_RELATION
            }
        else:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: status
            }
    except Error as e:
        logger.error("TypeError:", e)
        response = {
            Consts.STATUS_CODE: StatusCode.ERROR
        }
    json_response = jsonify(response)
    logger.info(json_response)
    return json_response

我把所有的任务都放在这里

from celery_app import celery
from flask import current_app as app
from model.model import db


@celery.task
def check_friend_status_from_db(user1, user2):
    status = db.engine.execute(
            "QUERY").fetchone()
    return status

现在，

controller/controller.py

文件导入并调用如下任务

（4） 控制器/controller.py

from consts.consts import Consts
from kombu.utils.url import quote
from celery import Celery
from config.config import Config

config = Config()
db_uri = 'db+' + config.get_db_uri()

aws_access_key = quote(config.get_config(Consts.AWS, Consts.AWS_ACCESS_KEY))
aws_secret_key = quote(config.get_config(Consts.AWS, Consts.AWS_SECRET_KEY))
broker_url = "sqs://{aws_access_key}:{aws_secret_key}@".format(
    aws_access_key=aws_access_key, aws_secret_key=aws_secret_key
)

celery = Celery(
    broker=broker_url,
    backend=db_uri,
    include=['task']
)

from flask import Blueprint, request, json, render_template, jsonify
from mysql.connector import Error
from sqlalchemy import or_, and_
from consts.consts import StatusCode
from consts.consts import Consts
from model.model import db, FriendRequest
from outbound.request import Request
from util.logging import logger
from task.task import check_friend_status_from_db


controller_blueprint = Blueprint('controller_blueprint', __name__)
outbound_request = Request()


@controller_blueprint.route('/friend/status/<requested_from>/<requested_to>', methods=['GET'])
def check_friend_status(requested_from, requested_to):
    logger.info('Checking the friend status')
    try:
        status = check_friend_status_from_db.apply_async((requested_from, requested_to)).get()

        if status is None:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: StatusCode.NO_RELATION
            }
        else:
            response = {
                Consts.STATUS_CODE: StatusCode.OK,
                Consts.FRIEND_STATUS: status
            }
    except Error as e:
        logger.error("TypeError:", e)
        response = {
            Consts.STATUS_CODE: StatusCode.ERROR
        }
    json_response = jsonify(response)
    logger.info(json_response)
    return json_response

从flask导入蓝图、请求、json、呈现模板、jsonify
从mysql.connector导入错误
从sqlalchemy导入或导出，以及_
从consts.consts导入状态代码
从consts.consts导入consts
从model.model导入数据库，FriendRequest
从outbound.request导入请求
从util.logging导入记录器
从task.task导入检查\u friend\u状态\u从\u db
控制器\u蓝图=蓝图（'controller\u blueprint'，\u名称\u）
出站请求=请求（）
@controller_blueprint.route（'/friend/status/'，methods=['GET']）
def检查朋友状态（请求自、请求至）：
logger.info（'正在检查好友状态'）
尝试：
status=检查来自\u db的\u friend\u status\u.apply\u async（（请求的\u from，请求的\u to））.get（）
如果状态为“无”：
答复={
Consts.STATUS\u代码：StatusCode.OK，
Consts.FRIEND\u状态：StatusCode.NO\u关系
}
其他：
答复={
Consts.STATUS\u代码：StatusCode.OK，
conss.FRIEND_状态：状态
}
除错误e外：
logger.error（“TypeError:，e）
答复={
Consts.STATUS\u代码：StatusCode.ERROR
}
json_response=jsonify（响应）
logger.info（json_响应）
返回json\u响应

当我运行代码时，我得到了标题中提到的错误

运行时错误：未找到应用程序。在视图函数内部工作或推送应用程序上下文

结果是控制器中try块下的这一部分，它是错误的来源

status=从\u db检查\u friend\u status\u。应用\u async（（请求的\u from，请求的\u to））.get（）

---

有什么解决方案吗？

看起来您需要注册您的蓝图

控制器\u蓝图

。由于此蓝图未注册到您的

应用程序

，因此您在应用程序的上下文之外工作，因此会出现错误

您可以在app.py中执行此操作：

从controller.controller导入controller\u蓝图
app=烧瓶（名称）
应用程序注册蓝图（控制器蓝图）