CheeseAPI 2.0.7b5__tar.gz → 2.0.8b2__tar.gz

{cheeseapi-2.0.7b5 → 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.7b5 → 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.7b5 → 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,25 +244,13 @@ 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'):
         try:
             while True:
                 try:
-                    pubsub = redis.Redis(connection_pool = static.scheduler_sync_servers[0]).pubsub()
+                    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':
@@ -278,16 +267,17 @@ class SchedulerProxy:
                             elif data[0] == 'remove':
                                 self.remove(data[1])
                 except redis.exceptions.RedisError:
+                    pubsub.close()
                     time.sleep(app.sync_server_timeout)
         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'])
@@ -305,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)
 
@@ -331,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)
 
@@ -349,13 +356,12 @@ 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:
             queue.get()
 
-            task = self.get_task(key)
             if static.scheduler_sync_servers:
-                task._queue.get()
+                self.get_task(task.key)._queue.get()
             if task.first_run_timer:
                 time.sleep(max(0, task.first_run_timer.timestamp() - time.time()))
 
@@ -372,21 +378,26 @@ class SchedulerProxy:
                 except Exception as e:
                     self.app.printer.scheduler_error(e, task)
 
+                if queue.qsize():
+                    break
+
                 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)
+                    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)
 
                 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):
         queue.get()
@@ -410,6 +421,9 @@ class SchedulerProxy:
             except Exception as e:
                 self.app.printer.scheduler_error(e, task)
 
+            if queue.qsize():
+                break
+
             task._last_run_time = time.time() - now
             task._last_run_timer = datetime.datetime.fromtimestamp(now)
             task._run_num += 1
@@ -429,8 +443,10 @@ class SchedulerProxy:
             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):
@@ -454,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:
@@ -482,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)
@@ -513,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:
@@ -566,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.7b5 → 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.7b5 → 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()
@@ -248,9 +248,9 @@ class WebsocketProxy:
     async def sync_server_running(self):
         try:
             if self.app.sync_server_url.startswith('redis'):
-                while self.websocket.is_running:
+                while True:
                     try:
-                        pubsub = static.websocket_sync_server[self.websocket.request.path].pubsub()
+                        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':

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

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

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

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