CheeseAPI 2.0.5b4__tar.gz → 2.0.6b1__tar.gz

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/app.py

@@ -334,7 +334,10 @@ class AppProxy:
     async def get_response(self, request: Request) -> Response:
         if inspect.isfunction(request.fn):
             try:
-                return await request.fn(request = request)
+                if 'request' in inspect.signature(request.fn).parameters:
+                    return await request.fn(request = request)
+                else:
+                    return await request.fn()
             except Exception as e:
                 self.app.printer.fn_error(e, request)
                 return Response(status = 500)
@@ -590,169 +593,127 @@ class CheeseAPI:
 
     @property
     def logger_path(self) -> str | None:
-        '''
-        日志文件路径，支持日期格式化
-        '''
+        ''' 日志文件路径，支持日期格式化 '''
 
         return self._logger_path
 
     @property
     def dual_stack(self) -> bool:
-        '''
-        是否启用双栈支持；若系统不支持，则自动回退
-        '''
+        ''' 是否启用双栈支持；若系统不支持，则自动回退 '''
 
         return self._dual_stack
 
     @property
     def socket_backlog(self) -> int | None:
-        '''
-        最大连接数
-        '''
+        ''' 最大连接数 '''
 
         return self._socket_backlog
 
     @property
     def socket_send_buffer_size(self) -> int | None:
-        '''
-        发送缓冲区大小
-        '''
+        ''' 发送缓冲区大小 '''
 
         return self._socket_send_buffer_size
 
     @property
     def socket_receive_buffer_size(self) -> int | None:
-        '''
-        接收缓冲区大小
-        '''
+        ''' 接收缓冲区大小 '''
 
         return self._socket_receive_buffer_size
 
     @property
     def workers(self) -> int:
-        '''
-        工作进程数
-        '''
+        ''' 工作进程数 '''
 
         return self._workers
 
     @property
     def ssl_cert(self) -> str | None:
-        '''
-        SSL 证书路径
-        '''
+        ''' SSL 证书路径 '''
 
         return self._ssl_cert
 
     @property
     def ssl_key(self) -> str | None:
-        '''
-        SSL 密钥路径
-        '''
+        ''' SSL 密钥路径 '''
 
         return self._ssl_key
 
     @property
     def sync_server_url(self) -> str | None:
-        '''
-        同步服务器地址，用于多进程间同步数据；支持redis
-        '''
+        ''' 同步服务器地址，用于多进程间同步数据；支持redis '''
 
         return self._sync_server_url
 
     @property
     def static_path(self) -> dict[str, str]:
-        '''
-        静态文件路径映射，格式为`{url_path: file_system_path}`
-        '''
+        ''' 静态文件路径映射，格式为`{url_path: file_system_path}` '''
 
         return self._static_path
 
     @property
     def printer(self) -> Type[Printer]:
-        '''
-        自定义消息输出
-        '''
+        ''' 自定义消息输出 '''
 
         return self._printer
 
     @property
     def compress(self) -> list[Literal['gzip', 'br', 'zstd', 'deflate']]:
-        '''
-        支持的压缩算法，按照顺序尝试压缩
-        '''
+        ''' 支持的压缩算法，按照顺序尝试压缩 '''
 
         return self._compress
 
     @property
     def compress_min_length(self) -> int:
-        '''
-        启用压缩的最小响应体长度
-        '''
+        ''' 启用压缩的最小响应体长度 '''
 
         return self._compress_min_length
 
     @property
     def compress_level(self) -> int:
-        '''
-        压缩等级，每个算法的压缩级别可能不同，详见各算法文档
-        '''
+        ''' 压缩等级，每个算法的压缩级别可能不同，详见各算法文档 '''
 
         return self._compress_level
 
     @property
     def manual_modules(self) -> list[str]:
-        '''
-        手动加载的模块列表
-        '''
+        ''' 手动加载的模块列表 '''
 
         return self._manual_modules
 
     @property
     def exclude_modules(self) -> list[str]:
-        '''
-        排除加载的模块列表
-        '''
+        ''' 排除加载的模块列表 '''
 
         return self._exclude_modules
 
     @property
     def priority_modules(self) -> list[str]:
-        '''
-        优先加载的模块列表
-        '''
+        ''' 优先加载的模块列表 '''
 
         return self._priority_modules
 
     @property
     def sync_server_data_encode(self) -> Callable[[bytes], bytes] | None:
-        '''
-        同步服务器数据编码处理函数
-        '''
+        ''' 同步服务器数据编码处理函数 '''
 
         return self._sync_server_data_encode
 
     @property
     def sync_server_data_decode(self) -> Callable[[bytes], bytes] | None:
-        '''
-        同步服务器数据解码处理函数
-        '''
+        ''' 同步服务器数据解码处理函数 '''
 
         return self._sync_server_data_decode
 
     @property
     def logger_messages(self) -> dict[str, 'Message']:
-        '''
-        归属于 CheeseAPI 日志的消息列表
-        '''
+        ''' 归属于 CheeseAPI 日志的消息列表 '''
 
         return self._logger_messages
 
     @property
     def logger(self) -> CheeseLogger:
-        '''
-        归属于 CheeseAPI 日志实例
-        '''
+        ''' 归属于 CheeseAPI 日志实例 '''
 
         return self._logger
 
@@ -770,9 +731,7 @@ class CheeseAPI:
 
     @property
     def keep_alive(self) -> bool:
-        '''
-        是否启用长连接
-        '''
+        ''' 是否启用长连接 '''
 
         return self._keep_alive
 
@@ -782,49 +741,37 @@ class CheeseAPI:
 
     @property
     def keep_alive_max_requests(self) -> int:
-        '''
-        长连接最大请求次数
-        '''
+        ''' 长连接最大请求次数 '''
 
         return self._keep_alive_max_requests
 
     @property
     def AppProxy_Class(self) -> Type[AppProxy]:
-        '''
-        若想要对底层逻辑进行处理，可传入自定义的 AppProxy 类
-        '''
+        ''' 若想要对底层逻辑进行处理，可传入自定义的 AppProxy 类 '''
 
         return self._AppProxy_Class
 
     @property
     def RequestProxy_Class(self) -> Type[RequestProxy]:
-        '''
-        若想要对请求处理逻辑进行处理，可传入自定义的 RequestProxy 类
-        '''
+        ''' 若想要对请求处理逻辑进行处理，可传入自定义的 RequestProxy 类 '''
 
         return self._RequestProxy_Class
 
     @property
     def ResponseProxy_Class(self) -> Type[ResponseProxy]:
-        '''
-        若想要对响应处理逻辑进行处理，可传入自定义的 ResponseProxy 类
-        '''
+        ''' 若想要对响应处理逻辑进行处理，可传入自定义的 ResponseProxy 类 '''
 
         return self._ResponseProxy_Class
 
     @property
     def RouteProxy_Class(self) -> Type[RouteProxy]:
-        '''
-        若想要对路由处理逻辑进行处理，可传入自定义的 RouteProxy 类
-        '''
+        ''' 若想要对路由处理逻辑进行处理，可传入自定义的 RouteProxy 类 '''
 
         return self._RouteProxy_Class
 
     @property
     def route(self) -> AppRoute:
-        '''
-        总路由
-        '''
+        ''' 总路由 '''
 
         return self._route
 
@@ -834,32 +781,24 @@ class CheeseAPI:
 
     @property
     def WebsocketProxy_Class(self) -> Type[WebsocketProxy]:
-        '''
-        若想要对 Websocket 处理逻辑进行处理，可传入自定义的 WebsocketProxy 类
-        '''
+        ''' 若想要对 Websocket 处理逻辑进行处理，可传入自定义的 WebsocketProxy 类 '''
 
         return self._WebsocketProxy_Class
 
     @property
     def scheduler(self) -> 'Scheduler':
-        '''
-        任务调度
-        '''
+        ''' 任务调度 '''
 
         return self._scheduler
 
     @property
     def SchedulerProxy_Class(self) -> Type[SchedulerProxy]:
-        '''
-        自定义任务调度器代理类
-        '''
+        ''' 自定义任务调度器代理类 '''
 
         return self._SchedulerProxy_Class
 
     @property
     def sync_server_timeout(self) -> float:
-        '''
-        同步服务器操作超时时间
-        '''
+        ''' 同步服务器操作超时时间 '''
 
         return self._sync_server_timeout

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/file.py

@@ -59,9 +59,7 @@ class File:
 
     @property
     def data_in_file(self) -> bool:
-        '''
-        是否将数据保存在文件中，若否则读取文件内容到内存
-        '''
+        ''' 是否将数据保存在文件中，若否则读取文件内容到内存 '''
 
         return self._data_in_file
 

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/request.py

@@ -48,9 +48,7 @@ class Request:
         return await self._proxy.recv_body(get_all = get_all)
 
     async def parse_body(self):
-        '''
-        若在路由中设置了 `auto_recv_body = False`，则需要手动调用此方法解析请求体
-        '''
+        ''' 若在路由中设置了 `auto_recv_body = False`，则需要手动调用此方法解析请求体 '''
 
         await self._proxy.parse_body()
 

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/route.py

@@ -137,9 +137,7 @@ class Route:
 
     @property
     def path(self) -> str:
-        '''
-        路由前缀
-        '''
+        ''' 路由前缀 '''
 
         return self._path
 
@@ -179,17 +177,13 @@ class AppRoute(Route):
 
     @property
     def patterns(self) -> list[Pattern]:
-        '''
-        动态路由匹配模式
-        '''
+        ''' 动态路由匹配模式 '''
 
         return self._patterns
 
     @property
     def routes(self) -> dict[str, dict[HTTP_METHOD_TYPE, RouteDict]]:
-        '''
-        所有路由
-        '''
+        ''' 所有路由 '''
 
         return self._routes
 

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/scheduler.py

@@ -1,3 +1,4 @@
+import inspect
 import datetime, uuid, threading, multiprocessing, asyncio, time, json
 from typing import Callable, Literal, TYPE_CHECKING
 
@@ -39,7 +40,7 @@ class Task:
             - expected_run_num: 预期执行次数，若未设置则无限次执行
             - key: 默认为随机 uuid
             - run_type: 任务执行方式，可选线程、协程、进程
-            - args: 默认首位是 `app: CheeseAPI`
+            - kwargs: 自动包含 `app: CheeseAPI`，如果不提供 app 参数位置，则不会传入
             - auto_remove: 任务完成期望次数后是否自动移除
             - timeout: 当 app.sync_server_url 存在时，任务超过多少秒没有执行完毕则认为执行失败，在 sync_server 中会视为任务删除，None 默认为 interval_time * 2 的值；恢复执行后会在 sync_server 上自动恢复
         '''
@@ -55,8 +56,8 @@ class Task:
         self.run_type: Literal['THREAD', 'PROCESS', 'ASYNC'] = run_type
         ''' 任务执行方式，可选线程、协程、进程 '''
         self.args: tuple = args
-        ''' 默认首位是 `app: CheeseAPI` '''
         self.kwargs: dict = kwargs
+        ''' 自动包含 `app: CheeseAPI`，如果不提供 app 参数位置，则不会传入 '''
         self.auto_remove: bool = auto_remove
         ''' 任务完成期望次数后是否自动移除 '''
         self.timeout: float = timeout if timeout is not None else interval_time * 2
@@ -108,33 +109,25 @@ class Task:
 
     @property
     def last_run_timer(self) -> datetime.datetime | None:
-        '''
-        上一次的运行时刻
-        '''
+        ''' 上一次的运行时刻 '''
 
         return self._last_run_timer
 
     @property
     def last_run_time(self) -> float | None:
-        '''
-        上一次的运行耗时
-        '''
+        ''' 上一次的运行耗时 '''
 
         return self._last_run_time
 
     @property
     def run_num(self) -> int:
-        '''
-        运行次数
-        '''
+        ''' 运行次数 '''
 
         return self._run_num
 
     @property
     def is_running(self) -> bool:
-        '''
-        任务是否在运行中
-        '''
+        ''' 任务是否在运行中 '''
 
         return not self._queue.qsize()
 
@@ -154,7 +147,7 @@ class Scheduler:
             - expected_run_num: 预期执行次数，若未设置则无限次执行
             - key: 默认为 uuid
             - run_type: 任务执行方式，可选线程、进程
-            - args: 默认首位是 `app: CheeseAPI`
+            - kwargs: 自动包含 `app: CheeseAPI`，如果不提供 app 参数位置，则不会传入
             - auto_remove: 任务完成期望次数后是否自动移除
             - timeout: 当 app.sync_server_url 存在时，任务超过多少秒没有执行完毕则认为执行失败，在 sync_server 中会视为任务删除，None 默认为 interval_time * 2 的值；恢复执行后会在 sync_server 上自动恢复
         '''
@@ -172,7 +165,7 @@ class Scheduler:
             - first_run_timer: 首次执行时间，若值小于当前时间则立刻执行
             - expected_run_num: 预期执行次数，若未设置则无限次执行
             - key: 默认为 uuid
-            - args: 默认首位是 `app: CheeseAPI`
+            - kwargs: 自动包含 `app: CheeseAPI`，如果不提供 app 参数位置，则不会传入
             - auto_remove: 任务完成期望次数后是否自动移除
             - timeout: 当 app.sync_server_url 存在时，任务超过多少秒没有执行完毕则认为执行失败，在 sync_server 中会视为任务删除，None 默认为 interval_time * 2 的值；恢复执行后会在 sync_server 上自动恢复
         '''
@@ -180,72 +173,53 @@ class Scheduler:
         return await self._proxy.async_add(interval_time, fn, first_run_timer = first_run_timer, expected_run_num = expected_run_num, key = key, args = args, kwargs = kwargs, auto_remove = auto_remove, timeout = timeout)
 
     def start(self, key: str):
-        '''
-        启动任务
-        '''
+        ''' 启动任务 '''
 
         self._proxy.start(key)
 
     async def async_start(self, key: str):
-        '''
-        启动任务
-        '''
+        ''' 启动任务 '''
 
         await self._proxy.async_start(key)
 
     def stop(self, key: str):
-        '''
-        停止任务
-        '''
+        ''' 停止任务 '''
+
 
         self._proxy.stop(key)
 
     def remove(self, key: str):
-        '''
-        移除任务
-        '''
+        ''' 移除任务 '''
 
         self._proxy.remove(key)
 
     async def async_stop(self, key: str):
-        '''
-        停止任务
-        '''
+        ''' 停止任务 '''
 
         await self._proxy.async_stop(key)
 
     async def async_remove(self, key: str):
-        '''
-        移除任务
-        '''
+        ''' 移除任务 '''
 
         await self._proxy.async_remove(key)
 
     def get_tasks(self) -> dict[str, Task]:
-        '''
-        获取所有任务
-        '''
+        ''' 获取所有任务 '''
 
         return self._proxy.get_tasks()
 
     async def async_get_tasks(self) -> dict[str, Task]:
-        '''
-        获取所有任务
-        '''
+        ''' 获取所有任务 '''
 
         return await self._proxy.async_get_tasks()
 
     def get_task(self, key: str) -> Task | None:
-        '''
-        获取任务
-        '''
+        ''' 获取任务 '''
 
         return self._proxy.get_task(key)
 
     async def async_get_task(self, key: str) -> Task | None:
-        '''
-        获取任务
-        '''
+        ''' 获取任务 '''
 
         return await self._proxy.async_get_task(key)
 
@@ -398,7 +372,10 @@ class SchedulerProxy:
                 now = time.time()
 
                 try:
-                    fn(self.app, *args, **kwargs)
+                    if 'app' in inspect.signature(fn).parameters:
+                        fn(*args, app = self.app, **kwargs)
+                    else:
+                        fn(*args, **kwargs)
                 except Exception as e:
                     self.app.printer.scheduler_error(e, task)
 
@@ -451,7 +428,10 @@ class SchedulerProxy:
             now = time.time()
 
             try:
-                await fn(self.app, *args, **kwargs)
+                if 'app' in inspect.signature(fn).parameters:
+                    await fn(*args, app = self.app, **kwargs)
+                else:
+                    await fn(*args, **kwargs)
             except Exception as e:
                 self.app.printer.scheduler_error(e, task)
 
@@ -477,7 +457,7 @@ class SchedulerProxy:
             await asyncio.sleep(max(0, task.interval_time - time.time() + now))
 
         if not task or task.auto_remove:
-            self._tasks.pop(task.key, None)
+            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:
@@ -544,10 +524,8 @@ class SchedulerProxy:
 
     def remove(self, key: str):
         task = self.get_task(key)
-        if not task:
-            raise KeyError(f'Task with key "{key}" does not exist')
-        if not task.is_running:
-            raise KeyError(f'Task with key "{key}" is not running')
+        if not task or not task.is_running:
+            return
 
         _task = self._tasks.get(key)
         if not _task:
@@ -576,10 +554,8 @@ class SchedulerProxy:
 
     async def async_remove(self, key: str):
         task = await self.async_get_task(key)
-        if not task:
-            raise KeyError(f'Task with key "{key}" does not exist')
-        if not task.is_running:
-            raise KeyError(f'Task with key "{key}" is remove')
+        if not task or not task.is_running:
+            return
 
         _task = self._tasks.get(key)
         if not _task:

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/signal.py

@@ -36,33 +36,25 @@ class Signal:
 
     @property
     def before_load_module(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, index: int, module: str)`
-        '''
+        ''' 绑定函数`def func(*, index: int, module: str)` '''
 
         return self._before_load_module
 
     @property
     def after_load_module(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, index: int, module: str)`
-        '''
+        ''' 绑定函数`def func(*, index: int, module: str)` '''
 
         return self._after_load_module
 
     @property
     def before_load_modules(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, modules: list[str])`
-        '''
+        ''' 绑定函数`def func(*, modules: list[str])` '''
 
         return self._before_load_modules
 
     @property
     def after_load_modules(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, modules: list[str])`
-        '''
+        ''' 绑定函数`def func(*, modules: list[str])` '''
 
         return self._after_load_modules
 
@@ -84,80 +76,60 @@ class Signal:
 
     @property
     def before_workers_start(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, workers: int)`
-        '''
+        ''' 绑定函数`def func(*, workers: int)` '''
 
         return self._before_workers_start
 
     @property
     def after_workers_start(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, workers: int)`
-        '''
+        ''' 绑定函数`def func(*, workers: int)` '''
 
         return self._after_workers_start
 
     @property
     def before_worker_start(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, is_first: bool)`
-        '''
+        ''' 绑定函数`def func(*, is_first: bool)` '''
 
         return self._before_worker_start
 
     @property
     def after_worker_start(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, is_first: bool)`
-        '''
+        ''' 绑定协程函数`async def func(*, is_first: bool)` '''
 
         return self._after_worker_start
 
     @property
     def before_worker_stop(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, is_first: bool)`
-        '''
+        ''' 绑定协程函数`async def func(*, is_first: bool)` '''
 
         return self._before_worker_stop
 
     @property
     def after_worker_stop(self) -> CheeseSignal:
-        '''
-        绑定函数`def func(*, is_first: bool)`
-        '''
+        ''' 绑定函数`def func(*, is_first: bool)` '''
 
         return self._after_worker_stop
 
     @property
     def before_request(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, client_socket: socket.socket, addr: tuple[str, int])`
-        '''
+        ''' 绑定协程函数`async def func(*, client_socket: socket.socket, addr: tuple[str, int])` '''
 
         return self._before_request
 
     @property
     def after_request(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, request: Request | None)`
-        '''
+        ''' 绑定协程函数`async def func(*, request: Request | None)` '''
 
         return self._after_request
 
     @property
     def before_response(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, response: Response) -> Response`
-        '''
+        ''' 绑定协程函数`async def func(*, response: Response) -> Response` '''
 
         return self._before_response
 
     @property
     def after_response(self) -> CheeseSignal:
-        '''
-        绑定协程函数`async def func(*, response: Response)`
-        '''
+        ''' 绑定协程函数`async def func(*, response: Response)` '''
 
         return self._after_response

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/CheeseAPI/websocket.py

@@ -210,7 +210,7 @@ class WebsocketProxy:
             await self.message()
             await self.disconnect()
         except Exception as e:
-            await self.app.printer.websocket_error(self.websocket, e)
+            await self.app.printer.websocket_error(e, self.websocket)
 
     async def get_response(self) -> Response:
         headers = {

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/PKG-INFO

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

{cheeseapi-2.0.5b4 → cheeseapi-2.0.6b1}/pyproject.toml

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