sanic-api 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

sanic_api/__init__.py

@@ -1,21 +1,21 @@
-from sanic import Sanic
-from sanic_ext import Extend
-
-from sanic_api import api, openapi
-
-from .api import ApiExtend
-from .logger import LoggerExtend
-
-
-def init_api(app: Sanic):
-    """
-    初始化API
-    Args:
-        app: Sanic的APP
-
-    Returns:
-
-    """
-    Extend.register(LoggerExtend)
-    Extend.register(ApiExtend)
-    openapi.init(app)
+from sanic import Sanic
+from sanic_ext import Extend
+
+from sanic_api import api, openapi
+
+from .api import ApiExtend
+from .logger import LoggerExtend
+
+
+def init_api(app: Sanic):
+    """
+    初始化API
+    Args:
+        app: Sanic的APP
+
+    Returns:
+
+    """
+    Extend.register(LoggerExtend)
+    Extend.register(ApiExtend)
+    openapi.init(app)

sanic_api/api/__init__.py

@@ -1,2 +1,2 @@
-from .api import API
-from .extend import ApiExtend
+from .api import API
+from .extend import ApiExtend

sanic_api/api/api.py

@@ -1,177 +1,177 @@
-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()
+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 +1,46 @@
-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)
+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 +1,25 @@
-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)
+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 +1,61 @@
-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()
+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()