CheeseAPI 2.0.7b4__tar.gz → 2.0.8b2__tar.gz

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/CheeseAPI/__init__.py

@@ -6,4 +6,4 @@ from CheeseAPI.websocket import Websocket
 from CheeseAPI.file import File
 from CheeseAPI.route import Route, RouteProxy
 from CheeseAPI.validator import validator
-
+from CheeseAPI.scheduler import Task

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/CheeseAPI/app.py

@@ -334,7 +334,7 @@ class AppProxy:
     async def get_response(self, request: Request) -> Response:
         if inspect.isfunction(request.fn):
             try:
-                signature = inspect.signature(request.fn)
+                signature = inspect.signature(request.fn, follow_wrapped = False)
                 if 'request' in signature.parameters or any(p.kind == inspect.Parameter.VAR_KEYWORD for p in signature.parameters.values()):
                     return await request.fn(request = request)
                 else:
@@ -473,9 +473,9 @@ class AppProxy:
         static.websocket_data_decode = app.sync_server_data_decode
         static.websocket_data_encode = app.sync_server_data_encode
         if app.sync_server_url:
-            static.websocket_sync_servers = (redis.ConnectionPool.from_url(app.sync_server_url), redis.asyncio.ConnectionPool.from_url(app.sync_server_url))
+            static.websocket_sync_servers = (redis.ConnectionPool.from_url(app.sync_server_url, socket_timeout = app.sync_server_timeout, socket_connect_timeout = app.sync_server_timeout), redis.asyncio.ConnectionPool.from_url(app.sync_server_url, socket_timeout = app.sync_server_timeout, socket_connect_timeout = app.sync_server_timeout))
             static.websocket_sync_server = {}
-        app.scheduler._proxy.init(app)
+            static.scheduler_sync_servers = (redis.ConnectionPool.from_url(app.sync_server_url, socket_timeout = app.sync_server_timeout, socket_connect_timeout = app.sync_server_timeout), redis.asyncio.ConnectionPool.from_url(app.sync_server_url, socket_timeout = app.sync_server_timeout, socket_connect_timeout = app.sync_server_timeout))
 
 class CheeseAPI:
     __slots__ = ('_host', '_port', '_ipv6', '_logger_path', '_dual_stack', '_socket_backlog', '_socket_send_buffer_size', '_socket_receive_buffer_size', '_workers', '_ssl_cert', '_ssl_key', '_sync_server_url', '_static_path', '_printer', '_compress', '_compress_min_length', '_compress_level', '_manual_modules', '_exclude_modules', '_priority_modules', '_sync_server_data_encode', '_sync_server_data_decode', '_logger_messages', '_logger', '_is_running', '_request_timeout', '_keep_alive', '_keep_alive_timeout', '_keep_alive_max_requests', '_AppProxy_Class', '_RequestProxy_Class', '_proxy', '_signal', '_ResponseProxy_Class', '_RouteProxy_Class', '_route', '_WebsocketProxy_Class', '_cors', '_SchedulerProxy_Class', '_scheduler', '_sync_server_timeout')

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/CheeseAPI/scheduler.py

@@ -1,4 +1,4 @@
-import inspect
+import inspect, os
 import datetime, uuid, threading, multiprocessing, asyncio, time, json
 from typing import Callable, Literal, TYPE_CHECKING
 
@@ -228,12 +228,13 @@ class Scheduler:
         return self._proxy.get_tasks()
 
 class SchedulerProxy:
-    __slots__ = ('app', '_tasks')
+    __slots__ = ('app', '_tasks', '_pubsub_ready')
 
     def __init__(self, app: 'CheeseAPI'):
         self.app: 'CheeseAPI' = app
 
         self._tasks: dict[str, Task] = {}
+        self._pubsub_ready: bool = False
 
     def __getstate__(self):
         return None, {
@@ -243,26 +244,14 @@ class SchedulerProxy:
     def __setstate__(self, state):
         self.app = state[1]['app']
         self._tasks = {}
-
-    def init(self, app = None):
-        if not app:
-            app = self.app
-
-        if app.sync_server_url:
-            static.scheduler_sync_servers = (redis.ConnectionPool.from_url(app.sync_server_url), redis.asyncio.ConnectionPool.from_url(app.sync_server_url))
-            threading.Thread(target = self._start_pubsub, args = (app,), daemon = True).start()
-            coro = self._async_start_pubsub(app)
-            try:
-                asyncio.create_task(coro)
-            except RuntimeError:
-                coro.close()
+        self._pubsub_ready = False
 
     def _start_pubsub(self, app: 'CheeseAPI'):
-        pubsub = redis.Redis(connection_pool = static.scheduler_sync_servers[0]).pubsub()
-        pubsub.subscribe('CheeseAPI_scheduler')
         try:
             while True:
                 try:
+                    pubsub = redis.from_url(app.sync_server_url, socket_timeout = None, socket_connect_timeout = None).pubsub()
+                    pubsub.subscribe('CheeseAPI_scheduler')
                     for message in pubsub.listen():
                         if message['type'] == 'message':
                             data = json.loads(message['data'])
@@ -280,16 +269,15 @@ class SchedulerProxy:
                 except redis.exceptions.RedisError:
                     pubsub.close()
                     time.sleep(app.sync_server_timeout)
-                    self._start_pubsub(app)
         except (KeyboardInterrupt, SystemExit):
             ...
 
     async def _async_start_pubsub(self, app: 'CheeseAPI'):
-        pubsub = redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).pubsub()
-        await pubsub.subscribe('CheeseAPI_scheduler')
         try:
             while True:
                 try:
+                    pubsub = redis.asyncio.from_url(app.sync_server_url, socket_timeout = None, socket_connect_timeout = None).pubsub()
+                    await pubsub.subscribe('CheeseAPI_scheduler')
                     async for message in pubsub.listen():
                         if message['type'] == 'message':
                             data = json.loads(message['data'])
@@ -307,12 +295,20 @@ class SchedulerProxy:
                 except redis.exceptions.RedisError:
                     await pubsub.close()
                     await asyncio.sleep(app.sync_server_timeout)
-                    await self._async_start_pubsub(app)
         except (KeyboardInterrupt, SystemExit):
             ...
 
     def add(self, interval_time: float, fn: Callable | None = None, *, first_run_timer: datetime.datetime | None = None, expected_run_num: int | None = None, key: str | None = None, run_type: Literal['THREAD', 'PROCESS'] = 'THREAD', args: tuple = (), kwargs: dict = {}, auto_remove: bool = False, timeout: float | None = None) -> Callable | Task:
         if fn:
+            if not self._pubsub_ready:
+                self._pubsub_ready = True
+                threading.Thread(target = self._start_pubsub, args = (self.app,), daemon = True).start()
+                coro = self._async_start_pubsub(self.app)
+                try:
+                    asyncio.create_task(coro)
+                except RuntimeError:
+                    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)
 
@@ -333,6 +329,15 @@ class SchedulerProxy:
 
     async def async_add(self, interval_time: float | None = None, fn: Callable | None = None, *, first_run_timer: datetime.datetime | None = None, expected_run_num: int | None = None, key: str | None = None, args: tuple = (), kwargs: dict = {}, auto_remove: bool = False, timeout: float | None = None) -> Callable | Task:
         if fn is not None:
+            if not self._pubsub_ready:
+                self._pubsub_ready = True
+                threading.Thread(target = self._start_pubsub, args = (self.app,), daemon = True).start()
+                coro = self._async_start_pubsub(self.app)
+                try:
+                    asyncio.create_task(coro)
+                except RuntimeError:
+                    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)
 
@@ -351,24 +356,16 @@ class SchedulerProxy:
                 return _fn
             return wrapper
 
-    def task_processing(self, key: str, queue: multiprocessing.Queue, fn, *args, **kwargs):
+    def task_processing(self, task: Task, queue: multiprocessing.Queue, fn, *args, **kwargs):
         try:
-            task = self.get_task(key)
-            if not task:
-                return
-
             queue.get()
-            first_run = True
 
+            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():
-                if static.scheduler_sync_servers:
-                    task = self.get_task(key)
-                    if (not task or (not first_run and task._queue.qsize())):
-                        break
-
                 now = time.time()
 
                 try:
@@ -381,49 +378,37 @@ class SchedulerProxy:
                 except Exception as e:
                     self.app.printer.scheduler_error(e, task)
 
-                if static.scheduler_sync_servers:
-                    task = self.get_task(key)
-
-                if task:
-                    task._last_run_time = time.time() - now
-                    task._last_run_timer = datetime.datetime.fromtimestamp(now)
-                    task._run_num += 1
-                    if first_run:
-                        task._queue.get()
+                if queue.qsize():
+                    break
 
-                    if static.scheduler_sync_servers:
-                        sync_server = redis.Redis(connection_pool = static.scheduler_sync_servers[0])
-                        sync_server.hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
-                        sync_server.hpexpire('CheeseAPI_scheduler_tasks', int(task.timeout * 1000), key)
+                task._last_run_time = time.time() - now
+                task._last_run_timer = datetime.datetime.fromtimestamp(now)
+                task._run_num += 1
 
-                if (not task or task._queue.qsize()) or task.run_num_completed:
-                    break
+                if static.scheduler_sync_servers:
+                    sync_server = redis.Redis(connection_pool = static.scheduler_sync_servers[0])
+                    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)
 
-                first_run = False
                 time.sleep(max(0, task.interval_time - time.time() + now))
         except (KeyboardInterrupt, SystemExit):
             ...
 
-        if static.scheduler_sync_servers and task:
-            redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hpersist('CheeseAPI_scheduler_tasks', key)
+        if static.scheduler_sync_servers:
+            _redis = redis.Redis(connection_pool = static.scheduler_sync_servers[0])
+            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):
-        task = self.get_task(key)
-        if not task:
-            return
-
         queue.get()
-        first_run = True
 
+        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():
-            if static.scheduler_sync_servers:
-                task = await self.async_get_task(key)
-                if (not task or (not first_run and task._queue.qsize())):
-                    break
-
             now = time.time()
 
             try:
@@ -436,34 +421,32 @@ class SchedulerProxy:
             except Exception as e:
                 self.app.printer.scheduler_error(e, task)
 
-            if static.scheduler_sync_servers:
-                task = await self.async_get_task(key)
+            if queue.qsize():
+                break
 
-            if task:
-                task._last_run_time = time.time() - now
-                task._last_run_timer = datetime.datetime.fromtimestamp(now)
-                task._run_num += 1
-                if first_run:
-                    task._queue.get()
+            task._last_run_time = time.time() - now
+            task._last_run_timer = datetime.datetime.fromtimestamp(now)
+            task._run_num += 1
 
-                if static.scheduler_sync_servers:
-                    sync_server = redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1])
-                    await sync_server.hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
-                    await sync_server.hpexpire('CheeseAPI_scheduler_tasks', int(task.timeout * 1000), key)
+            if static.scheduler_sync_servers:
+                sync_server = redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1])
+                await sync_server.hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
+                await sync_server.hpexpire('CheeseAPI_scheduler_tasks', int(task.timeout * 1000), key)
 
-            if (not task or task._queue.qsize()) or task.run_num_completed:
+            if task.run_num_completed:
                 break
 
-            first_run = False
             await asyncio.sleep(max(0, task.interval_time - time.time() + now))
 
-        if not task or task.auto_remove:
+        if task.auto_remove:
             self._tasks.pop(key, None)
             if static.scheduler_sync_servers is not None:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hdel('CheeseAPI_scheduler_tasks', key)
         else:
-            if static.scheduler_sync_servers is not None:
-                await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hpersist('CheeseAPI_scheduler_tasks', key)
+            if static.scheduler_sync_servers:
+                _redis = redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1])
+                if await _redis.hexists('CheeseAPI_scheduler_tasks', key):
+                    await _redis.hpersist('CheeseAPI_scheduler_tasks', key)
 
     def join(self, task: Task):
         if task.run_type == 'THREAD' and isinstance(task._handler, threading.Thread):
@@ -487,9 +470,9 @@ class SchedulerProxy:
             return
 
         if task.run_type == 'THREAD':
-            task._handler = threading.Thread(target = self.task_processing, args = (key, task._queue, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
+            task._handler = threading.Thread(target = self.task_processing, args = (task, task._queue, 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 = (key, 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._queue, task.fn, *task.args), kwargs = task.kwargs, daemon = True)
         task._handler.start()
 
         if task.auto_remove:
@@ -515,29 +498,31 @@ class SchedulerProxy:
         if not task.is_running:
             raise KeyError(f'Task with key "{key}" is not running')
 
-        _task = self._tasks.get(key)
-        if not _task:
+        local_task = self._tasks.get(key)
+        if not local_task:
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).publish('CheeseAPI_scheduler', json.dumps(['stop', key]))
         else:
-            _task._queue.put(None)
-        if static.scheduler_sync_servers:
-            redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
+            local_task._queue.put(None)
+            if static.scheduler_sync_servers:
+                redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hset('CheeseAPI_scheduler_tasks', key, json.dumps(task._to_dict()))
+
+        time.sleep(self.app.sync_server_timeout)
 
     def remove(self, key: str):
         task = self.get_task(key)
         if not task:
             return
 
-        _task = self._tasks.get(key)
-        if not _task:
+        local_task = self._tasks.get(key)
+        if not local_task:
             if static.scheduler_sync_servers:
                 redis.Redis(connection_pool = static.scheduler_sync_servers[0]).publish('CheeseAPI_scheduler', json.dumps(['remove', key]))
         else:
-            _task._queue.put(None)
+            local_task._queue.put(None)
             self._tasks.pop(key, None)
-        if static.scheduler_sync_servers:
-            redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hdel('CheeseAPI_scheduler_tasks', key)
+            if static.scheduler_sync_servers:
+                redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hdel('CheeseAPI_scheduler_tasks', key)
 
     async def async_stop(self, key: str):
         task = await self.async_get_task(key)
@@ -546,29 +531,29 @@ class SchedulerProxy:
         if not task.is_running:
             raise KeyError(f'Task with key "{key}" is not running')
 
-        _task = self._tasks.get(key)
-        if not _task:
+        local_task = self._tasks.get(key)
+        if not local_task:
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).publish('CheeseAPI_scheduler', json.dumps(['stop', key]))
         else:
-            _task._queue.put(None)
-        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()))
+            local_task._queue.put(None)
+            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()))
 
     async def async_remove(self, key: str):
         task = await self.async_get_task(key)
         if not task:
             return
 
-        _task = self._tasks.get(key)
-        if not _task:
+        local_task = self._tasks.get(key)
+        if not local_task:
             if static.scheduler_sync_servers:
                 await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).publish('CheeseAPI_scheduler', json.dumps(['remove', key]))
         else:
-            _task._queue.put(None)
+            local_task._queue.put(None)
             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)
+            if static.scheduler_sync_servers:
+                await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hdel('CheeseAPI_scheduler_tasks', key)
 
     def get_task(self, key: str) -> Task | None:
         if static.scheduler_sync_servers is not None:
@@ -599,7 +584,7 @@ class SchedulerProxy:
     async def async_get_tasks(self) -> dict[str, Task]:
         if static.scheduler_sync_servers is not None:
             return {
-                key: Task.from_dict(json.loads(data), self) for key, data in (await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hgetall('CheeseAPI_scheduler_tasks')).items()
+                key.decode(): Task.from_dict(json.loads(data), self) for key, data in (await redis.asyncio.Redis(connection_pool = static.scheduler_sync_servers[1]).hgetall('CheeseAPI_scheduler_tasks')).items()
             }
 
         return self._tasks

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/CheeseAPI/validator.py

@@ -57,7 +57,7 @@ def validator(*, json_model: pydantic.BaseModel | None = None, form_model: pydan
                 else:
                     return Response(json.loads(e.json()), 400)
 
-            signature = inspect.signature(fn)
+            signature = inspect.signature(fn, follow_wrapped = False)
             if 'request' in signature.parameters or any(p.kind == inspect.Parameter.VAR_KEYWORD for p in signature.parameters.values()):
                 return await fn(*args, request = request, **kwargs)
             else:

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/CheeseAPI/websocket.py

@@ -2,7 +2,7 @@ import base64, hashlib, asyncio, ssl, struct, json
 from functools import partial
 from typing import TYPE_CHECKING, AsyncIterable, Self
 
-import redis
+import redis, redis.exceptions
 
 from CheeseAPI import static
 from CheeseAPI.response import Response
@@ -230,7 +230,7 @@ class WebsocketProxy:
     async def connect(self) -> AsyncIterable[Response]:
         Websocket.connectors.setdefault(self.websocket.request.path, []).append(self.websocket)
         if self.app.sync_server_url and self.websocket.request.path not in static.websocket_sync_server:
-            static.websocket_sync_server[self.websocket.request.path] = redis.asyncio.Redis.from_url(self.app.sync_server_url)
+            static.websocket_sync_server[self.websocket.request.path] = redis.asyncio.Redis.from_url(self.app.sync_server_url, socket_timeout = self.app.sync_server_timeout, socket_connect_timeout = self.app.sync_server_timeout)
             asyncio.create_task(self.sync_server_running())
 
         loop = asyncio.get_running_loop()
@@ -246,35 +246,42 @@ class WebsocketProxy:
         await self.websocket.on_connect()
 
     async def sync_server_running(self):
-        if self.app.sync_server_url.startswith('redis'):
-            pubsub = static.websocket_sync_server[self.websocket.request.path].pubsub()
-            await pubsub.subscribe(self.websocket.request.path)
-            async for message in pubsub.listen():
-                if message['type'] != 'message':
-                    continue
-
-                connectors = Websocket.connectors.get(self.websocket.request.path)
-                if not connectors:
-                    continue
-
-                message = message['data']
-                if static.websocket_data_decode is not None:
-                    message = static.websocket_data_decode(message)
-                message = json.loads(message.decode())
-                if isinstance(message['key'], list):
-                    connectors = [connector for connector in connectors if connector.key in message['key']]
-                elif isinstance(message['key'], str):
-                    connectors = [connector for connector in connectors if connector.key == message['key']]
-                else:
-                    connectors = [connector for connector in connectors]
-
-                if connectors:
-                    if message['event'] == 'send':
-                        for connector in connectors:
-                            asyncio.create_task(connector.send(message['data']))
-                    elif message['event'] == 'close':
-                        for connector in connectors:
-                            asyncio.create_task(connector.close())
+        try:
+            if self.app.sync_server_url.startswith('redis'):
+                while True:
+                    try:
+                        pubsub = redis.asyncio.from_url(self.app.sync_server_url, socket_timeout = None, socket_connect_timeout = None).pubsub()
+                        await pubsub.subscribe(self.websocket.request.path)
+                        async for message in pubsub.listen():
+                            if message['type'] != 'message':
+                                continue
+
+                            connectors = Websocket.connectors.get(self.websocket.request.path)
+                            if not connectors:
+                                continue
+
+                            message = message['data']
+                            if static.websocket_data_decode is not None:
+                                message = static.websocket_data_decode(message)
+                            message = json.loads(message.decode())
+                            if isinstance(message['key'], list):
+                                connectors = [connector for connector in connectors if connector.key in message['key']]
+                            elif isinstance(message['key'], str):
+                                connectors = [connector for connector in connectors if connector.key == message['key']]
+                            else:
+                                connectors = [connector for connector in connectors]
+
+                            if connectors:
+                                if message['event'] == 'send':
+                                    for connector in connectors:
+                                        asyncio.create_task(connector.send(message['data']))
+                                elif message['event'] == 'close':
+                                    for connector in connectors:
+                                        asyncio.create_task(connector.close())
+                    except redis.exceptions.RedisError:
+                        await asyncio.sleep(self.app.sync_server_timeout)
+        except (KeyboardInterrupt, SystemExit, asyncio.CancelledError):
+            ...
 
     async def message(self):
         while True:

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/PKG-INFO

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

{cheeseapi-2.0.7b4 → cheeseapi-2.0.8b2}/pyproject.toml

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