KairoCore 1.0.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

KairoCore/utils/kc_http.py

@@ -0,0 +1,260 @@
+import asyncio
+from typing import Any, Dict, Optional, Union, Mapping
+
+import httpx
+
+from ..utils.log import get_logger
+from ..common.errors import (
+    KCHT_INIT_ERROR,
+    KCHT_REQUEST_ERROR,
+    KCHT_TIMEOUT_ERROR,
+    KCHT_STATUS_ERROR,
+    KCHT_PARSE_ERROR,
+)
+
+logger = get_logger()
+
+class KcHttpResponse:
+    """
+    统一的 HTTP 响应封装
+    
+    字段：
+    - status_code: int 状态码
+    - headers: Dict[str, str] 响应头
+    - data: Any 解析后的数据（按 Content-Type 自动解析 json / text / bytes）
+    - raw: httpx.Response 原始响应对象，保留供高级使用
+    
+    说明：
+    - 当解析失败时抛出 KCHT_PARSE_ERROR，调用方应捕获并按需处理。
+    - is_ok() 用于快速判断 2xx 响应。
+    """
+    def __init__(self, resp: httpx.Response):
+        # 基本属性直接从原始响应复制
+        self.status_code = resp.status_code
+        self.headers = dict(resp.headers)
+        self.raw = resp
+        # 尝试解析响应数据
+        self.data = None
+        try:
+            content_type = resp.headers.get("Content-Type", "")
+            if "application/json" in content_type:
+                self.data = resp.json()  # 自动 JSON 解析
+            elif "text/" in content_type or content_type == "":
+                self.data = resp.text   # 文本或未声明类型，按文本处理
+            else:
+                self.data = resp.content  # 其他类型按二进制处理
+        except Exception as e:
+            # 解析失败统一包装为 PARSE_ERROR，便于上层捕获
+            raise KCHT_PARSE_ERROR.msg_format(str(e))
+
+    def is_ok(self) -> bool:
+        """是否为 2xx 状态。"""
+        return 200 <= self.status_code < 300
+
+class KcHttpSession:
+    """
+    异步 HTTP 会话类（基于 httpx.AsyncClient）。
+    
+    能力：
+    - 连接池与超时配置
+    - 带退避的重试（超时/服务端错误）
+    - 统一的异常与日志
+    - 便捷的请求方法与下载方法
+    
+    典型用法：
+    - 在应用启动时创建实例，并在关闭时调用 close() 释放资源
+    - 或通过 async with 语法在局部作用域中使用
+    """
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout: float = 10.0,
+        max_keepalive: int = 10,
+        retries: int = 2,
+        retry_backoff: float = 0.5,
+        headers: Optional[Mapping[str, str]] = None,
+        verify: Union[bool, str] = True,
+        proxies: Optional[Union[str, Dict[str, str]]] = None,
+    ):
+        try:
+            # 基础配置与参数归一化
+            self.base_url = base_url
+            self.timeout = httpx.Timeout(timeout)
+            self.retries = max(0, retries)
+            self.retry_backoff = max(0.0, retry_backoff)
+            self.headers = dict(headers or {})  # 会话级默认请求头（可用于鉴权）
+            self.verify = verify
+            self.proxies = proxies
+            # 连接池配置（max_keepalive 用于并发连接与复用）
+            limits = httpx.Limits(max_keepalive_connections=max_keepalive, max_connections=max_keepalive)
+            # 创建底层异步客户端
+            self._client: Optional[httpx.AsyncClient] = httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=self.timeout,
+                headers=self.headers,
+                verify=self.verify,
+                proxies=self.proxies,
+                limits=limits,
+                follow_redirects=True,  # 默认为允许跟随重定向
+            )
+            logger.info(f"KcHttpSession 初始化完成 base_url={self.base_url}, timeout={timeout}, retries={self.retries}")
+        except Exception as e:
+            # 初始化失败统一包装为 INIT_ERROR
+            raise KCHT_INIT_ERROR.msg_format(str(e))
+
+    async def __aenter__(self):
+        """支持 async with 用法。"""
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """退出时自动关闭底层客户端。"""
+        await self.close()
+
+    async def close(self):
+        """关闭会话，释放连接池资源。"""
+        if self._client:
+            await self._client.aclose()
+            logger.info("KcHttpSession 已关闭")
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[float] = None,
+    ) -> KcHttpResponse:
+        """
+        底层请求方法（带重试与退避）。
+        
+        流程：
+        1) 合并会话级与方法级的 headers
+        2) 处理超时参数（方法级优先）
+        3) 循环重试：
+           - 5xx 作为服务端错误可重试
+           - 4xx 客户端错误不重试，直接抛出状态异常
+           - 超时按配置重试，最后一次抛出超时异常
+        4) 请求成功后封装为 KcHttpResponse 返回
+        """
+        attempt = 0
+        last_exc: Optional[Exception] = None
+        # 合并请求头：方法级覆盖会话级
+        req_headers = dict(self.headers)
+        if headers:
+            req_headers.update(headers)
+        # 处理方法级超时
+        req_timeout = self.timeout if timeout is None else httpx.Timeout(timeout)
+        while attempt <= self.retries:
+            try:
+                logger.debug(f"HTTP {method} {url} attempt={attempt} params={params} headers={req_headers}")
+                resp = await self._client.request(
+                    method,
+                    url,
+                    params=params,
+                    data=data,
+                    json=json,
+                    headers=req_headers,
+                    timeout=req_timeout,
+                )
+                # 状态码检查：500+ 作为可重试的服务端错误，400-499 直接抛出客户端错误
+                if resp.status_code >= 500:
+                    raise httpx.HTTPStatusError("server error", request=resp.request, response=resp)
+                elif resp.status_code >= 400:
+                    raise httpx.HTTPStatusError("client error", request=resp.request, response=resp)
+                result = KcHttpResponse(resp)
+                return result
+            except httpx.TimeoutException as e:
+                # 超时：记录最后异常并决定是否结束重试
+                last_exc = e
+                logger.warning(f"HTTP 超时: {method} {url} attempt={attempt} err={e}")
+                if attempt >= self.retries:
+                    raise KCHT_TIMEOUT_ERROR.msg_format(str(e))
+            except httpx.HTTPStatusError as e:
+                # 状态码异常：4xx 不重试；5xx 可根据 attempt 决定重试
+                last_exc = e
+                status = getattr(e.response, "status_code", None)
+                logger.warning(f"HTTP 状态异常: {method} {url} status={status} attempt={attempt} err={e}")
+                if attempt >= self.retries or (status and 400 <= status < 500):
+                    # 客户端错误不重试
+                    raise KCHT_STATUS_ERROR.msg_format(f"status={status}: {str(e)}")
+            except httpx.HTTPError as e:
+                # httpx 的其他错误（网络异常等）
+                last_exc = e
+                logger.error(f"HTTP 请求异常: {method} {url} attempt={attempt} err={e}")
+                if attempt >= self.retries:
+                    raise KCHT_REQUEST_ERROR.msg_format(str(e))
+            except Exception as e:
+                # 未知异常统一包装为 REQUEST_ERROR
+                last_exc = e
+                logger.error(f"未知请求异常: {method} {url} attempt={attempt} err={e}")
+                if attempt >= self.retries:
+                    raise KCHT_REQUEST_ERROR.msg_format(str(e))
+            # 退避等待（逐次递增），继续下一次尝试
+            attempt += 1
+            await asyncio.sleep(self.retry_backoff * attempt)
+        # 正常不会走到这里，兜底抛出最后一个异常信息
+        raise KCHT_REQUEST_ERROR.msg_format(str(last_exc) if last_exc else "未知错误")
+
+    # 公开方法
+    async def get(self, url: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Mapping[str, str]] = None, timeout: Optional[float] = None) -> KcHttpResponse:
+        """GET 请求。"""
+        return await self._request("GET", url, params=params, headers=headers, timeout=timeout)
+
+    async def post(self, url: str, data: Optional[Union[Dict[str, Any], str, bytes]] = None, json: Optional[Any] = None, headers: Optional[Mapping[str, str]] = None, timeout: Optional[float] = None) -> KcHttpResponse:
+        """POST 请求（支持 form/data/raw 或 JSON）。"""
+        return await self._request("POST", url, data=data, json=json, headers=headers, timeout=timeout)
+
+    async def put(self, url: str, data: Optional[Union[Dict[str, Any], str, bytes]] = None, json: Optional[Any] = None, headers: Optional[Mapping[str, str]] = None, timeout: Optional[float] = None) -> KcHttpResponse:
+        """PUT 请求（支持 form/data/raw 或 JSON）。"""
+        return await self._request("PUT", url, data=data, json=json, headers=headers, timeout=timeout)
+
+    async def delete(self, url: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Mapping[str, str]] = None, timeout: Optional[float] = None) -> KcHttpResponse:
+        """DELETE 请求（支持查询参数）。"""
+        return await self._request("DELETE", url, params=params, headers=headers, timeout=timeout)
+
+    async def download(self, url: str, save_path: str, chunk_size: int = 1024 * 64, headers: Optional[Mapping[str, str]] = None, timeout: Optional[float] = None) -> str:
+        """流式下载文件到指定路径，返回保存路径。
+        
+        - 使用 httpx.AsyncClient.stream 进行边读边写，适合大文件
+        - chunk_size 默认 64KB，可按网络与磁盘性能调整
+        - 支持方法级 headers 与超时覆盖会话级配置
+        - 4xx 直接视为状态异常；其他错误分别包装为超时/请求错误
+        """
+        # 合并请求头与超时设置
+        req_headers = dict(self.headers)
+        if headers:
+            req_headers.update(headers)
+        req_timeout = self.timeout if timeout is None else httpx.Timeout(timeout)
+        try:
+            async with self._client.stream("GET", url, headers=req_headers, timeout=req_timeout) as resp:
+                if resp.status_code >= 400:
+                    # 客户端或服务端错误直接抛出状态异常
+                    raise KCHT_STATUS_ERROR.msg_format(f"status={resp.status_code}")
+                with open(save_path, "wb") as f:
+                    async for chunk in resp.aiter_bytes(chunk_size):
+                        f.write(chunk)
+            logger.info(f"下载完成: {url} -> {save_path}")
+            return save_path
+        except httpx.TimeoutException as e:
+            # 超时错误单独包装，便于调用层区分
+            raise KCHT_TIMEOUT_ERROR.msg_format(str(e))
+        except httpx.HTTPError as e:
+            # 其他 HTTP 错误统一包装为请求错误
+            raise KCHT_REQUEST_ERROR.msg_format(str(e))
+        except Exception as e:
+            # 未知错误统一包装为请求错误
+            raise KCHT_REQUEST_ERROR.msg_format(str(e))
+
+# FastAPI 生命周期集成示例（可选）
+# 在 app.py 或 main.py 中：
+# from .utils.kc_http import KcHttpSession
+# kc_http = KcHttpSession(base_url="https://api.example.com", timeout=10, retries=2)
+# app.state.kc_http = kc_http
+# @app.on_event("startup")
+# async def startup_event():
+#     pass
+# @app.on_event("shutdown")
+# async def shutdown_event():
+#     await app.state.kc_http.close()

KairoCore/utils/kc_upload.py

@@ -0,0 +1,218 @@
+"""
+KcUploader: 文件上传/下载/导入/导出工具类
+
+提供四类能力：
+- save_upload_file: 处理 FastAPI UploadFile（multipart/form-data）并流式写入磁盘
+- save_base64: 处理 Base64 字符串并写入磁盘
+- export_to_base64: 将本地文件内容导出为 Base64 字符串（便于前端或第三方传输）
+- build_download_response: 构建用于浏览器下载的响应对象（FileResponse）
+
+异常处理：统一使用 common.errors 中定义的 Panic 常量
+日志：统一使用项目日志器
+安全约束：所有保存操作使用 os.path.basename 规避路径穿越，仅允许纯文件名
+"""
+# 导入类型注解与标准库
+from typing import Optional, Dict
+import os  # 文件系统操作（目录创建、路径拼接、文件读写）
+import base64  # Base64 编解码
+
+# FastAPI 类型：用于接收前端上传的文件
+from fastapi import UploadFile
+
+# 项目内的错误常量与日志工具
+from ..common.errors import (
+    KCU_SAVE_DIR_EMPTY_ERROR,  # 保存目录为空
+    KCU_MKDIR_ERROR,           # 目录创建失败
+    KCU_FILENAME_EMPTY_ERROR,  # 文件名为空
+    KCU_PARAM_MISSING_ERROR,   # 通用参数缺失错误
+    KCU_BASE64_PARSE_ERROR,    # Base64 解析失败
+    KCU_UPLOAD_SAVE_ERROR,     # 上传保存失败
+    KCU_BASE64_SAVE_ERROR,     # Base64 保存失败
+)
+from ..utils.panic import Panic
+from ..utils.log import get_logger
+import mimetypes  # 推断 MIME 类型，用于下载响应的 Content-Type
+from fastapi.responses import FileResponse  # 用于构建浏览器下载响应
+
+logger = get_logger()
+
+class KcUploader:
+    """
+    文件上传/下载相关的通用工具类。
+
+    方法总览：
+    - save_upload_file(file, target_dir, filename): 保存 multipart/form-data 上传的文件
+    - save_base64(content_base64, filename, target_dir): 保存 Base64 字符串为文件
+    - export_to_base64(src_path): 将本地文件导出为 Base64 字符串
+    - build_download_response(src_path, download_name, media_type, inline): 构建浏览器下载响应
+
+    使用建议：
+    - 实例化时可指定 default_target_dir（默认 /tmp），也可在方法调用时传入 target_dir 覆盖
+    - 建议在路由层对可下载/可保存的目录做白名单限制
+    """
+
+    def __init__(self, default_target_dir: str = "/tmp"):
+        # 默认保存目录，可在具体调用时覆盖
+        self.default_target_dir = default_target_dir
+
+    def _ensure_dir(self, dir_path: str) -> None:
+        # 校验目录参数
+        if not dir_path:
+            raise KCU_SAVE_DIR_EMPTY_ERROR
+        try:
+            # 确保目录存在（不存在则创建）
+            os.makedirs(dir_path, exist_ok=True)
+        except Exception as e:
+            # 创建目录失败时抛出统一错误
+            raise KCU_MKDIR_ERROR.msg_format(str(e))
+
+    def _safe_join(self, target_dir: Optional[str], filename: Optional[str]) -> str:
+        # 取调用传入目录或默认目录
+        dir_path = target_dir or self.default_target_dir
+        # 确保目录存在与可写
+        self._ensure_dir(dir_path)
+        # 仅使用纯文件名，防止路径穿越
+        name = os.path.basename(filename or "")
+        if not name:
+            raise KCU_FILENAME_EMPTY_ERROR
+        # 拼接安全的保存路径
+        return os.path.join(dir_path, name)
+
+    async def save_upload_file(self, file: UploadFile, target_dir: Optional[str] = None, filename: Optional[str] = None) -> Dict[str, str]:
+        """
+        保存 multipart/form-data 上传的文件。
+
+        Args:
+            file (UploadFile): FastAPI UploadFile 对象
+            target_dir (str, optional): 保存目录，默认使用初始化的 default_target_dir
+            filename (str, optional): 自定义文件名（仅文件名，不含路径）。不提供则使用原始文件名
+
+        Returns:
+            Dict[str, str]: {"saved": 保存路径, "size": 写入字节数}
+        """
+        try:
+            # 校验上传文件与文件名
+            if not file or not file.filename:
+                raise KCU_FILENAME_EMPTY_ERROR
+            # 生成安全的保存路径
+            save_path = self._safe_join(target_dir, filename or file.filename)
+            size = 0
+            # 以流式方式写入，避免一次性加载大文件至内存
+            with open(save_path, "wb") as f:
+                while True:
+                    # 1MB/chunk 读取上传内容
+                    chunk = await file.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    size += len(chunk)
+                    f.write(chunk)
+            logger.info(f"文件上传保存成功: path={save_path}, size={size}")
+            return {"saved": save_path, "size": str(size)}
+        except Panic:
+            # 上层已定义的业务中断异常，直接抛出以便统一处理
+            raise
+        except Exception as e:
+            # 其他异常统一包装为上传保存失败
+            raise KCU_UPLOAD_SAVE_ERROR.msg_format(str(e))
+
+    async def save_base64(self, content_base64: str, filename: str, target_dir: Optional[str] = None) -> Dict[str, str]:
+        """
+        保存 Base64 编码的文件内容。
+
+        Args:
+            content_base64 (str): Base64 字符串
+            filename (str): 保存文件名（仅文件名，不含路径）
+            target_dir (str, optional): 保存目录
+
+        Returns:
+            Dict[str, str]: {"saved": 保存路径, "size": 写入字节数}
+        """
+        try:
+            # 基本参数校验
+            if not content_base64 or not filename:
+                raise KCU_PARAM_MISSING_ERROR
+            # 生成安全的保存路径
+            save_path = self._safe_join(target_dir, filename)
+            try:
+                # Base64 → bytes
+                file_bytes = base64.b64decode(content_base64)
+            except Exception:
+                # Base64 内容不合法
+                raise KCU_BASE64_PARSE_ERROR
+            # 写入文件
+            with open(save_path, "wb") as f:
+                f.write(file_bytes)
+            size = len(file_bytes)
+            logger.info(f"Base64 文件保存成功: path={save_path}, size={size}")
+            return {"saved": save_path, "size": str(size)}
+        except Panic:
+            raise
+        except Exception as e:
+            # 其他异常统一包装为 Base64 保存失败
+            raise KCU_BASE64_SAVE_ERROR.msg_format(str(e))
+
+    async def export_to_base64(self, src_path: str) -> Dict[str, str]:
+        """
+        将本地文件内容导出为 Base64 字符串（便于通过 JSON 接口或第三方传输）。
+        """
+        try:
+            # 校验源文件路径
+            if not src_path:
+                raise KCU_PARAM_MISSING_ERROR
+            if not os.path.exists(src_path):
+                raise KCU_UPLOAD_SAVE_ERROR.msg_format("file not exist")
+            # 读取二进制并编码为 Base64
+            with open(src_path, "rb") as f:
+                data = f.read()
+            content_b64 = base64.b64encode(data).decode("ascii")
+            logger.info(f"文件导出为 Base64 成功: path={src_path}, size={len(data)}")
+            return {"path": src_path, "size": str(len(data)), "content_base64": content_b64}
+        except Panic:
+            raise
+        except Exception as e:
+            # 统一包装为上传保存错误（文件访问/IO 异常等）
+            raise KCU_UPLOAD_SAVE_ERROR.msg_format(str(e))
+
+    # 新增：构建用于浏览器下载的响应
+    async def build_download_response(
+        self,
+        src_path: str,
+        download_name: Optional[str] = None,
+        media_type: Optional[str] = None,
+        inline: bool = False,
+    ) -> FileResponse:
+        """
+        构建使浏览器触发下载的响应对象（支持设置文件名、Content-Type 与是否内联）。
+
+        Args:
+            src_path (str): 本地文件路径
+            download_name (str, optional): 下载时展示的文件名，默认取源文件名
+            media_type (str, optional): MIME 类型，不传则根据扩展名推断
+            inline (bool, optional): 是否内联显示（默认 False，即作为附件下载）
+
+        Returns:
+            FileResponse: 可直接在路由中 return 的响应
+        """
+        try:
+            # 基本校验：路径存在且可读
+            if not src_path:
+                raise KCU_PARAM_MISSING_ERROR
+            if not os.path.exists(src_path):
+                raise KCU_UPLOAD_SAVE_ERROR.msg_format("file not exist")
+            # 下载文件名：优先使用调用者指定，否则取源文件名
+            name = download_name or os.path.basename(src_path)
+            # 推断 Content-Type：不传则根据扩展名推断，兜底为 application/octet-stream
+            ctype = media_type
+            if not ctype:
+                guessed, _ = mimetypes.guess_type(name)
+                ctype = guessed or "application/octet-stream"
+            # Content-Disposition: attachment 触发下载；inline 尝试预览显示（如图片/PDF）
+            disposition = "inline" if inline else "attachment"
+            headers = {"Content-Disposition": f'{disposition}; filename="{name}"'}
+            logger.info(f"构建下载响应: path={src_path}, name={name}, inline={inline}")
+            return FileResponse(src_path, media_type=ctype, headers=headers)
+        except Panic:
+            raise
+        except Exception as e:
+            # 统一包装为上传保存错误（路径/IO 异常等）
+            raise KCU_UPLOAD_SAVE_ERROR.msg_format(str(e))

KairoCore/utils/panic.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Dict
+from typing import Any, List, Dict, Awaitable, TypeVar
 from fastapi import FastAPI as KarioCore
 from fastapi.responses import JSONResponse
 from fastapi.exceptions import RequestValidationError, HTTPException
@@ -9,6 +9,8 @@ from ..utils.log import get_logger
 
 logger = get_logger()
 
+T = TypeVar("T")
+
 class Panic(Exception):
     """
     自定义业务异常类，用于处理应用程序中的业务逻辑错误
@@ -189,3 +191,21 @@ def register_exception_handlers(app: KarioCore):
             }
         )
     
+# 通用路由异常包装，确保接口层统一返回 KCFU_* 异常
+async def exec_with_route_error(awaitable: Awaitable[T], error_const: Panic) -> T:
+    # 参数校验：awaitable 必须为可等待对象，error_const 必须为 Panic 实例
+    # 惰性导入集中定义的 Panic 常量，避免模块级循环依赖
+    from ..common.errors import (
+        KCP_EXEC_AWAITABLE_TYPE_ERROR,
+        KCP_EXEC_PANIC_CONST_TYPE_ERROR,
+    )
+    if not hasattr(awaitable, "__await"):
+        raise KCP_EXEC_AWAITABLE_TYPE_ERROR
+    if not isinstance(error_const, Panic):
+        raise KCP_EXEC_PANIC_CONST_TYPE_ERROR
+    try:
+        return await awaitable
+    except Panic:
+        raise
+    except Exception as e:
+        raise error_const.msg_format(str(e)) from e

KairoCore/utils/router.py

@@ -2,6 +2,8 @@ import os
 import importlib.util
 import inspect
 import functools
+from fastapi import FastAPI as KarioCore
+from fastapi.middleware.cors import CORSMiddleware
 from typing import Any, Callable, get_type_hints, Optional
 from fastapi import FastAPI, APIRouter, params
 from fastapi.responses import FileResponse
@@ -10,13 +12,29 @@ from ..utils.log import get_logger
 
 app_logger = get_logger()
 # --- 定义允许的参数名称 ---
-ALLOWED_PARAM_NAMES = {"query", "body"}
+ALLOWED_PARAM_NAMES = {"query", "body", "file"}
 # --- 定义参数到 FastAPI 依赖类型的映射 ---
 PARAM_TO_DEPENDENCY_TYPE = {
     "query": params.Query,
     "body": params.Body,
+    "file": params.File,
 }
 
+def add_cors_middleware(app: KarioCore) -> None:
+    """
+    为应用添加CORS中间件以解决跨域问题
+    
+    Args:
+        app (KarioCore): KairoCore应用实例
+    """
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # 在生产环境中应该指定具体的域名
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
 def _create_enforced_wrapper(original_func: Callable, allowed_param_names: set):
     """
     创建一个包装函数，该函数强制执行允许的参数名称

{kairocore-1.0.0.dist-info → kairocore-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KairoCore
-Version: 1.0.0
+Version: 1.2.1
 Summary: 时机，即是智能 —— 为关键时刻而生的核心API引擎。
 Author-email: Fatosy <fatosy_code@163.com>
 License: MIT
@@ -27,6 +27,10 @@ Requires-Dist: cryptography>=45.0.7
 Requires-Dist: pytz>=2025.2
 Requires-Dist: aiozk>=0.32.0
 Requires-Dist: jinja2>=3.1.6
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: starlette>=0.47.3
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: cryptography>=45.0.7
 
 # zWebApi
 一个功能丰富、开箱即用的 Python Web 框架，基于 FastAPI 构建。它旨在通过约定优于配置的原则，简化 API 开发流程，提供自动路由、统一异常处理、日志记录和可扩展工具集。

{kairocore-1.0.0.dist-info → kairocore-1.2.1.dist-info}/RECORD

@@ -1,16 +1,26 @@
-KairoCore/__init__.py,sha256=Vf2SHVbSh4ZwGoY6rKkkvkV5lS2WxdNOALlTCQgaTNw,654
-KairoCore/app.py,sha256=l8sGL6_0n-sGx5YHO4Tb6gJfLcgfIIrCaV10VZiV_j4,1117
+KairoCore/__init__.py,sha256=B53ucNBXlGMXwumrvs7icBINQwz8PE3suODDSDumZJg,878
+KairoCore/app.py,sha256=TQkNgKIuUps8nYFTWqj9Zn7X8FYeqXxQU9HxTvgi9Hk,1220
 KairoCore/code_generate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 KairoCore/code_generate/code_generator.py,sha256=HoYh4nNrLRl_k1OXwESWHZuJy7xxqCEJ8-KP-ck3D9U,14346
 KairoCore/code_generate/generate_page.html,sha256=ZDIcfwcMkkOKyOj1TVUtJz_fOBvQL7pWZl5aQwOkwoY,31733
 KairoCore/code_generate/generator_router.py,sha256=nx3zs7TynQq4cs_FQ_HiympiWuAmT7L1ut1o73gzjGU,1836
 KairoCore/common/consts.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-KairoCore/common/errors.py,sha256=VZD_qRNvJxi-dfmJhj1MjhnuaR-7pByoC96USr9cTzU,1108
+KairoCore/common/errors.py,sha256=KZ3h6jirFfmxUYwzoMJL4_IzealnCCi-0qv6gTWmNJU,3766
 KairoCore/common/http.py,sha256=YKj7M1vjRu8mos_XvoIEzYYfH-O9_-g9EIvqaXQGN9U,3177
 KairoCore/db_tools/kc_mysql.py,sha256=o7ko8q8uv7PO1tWEsfEBTwyZt34MxRYC32x3aINjRRI,21633
 KairoCore/db_tools/kc_redis.py,sha256=kQgl7SovxNK7XKmFrbQ_M9zRC0UaE_aUZR66Nq76fVo,15049
 KairoCore/db_tools/kc_zookeeper.py,sha256=wXw6EkNQPlGFZeXcQL6fxcAjC1i7Eqt4hE8CcdJIU3E,21182
+KairoCore/docs/CodeGenerateDoc.md,sha256=EwWvqoaGN72wGKBOCRrPMLgH0cLqSNRI7SslrmVTymU,2437
+KairoCore/docs/FileUploadDoc.md,sha256=64Gc8yinO54F4YzgpZUpXjR69UObFlBUKTvwQ1LFPDQ,4855
+KairoCore/docs/HttpSessionDoc.md,sha256=I9Lu9zEve74uUIY_LzIjn_E1macUsLn39DCwWJt4M1A,5767
+KairoCore/docs/TokenUseDoc.md,sha256=J0UX81TwdfP0AuMHhZx3VvnWxrXtULLpHITabEVEMF8,11885
+KairoCore/docs/UseDoc.md,sha256=OVrhRvOSEH11Ec--HPgk4Y9LrVORYkFTsJbQxpUeDuA,5206
 KairoCore/example/your_project_name/main.py,sha256=JmTP5uB7lL3lPVJaOCU938rJ0x9GJgVdiylN6C1eHvw,150
+KairoCore/example/your_project_name/action/api_key_admin.py,sha256=wJHBg1xBdaTLr8Gc8OviuMcbrAiz5sBJ7PFdjPWu234,1715
+KairoCore/example/your_project_name/action/auth.py,sha256=zbiQjrX_rDXHf3_JJFN4RKARt4yNz2d_gKZey2SCF1c,4109
+KairoCore/example/your_project_name/action/file_upload.py,sha256=iiJSt9I_u0r9n0CoDJSWr0Rlfu1m7s5rso7dUOuQYbk,2939
+KairoCore/example/your_project_name/action/http_demo.py,sha256=BxGQtWmUucTP40o8Z0zCJHg2iGwLJm_wNsHp3xQw7OY,2934
+KairoCore/example/your_project_name/action/protected_demo.py,sha256=1Zd3E5wUmYWivFy2EJEVl1KLNOZ6YfFqarkeYrqKUcU,2975
 KairoCore/example/your_project_name/action/user.py,sha256=ckvEVFRQXMHH5oTI3cuNpqEHMFGmDe_VfVmxdjvH-MU,1902
 KairoCore/example/your_project_name/common/consts.py,sha256=tPndbDTFIUSWIrrxRJ20SKXLqn7UX6BjOx3GG9mRDhg,55
 KairoCore/example/your_project_name/common/errors.py,sha256=bUD1VAdS9XOZKaYGwiIoQMGKUSnJ74ZogXW6pJS7-58,163
@@ -18,7 +28,9 @@ KairoCore/example/your_project_name/dao/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 KairoCore/example/your_project_name/dao/user.py,sha256=vG7tIKiNqV9XaEyDficOysyHYPaeYKSEaZalIYAvCtE,3736
 KairoCore/example/your_project_name/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 KairoCore/example/your_project_name/domain/user.py,sha256=flSGde-62HfL7WWajAaHKRemzIXHD5l7jwtscEUVG1k,2455
+KairoCore/example/your_project_name/schema/auth.py,sha256=vfvfU-QEq-9nFbPHxPes0Q1_0327MWgyd6D1LrIEwo8,310
 KairoCore/example/your_project_name/schema/user.py,sha256=tyjJT5UpZHhFphWq_CukpfEem3xOPi1-kCh6ZhV1Yj0,2738
+KairoCore/extensions/baidu/yijian.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 KairoCore/imgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 KairoCore/imgs/code_generator.png,sha256=hja21o4WE2KvO8GUYNQlGH4bwNdoWmTbYe4NYggwiWg,452411
 KairoCore/imgs/favicon.ico,sha256=3QYUzKzoYYSoxvTdypRIu-s-7E5k82GNVe7vmaoJM8g,964
@@ -31,14 +43,17 @@ KairoCore/imgs/logo-pixel-64.jpg,sha256=QVRPPdW35FWM4DLs4IR9Rih1pQCAWUuryPiHoDev
 KairoCore/imgs/logo-pixel.png,sha256=UGWJoY3m93eI3ZSGuLr7_0GY_LZ_v9pOMdaab618xoc,1781142
 KairoCore/imgs/logo.png,sha256=0CkWFgPrYPvc3X6F8GuN-8CPAxzQ8pgRbMbgBb1GO6w,1074473
 KairoCore/imgs/pay.png,sha256=PbEIWER5GAXFNXge_-LM6syYnQwP_A9hr79MfXGDc_U,341875
+KairoCore/utils/auth.py,sha256=LvdSnY7IDLGldQHnaSgVlTx-7f7iTNqeC9WewGjaHBA,25806
+KairoCore/utils/kc_http.py,sha256=Nkc1m1ySwTjrtyeCpx5h5s1hZA0PKNPDxywV2z0B0UI,11859
 KairoCore/utils/kc_re.py,sha256=Yl-cAvpu_XPS6HJ2E3uIHyjVxzx5_tciL-BlrO5-_Jo,1817
 KairoCore/utils/kc_timer.py,sha256=N7MCnG02K1S_l0cWl0S6aF5yYox7Ze6VEcQBb3HMvcI,12261
+KairoCore/utils/kc_upload.py,sha256=wk7wGwBQNIwOSM5RsrwrPRPjX42L-nlNDeAK18brLKM,9682
 KairoCore/utils/log.py,sha256=a6W0Q7Wnwv8xeHC4SAny37i7tH-5MaxhdKxLB8kkzJk,4950
-KairoCore/utils/panic.py,sha256=XeXT6uMAcmqH2hy9ij5aZXbFcTkoVXx05dKaTzDPPUQ,6445
-KairoCore/utils/router.py,sha256=3HEx5JNE0fk0_9eTuDaEOxmzdQUWXLV0o1RqUrjsqRc,18585
+KairoCore/utils/panic.py,sha256=MMEgK_8iMTTaulRLkZ2uPIvCx2b_J522YSkoYxj-i6M,7252
+KairoCore/utils/router.py,sha256=fVD0VZmlYp_7b5lb3MifvluL9eHXMGP2JrfNxSSIDo8,19114
 KairoCore/utils/sql_tool.py,sha256=WtmeAAcmzVJktRx_Es_w0RN73QsUZlV7C-E5J6d0Zn8,8809
 imgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kairocore-1.0.0.dist-info/METADATA,sha256=xuHD43ZrZvsXnuOb_gijIw7X9Eo60-vOcvZFYg14GZA,13061
-kairocore-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kairocore-1.0.0.dist-info/top_level.txt,sha256=N1Rj81TOK7s9p9oB4ej0Q4MNCdcdgrn-JopszDuvAvA,15
-kairocore-1.0.0.dist-info/RECORD,,
+kairocore-1.2.1.dist-info/METADATA,sha256=QXmLxQs3jRr6CeWK_jUuTNN7z2AOtLt3pLdXnzijSJE,13198
+kairocore-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kairocore-1.2.1.dist-info/top_level.txt,sha256=N1Rj81TOK7s9p9oB4ej0Q4MNCdcdgrn-JopszDuvAvA,15
+kairocore-1.2.1.dist-info/RECORD,,