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

sanic_api/__init__.py

@@ -1,21 +1,3 @@
-from sanic import Sanic
-from sanic_ext import Extend
+from sanic_api.logger.extension import LoggerExtend
 
-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)
+__version__ = "0.3.0"

sanic_api/api/__init__.py

@@ -1,2 +1,17 @@
-from .api import API
-from .extend import ApiExtend
+from sanic_api.api.request import Request
+from sanic_api.api.response import BaseResp, BaseRespTml, TempModel
+
+"""
+class BaseResponseModel(BaseModel):
+    "直接返回str、int、float、bool等类型"
+    ...
+
+class JsonResponseModel(BaseModel):
+    "返回JSON的Pydantic结构"
+    ...
+
+class ListResponseModel(BaseModel):
+    "返回JSON的Pydantic结构的列表"
+    ...
+
+"""

sanic_api/api/model.py

@@ -1,46 +0,0 @@
-from typing import Optional, Union
-
-from pydantic.fields import ModelPrivateAttr
-from pydantic.main import BaseModel
-from pydantic_core.core_schema import ModelField
-
-
-class ResponseModel(BaseModel):
-    """
-    响应基础模型
-    """
-
-    def __new__(cls, *args, **kwargs):
-        for _field, value in cls.model_fields.items():
-            if not isinstance(value, ModelField):
-                continue
-            value.required = False
-
-        return super().__new__(cls, *args, **kwargs)
-
-
-class ListRespModel(ResponseModel):
-    """
-    列表格式的响应基础模型
-    """
-
-    _data_list: Optional[Union[ModelPrivateAttr, list]] = ModelPrivateAttr(default_factory=list)
-
-    def add_data(self):
-        """
-        当前模型下数据添加到列表中
-        Returns:
-
-        """
-        data = self.dict()
-        self._data_list.append(data)
-        for attr in data.keys():
-            self.__setattr__(attr, None)
-
-    def to_list(self):
-        """
-        返回列表响应数据
-        Returns:
-
-        """
-        return self._data_list

sanic_api/api/request.py

@@ -0,0 +1,157 @@
+import inspect
+from collections.abc import Collection
+from typing import get_origin
+
+from pydantic import BaseModel
+from sanic import Request as SanicRequest
+from sanic_ext.extensions.openapi.builders import OperationStore
+
+
+class Request(SanicRequest):
+    """
+    自定义的请求类
+    加入便于接口参数获取校验的方法
+    """
+
+    json_data: BaseModel
+    form_data: BaseModel
+    query_data: BaseModel
+
+    _request_type: type["Request"] | None
+    _json_data_type: type[BaseModel] | None
+    _form_data_type: type[BaseModel] | None
+    _query_data_type: type[BaseModel] | None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    async def receive_body(self):
+        """
+        接收请求体
+        在这里进行参数校验注入的所有操作
+        Returns:
+
+        """
+        await super().receive_body()
+        self._get_data_type()
+        self._load_data()
+        self._set_openapi()
+
+    def _get_type(self, name: str, base_type: type):
+        """
+        获取指定属性的类型
+        Args:
+            name: 属性名字
+            base_type: 所属的基本类型
+
+        Returns:
+            对于参数返回BaseModel或None
+            对于情求类型返回Request或None
+        """
+
+        route_handler_arg_spec = inspect.getfullargspec(self.route.handler)
+        arg_type = route_handler_arg_spec.annotations.get(name)
+        is_name = name in route_handler_arg_spec.args
+        is_type = arg_type and issubclass(arg_type, base_type) and arg_type not in (Request, SanicRequest)
+        if is_name and is_type:
+            return arg_type
+        return None
+
+    def _get_data_type(self):
+        """
+        获取json_data、form_data、query_data、request的类型
+        如果定义了request就从request上面获取上述类型
+        Returns:
+
+        """
+
+        # 从函数参数注解上面获取类型
+        self._json_data_type = self._get_type("json_data", BaseModel)
+        self._form_data_type = self._get_type("form_data", BaseModel)
+        self._query_data_type = self._get_type("query_data", BaseModel)
+        self._request_type = self._get_type("request", Request)
+
+        # 没有json_data参数 但是有自定义的request类就从request类上面获取json_data类型
+        if self._request_type and not self._json_data_type:
+            self._json_data_type = self._request_type.__annotations__.get("json_data")
+
+        # 没有form_data参数 但是有自定义的request类就从request类上面获取form_data类型
+        if self._request_type and not self._form_data_type:
+            self._form_data_type = self._request_type.__annotations__.get("form_data")
+
+        # 没有query_data参数 但是有自定义的request类就从request类上面获取query_data类型
+        if self._request_type and not self._query_data_type:
+            self._query_data_type = self._request_type.__annotations__.get("query_data")
+
+    # noinspection PyBroadException
+    def _load_data(self):
+        """
+        加载json_data、form_data、query_data数据
+        同时做参数校验及参数的注入
+        Returns:
+
+        """
+        route_handler_arg_spec = inspect.getfullargspec(self.route.handler)
+
+        def _set_arg(name, value):
+            arg_type = route_handler_arg_spec.annotations.get(name)
+            if name in route_handler_arg_spec.args and issubclass(arg_type, BaseModel):
+                self.match_info.update({name: value})
+
+        def _proc_param_data(data: dict, data_type: BaseModel | None):
+            for k, v in data.items():
+                if isinstance(v, list) and len(v) == 1:
+                    field = data_type.model_fields.get(k)
+                    if not field:
+                        continue
+                    arg_type = field.annotation
+                    arg_type = get_origin(arg_type) or arg_type
+                    is_list = issubclass(arg_type, Collection) and arg_type is not str
+                    if not is_list:
+                        data[k] = v[0]
+            return data
+
+        try:
+            json_data = self.json
+        except Exception:
+            json_data = None
+        if json_data and self._json_data_type:
+            self.json_data = self._json_data_type(**json_data)
+            _set_arg("json_data", self.json_data)
+
+        # 由于form和query的参数的key是可以重复的，所以默认类型是类似dict[str, list]的
+        # 这里做了个处理，如果key的数量是1个则直接转为dict[str, dict]
+        try:
+            form_data = self.form
+        except Exception:
+            form_data = None
+        if form_data and self._form_data_type:
+            form_data = _proc_param_data(form_data, self._form_data_type)
+            self.form_data = self._form_data_type(**form_data)
+            _set_arg("form_data", self.form_data)
+
+        try:
+            query_data = self.args
+        except Exception:
+            query_data = None
+        if query_data and self._query_data_type:
+            query_data = _proc_param_data(query_data, self._query_data_type)
+            self.query_data = self._query_data_type(**query_data)
+            _set_arg("query_data", self.query_data)
+
+    def _set_openapi(self):
+        """
+        注入 OpenAPI 信息
+        """
+
+        func = self.route.handler
+
+        # 设置接口的概括和描述
+        api_doc = self._request_type.__doc__ if self._request_type else func.__doc__
+
+        if api_doc:
+            api_doc = api_doc.strip()
+            summary = api_doc.split("\n")[0]
+            description = "\n".join(api_doc.split("\n")[1:])
+
+            OperationStore()[func].describe(summary=summary, description=description)

sanic_api/api/response.py

@@ -0,0 +1,34 @@
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field, PrivateAttr
+from sanic.compat import Header
+from sanic.response import JSONResponse
+
+
+class TempModel(BaseModel):
+    _data_field: str = PrivateAttr(default="data")
+    data: Any = Field(default=None, title="数据")
+    code: str = Field(default_factory=str, title="业务状态码")
+    msg: str = Field(default_factory=str, title="消息")
+
+    def get_data_field_name(self) -> str:
+        return self._data_field
+
+
+class BaseResp(BaseModel):
+    temp_data: ClassVar = Ellipsis
+
+    def resp(self, status: int = 200, headers: Header | dict[str, str] | None = None) -> JSONResponse:
+        data = self.model_dump(mode="json")
+        return JSONResponse(data, status=status, headers=headers)
+
+
+class BaseRespTml(BaseModel):
+    temp_data: TempModel | None = Field(default_factory=TempModel)
+
+    def resp(self, status: int = 200, headers: Header | dict[str, str] | None = None) -> JSONResponse:
+        tmp_data_field_name = self.temp_data.get_data_field_name()
+        self_data = self.model_dump(mode="json", exclude={"temp_data"})
+        setattr(self.temp_data, tmp_data_field_name, self_data)
+        tml_data = self.temp_data.model_dump(mode="json")
+        return JSONResponse(tml_data, status=status, headers=headers)

sanic_api/app.py

@@ -0,0 +1,306 @@
+import sentry_sdk
+from sanic import Sanic, text
+from sanic.log import logger
+from sanic.worker.loader import AppLoader
+from sanic_ext import Extend
+from sentry_sdk.integrations.asyncio import AsyncioIntegration
+
+from sanic_api import LoggerExtend
+from sanic_api.api import Request
+from sanic_api.config import DefaultSettings, RunModeEnum
+
+
+class BaseApp:
+    name: str = "sanic-server"
+    settings: DefaultSettings
+
+    def __init__(self, settings: DefaultSettings):
+        self.settings = settings
+
+    @classmethod
+    def run(cls, settings: DefaultSettings = None):
+        """
+        运行服务
+        Args:
+            settings: 设置，为空就使用默认设置
+
+        Returns:
+
+        """
+        if not cls.name:
+            raise ValueError("请设置服务名称！")
+
+        settings = settings or DefaultSettings()
+        self = cls(settings)
+        loader = AppLoader(factory=self._create_app)
+        app = loader.load()
+
+        # 服务配置
+        # 开发模式下workers指定为1，自动重载根据配置决定，默认关闭，跨域设置为允许所有跨域
+        # 生产模式下使用fast模型，自动指定最多的workers，自定重载强制关闭，跨域使用配置中的跨域列表
+        # 默认启用sanic_ext里面的后台日志记录器
+        motd_display = {"envornment": settings.envornment}
+        config = {"access_log": settings.access_log, "motd_display": motd_display}
+        if settings.mode == RunModeEnum.DEBNUG:
+            config.update({"auto_reload": settings.auto_reload, "workers": 1, "debug": True})
+        else:
+            config.update({"fast": True, "auto_reload": False})
+
+        app.prepare(settings.host, settings.port, **config)
+        Sanic.serve(primary=app, app_loader=loader)
+
+    def _create_app(self):
+        """
+        创建app的内部工厂方法
+        Returns:
+
+        """
+        app = Sanic(self.name, configure_logging=False, request_class=Request)
+
+        self._setup_logger(app)
+        self._setup_config(app)
+        self._setup_openai(app)
+
+        app.main_process_stop(self._main_process_stop)
+        app.main_process_start(self._main_process_start)
+        app.before_server_start(self._before_server_start)
+        app.before_server_stop(self._before_server_stop)
+        app.after_server_start(self._after_server_start)
+        app.after_server_stop(self._after_server_stop)
+        return app
+
+    async def _main_process_start(self, app: Sanic):
+        """
+        主进程启动的内部方法
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info("主进程启动")
+        await self.main_process_start(app)
+
+    async def _main_process_stop(self, app: Sanic):
+        """
+        主进程停止的内部方法
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info("主进程停止")
+        await self.main_process_stop(app)
+
+    async def _before_server_start(self, app: Sanic):
+        """
+        工作进程启动之前的内部方法。
+        设置路由写在这里是因为sanic_ext是会在before_server_start阶段对路由设置_cors属性
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info(f"工作进程 {app.m.pid} 即将启动")
+
+        await self._setup_route(app)
+        await self.before_server_start(app)
+
+    async def _before_server_stop(self, app: Sanic):
+        """
+        服务停止之前的内部方法
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info(f"工作进程 {app.m.pid} 即将停止")
+        await self.before_server_stop(app)
+
+    async def _after_server_start(self, app: Sanic):
+        """
+        服务启动之后的内部方法
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info(f"工作进程 {app.m.pid} 启动完毕")
+        await self.after_server_start(app)
+
+    async def _after_server_stop(self, app: Sanic):
+        """
+        服务停止之后的内部方法
+        Args:
+            app:
+
+        Returns:
+
+        """
+        logger.info(f"工作进程 {app.m.pid} 停止")
+        await self.after_server_stop(app)
+
+    def _setup_config(self, app: Sanic):
+        """
+        设置配置
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+        app.config.LOGGING = True
+        self._setup_cors(app)
+
+    def _setup_openai(self, app: Sanic): ...
+
+    def _setup_cors(self, app: Sanic):
+        """
+        设置跨域: 开发模式下允许所有跨域，生产模式下使用配置中的跨域列表
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+        cors = ",".join(self.settings.cors.origins)
+        if self.settings.mode == RunModeEnum.DEBNUG:
+            app.config.CORS_SEND_WILDCARD = True
+            app.config.CORS_SUPPORTS_CREDENTIALS = self.settings.cors.supports_credentials
+            app.config.CORS_ORIGINS = cors or "*"
+        else:
+            app.config.CORS_ORIGINS = cors
+
+    async def _setup_route(self, app: Sanic):
+        """
+        设置路由和蓝图的内部方法，自动设置一个ping的路由
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+        app.add_route(self._ping, "ping", methods=["GET", "POST"])
+        await self.setup_route(app)
+
+    def _setup_logger(self, app: Sanic):
+        """
+        设置日志
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+        log_config = self.settings.logger
+        log_ext = LoggerExtend(
+            app,
+            log_file=log_config.file,
+            rotation=log_config.rotation,
+            retention=log_config.retention,
+            compression=log_config.compression,
+            loki_url=log_config.loki_url,
+            loki_labels={"Application": self.name, "Envornment": self.settings.envornment},
+        )
+        Extend.register(log_ext)
+
+    def _setup_sentry(self, _app: Sanic):
+        """
+        如果存在sentryURL配置，则自动设置sentry哨兵
+        Args:
+            _app: Sanic App
+
+        Returns:
+
+        """
+        if self.settings.sentry_dsn is None:
+            return
+
+        sentry_sdk.init(
+            dsn=str(self.settings.sentry_dsn),
+            # Set traces_sample_rate to 1.0 to capture 100%
+            # of transactions for tracing.
+            traces_sample_rate=1.0,
+            # Set profiles_sample_rate to 1.0 to profile 100%
+            # of sampled transactions.
+            # We recommend adjusting this value in production.
+            profiles_sample_rate=1.0,
+            integrations=[AsyncioIntegration()],
+        )
+
+    async def _ping(self, _request):
+        return text("ok")
+
+    async def main_process_start(self, app: Sanic):
+        """
+        主进程启动的方法
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def main_process_stop(self, app: Sanic):
+        """
+        主进程停止的方法
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def before_server_start(self, app: Sanic):
+        """
+        工作进程启动之前的方法。
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def before_server_stop(self, app: Sanic):
+        """
+        工作进程停止之前的方法。
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def after_server_start(self, app: Sanic):
+        """
+        工作进程启动之后的方法。
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def after_server_stop(self, app: Sanic):
+        """
+        工作进程停止之后的方法。
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """
+
+    async def setup_route(self, app: Sanic):
+        """
+        继承此方法去设置蓝图及路由
+        Args:
+            app: Sanic App
+
+        Returns:
+
+        """

sanic_api/config/__init__.py

@@ -1 +1 @@
-from .setting import DefaultSettings
+from sanic_api.config.setting import DefaultSettings, RunModeEnum, SettingsBase

sanic_api/config/setting.py

@@ -1,12 +1,57 @@
-from hs_config import ConfigBase
-from pydantic import Field
+from hs_config import SettingsBase
+from pydantic import BaseModel, Field, FilePath, HttpUrl, NewPath
 
-from sanic_api.config.sanic import SanicConfig
-from sanic_api.config.sanic_api import SanicApiConfig
-from sanic_api.enum import RunModeEnum
+from sanic_api.utils.enum import EnumBase, EnumField
 
 
-class DefaultSettings(ConfigBase):
+class RunModeEnum(EnumBase):
+    """
+    运行模式
+    """
+
+    DEBNUG = EnumField("debug", desc="开发模式")
+    PRODUCTION = EnumField("prod", desc="生产模式")
+
+
+class LoggerSettings(BaseModel):
+    """
+    日志配置类
+    """
+
+    # 日志文件路径
+    file: FilePath | NewPath | None = Field(default=None)
+
+    # 自动轮转条件。就是保留几天的日志。
+    # 具体查看loguru文档：https://loguru.readthedocs.io/en/stable/api/logger.html#file
+    rotation: str | None = Field(default=None)
+
+    # 日志文件保留条件。就是保留多大的日志。
+    # 具体查看loguru文档：https://loguru.readthedocs.io/en/stable/api/logger.html#file
+    retention: str | None = Field(default=None)
+
+    # 日志文件的压缩格式。zip、gz、tar等。
+    # 体查看loguru文档：https://loguru.readthedocs.io/en/stable/api/logger.html#file
+    compression: str | None = Field(default=None)
+
+    # loji的地址。如果存在，则会把日志推送给logki
+    loki_url: HttpUrl | None = Field(default=None)
+
+
+class CrosSettings(BaseModel):
+    """
+    跨域设置
+    """
+
+    # 地址、地址列表、*
+    # 当 credentials等于 'include' 时，origins必须是具体是地址不能是 “*”
+    origins: list[str] | None = Field(default_factory=list)
+
+    # 支持凭证。
+    # 当前端启用了withCredentials 后端需要设置这个值为True
+    supports_credentials: bool = Field(default=False)
+
+
+class DefaultSettings(SettingsBase):
     """
     配置类
     """
@@ -15,16 +60,26 @@ class DefaultSettings(ConfigBase):
     host: str = Field(default="127.0.0.1")
 
     # 端口
-    port: int = Field(default=5798)
+    port: int = Field(default=6969)
 
     # 运行模式
-    mode: RunModeEnum = Field(default=RunModeEnum.DEV)
+    mode: RunModeEnum = Field(default=RunModeEnum.DEBNUG)
+
+    # 运行环境，仅作为环境标识。
+    # 尽量不要使用这个字段去做逻辑判断。请使用mode去进行判断，因为测试环境、预发布环境、生产环境都应属于生产模式模式
+    envornment: str = Field(default="dev")
+
+    # 自动重载。生产模式强制关闭
+    auto_reload: bool = Field(default=False)
+
+    # 访问日志开关
+    access_log: bool = Field(default=True)
 
-    # 工作进程的数量
-    workers: int = Field(default=1)
+    # 跨域设置
+    cors: CrosSettings = Field(default_factory=CrosSettings)
 
-    # sanic 自身的配置
-    sanic: SanicConfig = Field(default_factory=SanicConfig)
+    # 哨兵连接dsn，如果存在则会把错误信息推送给哨兵
+    sentry_dsn: HttpUrl | None = Field(default=None)
 
-    # sanic_api 扩展自身需要的配置
-    sanic_api: SanicApiConfig = Field(default_factory=SanicApiConfig)
+    # 日志配置
+    logger: LoggerSettings = Field(default_factory=LoggerSettings)

sanic_api/logger/__init__.py

@@ -1 +0,0 @@
-from .extend import LoggerExtend