sanic-api 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

example/api/user.py

@@ -1,89 +0,0 @@
-from typing import Any, Dict, List
-from uuid import uuid4
-
-from sanic import Blueprint, text
-from sanic.request import Request
-
-from .validator import (
-    UserAddApi,
-    UserDelApi,
-    UserFindOneApi,
-    UserListApi,
-    UserUpdateApi,
-)
-
-users_blueprint = Blueprint("users_blueprint", url_prefix="/users")
-users_blueprint.ctx.desc = "用户"
-
-
-@users_blueprint.route("/test", methods=["GET"])
-async def hello(request):
-    return text("Hello world!")
-
-
-@users_blueprint.route("/", methods=["POST"])
-async def user_add(request: Request, api: UserAddApi):
-    """
-    添加用户
-    """
-    api.resp.uid = 1
-    return api.json_resp()
-
-
-@users_blueprint.route("/<uid>", methods=["DELETE"])
-async def user_del(request: Request, uid: int, api: UserDelApi):
-    """
-    刪除一个用户
-    """
-
-    api.resp.uid = uid
-
-    return api.json_resp()
-
-
-@users_blueprint.route("/<uid>", methods=["PUT"])
-async def user_update(request: Request, uid: int, api: UserUpdateApi):
-    """
-    更新一个用户
-    """
-
-    api.resp.uid = uid
-
-    return api.json_resp()
-
-
-@users_blueprint.route("/<uid>", methods=["GET"])
-async def user_one(request: Request, uid: int, api: UserFindOneApi):
-    """
-    获取一个用户
-    """
-
-    api.resp.uid = 1
-    api.resp.username = "username"
-    api.resp.password = uuid4().hex
-
-    return api.json_resp()
-
-
-@users_blueprint.route("/", methods=["GET"])
-async def user_list(request: Request, api: UserListApi):
-    """
-    获取一些用户
-    """
-
-    users: List[Dict[str, Any]] = [
-        {
-            "uid": 1,
-            "username": "user1",
-        },
-        {
-            "uid": 2,
-            "username": "user2",
-        },
-    ]
-    for user in users:
-        api.resp.username = user["username"]
-        api.resp.uid = user["uid"]
-        api.resp.add_data()
-
-    return api.json_resp()

example/api/validator.py

@@ -1,97 +0,0 @@
-from pydantic import BaseModel, Field
-
-from sanic_api.api import API
-from sanic_api.api.model import ListRespModel, ResponseModel
-
-
-class Pagination(BaseModel):
-    """
-    分页
-    """
-
-    page: int = Field(1, gt=0, title="页数")
-    per_page: int = Field(20, title="每页数量", gt=0, lt=100)
-
-
-class ListParam(Pagination):
-    """
-    列表
-    """
-
-    orderings: str = Field(None, title="排序字段", description='排序字段，多个字段 ”,“ 分割，倒序使用 "-", 如："id, -name"')
-
-
-class UserModel(BaseModel):
-    username: str = Field(title="用户名")
-    password: str = Field(title="密码", description="密码，经过md5加密的")
-
-
-class AddUserReqModel(BaseModel):
-    """
-    添加请求参数
-    """
-
-    user: UserModel = Field(title="用户信息")
-
-
-class AddUserRespModel(ResponseModel):
-    """
-    响应参数
-    """
-
-    uid: int = Field(default=None, title="用户ID", description="创建用户的用户ID")
-
-
-class FindOneUserRespModel(UserModel, AddUserRespModel):
-    """
-    响应参数
-    """
-
-
-class UserListRespModel(ListRespModel, FindOneUserRespModel):
-    """
-    用户列表响应参数
-    """
-
-
-class UserAddApi(API):
-    """
-    添加用户API
-    """
-
-    json_req: AddUserReqModel
-    resp: AddUserRespModel
-
-
-class UserDelApi(API):
-    """
-    删除用户API
-    """
-
-    resp: AddUserRespModel
-
-
-class UserUpdateApi(UserAddApi):
-    """
-    更新用户API
-    """
-
-    json_req: AddUserReqModel
-    resp: AddUserRespModel
-
-
-class UserFindOneApi(API):
-    """
-    查询单个用户API
-    """
-
-    resp: FindOneUserRespModel
-
-
-class UserListApi(API):
-    """
-    用户列表API
-    """
-
-    query_req: ListParam
-    resp: UserListRespModel

example/app.py

@@ -1,62 +0,0 @@
-from sanic import Sanic
-from sanic.log import logger
-
-from example.settings import settings
-from sanic_api import init_api
-from sanic_api.utils import auto_blueprint
-
-
-async def main_process_start(sanic_app: Sanic):
-    """
-    主进程启动之前调用
-    Args:
-        sanic_app: application
-
-    Returns:
-
-    """
-    sanic_cfg = settings.sanic.dict(by_alias=True)
-    sanic_app.config.update(sanic_cfg)
-    logger.info(f"{sanic_app.name} 服务启动")
-
-
-async def main_process_stop(sanic_app: Sanic):
-    """
-    主进程停止之后调用
-    Args:
-        sanic_app: application
-
-    Returns:
-
-    """
-
-    logger.info(f"{sanic_app.name} 服务停止")
-
-
-async def before_server_start(sanic_app: Sanic):
-    """
-    worker启动之前调用
-    Args:
-        sanic_app: application
-
-    Returns:
-
-    """
-    logger.debug(f"Worler {sanic_app.m.pid} 启动")
-
-
-def app_factory():
-    """
-    app 工厂方法
-    Returns:
-
-    """
-    app = Sanic(name="test", configure_logging=False)
-    app.main_process_start(main_process_start)
-    app.main_process_stop(main_process_stop)
-    app.before_server_start(before_server_start)
-
-    auto_blueprint(app, "api")
-    init_api(app)
-
-    return app

example/settings.py

@@ -1,10 +0,0 @@
-from sanic_api.config import DefaultSettings
-
-
-class Settings(DefaultSettings):
-    """
-    设置类
-    """
-
-
-settings = Settings()

sanic_api/api/api.py

@@ -1,177 +0,0 @@
-import functools
-from abc import ABCMeta
-from typing import Any, Callable, Dict, Optional
-
-from pydantic import BaseModel, Field
-from pydantic import ValidationError as PyDanticValidationError
-from sanic import HTTPResponse, Sanic
-from sanic.response import json
-
-from sanic_api.api.exception import ValidationError
-from sanic_api.api.model import ListRespModel, ResponseModel
-from sanic_api.enum import EnumBase, ParamEnum, RespCodeEnum
-from sanic_api.utils import json_dumps
-
-
-def get_resp_tmp(key: str, default):
-    """
-    获取响应字段模板
-    """
-    app = Sanic.get_app()
-    sanic_api: dict = app.config.get("sanic_api", {})
-    return sanic_api.get(key, default)
-
-
-class Response:
-    def __init__(
-        self,
-        http_code: int = 200,
-        headers: Optional[Dict[str, str]] = None,
-        server_code: EnumBase = RespCodeEnum.SUCCESS,
-        message: str = "Success",
-        data: Any = None,
-        response_type: Optional[type] = None,
-    ):
-        """
-        初始化函数
-        Args:
-            http_code: http响应码 默认是200
-            headers: 自定义的响应头
-            server_code: 自定义的服务码
-            message: 返回的消息
-            data: 返回的数据
-        """
-
-        self.http_code = http_code
-        self.headers = headers
-        self.message = message
-        response_type = response_type or Response.get_response_type(type(data))
-
-        if isinstance(data, ListRespModel):
-            data = data.to_list()
-        elif isinstance(data, BaseModel):
-            data = data.dict()
-
-        resp: ResponseModel = response_type()
-        code_tmp = get_resp_tmp("code_tmp", "code")
-        msg_tmp = get_resp_tmp("msg_tmp", "msg")
-        data_tmp = get_resp_tmp("data_tmp", "data")
-
-        setattr(resp, code_tmp, server_code)
-        setattr(resp, msg_tmp, message)
-        setattr(resp, data_tmp, data)
-
-        data = resp.dict()
-
-        self.data = data
-
-    def json_resp(self, default: Optional[Callable[[Any], Any]] = None) -> HTTPResponse:
-        """
-        返回json格式的响应
-        Args:
-
-        """
-        return json(
-            body=self.data,
-            status=self.http_code,
-            headers=self.headers,
-            dumps=functools.partial(json_dumps, default=default),
-        )
-
-    @classmethod
-    def get_response_type(cls, data_type: type):
-        """
-        获取响应的类型
-        Args:
-            data_type: 响应中data的类型
-
-        Returns:
-
-        """
-        code_tmp = get_resp_tmp("code_tmp", "code")
-        msg_tmp = get_resp_tmp("msg_tmp", "msg")
-        data_tmp = get_resp_tmp("data_tmp", "data")
-
-        attr_dict = {
-            code_tmp: Field(title="业务响应码"),
-            msg_tmp: Field(title="响应消息"),
-            data_tmp: Field(title="响应数据"),
-            "__annotations__": {code_tmp: int, msg_tmp: str, data_tmp: data_type},
-        }
-        resp_name = data_type.__name__ if data_type.__name__ != "NoneType" else "Response"
-        response_type = type(resp_name, (ResponseModel,), attr_dict)
-        return response_type
-
-    @staticmethod
-    def _get_tmp(key: str, default):
-        """
-        获取字段模板
-        """
-        app = Sanic.get_app()
-        sanic_api: dict = app.config.get("sanic_api", {})
-        return sanic_api.get(key, default)
-
-
-class API(metaclass=ABCMeta):
-    json_req: Optional[BaseModel] = None
-    form_req: Optional[BaseModel] = None
-    query_req: Optional[BaseModel] = None
-    resp: Optional[Any] = None
-    tags: list = []
-    description: str = ""
-
-    def __init__(self):
-        response_type = self.__class__.__annotations__.get("resp")
-        self.json_req_type = self.__class__.__annotations__.get("json_req")
-        self.form_req_type = self.__class__.__annotations__.get("form_req")
-        self.query_req_type = self.__class__.__annotations__.get("query_req")
-        self.response_type = Response.get_response_type(response_type)
-        self.resp = response_type()
-
-    def validate_params(self, req_data: dict, param_enum: ParamEnum):
-        """
-        验证参数，参数有问题抛出异常
-        Args:
-            req_data: 数据
-            param_enum: 参数类型
-
-        Returns:
-
-        """
-        try:
-            if param_enum == ParamEnum.JSON:
-                self.json_req = self.json_req_type(**req_data)
-            elif param_enum == ParamEnum.QUERY:
-                self.query_req = self.query_req_type(**req_data)
-            elif param_enum == ParamEnum.FORM:
-                self.form_req = self.form_req_type(**req_data)
-        except PyDanticValidationError as e:
-            raise ValidationError(e.errors()) from e
-
-    def json_resp(
-        self,
-        http_code: int = 200,
-        headers: Optional[Dict[str, str]] = None,
-        server_code: RespCodeEnum = RespCodeEnum.SUCCESS,
-        message: str = "Success",
-    ):
-        """
-        根据响应数据返回json格式的响应
-        Args:
-            http_code: http协议响应码
-            headers: 响应头
-            server_code: 应用协议响应码
-            message: 响应消息
-
-        Returns:
-            返回一个sanic的HTTPResponse
-        """
-
-        return Response(
-            data=self.resp,
-            http_code=http_code,
-            headers=headers,
-            server_code=server_code,
-            message=message,
-            response_type=self.response_type,
-        ).json_resp()

sanic_api/api/exception.py

@@ -1,46 +0,0 @@
-from typing import Any, Optional
-
-from sanic.exceptions import SanicException
-
-from sanic_api.enum import EnumBase, RespCodeEnum
-from sanic_api.utils import get_current_request
-
-
-class ServerException(SanicException):
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        status_code: Optional[int] = None,
-        server_code: Optional[EnumBase] = None,
-        quiet: Optional[bool] = None,
-        context: Any = None,
-        extra=None,
-    ):
-        super().__init__(
-            message=message,
-            status_code=status_code,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-        )
-        self.server_code = server_code or RespCodeEnum.FAILED
-        self.message = message or self.server_code.desc
-        self.status_code = status_code or 200
-        req = get_current_request()
-        if req:
-            req.ctx.exception = self
-
-
-class ValidationInitError(ServerException):
-    """
-    验证器初始化失败
-    """
-
-
-class ValidationError(ServerException):
-    """
-    参数验证失败
-    """
-
-    def __init__(self, errors: list, *args, **kwargs):
-        super().__init__(server_code=RespCodeEnum.PARAM_FAILED, context=errors)

sanic_api/api/extend.py

@@ -1,25 +0,0 @@
-from sanic.exceptions import NotFound
-from sanic_ext import Extension
-
-from sanic_api.api.exception import ServerException
-
-from .handle_exception import not_found, other_exception, server_exception
-from .validators import validators
-
-
-class ApiExtend(Extension):
-    """
-    接口处理扩展
-    参数校验、异常拦截等功能
-    """
-
-    name = "ApiExtend"
-
-    def startup(self, bootstrap) -> None:
-        if not self.included():
-            return
-
-        self.app.error_handler.add(ServerException, server_exception)
-        self.app.error_handler.add(Exception, other_exception)
-        self.app.error_handler.add(NotFound, not_found)
-        self.app.on_request(validators, priority=998)

sanic_api/api/handle_exception.py

@@ -1,61 +0,0 @@
-from sanic import Request
-from sanic.log import logger
-
-from sanic_api.api.api import Response
-from sanic_api.api.exception import ServerException
-from sanic_api.enum import RespCodeEnum
-
-
-def server_exception(request: Request, e: ServerException):
-    """
-    处理业务异常
-    Args:
-        request: 请求
-        e: 异常信息
-
-    Returns:
-        返回处理异常后的响应
-    """
-
-    return Response(
-        http_code=e.status_code,
-        server_code=e.server_code,
-        message=e.message,
-        data=e.context,
-    ).json_resp()
-
-
-def not_found(request: Request, e):
-    """
-    处理 NotFound 异常
-    Args:
-        request: 请求信息
-        e: 异常信息
-
-    Returns:
-
-    """
-    if "/favicon.ico" == request.path:
-        return
-
-    logger.warning(f"找不到路由：{request.path}")
-
-
-def other_exception(request: Request, e):
-    """
-    处理其他异常
-    Args:
-        request:
-        e:
-
-    Returns:
-
-    """
-    logger.exception(e)
-
-    error_name = e.__class__.__name__
-    return Response(
-        http_code=500,
-        server_code=RespCodeEnum.FAILED,
-        message=f"服务端业务发生未知异常：[{error_name}] {e}",
-    ).json_resp()

sanic_api/api/validators.py

@@ -1,76 +0,0 @@
-import inspect
-
-from sanic import Request
-
-from sanic_api.api import API
-from sanic_api.api.exception import ValidationInitError
-from sanic_api.enum import ParamEnum
-
-
-def _do_validation(param_enum: ParamEnum, api: API, data: dict):
-    if param_enum == ParamEnum.JSON:
-        req_data = data
-    elif param_enum in [ParamEnum.QUERY, param_enum.FORM]:
-        req_data = {}
-        for k, v in data.items():
-            if type(v) == list and len(v) == 1:
-                req_data[k] = v[0]
-            else:
-                req_data[k] = v
-    else:
-        raise ValidationInitError("未知的验证器类型")
-
-    api.validate_params(req_data, param_enum)
-
-
-def get_handler_param(handler):
-    """
-    获取参数处理器的json、form、query参数
-    Args:
-        handler:
-
-    Returns:
-
-    """
-    sig = inspect.signature(handler)
-    api_parameter = sig.parameters.get("api")
-    api_cls = api_parameter.annotation if api_parameter else None
-    return api_cls
-
-
-async def validators(request: Request):
-    """
-    校验请求参数中间件
-    Args:
-        request: 请求
-
-    Returns:
-
-    """
-    # 如果执行中间价直接就发生了异常则直接抛出
-    if hasattr(request.ctx, "exception"):
-        raise request.ctx.exception
-
-    _, handler, _ = request.app.router.get(
-        request.path,
-        request.method,
-        request.headers.getone("host", None),
-    )
-
-    api_cls = get_handler_param(handler)
-    if not api_cls:
-        return
-
-    api: API = api_cls()
-    if api.json_req_type and api.query_req_type:
-        raise ValidationInitError("不能同时存在json参数和form参数")
-
-    if api.json_req_type and request.json:
-        _do_validation(param_enum=ParamEnum.JSON, api=api, data=request.json)
-    elif api.form_req_type and request.form:
-        _do_validation(param_enum=ParamEnum.FORM, api=api, data=request.form)
-    if api.query_req_type and request.query_args:
-        _do_validation(param_enum=ParamEnum.QUERY, api=api, data=request.args)
-
-    request.match_info.update({"api": api})
-    request.ctx.api = api

sanic_api/config/sanic.py

@@ -1,19 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class SanicConfig(BaseModel):
-    """
-    sanic 框架本身的配置
-    """
-
-    # 是否开启OpenAPI规范文档生成
-    oas: bool = Field(default=True)
-
-    # 访问日志开关
-    access_log: bool = Field(default=True, alias="ACCESS_LOG", env="ACCESS_LOG")
-
-    # 后台日志记录器，开启可增加一些性能。见：https://sanic.dev/en/plugins/sanic-ext/logger.html
-    background_log: bool = Field(default=True, alias="LOGGING", env="LOGGING")
-
-    # OpenAPI规范文档的URL前缀
-    oas_url_prefix: str = Field(default="docs", alias="OAS_URL_PREFIX", env="OAS_URL_PREFIX")

sanic_api/config/sanic_api.py

@@ -1,11 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class SanicApiConfig(BaseModel):
-    """
-    sanic_api 框架需要的配置
-    """
-
-    data_tmp: str = Field(title="响应中data类型字段的key", default="data")
-    code_tmp: str = Field(title="响应中data类型字段的key", default="code")
-    msg_tmp: str = Field(title="响应中data类型字段的key", default="msg")