def create_app(self):
    return app

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8mb4".format(
    "***", "***", "***", 3306, "unittest")
app.config['TESTING'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.register_blueprint(v1_recharge.bp, url_prefix='/v1/recharge')
db.init_app(app)

No application found. Either work inside a view function or push an application context.

with app.app_context():

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8mb4".format(
    "***", "***", "***", 3306, "unittest")
app.config['TESTING'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.register_blueprint(v1_recharge.bp, url_prefix='/v1/recharge')
db.init_app(app)
class RechargeTest(TestCase):
    member_id = "201810241615509296"
    def create_app(self):
        return app
    @classmethod
    def setUpClass(cls):
        with app.app_context():
            db.create_all()
            m = Member(member_id=cls.member_id)
            db.session.add(m)
            db.session.commit()
    @classmethod
    def tearDownClass(cls):
        with app.app_context():
            db.session.remove()
            db.drop_all()

def recharge(self):
    res = self.client.post("/v1/recharge/recharge", json={
        "member_id": self.member_id,
        "payment": 1,
        "amount": random.choice(range(100)),
        "bonus": random.choice(range(20)),
        "date": "2019-02-01"
    })
    return res

class RechargeModel(db.Model):
    __tablename__ = 'member_recharge'
    id = db.Column(db.Integer, primary_key=True)
    member_id = db.Column(db.String(40))
    order_no = db.Column(db.String(20))
    payment = db.Column(db.Integer)
    amount = db.Column(db.DECIMAL)
    bonus = db.Column(db.DECIMAL)
    status = db.Column(db.Integer)
    date = db.Column(db.DATETIME, default=datetime.now)
    ...
    @classmethod
    def get_recharge_data(cls, member_id, start_date="2001-01-01", end_date="2099-01-01", page=1, perpage=20):
        """
        获取充值记录
        参数：
        member_id: 会员号
        start_date: 查询开始时间
        end_date: 查询结束时间
        page: 页码
        perpage: 每页条数
        """
        return RechargeModel.query.filter(
            RechargeModel.member_id == member_id,
            RechargeModel.date >= start_date,
            RechargeModel.date <= end_date
        ).paginate(
            int(page), int(perpage), False)
    ...

def test_get_recharge_data(self):
        """测试获取充值记录"""
        self.recharge()
        self.assertTrue(bool(RechargeModel.get_recharge_data(self.member_id)))

from collections import OrderedDict
from setuptools import setup, find_packages
setup(
    name='my_project',
    version="1.0.0",
    url='https://www.palletsprojects.com/p/flask/',
    project_urls=OrderedDict((
        ('Documentation', 'http://flask.pocoo.org/docs/'),
        ('Code', 'https://github.com/pallets/flask'),
        ('Issue tracker', 'https://github.com/pallets/flask/issues'),
    )),
    license='BSD',
    author='Backend Team',
    maintainer='Pallets team',
    description='xxx project',
    packages=find_packages(),
    include_package_data=True,
    zip_safe=False,
    platforms='any',
    python_requires='>=3.5',
    test_suite="tests"
)

ImportError: No module named ordered_dict

urllib3==1.23

from flask import Flask
app = Flask(__name__)
@app.route("/getname", methods=['GET'])
def get_name():
    return json.dumps({
        "name": "张三"
    })
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=os.environ.get('PORT', 5000))

class User(ObjectType):
    id = Int()
    name = String()

class Query(ObjectType):
    users = List(User, id=Int(required=True))
    user = Field(User, id=Int(required=True))
    def resolve_user(self, info, id):
        """返回单个实例对象"""
        from app import get_name
        data = json.loads(get_name())
        return User(id=id, name=data["name"])
    def resolve_users(self, info, id):
        """返回列表对象"""
        from app import get_name
        data = json.loads(get_name())
        return [User(id=id, name=data["name"])]

view_func = GraphQLView.as_view(
    'graphql', schema=Schema(query=Query), graphiql=True)
app.add_url_rule('/graphql', view_func=view_func)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=os.environ.get('PORT', 5000))

pip install "graphene-sqlalchemy>=2.0"

from app import db
class User(db.Model):
    __tablename__ = 'users'
    id  = db.Column(db.Integer,primary_key=True)
    name  = db.Column(db.String)

from graphene_sqlalchemy import SQLAlchemyObjectType
from models import User
from graphene import ObjectType,List, Schema
class UserGraph(SQLAlchemyObjectType):
    class Meta:
        model = User
        only_fields = ("name",)
class Query(ObjectType):
    users = List(UserGraph)
    def resolve_users(self,info):
        query = UserGraph.get_query(info)
        return query.all()
schema = Schema(query=Query)

#!/usr/bin/env python3
"""解密flask 客户端session问题 """
import sys
import zlib
from base64 import b64decode
from flask.sessions import session_json_serializer
from itsdangerous import base64_decode
def decryption(payload):
    payload, sig = payload.rsplit(b'.', 1)
    payload, timestamp = payload.rsplit(b'.', 1)
    decompress = False
    if payload.startswith(b'.'):
        payload = payload[1:]
        decompress = True
    try:
        payload = base64_decode(payload)
    except Exception as e:
        raise Exception('Could not base64 decode the payload because of '
                         'an exception')
    if decompress:
        try:
            payload = zlib.decompress(payload)
        except Exception as e:
            raise Exception('Could not zlib decompress the payload before '
                             'decoding the payload')
    return session_json_serializer.loads(payload)
if __name__ == '__main__':
    print(decryption(sys.argv[1].encode()))

import pickle
from datetime import timedelta
from uuid import uuid4
from redis import StrictRedis
from werkzeug.datastructures import CallbackDict
from flask.sessions import SessionInterface, SessionMixin
class RedisSession(CallbackDict, SessionMixin):
    def __init__(self, initial=None, sid=None, new=False):
        def on_update(self):
            self.modified = True
        CallbackDict.__init__(self, initial, on_update)
        self.sid = sid
        self.new = new
        self.modified = False
class RedisSessionInterface(SessionInterface):
    serializer = pickle
    session_class = RedisSession
    def __init__(self, redis=None, prefix='session:'):
        if redis is None:
            redis = StrictRedis()
        self.redis = redis
        self.prefix = prefix
    def generate_sid(self):
        return str(uuid4())
    def get_redis_expiration_time(self, app, session):
        if session.permanent:
            return app.permanent_session_lifetime
        return timedelta(days=1)
    def open_session(self, app, request):
        sid = request.cookies.get(app.session_cookie_name)
        if not sid:
            sid = self.generate_sid()
            return self.session_class(sid=sid, new=True)
        val = self.redis.get(self.prefix + sid)
        if val is not None:
            data = self.serializer.loads(val)
            return self.session_class(data, sid=sid)
        return self.session_class(sid=sid, new=True)
    def save_session(self, app, session, response):
        domain = self.get_cookie_domain(app)
        if not session:
            self.redis.delete(self.prefix + session.sid)
            if session.modified:
                response.delete_cookie(app.session_cookie_name,
                                       domain=domain)
            return
        redis_exp = self.get_redis_expiration_time(app, session)
        cookie_exp = self.get_expiration_time(app, session)
        val = self.serializer.dumps(dict(session))
        self.redis.setex(self.prefix + session.sid,
                         int(redis_exp.total_seconds()), val)
        response.set_cookie(app.session_cookie_name, session.sid,
                            expires=cookie_exp, httponly=True,
                            domain=domain)

app = Flask(__name__)
app.session_interface = RedisSessionInterface()