CheeseAPI 2.0.6b2__tar.gz → 2.0.7__tar.gz

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

@@ -334,7 +334,8 @@ class AppProxy:
     async def get_response(self, request: Request) -> Response:
         if inspect.isfunction(request.fn):
             try:
-                if 'request' in inspect.signature(request.fn).parameters:
+                signature = inspect.signature(request.fn)
+                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:
                     return await request.fn()

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

@@ -242,6 +242,7 @@ class SchedulerProxy:
 
     def __setstate__(self, state):
         self.app = state[1]['app']
+        self._tasks = {}
 
     def init(self, app = None):
         if not app:
@@ -257,11 +258,11 @@ class SchedulerProxy:
                 coro.close()
 
     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.Redis(connection_pool = static.scheduler_sync_servers[0]).pubsub()
+                    pubsub.subscribe('CheeseAPI_scheduler')
                     for message in pubsub.listen():
                         if message['type'] == 'message':
                             data = json.loads(message['data'])
@@ -277,9 +278,7 @@ class SchedulerProxy:
                             elif data[0] == 'remove':
                                 self.remove(data[1])
                 except redis.exceptions.RedisError:
-                    pubsub.close()
                     time.sleep(app.sync_server_timeout)
-                    self._start_pubsub(app)
         except (KeyboardInterrupt, SystemExit):
             ...
 
@@ -352,111 +351,80 @@ class SchedulerProxy:
 
     def task_processing(self, key: str, queue: multiprocessing.Queue, fn, *args, **kwargs):
         try:
-            task = self.get_task(key)
-            if not task:
-                return
-
             queue.get()
-            task._queue.get()
-            first_run = True
 
+            task = self.get_task(key)
+            if static.scheduler_sync_servers:
+                task._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:
-                    if 'app' in inspect.signature(fn).parameters:
+                    signature = inspect.signature(fn)
+                    has_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in signature.parameters.values())
+                    if 'app' in signature.parameters or has_kwargs:
                         fn(*args, app = self.app, **kwargs)
                     else:
                         fn(*args, **kwargs)
                 except Exception as e:
                     self.app.printer.scheduler_error(e, task)
 
-                if static.scheduler_sync_servers:
-                    task = self.get_task(key)
-
-                if task:
-                    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.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', key, json.dumps(task._to_dict()))
+                    sync_server.hpexpire('CheeseAPI_scheduler_tasks', int(task.timeout * 1000), key)
 
-                first_run = False
                 time.sleep(max(0, task.interval_time - time.time() + now))
         except (KeyboardInterrupt, SystemExit):
             ...
 
-        queue.put(None)
-
         if static.scheduler_sync_servers and task:
             redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hpersist('CheeseAPI_scheduler_tasks', 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()
-        task._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:
-                if 'app' in inspect.signature(fn).parameters:
+                signature = inspect.signature(fn)
+                has_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in signature.parameters.values())
+                if 'app' in signature.parameters or has_kwargs:
                     await fn(*args, app = self.app, **kwargs)
                 else:
                     await fn(*args, **kwargs)
             except Exception as e:
                 self.app.printer.scheduler_error(e, task)
 
-            if static.scheduler_sync_servers:
-                task = await self.async_get_task(key)
-
-            if task:
-                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
+            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)
@@ -470,7 +438,8 @@ class SchedulerProxy:
         elif task.run_type == 'PROCESS' and isinstance(task._handler, multiprocessing.Process):
             task._handler.join()
         self._tasks.pop(task.key, None)
-        redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hdel('CheeseAPI_scheduler_tasks', task.key)
+        if static.scheduler_sync_servers:
+            redis.Redis(connection_pool = static.scheduler_sync_servers[0]).hdel('CheeseAPI_scheduler_tasks', task.key)
 
     def start(self, key: str):
         task = self.get_task(key)
@@ -504,7 +473,7 @@ 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(task, *task.args, **task.kwargs))
+            task._handler = asyncio.create_task(self.async_task_processing(key, task._queue, task.fn, *task.args, **task.kwargs))
 
     def stop(self, key: str):
         task = self.get_task(key)
@@ -524,7 +493,7 @@ class SchedulerProxy:
 
     def remove(self, key: str):
         task = self.get_task(key)
-        if not task or not task.is_running:
+        if not task:
             return
 
         _task = self._tasks.get(key)
@@ -532,6 +501,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:
+            _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)
@@ -554,7 +524,7 @@ class SchedulerProxy:
 
     async def async_remove(self, key: str):
         task = await self.async_get_task(key)
-        if not task or not task.is_running:
+        if not task:
             return
 
         _task = self._tasks.get(key)
@@ -562,6 +532,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:
+            _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)

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

@@ -1,4 +1,4 @@
-import json
+import json, inspect
 from typing import Callable, TYPE_CHECKING
 from functools import wraps
 
@@ -20,10 +20,8 @@ def validator(*, json_model: pydantic.BaseModel | None = None, form_model: pydan
 
     def wrapper(fn: Callable) -> Callable:
         @wraps(fn)
-        async def decorator(*args, **kwargs):
+        async def decorator(*args, request: 'Request', **kwargs):
             try:
-                request: 'Request' = kwargs.get('request', None)
-
                 json_data = None
                 if json_model is not None:
                     json_data = json_model.model_validate(request.json or {}, by_alias = True)
@@ -59,6 +57,10 @@ def validator(*, json_model: pydantic.BaseModel | None = None, form_model: pydan
                 else:
                     return Response(json.loads(e.json()), 400)
 
-            return await fn(*args, **kwargs)
+            signature = inspect.signature(fn)
+            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:
+                return await fn(*args, **kwargs)
         return decorator
     return wrapper

{cheeseapi-2.0.6b2 → cheeseapi-2.0.7}/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
@@ -246,35 +246,43 @@ 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 = static.websocket_sync_server[self.websocket.request.path].pubsub()
+                        await pubsub.subscribe(self.websocket.request.path)
+                        async for message in pubsub.listen():
+                            print(message)
+                            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.6b2 → cheeseapi-2.0.7}/PKG-INFO

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

{cheeseapi-2.0.6b2 → cheeseapi-2.0.7}/pyproject.toml

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