def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class User(object):
def __init__(self, name):
self.name = name
class Hello(Resource):
name = "name&required&default='world'"
date_in = {"validater": "datetime", "input": True, "default": datetime.utcnow}
date_out = "datetime&required&output"
schema_inputs = {"get": {"name": name}, "get_user": {"name": name}, "post": {"date": date_in}}
schema_outputs = {
"get": {"hello": "unicode&required"},
"get_user": {"user": {"name": name}},
"post": {"date": date_out},
}
output_types = [User]
def get(self, name):
return {"hello": name}
def get_user(self, name):
return {"user": User(name)}
def post(self, date):
return {"date": date}
api.add_resource(Hello)
return app
def create_api():
class Hello(Resource):
schema_inputs = {
"get": {"name": ("name&required&default='world'", "name")},
"post_login": {"date": ("date&required", "date")},
}
hello = {"hello": "unicode&required"}
schema_outputs = {
"get": hello,
"get_error": hello,
"post_login": hello,
}
def get(self, name):
return {"hello": name}
def get_error(self):
raise ValueError("get_error")
def post_login(self, date):
return {"hello": "world"}
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
return api
def test_parse_schema():
hello = {"hello": "safestr&required"}
sche_inputs = {
"get": {"name": "name&default='world'"},
"post_login": {
"name": "name&default='world'",
"password": "******"
}
}
sche_outputs = {
"get": hello,
"post_login": hello
}
class Hello(Resource):
schema_inputs = sche_inputs
schema_outputs = sche_outputs
output_types = [Flask]
def get(self, name):
pass
def post_login(self, name, password):
pass
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
assert Hello.schema_inputs == validater.parse(sche_inputs)
assert Hello.schema_outputs == validater.parse(sche_outputs)
assert Hello.output_types == [Flask]
def config_api(app):
api = Api(app, metafile="meta.json", docs=__doc__)
app.route("/")(api.meta_view)
auth = init_auth(api)
auth.get_role(get_role)
for x in ALL_RESOURCE:
api.add_resource(x)
def test_user_role():
class Hello(Resource):
def get(self):
return "hello"
def post_login(self):
me = {"id": 123}
return "login", 200, api.gen_auth_header(me)
def user_role(uid, user):
return "role_%s" % uid
app = Flask(__name__)
app.debug = True
api = Api(app, fn_user_role=user_role)
api.add_resource(Hello)
with app.test_client() as c:
rv = c.post("/hello/login")
assert b"login" in rv.data
assert api.auth_header in rv.headers
auth = {api.auth_header: rv.headers[api.auth_header]}
rv2 = c.get("/hello", headers=auth)
assert str(g.me["id"]) == "123"
# if permission file not exists, user_role will not be called
# assert g.me["role"] == "role_123"
assert g.me["role"] == None
def app(tmpdir):
app = Flask(__name__)
app.debug = True
shutil.copy("tests/testdata/resource.json", str(tmpdir))
shutil.copy("tests/testdata/permission.json", str(tmpdir))
app.config["API_RESOURCE_JSON"] = join(str(tmpdir), "resource.json")
app.config["API_PERMISSION_JSON"] = join(str(tmpdir), "permission.json")
def fn_user_role(token):
user_id = token["id"]
user_roles = ["访客", "普通用户", "管理员"]
return user_roles[user_id]
api = Api(app)
auth = Auth(api, fn_user_role=fn_user_role)
class User(Resource):
schema_inputs = {"post": {"id": "int(0,2)&required"}}
def get(self):
return "ok"
def post(self, id):
return "ok", auth.gen_header({"id": id})
api.add_resource(User)
api.add_resource(Permission, auth=auth)
app.api = api
app.auth = auth
return app
def config_api(app):
api = Api(app, metafile="meta.json", docs=__doc__)
app.route("/")(api.meta_view)
auth = init_auth(api)
auth.get_role(get_role)
for x in ALL_RESOURCE:
api.add_resource(x)
def test_config():
app = Flask(__name__)
app.config.from_object("testdata.config")
app.debug = True
configs = ["resource_json", "permission_json", "auth_header",
"auth_token_name", "auth_secret", "auth_alg", "auth_exp",
"resjs_name", "resdocs_name", "bootstrap"]
bp = Blueprint("blueprint", __name__)
api_bp = Api(bp)
api_app = Api(app)
api_no_app = Api()
for k in configs:
key = "API_" + k.upper()
assert key in app.config
assert app.config[key] == key
assert hasattr(api_app, k)
assert getattr(api_app, k) == key
assert getattr(api_no_app, k) != key
# inited with blue_print can't load configs
assert getattr(api_bp, k) != key
api_bp.config(app.config)
for k in configs:
key = "API_" + k.upper()
assert getattr(api_bp, k) == key
def create_app(tmpdir, refresh=True, cookie=None):
class Hello:
def get(self):
"""
Get Name
$output:
name?str&optional: Your name
"""
return {"name": g.token["name"]}
def post(self, name):
"""
Generate Token
$input:
name?str: Your name
"""
if name == "admin":
role = "admin"
else:
role = "normal"
g.token = {"role": role, "name": name}
return "OK"
metafile = tmpdir.join("meta.json")
json.dump(
{
"$desc": "test",
"$auth": {
"refresh": refresh,
"cookie": cookie
},
"$roles": {
"admin": {
"hello": ["get", "post"]
},
"guest": {
"hello": ["post"]
}
}
}, metafile.open("w"))
app = Flask(__name__)
app.secret_key = "secret_key"
api = Api(app, metafile=metafile.strpath)
auth = TokenAuth(api)
@auth.get_role
def get_role(token):
if token:
return token["role"]
else:
return "guest"
api.add_resource(Hello)
return app
def create_app(tmpdir, refresh=True, cookie=None):
class Hello:
def get(self):
"""
Get Name
$output:
name?str&optional: Your name
"""
return {"name": g.token["name"]}
def post(self, name):
"""
Generate Token
$input:
name?str: Your name
"""
if name == "admin":
role = "admin"
else:
role = "normal"
g.token = {"role": role, "name": name}
return "OK"
metafile = tmpdir.join("meta.json")
json.dump({
"$desc": "test",
"$auth": {
"refresh": refresh,
"cookie": cookie
},
"$roles": {
"admin": {
"hello": ["get", "post"]
},
"guest": {
"hello": ["post"]
}
}
}, metafile.open("w"))
app = Flask(__name__)
app.secret_key = "secret_key"
api = Api(app, metafile=metafile.strpath)
auth = TokenAuth(api)
@auth.get_role
def get_role(token):
if token:
return token["role"]
else:
return "guest"
api.add_resource(Hello)
return app
def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class Hello(Resource):
def get(self):
return [123]
api.add_resource(Hello)
return app
def test_testclient():
api = create_api()
with api.test_client() as c:
assert 200 == c.hello.get().code
assert {"hello": "guyskk"} == c.hello.get({"name": "guyskk"}).rv
assert 404 == c.hello.get_asd().code
with pytest.raises(ValueError):
c.asdfgh.get()
# api did't inited
with pytest.raises(AttributeError):
api = Api()
with api.test_client() as c:
pass
def test_gendocs():
class Hello(Resource):
"""中文docstring for Hello哈哈"""
def get(self):
"""你好啊"""
return "hello"
app = Flask(__name__)
api = Api(app, docs=__doc__)
api.add_resource(Hello)
gen = Gen(api)
gen.resjs('static/res.js')
gen.resdocs('static/resdocs.html', resjs='static/res.js',
bootstrap="bootstrap.css")
def test_response_status_code():
class Hello(Resource):
def get(self):
return 'hello world', 201
def get_302(self):
return redirect(url_for('hello'))
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
with app.test_client() as c:
assert c.get("/hello").status_code == 201
assert c.get("/hello/302").status_code == 302
def test_no_secret_key():
app = Flask(__name__)
api = Api(app)
auth = TokenAuth(api)
with app.test_request_context("/"):
token = jwt.encode({"user_id": 1}, "")
assert auth.decode_token(token) is None
def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class Hello(Resource):
def get(self):
return "hello"
def get_error(self):
raise ValueError("error")
api.add_resource(Hello)
app.resource = Hello
app.api = api
return app
def create_app(server_address, shared_folder):
app = Flask(__name__, static_url_path="/static", static_folder="static/dist")
if not exists(shared_folder):
makedirs(shared_folder)
app.add_url_rule('/shared/<filename>', 'shared', build_only=True)
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app, {'/shared': shared_folder})
bp_api = Blueprint("api", __name__)
api = Api(bp_api)
api.meta["$url_prefix"] = "/api"
api.add_resource(Shared, server_address, shared_folder)
app.register_blueprint(bp_api, url_prefix="/api")
@app.route("/")
def index():
return app.send_static_file("index.html")
return app
def test_parse_request():
class Hello(Resource):
def get(self):
return "hello"
app = Flask(__name__)
app.debug = True
bp = Blueprint("blueprint", __name__)
api = Api(bp)
api.add_resource(Hello)
app.register_blueprint(bp, url_prefix="/api")
with app.test_client() as c:
rv = c.get("/api/hello")
assert b"hello" in rv.data
assert g.resource == "hello"
assert g.action == "get"
assert g.me["id"] is None
def test_request_content_type():
class Hello(Resource):
schema_inputs = {
"post": {"name": "safestr"}
}
def post(self, name):
return {"hello": name}
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
with app.test_client() as c:
headers = {"Content-Type": "application/json"}
params = dict(headers=headers, data='{"name": "jsoner"}')
assert 200 == c.post("/hello", **params).status_code
headers["Content-Type"] = "application/json;charset=UTF-8"
assert 200 == c.post("/hello", **params).status_code
def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class User(object):
def __init__(self, name):
self.name = name
class Hello(Resource):
name = "name&required&default='world'"
date_in = {'validater': 'datetime',
'input': True,
'default': datetime.utcnow}
date_out = 'datetime&required&output'
schema_inputs = {
"get": {"name": name},
"get_user": {"name": name},
"get_list": {"name": name},
"post": {"date": date_in}}
schema_outputs = {
"get": {"hello": "unicode&required"},
"get_user": {"user": {"name": name}},
"get_list": [{"name": name}],
"post": {"date": date_out}
}
output_types = [User]
def get(self, name):
return {'hello': name}
def get_user(self, name):
return {'user': User(name)}
def get_list(self, name):
return [User(name)] * 5
def post(self, date):
return {'date': date}
api.add_resource(Hello)
return app
def test_parse_request():
class Hello(Resource):
def get(self):
return "hello"
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
with app.test_request_context('hello'):
assert request.endpoint == "hello"
assert url_for("hello") == "/hello"
with app.test_client() as c:
rv = c.get("hello")
assert 200 == rv.status_code
assert b"hello" in rv.data
assert g.resource == "hello"
assert g.action == "get"
def test_parse_request():
class Hello(Resource):
schema_inputs = {
"post": {"name": "unicode&default='world'"},
"put": "unicode&default='world'"
}
def get(self):
return "hello"
def post(self, name):
return name
def put(self, name):
return "hello"
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
with app.test_request_context('hello'):
assert request.endpoint == "hello"
assert url_for("hello") == "/hello"
with app.test_client() as c:
rv = c.get("hello")
assert 200 == rv.status_code
assert b"hello" in rv.data
assert g.resource == "hello"
assert g.action == "get"
with app.test_client() as c:
headers = {'Content-Type': 'application/json'}
# empty request data is invalid json content
assert c.post('hello', headers=headers).status_code == 400
assert c.put('hello', headers=headers).status_code == 400
assert c.post('hello', data="{}", headers=headers).status_code == 200
assert c.put('hello', data="null", headers=headers).status_code == 200
# bad json
assert c.post('hello', headers=headers, data="x").status_code == 400
assert c.put('hello', headers=headers, data="x").status_code == 400
def test_blueprint():
class Hello(Resource):
def get(self):
return "hello"
app = Flask(__name__)
app.debug = True
bp = Blueprint("blueprint", __name__)
api = Api(app, blueprint=bp)
api.add_resource(Hello)
app.register_blueprint(bp, url_prefix="/api")
with app.test_request_context('/api/hello'):
assert request.endpoint == "blueprint.hello"
assert url_for("blueprint.hello") == "/api/hello"
with app.test_client() as c:
rv = c.get("/api/hello")
assert 200 == rv.status_code
assert b"hello" == rv.data
assert g.resource == "hello"
assert g.action == "get"
def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class Hello(Resource):
def get(self):
return "hello"
def get_error(self):
raise ValueError("error")
def post_login(self):
return "login"
api.add_resource(Hello)
# name can't be unicode on py2
api.add_resource(Hello, name=str("hi"))
app.resource = Hello
app.api = api
return app
def test_return_inner_custom_type():
class User(object):
def __init__(self, name):
self.name = name
class Hello(Resource):
sche = {"name": "str"}
schema_outputs = {
"get": sche,
"get_list": [sche],
"get_dict": {"user": sche}
}
output_types = [User]
def get(self):
return User("kk")
def get_list(self):
return [User("kk")] * 10
def get_dict(self):
return {"user": User("kk")}
app = Flask(__name__)
app.debug = True
api = Api(app)
api.add_resource(Hello)
with app.test_client() as c:
assert 200 == c.get("/hello").status_code
assert 200 == c.get("/hello/list").status_code
assert 200 == c.get("/hello/dict").status_code
user = loads(c.get("/hello").data)
assert user == {"name": "kk"}
userlist = loads(c.get("/hello/list").data)
assert userlist == [{"name": "kk"}] * 10
userdict = loads(c.get("/hello/dict").data)
assert userdict["user"] == {"name": "kk"}
def test_gendocs_str():
class Hello(Resource):
"""中文docstring for Hello哈哈"""
def get(self):
"""你好啊"""
return "hello"
app = Flask(__name__)
api = Api(app)
api.add_resource(Hello)
api.gen_resdocs()
api.gen_resjs()
def app():
app = Flask(__name__)
app.debug = True
api = Api(app)
class Hello(Resource):
def get(self):
return "hello"
def get_error(self):
raise ValueError("get_error")
def post_login(self):
return "login"
@Hello.error_handler
def error_handler(self, ex):
return {"ok": "error_hander"}
class File(Resource):
def get(self):
return "file"
def get_error(self):
raise ValueError("get_error")
def post_login(self):
return "login"
api.add_resource(Hello)
# name can't be unicode on py2
api.add_resource(File, name=str("upload"))
return app
# coding:utf-8
import sys
import os
sys.path.insert(0, os.path.abspath("../"))
from flask import Flask
from flask_restaction import Api
from flask_restaction import Resource
from flask_restaction import abort
from datetime import datetime
app = Flask(__name__)
api = Api(app)
app.config["JSON_AS_ASCII"] = False
app.config["RESOURCE_JWT_SECRET"] = "RESOURCE_JWT_SECRET"
todos = {
1: {
"name": "todo1",
"date": datetime.utcnow(),
"finish": False
},
}
class Todo(Resource):
"""docstring for Todo"""
schema_id = ("id", {
"desc": "todo's id",
"""Test Server"""
from flask import Flask, Response, request, abort, redirect, url_for, g
from flask_restaction import Api, TokenAuth
from flask_cors import CORS
from os.path import abspath, dirname, join
app = Flask(__name__)
app.secret_key = "secret_key"
CORS(app, expose_headers=['Authorization'])
metafile = abspath(join(dirname(__file__), "meta.json"))
api = Api(app, metafile=metafile)
auth = TokenAuth(api)
@auth.get_role
def get_role(token):
if token:
return token["role"]
return "guest"
class Test:
"""
$shared:
name: str&default="world"
"""
def __init__(self, api):
self.api = api
def get(self, name):
from flask import Flask
from flask_restaction import Resource, Api, Gen
app = Flask(__name__)
api = Api(app)
class Hello(Resource):
"""hello world"""
schema_inputs = {
"get": {
"name": ("safestr&default='world'", "your name")
}
}
schema_outputs = {
"get": {"hello": "unicode&required"}
}
def get(self, name):
"""welcome to flask-restaction"""
return {"hello": name}
api.add_resource(Hello)
gen = Gen(api)
gen.resjs('static/res.js')
gen.resdocs('static/resdocs.html', resjs='/static/res.js',
bootstrap='/static/bootstrap.min.css')
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask, Blueprint
from flask_restaction import Api
from flask_sqlalchemy import SQLAlchemy
from config import config
app = Flask(__name__)
app.config.from_object(config["development"])
# 数据库连接
db = SQLAlchemy(app)
# 蓝图
apiv1bp = Blueprint('api', __name__)
front = Blueprint('front', __name__)
# 过滤器
# view
# Flask-restAction 创建API,并且给API添加资源
apiv1 = Api(apiv1bp)
from app.apis.v1.demo import Hello
apiv1.add_resource(Hello)
apiv1.add_resource(type('Docs', (), {'get': apiv1.meta_view}))
# 蓝图添加路由
app.register_blueprint(front, url_prefix='/')
app.register_blueprint(apiv1bp, url_prefix='/v1')
# app.register_blueprint(apiv1bp, url_prefix='/v1')
from __future__ import absolute_import
from flask import Flask
from flask_restaction import Api
from datetime import datetime
from validater import add_validater
def user_role(uid):
if uid == 1:
return "admin"
def iso_datetime_validater(v):
if isinstance(v, datetime):
return (True, v.isoformat())
else:
return (False, None)
add_validater("iso_datetime", iso_datetime_validater)
app = Flask(__name__)
app.debug = True
api = Api(app, fn_user_role=user_role)
app.config["JSON_AS_ASCII"] = False
from .users import User
from .todos import Todo
api.add_resource(User)
api.add_resource(Todo)
api.gen_resjs()
api.gen_resdocs()
from flask import Flask, Response
from flask_restaction import Api, abort
app = Flask(__name__)
# 创建一个 Api 对象，把 app 作为参数
api = Api(app)
# 创建 Welcome 类，描述欢迎信息(框架可以序列化任意类型的对象)
class Welcome:
def __init__(self, name):
self.name = name
self.message = "Hello %s, Welcome to flask-restaction!" % name
def foo(self):
print("test for sire")
count =100
# 创建一个 Hello 类，定义 get 方法
class Hello:
"""Hello world"""
# 在 get 方法文档字符串中描述输入参数和输出的格式
def get(self, name):
"""
Get welcome message
$input:
name?str&default="world": Your name
$output:
message?str: Welcome message
$error:
"""Test Server"""
from flask import Flask, Response, request, abort, redirect, url_for, g
from flask_restaction import Api, TokenAuth
from flask_cors import CORS
from os.path import abspath, dirname, join
app = Flask(__name__)
app.secret_key = "secret_key"
CORS(app, expose_headers=['Authorization'])
metafile = abspath(join(dirname(__file__), "meta.json"))
api = Api(app, metafile=metafile)
auth = TokenAuth(api)
@auth.get_role
def get_role(token):
if token:
return token["role"]
return "guest"
class Test:
"""
$shared:
name: str&default="world"
"""
def __init__(self, api):
self.api = api
$shared:
paging:
page_num?int&min=1&default=1: 第几页，从1开始计算
page_size?int&min=1&default=10: 每页的数量
$error:
404.NotFound: 未找到页面
500.ServerError: 服务器错误
"""
from flask_restaction import Api
from flask import Flask
app = Flask(__name__)
app.debug = True
app.config['API_URL_PREFIX'] = '/api'
api = Api(app, docs=__doc__)
api.meta["$roles"] = {
"管理员": {
"hello": ["get", "post_login", "delete", "put", "post", "put_login"],
"User": ["get", "post_login", "delete", "put", "post"],
"Article": ["get", "post_login", "delete", "put"],
"hello5": ["get", "post_login", "delete"],
"hello6": ["get", "post_login"]
},
"普通用户": {
"hello": ["get", "post_login"]
},
"访客": {
"hello": ["post_login"]
}
}
"""flask exts""" from flask_restaction import Api, Auth from flask_github import GitHub from flask_mail import Mail from flask_limiter import Limiter from flask_limiter.util import get_remote_address from flask_couchdb import CouchDB db = CouchDB() github = GitHub() mail = Mail() limiter = Limiter(key_func=get_remote_address) api = Api() auth = Auth()
Support markdown in docs:
执行以下命令，将会在static目录下生成res.js文件:
```
resjs http://127.0.0.1:5000/docs -d static/res.js
```
之后打开chrome控制台就可以用res.js调用API了。
"""
from flask import Flask, g
from flask_restaction import Api, TokenAuth
app = Flask(__name__)
api = Api(app, docs=__doc__, metafile="meta.json")
app.secret_key = b'secret_key'
auth = TokenAuth(api)
@auth.get_role
def get_role(token):
if token:
return token.get('role', 'guest')
return 'guest'
class Welcome:
def __init__(self, name):
self.name = name
self.message = "Hello %s, Welcome to flask-restaction!" % name
# --*-- coding:utf-8 --*--
from __future__ import print_function, unicode_literals, division
from flask import Flask, jsonify, request
from flask_restaction import Resource, Api, Gen, Res
import json
app = Flask(__name__)
api = Api(app)
res = Res(api)
Userlist = []
def inc(cls):
counter = {"result": 0}
def wrap(*args):
counter["result"] += 1
result = cls(counter["result"], *args)
global Userlist
Userlist.append(result)
return result
return wrap
@inc
class User(object):
def __str__(self):
return "<USER: id-{self._id}-{self.name}>".format(self=self)
import sys
import os
sys.path.insert(0, os.path.abspath("../"))
from flask import Flask
from flask_restaction import Resource, Api
app = Flask(__name__)
api = Api(app)
class Hello(Resource):
schema_inputs = {
"get": {
"name": {
"desc": "you name",
"required": True,
"validate": "safestr",
"default": "world"
}
}
}
def get(self, name):
return {"hello": name}
api.add_resource(Hello)
api.gen_resjs()
if __name__ == '__main__':
app.run(debug=True)
> flask-restaction is awsome !!
$shared:
paging:
page_num?int&min=1&default=1: 第几页，从1开始计算
page_size?int&min=1&default=10: 每页的数量
$error:
404.NotFound: 未找到页面
500.ServerError: 服务器错误
"""
from flask_restaction import Api
from flask import Flask
app = Flask(__name__)
app.debug = True
api = Api(app, docs=__doc__)
api.meta["$roles"] = {
"管理员": {
"hello": ["get", "post_login", "delete", "put", "post", "put_login"],
"User": ["get", "post_login", "delete", "put", "post"],
"Article": ["get", "post_login", "delete", "put"],
"hello5": ["get", "post_login", "delete"],
"hello6": ["get", "post_login"]
},
"普通用户": {
"hello": ["get", "post_login"]
},
"访客": {
"hello": ["post_login"]
}
}
