CheeseAPI 2.0.8b6__tar.gz → 2.0.8b8__tar.gz

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/__init__.py

@@ -1,7 +1,7 @@
 from CheeseAPI.app import CheeseAPI, AppProxy
 from CheeseAPI.printer import Printer
 from CheeseAPI.request import Request, RequestProxy
-from CheeseAPI.response import Response, ResponseProxy, FileResponse
+from CheeseAPI.response import Response, ResponseProxy, FileResponse, RedirectResponse
 from CheeseAPI.websocket import Websocket
 from CheeseAPI.file import File
 from CheeseAPI.route import Route, RouteProxy

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/app.py

@@ -1,4 +1,4 @@
-import os, pathlib, multiprocessing, ssl, socket, asyncio, concurrent.futures, inspect, importlib.util
+import os, re, pathlib, multiprocessing, ssl, socket, asyncio, concurrent.futures, inspect, importlib.util
 from typing import Type, Literal, Callable, AsyncIterable, TYPE_CHECKING
 
 import signal, redis
@@ -44,8 +44,6 @@ class AppProxy:
 
             self.app._is_running = True
 
-            self.app.signal.before_server_start.send()
-
             self.server_start()
 
             waiting_list = self.worker_start()
@@ -215,6 +213,7 @@ class AppProxy:
 
         processes = []
         if workers == 1:
+            ''' 单进程模式下工作进程复用当前进程，after_workers_start 在 worker 内、开始接收请求前触发 '''
             self.worker_running(True)
         else:
             processes: list[multiprocessing.Process] = []
@@ -223,10 +222,10 @@ class AppProxy:
                 process.start()
                 processes.append(process)
 
-        self.after_workers_start(workers)
-        self.app.signal.after_workers_start.send(kwargs = {
-            'workers': workers
-        })
+            self.after_workers_start(workers)
+            self.app.signal.after_workers_start.send(kwargs = {
+                'workers': workers
+            })
         return processes
 
     def before_workers_start(self, workers: int) -> int:
@@ -272,6 +271,12 @@ class AppProxy:
                 'is_first': is_first
             })
 
+            if is_first and self.app.workers == 1:
+                self.after_workers_start(self.app.workers)
+                self.app.signal.after_workers_start.send(kwargs = {
+                    'workers': self.app.workers
+                })
+
             while True:
                 client_socket, addr = await loop.sock_accept(self.server_socket)
                 loop.create_task(self.client_socket_process(client_socket, addr))
@@ -289,6 +294,7 @@ class AppProxy:
             self.app.printer.app_error(e)
 
     async def client_socket_process(self, client_socket: socket.socket, addr: tuple[str, int]):
+        request = None
         try:
             loop = asyncio.get_event_loop()
 
@@ -298,6 +304,8 @@ class AppProxy:
             async for request, response in self.get_request(client_socket, addr):
                 if not response:
                     response = await self.get_response(request)
+                    if inspect.isfunction(request.fn):
+                        await self.attach_cors_headers(request, response)
 
                 if not response._proxy:
                     response = self.app.ResponseProxy_Class(self.app, response).response
@@ -313,7 +321,11 @@ class AppProxy:
             if client_socket._closed is False:
                 client_socket.close()
         except Exception as e:
-            self.app.printer.fn_error(e, request)
+            ''' 请求尚未创建时无法定位请求上下文，直接上报原始异常，而不是引用未赋值的 request '''
+            if request is None:
+                self.app.printer.app_error(e)
+            else:
+                self.app.printer.fn_error(e, request)
 
         if client_socket._closed is False:
             client_socket.close()
@@ -331,6 +343,25 @@ class AppProxy:
             'response': response
         })
 
+    async def attach_cors_headers(self, request: Request, response: Response):
+        ''' 简单请求：把 CORS 响应头并入路由响应；来源不在白名单内时不附加任何 CORS 头 '''
+        if not request.headers.get('origin'):
+            return
+
+        cors_response = self.get_request_cors(request).get_response(request)
+        if cors_response.status != 204:
+            return
+
+        for key, value in cors_response.headers.items():
+            response.headers.setdefault(key, value)
+
+    def get_request_cors(self, request: Request) -> CORS:
+        ''' 取请求命中路由的 CORS 配置，未配置时回退应用级 '''
+        route = self.app.route._proxy.get_route(request.method, request.path)
+        if route != 404 and route != 405 and route[0]['cors'] is not None:
+            return route[0]['cors']
+        return self.app.cors
+
     async def get_response(self, request: Request) -> Response:
         if inspect.isfunction(request.fn):
             try:
@@ -352,7 +383,7 @@ class AppProxy:
     async def get_request(self, client_socket: socket.socket, addr: tuple[str, int]) -> AsyncIterable[tuple[Request, Response | None]]:
         keep_alive_max_requests = 0
         request = None
-        while keep_alive_max_requests < self.app.keep_alive_max_requests and client_socket._closed is False:
+        while client_socket._closed is False:
             if request:
                 keep_alive_max_requests += 1
 
@@ -364,6 +395,9 @@ class AppProxy:
                 if request._proxy.protocol is None or not self.app.keep_alive or (request._proxy.protocol == 'HTTP/1.0' and request.headers.get('connection') != 'keep-alive') or (request._proxy.protocol == 'HTTP/1.1' and request.headers.get('connection') == 'close'):
                     break
 
+                if keep_alive_max_requests >= self.app.keep_alive_max_requests:
+                    break
+
             client_socket, addr = await self.before_request(client_socket, addr)
             await self.app.signal.before_request.async_send(kwargs = {
                 'client_socket': client_socket,
@@ -426,7 +460,9 @@ class AppProxy:
                 relative_path = relative_path[1:]
 
             path = os.path.join(_path, relative_path)
-            if not os.path.abspath(path).startswith(os.path.abspath(_path)):
+            static_root = os.path.abspath(_path)
+            target_path = os.path.abspath(path)
+            if target_path != static_root and target_path.startswith(f'{static_root}{os.sep}') is False:
                 return Response(status = 403)
 
             if os.path.exists(path):
@@ -440,13 +476,33 @@ class AppProxy:
         return Response(status = 404)
 
     async def get_cors_response(self, request: Request) -> Response:
-        route = self.app.route._proxy.get_route(request.method, request.path)
-        if route != 405:
-            if route[0]['cors']:
-                return route[0]['cors'].get_response(request)
-            else:
-                return self.app.cors.get_response(request)
-        return Response(status = 405)
+        ''' 预检请求（OPTIONS + Origin + Access-Control-Request-Method）返回 CORS 响应，其余 405 场景保持裸 405 '''
+        if request.method != 'OPTIONS' or not request.headers.get('origin') or not request.headers.get('access-control-request-method'):
+            return Response(status = 405)
+
+        cors = self.get_route_cors(request.path) or self.app.cors
+        return cors.get_response(request)
+
+    def get_route_cors(self, path: str) -> CORS | None:
+        ''' 按路径取路由级 CORS 配置（与请求方法无关），供预检请求使用 '''
+        routes = self.app.route.routes.get(path)
+        if routes is None:
+            for _path, dynamic_routes in self.app.route._proxy.dynamic_routes.items():
+                if re.match(_path, path) is not None:
+                    routes = dynamic_routes
+                    break
+
+        if not routes:
+            return None
+
+        if routes.get('OPTIONS') and routes['OPTIONS']['cors'] is not None:
+            return routes['OPTIONS']['cors']
+
+        for route in routes.values():
+            if route['cors'] is not None:
+                return route['cors']
+
+        return None
 
     async def before_request(self, client_socket: socket.socket, addr: tuple[str, int]) -> tuple[socket.socket, tuple]:
         return client_socket, addr

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/cors.py

@@ -27,8 +27,9 @@ class CORS:
 
         if origin in self.allow_origins:
             headers['access-control-allow-origin'] = origin
-        elif '*' in self.allow_origins and not self.allow_credentials:
-            headers['access-control-allow-origin'] = '*'
+        elif '*' in self.allow_origins:
+            ''' 通配来源与凭证不能同用，携带凭证时回显具体 origin '''
+            headers['access-control-allow-origin'] = origin if self.allow_credentials else '*'
 
         headers['access-control-allow-methods'] = ', '.join(self.allow_methods)
 

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/file.py

@@ -29,6 +29,7 @@ class File:
         elif len(args) == 2:
             self._name = args[0]
             self._data = args[1]
+            self._data_in_file = False
 
     def save(self, path: str, update_path: bool = False, data_in_file: bool = False):
         '''
@@ -65,7 +66,7 @@ class File:
 
     @property
     def data(self) -> bytes:
-        if self._data:
+        if self._data is not None:
             return self._data
         else:
             with open(self._path, 'rb') as f:

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/printer.py

@@ -12,6 +12,9 @@ if TYPE_CHECKING:
 
 HTTP_STATUS_COLOR: tuple[str] = ('blue', 'green', 'cyan', 'yellow', 'red')
 
+MAX_ERROR_LINES: int = 50
+''' 单条错误日志中堆栈的最大行数；超出部分会被截断，避免异常堆栈无限增长 '''
+
 class Printer:
     __slots__ = ('_app', '_progress_bar')
 
@@ -33,8 +36,19 @@ class Printer:
     def server_start(self):
         self.app.logger.print('START', f'CheeseAPI is running on {self.app.host}:{self.app.port}', f'CheeseAPI is running on <cyan>{self.app.host}:{self.app.port}</cyan>')
 
+    def _error(self) -> str:
+        '''
+        格式化当前异常的堆栈
+
+        限制最大行数，避免反复报错时堆栈越来越长把日志写爆
+        '''
+        lines = traceback.format_exc()[:-1].splitlines()
+        if len(lines) > MAX_ERROR_LINES:
+            lines = lines[:MAX_ERROR_LINES] + [f'... truncated {len(lines) - MAX_ERROR_LINES} lines ...']
+        return '\n'.join(lines).replace('\n', '\n    ')
+
     def app_error(self, e: Exception):
-        error = traceback.format_exc()[:-1].replace("\n", "\n    ")
+        error = self._error()
         self.app.logger.error(f'An error occurred causing the server to stop:\n    {error}', f'An error occurred causing the server to stop:\n    {self.app.logger.encode(error)}')
 
     def server_stop(self):
@@ -44,11 +58,11 @@ class Printer:
         self.app.logger.print('STOP', 'CheeseAPI has stopped')
 
     def fn_error(self, e: Exception, request: 'Request'):
-        error = traceback.format_exc()[:-1].replace("\n", "\n    ")
+        error = self._error()
         self.app.logger.danger(f'An error occurred causing the {request.ip} visited {request.method} {request.full_path}:\n    {error}', f'An error occurred causing the <cyan>{request.ip}</cyan> visited <cyan>{request.method} {self.app.logger.encode(request.full_path)}</cyan>:\n    {self.app.logger.encode(error)}')
 
     def websocket_error(self, e: Exception, websocket: 'Websocket'):
-        error = traceback.format_exc()[:-1].replace("\n", "\n    ")
+        error = self._error()
         self.app.logger.danger(f'An error occurred causing the {websocket.request.ip} disconnected  {websocket.request.method} {websocket.request.full_path}:\n    {error}', f'An error occurred causing the <cyan>{websocket.request.ip}</cyan> disconnected <cyan>{websocket.request.method} {self.app.logger.encode(websocket.request.full_path)}</cyan>:\n    {self.app.logger.encode(error)}')
 
     def response(self, request: 'Request', response: 'Response'):
@@ -65,11 +79,11 @@ class Printer:
         self.app.logger.print('WEBSOCKET', f'The {websocket.request.ip} disconnected {websocket.request.method} {websocket.request.full_path}', f'The <cyan>{websocket.request.ip}</cyan> disconnected <cyan>{websocket.request.method} {self.app.logger.encode(websocket.request.full_path)}</cyan>')
 
     def websocket_message_error(self, e: Exception, websocket: 'Websocket'):
-        error = traceback.format_exc()[:-1].replace("\n", "\n    ")
+        error = self._error()
         self.app.logger.danger(f'An error occurred causing the {websocket.request.ip} received a message to {websocket.request.method} {websocket.request.full_path}:\n    {error}', f'An error occurred causing the <cyan>{websocket.request.ip}</cyan> receive a message to <cyan>{websocket.request.method} {self.app.logger.encode(websocket.request.full_path)}</cyan>:\n    {self.app.logger.encode(error)}')
 
     def scheduler_error(self, e: Exception, task: 'Task'):
-        error = traceback.format_exc()[:-1].replace("\n", "\n    ")
+        error = self._error()
         self.app.logger.danger(f'An error occurred in the scheduled task {task.key} running:\n    {error}', f'An error occurred in the scheduled task running <green>{self.app.logger.encode(task.key)}</green>:\n    {self.app.logger.encode(error)}')
 
     @property

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/request.py

@@ -169,7 +169,12 @@ class RequestProxy:
                 range_part = range_part.strip()
                 if '-' in range_part:
                     start, end = range_part.split('-', 1)
-                    self.request.ranges.append((int(start) if start else 0, int(end) if end else None))
+                    if start:
+                        self.request.ranges.append((int(start), int(end) if end else None))
+                    elif end:
+                        self.request.ranges.append((-int(end), None))  # 后缀 Range（`bytes=-50`）：负起点表示从末尾倒数，末尾 50 字节
+                    else:
+                        self.request.ranges.append((0, None))
 
         if 'upgrade' in self.request.headers and self.request.headers['upgrade'] == 'websocket':
             self.request._method = 'WEBSOCKET'
@@ -246,17 +251,20 @@ class RequestProxy:
         if self.request.body is None:
             return
 
+        body = self.request.body
         content_type = self.request.headers.get('content-type')
-        if content_type == 'text/plain' or content_type is None:
-            self.request._body = self.request.body.decode()
-        elif content_type == 'application/json':
-            self.request._json = json.loads(self.request.body)
-        elif content_type == 'application/x-www-form-urlencoded':
+        media_type = (content_type or '').split(';')[0].strip().lower() or None  # 忽略 `; charset=utf-8` 等参数
+
+        if media_type == 'text/plain' or media_type is None:
+            self.request._body = body.decode()
+        elif media_type == 'application/json':
+            self.request._json = json.loads(body)
+        elif media_type == 'application/x-www-form-urlencoded':
             self.request._form = {
-                key: value[0] for key, value in urllib.parse.parse_qs(self.request.body.decode()).items()
+                key: value[0] for key, value in urllib.parse.parse_qs(body.decode()).items()
             }
-        elif content_type.startswith('multipart/form-data'):
-            for part in self.request.body.split(f'--{content_type.split("boundary=")[1].strip()}'.encode()):
+        elif media_type == 'multipart/form-data':
+            for part in body.split(f'--{content_type.split("boundary=")[1].strip()}'.encode()):
                 if part == b'' or part == b'--\r\n':
                     continue
 
@@ -290,4 +298,4 @@ class RequestProxy:
         if self.request.headers.get('content-disposition'):
             match = re.search(r'filename="([^"]*)"', self.request.headers['content-disposition'])
             if match:
-                self.request._file = File(match.group(1), self.request.body)
+                self.request._file = File(match.group(1), body)  # 始终用原始 bytes，避免 text/plain 分支已解码成 str

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/response.py

@@ -1,4 +1,4 @@
-import socket, asyncio, datetime, json, zlib, gzip, os, mimetypes, uuid, math
+import socket, asyncio, datetime, json, zlib, gzip, os, mimetypes, uuid
 from typing import TYPE_CHECKING, TypedDict, Literal, AsyncIterable
 
 import brotli, zstandard
@@ -127,7 +127,7 @@ class RedirectResponse(Response):
             headers = {}
         headers['location'] = location
 
-        super().__init__(status, body, headers)
+        super().__init__(body, status, headers)
 
 class FileResponse(Response):
     __slots__ = ('file', 'preview', 'transmission_type', 'chunked_size')
@@ -169,21 +169,34 @@ class ResponseProxy:
             status, headers, data = await anext(gen)
 
         bytes = [f'HTTP/1.1 {status} {HTTP_STATUS[status]}']
-        bytes.extend(f'{key}: {value}' for key, value in headers.items())
+        for key, value in headers.items():
+            if isinstance(value, list): # 某些响应头（如 set-cookie）需要写成多行
+                bytes.extend(f'{key}: {_value}' for _value in value)
+            else:
+                bytes.append(f'{key}: {value}')
         bytes.extend(['', ''])
         bytes = '\r\n'.join(bytes).encode()
         if not no_body:
-            if self.response.headers.get('transfer-encoding') == 'chunked':
-                bytes += hex(len(data)).encode() + b'\r\n' + data + b'\r\n'
+            if headers.get('transfer-encoding') == 'chunked':
+                bytes += f'{len(data):x}'.encode() + b'\r\n' + data + b'\r\n'
             else:
                 bytes += data
         await loop.sock_sendall(client_socket, bytes)
 
         if not no_body:
-            if self.response.headers.get('transfer-encoding') == 'chunked':
-                async for _, _, data in gen:
-                    await loop.sock_sendall(client_socket, hex(len(data)).encode() + b'\r\n' + data + b'\r\n')
-                await loop.sock_sendall(client_socket, b'0\r\n\r\n')
+            if headers.get('transfer-encoding') == 'chunked':
+                '''
+                分块传输：无论生成器是否抛异常，都必须补发 0 长度块结束分块流，
+                否则客户端会认为响应被截断
+                '''
+                try:
+                    async for _, _, data in gen:
+                        await loop.sock_sendall(client_socket, f'{len(data):x}'.encode() + b'\r\n' + data + b'\r\n')
+                finally:
+                    try:
+                        await loop.sock_sendall(client_socket, b'0\r\n\r\n')
+                    except Exception:
+                        ...
             elif self.request.ranges:
                 async for _, _, data in gen:
                     await loop.sock_sendall(client_socket, data)
@@ -192,19 +205,14 @@ class ResponseProxy:
             self.app.printer.response(self.request, self.response)
 
     async def get_status(self, status: int, headers: dict[str, str], body: dict | list | str | bytes | None) -> tuple[int, dict[str, str], dict | list | str | bytes | None]:
-        if isinstance(self.response, FileResponse):
-            if self.request.headers.get('range') is not None:
-                max_range = -1
-                for range in self.request.ranges:
-                    if range[1] is not None:
-                        max_range = max(max_range, range[1])
-                max_range += 1
-                if self.response.file._data is not None:
-                    if len(self.response.file.data) < max_range:
-                        status = 416
-                else:
-                    if os.path.getsize(self.response.file.path) < max_range:
-                        status = 416
+        if isinstance(self.response, FileResponse) and self.request.ranges:
+            max_range = -1
+            for range in self.request.ranges:
+                if range[1] is not None:
+                    max_range = max(max_range, range[1])
+            max_range += 1
+            size = len(self.response.file.data) if self.response.file._data is not None else os.path.getsize(self.response.file.path)
+            status = 416 if size < max_range else 206
 
         return status, headers, body
 
@@ -236,7 +244,7 @@ class ResponseProxy:
                 headers['content-type'] = f'{mime_type}; charset=utf-8'
                 headers['content-disposition'] = f'{"inline" if self.response.preview and mime_type in PREVIEWABLE_TYPES else "attachment"}; filename="{self.response.file.name}"'
 
-        if isinstance(self.response.body, AsyncIterable):
+        if isinstance(body, AsyncIterable):
             if 'transfer-encoding' not in headers:
                 headers['transfer-encoding'] = 'chunked'
 
@@ -265,6 +273,8 @@ class ResponseProxy:
                     else:
                         encoding_quality = True
                         encoding_split[1] = float(encoding_split[1].split('=')[1])
+                    if float(encoding_split[1]) <= 0: # q=0 表示该算法不可接受
+                        continue
                     encodings.append(encoding_split)
                 encodings.sort(key = lambda x: float(x[1]), reverse = True)
                 encodings = [encoding[0] for encoding in encodings]
@@ -304,51 +314,55 @@ class ResponseProxy:
                 if cookie['http_only']:
                     _cookie += '; HttpOnly'
                 cookies.append(_cookie)
-            headers['set-cookie'] = ', '.join(cookies)
+            headers['set-cookie'] = cookies # set-cookie 需要写成多行，此处保留列表，由 ResponseProxy.send 展开
 
         return status, headers, body
 
     async def get_body(self, status: int, headers: dict[str, str], body: dict | list | str | bytes | AsyncIterable | None) -> AsyncIterable[tuple[int, dict[str, str], bytes]]:
         if type(self.response) is FileResponse and self.request.ranges and status != 416:
-            if self.response.file._data is None:
+            if self.response.file._data is not None:
+                size = len(self.response.file.data)
+            else:
+                size = os.path.getsize(self.response.file.path)
                 handler = open(self.response.file.path, 'rb')
+
             if len(self.request.ranges) == 1:
+                start, end = self.request.ranges[0]
+                end = size - 1 if end is None else end # 区间为闭区间，末尾含在响应内
                 if self.response.file._data is not None:
-                    size = len(self.response.file.data)
-                    data = self.response.file.data[self.request.ranges[0][0] or 0:self.request.ranges[0][1] or len(self.response.file.data) + 1]
+                    data = self.response.file.data[start:end + 1]
                 else:
-                    size = os.path.getsize(self.response.file.path)
-                    handler.seek(self.request.ranges[0][0] or 0)
-                    data = handler.read((self.request.ranges[0][1] or size) - (self.request.ranges[0][0]))
+                    handler.seek(start)
+                    data = handler.read(end + 1 - start)
                     handler.close()
+
                 headers['content-length'] = str(len(data))
-                headers['content-range'] = f'bytes {self.request.ranges[0][0]}-{(self.request.ranges[0][1] or size) - 1}/{size}'
+                headers['content-range'] = f'bytes {start}-{end}/{size}'
                 yield status, headers, data
             else:
                 boundary = uuid.uuid4().hex
                 content_type = headers['content-type']
                 headers['content-type'] = f'multipart/byteranges; boundary={boundary}'
-                if self.response.file._data is not None:
-                    size = len(self.response.file.data)
-                else:
-                    size = os.path.getsize(self.response.file.path)
-
-                content_length = 0
-                for range in self.request.ranges:
-                    content_length += 2 + 32 + 2 + 14 + len(content_type) + 2 + 21 + (1 if range[0] == 0 else int(math.log10(range[0]))) + 1 + 1 + int(math.log10(range[1] or size)) + 1 + 1 + int(math.log10(size)) + 1 + 4 + (range[1] or size) - range[0] + 1
-                headers['content-length'] = str(content_length)
 
-                for range in self.request.ranges:
-                    data = [b'--', boundary.encode(), b'\r\n', b'content-type: ', content_type.encode(), b'\r\n', b'content-range: bytes ', str(range[0]).encode(), b'-', str(range[1] or size).encode(), b'/', str(size).encode() + b'\r\n\r\n']
+                parts = []
+                for start, end in self.request.ranges:
+                    end = size - 1 if end is None else end
                     if self.response.file._data is not None:
-                        data.append(self.response.file.data[range[0]:range[1] or size + 1])
+                        data = self.response.file.data[start:end + 1]
                     else:
-                        handler.seek(range[0])
-                        data.append(handler.read((range[1] or size) - (range[0])))
-                    yield status, headers, b''.join(data)
+                        handler.seek(start)
+                        data = handler.read(end + 1 - start)
+                    parts.append(b''.join([b'--', boundary.encode(), b'\r\n', b'content-type: ', content_type.encode(), b'\r\n', b'content-range: bytes ', str(start).encode(), b'-', str(end).encode(), b'/', str(size).encode(), b'\r\n\r\n', data]))
+
                 if self.response.file._data is None:
                     handler.close()
-                yield status, headers, b'--' + boundary.encode() + b'--'
+
+                trailer = b'--' + boundary.encode() + b'--'
+                headers['content-length'] = str(sum(len(part) for part in parts) + len(trailer))
+
+                for part in parts:
+                    yield status, headers, part
+                yield status, headers, trailer
         else:
             if isinstance(body, AsyncIterable):
                 data = await anext(body)
@@ -386,11 +400,11 @@ class ResponseProxy:
 
     async def get_encode_body(self, status: int, headers: dict[str, str], body: bytes) -> tuple[int, dict[str, str], bytes]:
         content_length = headers.get('content-length')
-        if content_length and int(content_length) < self.app.compress_min_length:
+        if self.response.compress is None and content_length and int(content_length) < self.app.compress_min_length:
             if 'content-encoding' in headers:
                 del headers['content-encoding']
 
-        if 'content-encoding' in headers and 'content-length' in headers and (int(headers['content-length']) > self.app.compress_min_length or self.response.compress is not None):
+        if 'content-encoding' in headers and 'content-length' in headers and (self.response.compress is not None or int(headers['content-length']) >= self.app.compress_min_length):
             compress_level = self.response.compress_level if self.response.compress_level is not None else self.app.compress_level
             if headers['content-encoding'] == 'gzip':
                 body = gzip.compress(body, compress_level)

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/scheduler.py

@@ -1,5 +1,6 @@
 import inspect, os
 import datetime, uuid, threading, multiprocessing, asyncio, time, json
+from queue import Empty
 from typing import Callable, Literal, TYPE_CHECKING
 
 import redis, redis.exceptions
@@ -13,22 +14,25 @@ class Task:
     @classmethod
     def from_dict(cls, data: dict[str, any], _scheduler_proxy) -> 'Task':
         instance = cls.__new__(cls)
+
         for key, value in data.items():
             if key == '_queue':
-                if value:
-                    value = multiprocessing.get_context('spawn').Queue()
-                    value.put(None)
-                else:
-                    value = multiprocessing.get_context('spawn').Queue()
+                value = multiprocessing.get_context('spawn').Queue()
+            elif key == '_stop_event':
+                value = threading.Event()
             elif key == 'first_run_timer':
                 value = datetime.datetime.fromtimestamp(value) if value else None
             elif key == '_last_run_timer':
                 value = datetime.datetime.fromtimestamp(value) if value else None
             setattr(instance, key, value)
+
+        if '_running_remote' not in data:
+            instance._running_remote = not data.get('_queue', True) # 旧数据只有 `_queue`（非空代表未运行）
+
         setattr(instance, '_scheduler_proxy', _scheduler_proxy)
         return instance
 
-    __slots__ = ('fn', 'interval_time', 'first_run_timer', 'expected_run_num', '_key', 'run_type', 'args', 'kwargs', 'auto_remove', '_last_run_timer', '_last_run_time', '_run_num', '_handler', '_queue', '_scheduler_proxy', 'timeout')
+    __slots__ = ('fn', 'interval_time', 'first_run_timer', 'expected_run_num', '_key', 'run_type', 'args', 'kwargs', 'auto_remove', '_last_run_timer', '_last_run_time', '_run_num', '_handler', '_queue', '_stop_event', '_running_remote', '_scheduler_proxy', 'timeout')
 
     def __init__(self, fn: Callable, interval_time: float, *, first_run_timer: datetime.datetime | float | None = None, expected_run_num: int | None = None, key: str | None = None, run_type: Literal['THREAD', 'PROCESS', 'ASYNC'] = 'THREAD', args: tuple = (), kwargs: dict = {}, auto_remove: bool = False, timeout: float | None = None, _scheduler_proxy: 'SchedulerProxy'):
         '''
@@ -67,23 +71,66 @@ class Task:
         self._last_run_time: float | None = None
         self._run_num: int = 0
         self._handler: threading.Thread | multiprocessing.Process | asyncio.Task | None = None
+
         self._queue = multiprocessing.get_context('spawn').Queue()
+        ''' 进程任务的停止信号队列（父进程放入、子进程取出） '''
+        self._stop_event = threading.Event()
+        ''' 线程 / 协程任务的停止信号（同进程内使用） '''
+        self._running_remote: bool = False
+        ''' 任务是否运行在其它进程（由 `sync_server` 反序列化而来的任务） '''
+
+    '''
+    停止信号的收发
+
+    不使用 `multiprocessing.Queue.qsize()`（macOS 未实现，调用即 `NotImplementedError`）：
+    线程 / 协程任务用 `threading.Event`，进程任务用队列的 `empty()` / `get_nowait()` 判断与取出信号。
+    '''
+
+    def _stop(self):
+        ''' 发送停止信号 '''
+
+        if self.run_type == 'PROCESS':
+            self._queue.put(None)
+        else:
+            self._stop_event.set()
+
+    def _reset_stop(self):
+        ''' 清除停止信号（启动任务前调用） '''
+
+        if self.run_type == 'PROCESS':
+            while True:
+                try:
+                    self._queue.get_nowait()
+                except Empty:
+                    break
+        else:
+            self._stop_event.clear()
+
+    def _stops(self) -> bool:
+        ''' 是否收到了停止信号 '''
+
+        if self.run_type == 'PROCESS':
+            return not self._queue.empty()
+        return self._stop_event.is_set()
 
     def __getstate__(self) -> tuple[None, dict[str, any]]:
         state = {
             key: getattr(self, key) for key in self.__slots__
         }
         state['_handler'] = None
+        state['_stop_event'] = None # `threading.Event` 不能被 pickle，进程任务只用队列信号
         return None, state
 
     def _to_dict(self) -> dict[str, any]:
         data = {
             key: getattr(self, key) for key in self.__slots__
         }
-        data['_queue'] = bool(data['_queue'].qsize())
+        data['_queue'] = None
+        data['_stop_event'] = None
+        data['_handler'] = None
+        data['_running_remote'] = self.is_running
         data['first_run_timer'] = self.first_run_timer.timestamp() if self.first_run_timer else None
         data['_last_run_timer'] = self._last_run_timer.timestamp() if self._last_run_timer else None
-        data['_handler'] = None
         data['fn'] = None
         data['args'] = tuple()
         data['kwargs'] = {}
@@ -95,7 +142,7 @@ class Task:
 
     async def async_start(self):
         if not self._handler:
-            self._handler = asyncio.create_task(self._scheduler_proxy.async_task_processing(self.key, self._queue, self.fn, *self.args, **self.kwargs))
+            self._handler = asyncio.create_task(self._scheduler_proxy.async_task_processing(self.key, self.fn, *self.args, **self.kwargs))
 
     @property
     def key(self) -> str:
@@ -105,7 +152,7 @@ class Task:
     def run_num_completed(self) -> bool:
         if self.expected_run_num is None:
             return False
-        return self._run_num >= self.expected_run_num
+        return self.run_num >= self.expected_run_num
 
     @property
     def last_run_timer(self) -> datetime.datetime | None:
@@ -129,7 +176,11 @@ class Task:
     def is_running(self) -> bool:
         ''' 任务是否在运行中 '''
 
-        return not self._queue.qsize()
+        if self._handler is None:
+            return self._running_remote
+        if isinstance(self._handler, asyncio.Task):
+            return not self._handler.done()
+        return self._handler.is_alive()
 
 class Scheduler:
     __slots__ = ('_proxy',)
@@ -310,7 +361,6 @@ class SchedulerProxy:
                     coro.close()
 
             task = Task(fn, interval_time, first_run_timer = first_run_timer, expected_run_num = expected_run_num, key = key, run_type = run_type, args = args, kwargs = kwargs, auto_remove = auto_remove, timeout = timeout, _scheduler_proxy = self)
-            task._queue.put(None)
 
             if task.key in self.get_tasks():
                 raise KeyError(f'Task with key "{task.key}" already exists')
@@ -339,7 +389,6 @@ class SchedulerProxy:
                     coro.close()
 
             task = Task(fn, interval_time = interval_time, first_run_timer = first_run_timer, expected_run_num = expected_run_num, key = key, run_type = 'ASYNC', args = args, kwargs = kwargs, auto_remove = auto_remove, timeout = timeout, _scheduler_proxy = self)
-            task._queue.put(None)
 
             if task.key in await self.async_get_tasks():
                 raise KeyError(f'Task with key "{task.key}" already exists')
@@ -356,16 +405,12 @@ class SchedulerProxy:
                 return _fn
             return wrapper
 
-    def task_processing(self, task: Task, queue: multiprocessing.Queue, fn, *args, **kwargs):
+    def task_processing(self, task: Task, fn, *args, **kwargs):
         try:
-            queue.get()
-
-            if static.scheduler_sync_servers:
-                self.get_task(task.key)._queue.get()
             if task.first_run_timer:
                 time.sleep(max(0, task.first_run_timer.timestamp() - time.time()))
 
-            while not queue.qsize():
+            while not task._stops():
                 now = time.time()
 
                 try:
@@ -378,7 +423,7 @@ class SchedulerProxy:
                 except Exception as e:
                     self.app.printer.scheduler_error(e, task)
 
-                if queue.qsize():
+                if task._stops():
                     break
 
                 task._last_run_time = time.time() - now
@@ -390,6 +435,9 @@ class SchedulerProxy:
                     sync_server.hset('CheeseAPI_scheduler_tasks', task.key, json.dumps(task._to_dict()))
                     sync_server.hpexpire('CheeseAPI_scheduler_tasks', int(task.timeout * 1000), task.key)
 
+                if task.run_num_completed:
+                    break
+
                 time.sleep(max(0, task.interval_time - time.time() + now))
         except (KeyboardInterrupt, SystemExit):
             ...
@@ -399,16 +447,16 @@ class SchedulerProxy:
             if _redis.hexists('CheeseAPI_scheduler_tasks', task.key):
                 _redis.hpersist('CheeseAPI_scheduler_tasks', task.key)
 
-    async def async_task_processing(self, key: str, queue: multiprocessing.Queue, fn, *args, **kwargs):
-        queue.get()
+        if task.run_type == 'PROCESS':
+            task._reset_stop() # 取出残留的停止信号，保证下次启动时队列是干净的
 
+    async def async_task_processing(self, key: str, fn, *args, **kwargs):
         task = await self.async_get_task(key)
-        if static.scheduler_sync_servers:
-            task._queue.get()
+
         if task.first_run_timer:
             await asyncio.sleep(max(0, task.first_run_timer.timestamp() - time.time()))
 
-        while not queue.qsize():
+        while not task._stops():
             now = time.time()
 
             try:
@@ -421,7 +469,7 @@ class SchedulerProxy:
             except Exception as e:
                 self.app.printer.scheduler_error(e, task)
 
-            if queue.qsize():
+            if task._stops():
                 break
 
             task._last_run_time = time.time() - now
@@ -469,10 +517,11 @@ class SchedulerProxy:
             redis.Redis(connection_pool = static.scheduler_sync_servers[0]).publish('CheeseAPI_scheduler', json.dumps(['start', key]))
             return
 
+        task._reset_stop()
         if task.run_type == 'THREAD':
-            task._handler = threading.Thread(target = self.task_processing, args = (task, task._queue, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
+            task._handler = threading.Thread(target = self.task_processing, args = (task, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
         elif task.run_type == 'PROCESS':
-            task._handler = multiprocessing.get_context('spawn').Process(target = self.task_processing, args = (task, task._queue, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
+            task._handler = multiprocessing.get_context('spawn').Process(target = self.task_processing, args = (task, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
         task._handler.start()
 
         if task.auto_remove:
@@ -489,7 +538,8 @@ class SchedulerProxy:
         if not task and static.scheduler_sync_servers:
             await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).publish('CheeseAPI_scheduler', json.dumps(['start', key]))
         else:
-            task._handler = asyncio.create_task(self.async_task_processing(key, task._queue, task.fn, *task.args, **task.kwargs))
+            task._reset_stop()
+            task._handler = asyncio.create_task(self.async_task_processing(key, task.fn, *task.args, **task.kwargs))
 
     def stop(self, key: str):
         task = self.get_task(key)
@@ -503,7 +553,7 @@ class SchedulerProxy:
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).publish('CheeseAPI_scheduler', json.dumps(['stop', key]))
         else:
-            local_task._queue.put(None)
+            local_task._stop()
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
 
@@ -519,7 +569,7 @@ class SchedulerProxy:
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).publish('CheeseAPI_scheduler', json.dumps(['remove', key]))
         else:
-            local_task._queue.put(None)
+            local_task._stop()
             self._tasks.pop(key, None)
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hdel('CheeseAPI_scheduler_tasks', key)
@@ -536,7 +586,7 @@ class SchedulerProxy:
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).publish('CheeseAPI_scheduler', json.dumps(['stop', key]))
         else:
-            local_task._queue.put(None)
+            local_task._stop()
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
 
@@ -550,7 +600,7 @@ class SchedulerProxy:
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).publish('CheeseAPI_scheduler', json.dumps(['remove', key]))
         else:
-            local_task._queue.put(None)
+            local_task._stop()
             self._tasks.pop(key, None)
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hdel('CheeseAPI_scheduler_tasks', key)

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/CheeseAPI/websocket.py

@@ -1,4 +1,4 @@
-import base64, hashlib, asyncio, ssl, struct, json
+import base64, hashlib, asyncio, ssl, struct, json, inspect
 from functools import partial
 from typing import TYPE_CHECKING, AsyncIterable, Self
 
@@ -48,8 +48,8 @@ class Websocket:
         self._request: 'Request' = request
 
         self._proxy: 'WebsocketProxy' = request._proxy.app.WebsocketProxy_Class(request._proxy.app, self)
-        self._key: str = self.request.headers.get('Sec-WebSocket-Key')
-        subprotocols = self.request.headers.get('Sec-WebSocket-Protocol')
+        self._key: str = self.request.headers.get('sec-websocket-key') or self.request.headers.get('Sec-WebSocket-Key')
+        subprotocols = self.request.headers.get('sec-websocket-protocol') or self.request.headers.get('Sec-WebSocket-Protocol')
         self._subprotocols: list[str] | None = subprotocols.strip().split(',') if subprotocols else None
         self._subprotocol: str | None = None
         self.response: Response | None = None
@@ -111,6 +111,37 @@ class Websocket:
 class WebsocketProxy:
     _sync_tasks: dict[str, asyncio.Task] = {}
 
+    @staticmethod
+    def _consume_exception(future: asyncio.Future):
+        ''' 消费投递结果的异常，避免出现 "exception was never retrieved" '''
+        if not future.cancelled():
+            future.exception()
+
+    @staticmethod
+    def _schedule(connector: Websocket, coroutine):
+        '''
+        同步入口（`_static_send` / `_static_close`）不能 await，将协程投递到连接所属的事件循环执行
+
+        既不能直接丢弃（会报 `coroutine ... was never awaited` 且消息实际发不出去），
+        也不能在调用方的循环里执行（连接的 writer 属于创建它的那个循环）
+        '''
+        loop: asyncio.AbstractEventLoop | None = connector._proxy._loop
+
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if loop is None:
+            coroutine.close()
+        elif current_loop is loop:
+            loop.create_task(coroutine)
+        elif loop.is_running():
+            ''' 调用方在其他线程 / 非协程上下文，线程安全地投递回该循环 '''
+            asyncio.run_coroutine_threadsafe(coroutine, loop).add_done_callback(WebsocketProxy._consume_exception)
+        else:
+            coroutine.close()
+
     @staticmethod
     def _static_send(path: str, data: bytes | list | str | dict, *, websocket_key_or_keys: str | list[str] | None = None):
         if static.websocket_sync_servers is not None:
@@ -131,16 +162,16 @@ class WebsocketProxy:
         elif path in Websocket.connectors:
             if websocket_key_or_keys is None:
                 for connector in Websocket.connectors[path]:
-                    connector.send(data)
+                    WebsocketProxy._schedule(connector, connector.send(data))
             elif isinstance(websocket_key_or_keys, str):
                 for connector in Websocket.connectors[path]:
                     if connector.key == websocket_key_or_keys:
-                        connector.send(data)
+                        WebsocketProxy._schedule(connector, connector.send(data))
                         break
             elif isinstance(websocket_key_or_keys, list):
                 for connector in Websocket.connectors[path]:
                     if connector.key in websocket_key_or_keys:
-                        connector.send(data)
+                        WebsocketProxy._schedule(connector, connector.send(data))
 
     @staticmethod
     async def async_send(path: str, data: bytes | list | str | dict, *, websocket_key_or_keys: str | list[str] | None = None):
@@ -182,16 +213,16 @@ class WebsocketProxy:
         elif path in Websocket.connectors:
             if websocket_key_or_keys is None:
                 for connector in Websocket.connectors[path]:
-                    connector.close(code, message)
+                    WebsocketProxy._schedule(connector, connector.close(code, message))
             elif isinstance(websocket_key_or_keys, str):
                 for connector in Websocket.connectors[path]:
                     if connector.key == websocket_key_or_keys:
-                        connector.close(code, message)
+                        WebsocketProxy._schedule(connector, connector.close(code, message))
                         break
             elif isinstance(websocket_key_or_keys, list):
                 for connector in Websocket.connectors[path]:
                     if connector.key in websocket_key_or_keys:
-                        connector.close(code, message)
+                        WebsocketProxy._schedule(connector, connector.close(code, message))
 
     @staticmethod
     async def async_close(path: str, code: int = 1000, message: str = '', *, websocket_key_or_keys: str | list[str] | None = None):
@@ -218,14 +249,25 @@ class WebsocketProxy:
 
         self.reader: asyncio.StreamReader | None = None
         self.writer: asyncio.StreamWriter | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._is_disconnected: bool = False
 
     async def running(self) -> AsyncIterable[Response]:
         try:
             await self.connect()
             await self.message()
-            await self.disconnect()
         except Exception as e:
-            await self.app.printer.websocket_error(e, self.websocket)
+            result = self.app.printer.websocket_error(e, self.websocket)
+            if inspect.isawaitable(result):
+                await result
+        finally:
+            ''' 无论连接、接收如何结束（含异常断连），都必须执行一次清理，否则心跳与推送任务不会停止 '''
+            try:
+                await self.disconnect()
+            except Exception as e:
+                result = self.app.printer.websocket_error(e, self.websocket)
+                if inspect.isawaitable(result):
+                    await result
 
     async def get_response(self) -> Response:
         headers = {
@@ -249,6 +291,7 @@ class WebsocketProxy:
             WebsocketProxy._sync_tasks[self.websocket.request.path] = asyncio.create_task(self.sync_server_running())
 
         loop = asyncio.get_running_loop()
+        self._loop = loop
         self.reader = asyncio.StreamReader()
         protocol = asyncio.StreamReaderProtocol(self.reader)
         if isinstance(self.websocket.request._proxy.client_socket, ssl.SSLSocket):
@@ -344,13 +387,52 @@ class WebsocketProxy:
                 await self.websocket.on_pong()
 
     async def disconnect(self):
+        '''
+        清理连接
+
+        - 允许重复调用：接收、发送两侧可能同时发现断连，重复清理直接返回
+        - 兼容连接未完全建立的情况：reader / writer 可能为 None，也未加入 connectors
+        - 保证执行 on_disconnect()：心跳任务与业务推送任务依赖它停止
+        - 用 finally 保证底层连接关闭，即使回调清理报错也要关闭
+        '''
+        if self._is_disconnected:
+            return
+        self._is_disconnected = True
+
         self.websocket._is_running = False
-        Websocket.connectors[self.websocket.request.path].remove(self.websocket)
-        self.app.printer.websocket_disconnect(self.websocket)
-        await self.websocket.on_disconnect()
-        if self.writer:
-            self.writer.close()
-            await self.writer.wait_closed()
+
+        connectors = Websocket.connectors.get(self.websocket.request.path)
+        if connectors is not None:
+            try:
+                connectors.remove(self.websocket)
+            except ValueError:
+                ...
+
+        try:
+            self.app.printer.websocket_disconnect(self.websocket)
+        except Exception:
+            ...
+
+        try:
+            await self.websocket.on_disconnect()
+        except Exception as e:
+            result = self.app.printer.websocket_error(e, self.websocket)
+            if inspect.isawaitable(result):
+                await result
+        finally:
+            writer, self.writer = self.writer, None
+            self.reader = None
+
+            if writer is not None:
+                try:
+                    writer.close()
+                except Exception:
+                    ...
+                try:
+                    await writer.wait_closed()
+                except Exception:
+                    ''' 对端已断开时 wait_closed 可能再报 OSError，属于预期错误，不能中断清理 '''
+                    ...
 
     def encode(self, opcode: int, data: bytes) -> bytes:
         _bytes = bytearray()
@@ -404,23 +486,51 @@ class WebsocketProxy:
         except asyncio.TimeoutError:
             return opcode, full_payload
 
+    def _check_running(self):
+        ''' 发送前的连接校验，连接已断开或未建立时直接拒绝，避免继续向坏连接写入 '''
+        if self._is_disconnected or self.writer is None or not self.websocket._is_running:
+            raise ConnectionError('The websocket is disconnected, data will not be sent')
+
+    def _disconnected(self, e: Exception) -> ConnectionError:
+        ''' 标记连接断开并返回统一的异常，阻止后续继续向坏连接发送 '''
+        self.websocket._is_running = False
+        self._is_disconnected = True
+        return ConnectionError('The websocket is disconnected, data will not be sent')
+
     async def _instance_send(self, data: bytes | list | str | dict, **kwargs):
-        if isinstance(data, str):
-            self.writer.write(self.encode(0x1, data.encode()))
-        elif isinstance(data, bytes):
-            self.writer.write(self.encode(0x2, data))
-        else:
-            self.writer.write(self.encode(0x1, json.dumps(data).encode()))
-        await self.writer.drain()
+        self._check_running()
+        try:
+            if isinstance(data, str):
+                self.writer.write(self.encode(0x1, data.encode()))
+            elif isinstance(data, bytes):
+                self.writer.write(self.encode(0x2, data))
+            else:
+                self.writer.write(self.encode(0x1, json.dumps(data).encode()))
+            await self.writer.drain()
+        except (ConnectionError, OSError, RuntimeError) as e:
+            raise self._disconnected(e) from e
 
     async def _instance_close(self, code: int = 1000, message: str = ''):
-        self.writer.write(self.encode(0x8, struct.pack('!H', code) + message.encode('utf-8')))
-        await self.writer.drain()
+        if self._is_disconnected or self.writer is None:
+            return
+        try:
+            self.writer.write(self.encode(0x8, struct.pack('!H', code) + message.encode('utf-8')))
+            await self.writer.drain()
+        except (ConnectionError, OSError, RuntimeError) as e:
+            raise self._disconnected(e) from e
 
     async def ping(self):
-        self.writer.write(self.encode(0x9, b''))
-        await self.writer.drain()
+        self._check_running()
+        try:
+            self.writer.write(self.encode(0x9, b''))
+            await self.writer.drain()
+        except (ConnectionError, OSError, RuntimeError) as e:
+            raise self._disconnected(e) from e
 
     async def pong(self):
-        self.writer.write(self.encode(0xA, b''))
-        await self.writer.drain()
+        self._check_running()
+        try:
+            self.writer.write(self.encode(0xA, b''))
+            await self.writer.drain()
+        except (ConnectionError, OSError, RuntimeError) as e:
+            raise self._disconnected(e) from e

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: CheeseAPI
-Version: 2.0.8b6
+Version: 2.0.8-beta.8
 Summary: 一款web协程框架
 Project-URL: Source, https://github.com/CheeseUnknown/CheeseAPI
 Author-email: Cheese Unknown <cheese@cheese.ren>

{cheeseapi-2.0.8b6 → cheeseapi-2.0.8b8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "CheeseAPI"
-version = "2.0.8-beta.6"
+version = "2.0.8-beta.8"
 description = "一款web协程框架"
 readme = "README.md"
 license-files = { paths = [ "LICENSE" ] }