CheeseAPI 2.0.5b3__tar.gz → 2.0.6__tar.gz

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

@@ -590,169 +590,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 +728,7 @@ class CheeseAPI:
 
     @property
     def keep_alive(self) -> bool:
-        '''
-        是否启用长连接
-        '''
+        ''' 是否启用长连接 '''
 
         return self._keep_alive
 
@@ -782,49 +738,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 +778,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.5b3 → cheeseapi-2.0.6}/CheeseAPI/file.py

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

{cheeseapi-2.0.5b3 → cheeseapi-2.0.6}/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.5b3 → cheeseapi-2.0.6}/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.5b3 → cheeseapi-2.0.6}/CheeseAPI/scheduler.py

@@ -94,7 +94,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.fn, *self.args, **self.kwargs))
+            self._handler = asyncio.create_task(self._scheduler_proxy.async_task_processing(self.key, self._queue, self.fn, *self.args, **self.kwargs))
 
     @property
     def key(self) -> str:
@@ -108,33 +108,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()
 
@@ -180,72 +172,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)
 
@@ -436,13 +409,16 @@ class SchedulerProxy:
             return
 
         queue.get()
+        task._queue.get()
+        first_run = True
+
         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 task._queue.qsize()):
+                if (not task or (not first_run and task._queue.qsize())):
                     break
 
             now = time.time()
@@ -456,22 +432,25 @@ class SchedulerProxy:
                 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
 
-            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.run_num_completed or (not task or task._queue.qsize()):
+            if (not task or task._queue.qsize()) or task.run_num_completed:
                 break
 
+            first_run = False
             await asyncio.sleep(max(0, task.interval_time - time.time() + now))
 
-        if task.auto_remove:
-            self._tasks.pop(task.key, None)
+        if not task or 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:
@@ -538,10 +517,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:
@@ -570,10 +547,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.5b3 → cheeseapi-2.0.6}/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.5b3 → cheeseapi-2.0.6}/PKG-INFO

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

{cheeseapi-2.0.5b3 → cheeseapi-2.0.6}/pyproject.toml

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