Flask==2.1.3
Flask-Cors==3.0.10
Flask-JWT-Extended==4.4.2
Flask-SQLAlchemy==2.5.1

import os, json
from flask import Flask, jsonify, request
from datetime import timedelta
from flask_cors import CORS, cross_origin
from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_required, JWTManager, get_jwt_identity

basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
    SECRET_KEY = "secret"
    ,JWT_SECRET_KEY = "secret"
    ,JWT_ACCESS_TOKEN_EXPIRES = timedelta(minutes=15)
    ,JWT_REFRESH_TOKEN_EXPIRES = timedelta(hours=24)
    ,JSON_AS_ASCII = False
)
cors = CORS(app, responses={r"/*": {"origins": "*"}})
jwt = JWTManager(app)

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

access_token = create_access_token(identity="ユーザ名とかユーザーidとか、トークンを見れば後から分かる")

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTY2ODQwNDA1NywianRpIjoiMDQyN2U5ZmEtZTVmMS00MTg2LTg3ZjUtOWZlOGVlNmZhYmE2IiwidHlwZSI6ImFjY2VzcyIsInN1YiI6ImFwcGxlIiwibmJmIjoxNjY4NDA0MDU3LCJleHAiOjE2Njg0MDQ5NTd9.XxoAnoG7huTrLVz0wFPn2zzpfkyyV3F1_KCSxbe-s5Y"
}

@jwt_required()

current_identity = get_jwt_identity()

{
  "user": "apple"
}

@app.route("/files/<path>", methods=["GET"])
@cross_origin()
@jwt_required()
def send_image(path):
    return send_from_directory("",path)

http://127.0.0.1:5000/files/test.png?jwt=exampletoken

refresh_token = create_refresh_token(identity=identity="ユーザ名とかユーザーidとか、トークンを見れば後から分かる")

@jwt_required(refresh=True)

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTY2ODQxMTAyMywianRpIjoiZGJlMjI5NzUtOWYxNS00NGYyLWJkMDEtYWNkMzA3YThmNmRhIiwidHlwZSI6ImFjY2VzcyIsInN1YiI6ImFwcGxlIiwibmJmIjoxNjY4NDExMDIzLCJleHAiOjE2Njg0MTE5MjN9.3u6l8jwWaBYr0pYTXFKx8pmyATNI2TAtFQgK3RWY1M0",
  "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTY2ODQxMTAyMywianRpIjoiY2QyMmRiZTAtOTg0MC00ZmQ2LWE0MzMtYTY0ODZhNzU2OThmIiwidHlwZSI6InJlZnJlc2giLCJzdWIiOiJhcHBsZSIsIm5iZiI6MTY2ODQxMTAyMywiZXhwIjoxNjY4NDk3NDIzfQ.XsGzDqssLtre-qMVO4DceoghrGnltyX2gUNVfTxWjYc"
}

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTY2ODQxMjM4NCwianRpIjoiYTMzMWRjY2UtNjE2Zi00Y2ZjLThjOTMtMTIzMGM1ZmQyMjEzIiwidHlwZSI6ImFjY2VzcyIsInN1YiI6ImFwcGxlIiwibmJmIjoxNjY4NDEyMzg0LCJleHAiOjE2Njg0MTMyODR9.EGeWj3koN8APQz8tET0d2ZoXY6TmpFLcXumObkVEfow"
}

>>>db.create_all()

A:\abc>cd A:\abc\osaka\main\api

A:\abc\osaka\main\api>venv\Scripts\activate

(venv) A:\abc\osaka\main\api>python
Python 3.9.4 (tags/v3.9.4:*******, ****  ** ****, **:**:**) [MSC v.**** ** bit (******)] on ******
Type "help", "copyright", "credits" or "license" for more information.
>>>from app import db

>>>db.create_all()

>>>Ctrl + Z

(venv) A:\abc\osaka\main\api>

@jwt_required(verify_type=False)

get_jwt()

@jwt.token_in_blocklist_loader

"Token has been revoked"

>>>from app import db
>>>db.drop_all()
>>>db.create_all()

import os, json
from flask import Flask, jsonify, request
from datetime import timedelta
from flask_cors import CORS, cross_origin
from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_required, JWTManager \
    , get_jwt,get_jwt_identity, current_user, create_refresh_token \
    , decode_token, get_current_user
from sqlalchemy import func
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime, timezone
from werkzeug.security import generate_password_hash, check_password_hash

basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
    SECRET_KEY = "secret"
    ,JWT_SECRET_KEY = "secret"
    ,JWT_ACCESS_TOKEN_EXPIRES = timedelta(minutes=15)
    ,JWT_REFRESH_TOKEN_EXPIRES = timedelta(hours=24)
    ,JSON_AS_ASCII = False
    ,SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
        'sqlite:///' + os.path.join(basedir, 'app.db')
    ,SQLALCHEMY_TRACK_MODIFICATIONS = False
)
cors = CORS(app, responses={r"/*": {"origins": "*"}})
jwt = JWTManager(app)
db = SQLAlchemy(app)

class User(db.Model):  # type: ignore
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(), nullable=False)
    password = db.Column(db.String())
    def set_password(self, password):
        self.password = generate_password_hash(password)
    def check_password(self, password):
        return check_password_hash(self.password, password)

class TokenBlocklist(db.Model): # type: ignore
    id = db.Column(db.Integer, primary_key=True)
    jti = db.Column(db.String(36), nullable=False, index=True)
    type = db.Column(db.String(16), nullable=False)
    created_at = db.Column(db.DateTime, server_default=func.now(), nullable=False)

@app.route('/register', methods=['POST'])
@cross_origin()
def register():
    username = json.loads(json.loads(request.get_data().decode('utf-8'))["body"])["username"]
    password = json.loads(json.loads(request.get_data().decode('utf-8'))["body"])["password"]
    if password is None or username is None or password == "" or username == "":
        return jsonify({"msg": "password or username has not been entered"}), 400
    if len(password) < 5:
        return jsonify({"msg": "password is too short"}), 400
    if len(username) < 3:
        return jsonify({"msg": "username is too short"}), 400
    if User.query.filter_by(name=username).first() is not None:
        return jsonify({"msg": "The username is already in use"}), 409
    user = User(name=username)
    user.set_password(password)
    db.session.add(user)
    db.session.commit()
    return jsonify("create account")

@app.route('/login', methods=['POST'])
@cross_origin()
def create_token():
    username = json.loads(json.loads(request.get_data().decode('utf-8'))["body"])["username"]
    password = json.loads(json.loads(request.get_data().decode('utf-8'))["body"])["password"]
    user = User.query.filter_by(name=username).first()
    if user is None or not user.check_password(password):
        return jsonify({"msg": "Incorrect password or username"}), 401
    access_token = create_access_token(identity=username)
    refresh_token = create_refresh_token(identity=username)
    return jsonify(access_token=access_token, refresh_token=refresh_token)

@app.route("/refresh", methods=["POST"])
@jwt_required(refresh=True)
@cross_origin()
def refresh():
    identity = get_jwt_identity()
    access_token = create_access_token(identity=identity)
    return jsonify(access_token=access_token)

@app.route("/logout", methods=["DELETE"])
@jwt_required(verify_type=False)
@cross_origin()
def modify_token():
    token = get_jwt()
    jti = token["jti"]
    ttype = token["type"]
    now = datetime.now(timezone.utc)
    db.session.add(TokenBlocklist(jti=jti, type=ttype, created_at=now))
    db.session.commit()
    return jsonify(msg=f"{ttype.capitalize()} token successfully revoked")

@jwt.token_in_blocklist_loader
def token_block(_jwt_header, jwt_data):
    if TokenBlocklist.query.filter_by(jti=jwt_data["jti"]).first():
        return True
    return False

@jwt.user_lookup_loader
def user_lookup_callback(_jwt_header, jwt_data):
    identity = jwt_data["sub"]
    return User.query.filter_by(name=identity).one_or_none()

@app.route("/user-data", methods=["GET"])
@jwt_required()
@cross_origin()
def need_token2():
    current_identity = get_jwt_identity()
    return jsonify({"user":current_identity}) # type: ignore

@app.route("/user-data-v2", methods=["GET"])
@jwt_required()
@cross_origin()
def need_tokenV2():
    return jsonify({"username":current_user.name,"id":current_user.id}) # type: ignore

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