CheeseAPI 2.0.4b1__tar.gz → 2.0.5b3__tar.gz

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

@@ -1,9 +1,10 @@
-import os, pathlib, multiprocessing, ssl, socket, asyncio, concurrent.futures, inspect
+import os, pathlib, multiprocessing, ssl, socket, asyncio, concurrent.futures, inspect, importlib.util
 from typing import Type, Literal, Callable, AsyncIterable, TYPE_CHECKING
 
-import redis, signal
+import signal, redis
 from CheeseLog import CheeseLogger, Message
 
+from CheeseAPI import static
 from CheeseAPI.printer import Printer
 from CheeseAPI.signal import Signal
 from CheeseAPI.request import RequestProxy
@@ -31,6 +32,8 @@ class AppProxy:
     def start(self):
         signal.signal(signal.SIGTERM, lambda signum, frame: self.app.stop())
 
+        self._process_init()
+
         waiting_list = []
 
         try:
@@ -98,7 +101,31 @@ class AppProxy:
                 'modules': module
             })
 
-            for path in pathlib.Path(module.replace('.', '/')).glob('*.py'):
+            try:
+                spec = importlib.util.find_spec(module)
+            except (ImportError, ValueError, AttributeError):
+                continue
+
+            if spec is None:
+                continue
+
+            p = None
+            if spec.origin is None and spec.submodule_search_locations:
+                for location in spec.submodule_search_locations:
+                    p = pathlib.Path(location)
+                    if p.exists():
+                        break
+                if not p:
+                    continue
+
+            if spec.origin is None:
+                continue
+
+            origin = pathlib.Path(spec.origin)
+            if origin.name == '__init__.py':
+                origin = origin.parent
+
+            for path in origin.glob('*.py'):
                 __import__(f'{module}.{path.stem}')
 
             self.after_load_module(i, module)
@@ -240,14 +267,6 @@ class AppProxy:
             loop = asyncio.get_event_loop()
             loop.set_default_executor(concurrent.futures.ThreadPoolExecutor())
 
-            if self.app.sync_server_url:
-                if WebsocketProxy.sync_servers is None:
-                    WebsocketProxy.sync_servers = (redis.Redis.from_url(self.app.sync_server_url), redis.asyncio.Redis.from_url(self.app.sync_server_url))
-                if WebsocketProxy.data_encode is None:
-                    WebsocketProxy.data_encode = self.app.sync_server_data_encode
-                if WebsocketProxy.data_decode is None:
-                    WebsocketProxy.data_decode = self.app.sync_server_data_decode
-
             await self.after_worker_start(is_first)
             await self.app.signal.after_worker_start.async_send(kwargs = {
                 'is_first': is_first
@@ -443,10 +462,21 @@ class AppProxy:
     async def after_response(self, response: Response):
         ...
 
+    def _process_init(self, app: 'CheeseAPI' = None):
+        if not app:
+            app = self.app
+
+        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_server = {}
+        app.scheduler._proxy.init(app)
+
 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')
+    __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')
 
-    def __init__(self, host: str | None = None, port: int = 5214, *, ipv6: bool = False, logger_path: str | None = None, dual_stack: bool = False, socket_backlog: int | None = None, socket_send_buffer_size: int | None = None, socket_receive_buffer_size: int | None = None, workers: int = 1, ssl_cert: str | None = None, ssl_key: str | None = None, sync_server_url: str | None = None, static_path: dict[str, str] = {}, printer: Type[Printer] = Printer, compress: list[Literal['gzip', 'br', 'zstd', 'deflate']] = ['gzip', 'br', 'zstd', 'deflate'], compress_min_length: int = 1024, compress_level: int = 6, manual_modules: list[str] = [], exclude_modules: list[str] = [], priority_modules: list[str] = [], sync_server_data_encode: Callable[[bytes], bytes] | None = None, sync_server_data_decode: Callable[[bytes], bytes] | None = None, logger_messages: dict[str, 'Message'] = {}, request_timeout: float | None = None, keep_alive: bool = True, keep_alive_timeout: float = 5, keep_alive_max_requests: int = 100, AppProxy_Class: Type[AppProxy] = AppProxy, RequestProxy_Class: Type[RequestProxy] = RequestProxy, ResponseProxy_Class: Type[ResponseProxy] = ResponseProxy, RouteProxy_Class: Type[RouteProxy] = RouteProxy, cors_allow_origins: list[str] = ['*'], cors_allow_methods: Literal['GET', 'PUT', 'POST', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT'] = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH', 'CONNECT'], cors_allow_headers: list[str] = ['*'], cors_allow_credentials: bool = True, cors_expose_headers: list[str] = [], cors_max_age: int | None = None, WebsocketProxy_Class: Type[WebsocketProxy] = WebsocketProxy, route_patterns: list['Pattern'] = [], SchedulerProxy_Class: Type[SchedulerProxy] = SchedulerProxy):
+    def __init__(self, host: str | None = None, port: int = 5214, *, ipv6: bool = False, logger_path: str | None = None, dual_stack: bool = False, socket_backlog: int | None = None, socket_send_buffer_size: int | None = None, socket_receive_buffer_size: int | None = None, workers: int = 1, ssl_cert: str | None = None, ssl_key: str | None = None, sync_server_url: str | None = None, static_path: dict[str, str] = {}, printer: Type[Printer] = Printer, compress: list[Literal['gzip', 'br', 'zstd', 'deflate']] = ['gzip', 'br', 'zstd', 'deflate'], compress_min_length: int = 1024, compress_level: int = 6, manual_modules: list[str] = [], exclude_modules: list[str] = [], priority_modules: list[str] = [], sync_server_data_encode: Callable[[bytes], bytes] | None = None, sync_server_data_decode: Callable[[bytes], bytes] | None = None, logger_messages: dict[str, 'Message'] = {}, request_timeout: float | None = None, keep_alive: bool = True, keep_alive_timeout: float = 5, keep_alive_max_requests: int = 100, AppProxy_Class: Type[AppProxy] = AppProxy, RequestProxy_Class: Type[RequestProxy] = RequestProxy, ResponseProxy_Class: Type[ResponseProxy] = ResponseProxy, RouteProxy_Class: Type[RouteProxy] = RouteProxy, cors_allow_origins: list[str] = ['*'], cors_allow_methods: Literal['GET', 'PUT', 'POST', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT'] = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH', 'CONNECT'], cors_allow_headers: list[str] = ['*'], cors_allow_credentials: bool = True, cors_expose_headers: list[str] = [], cors_max_age: int | None = None, WebsocketProxy_Class: Type[WebsocketProxy] = WebsocketProxy, route_patterns: list['Pattern'] = [], SchedulerProxy_Class: Type[SchedulerProxy] = SchedulerProxy, sync_server_timeout: float = 5):
         '''
         - Args
             - logger_path: 日志文件路径，支持日期格式化
@@ -478,6 +508,7 @@ class CheeseAPI:
             - WebsocketProxy_Class: 若想要对 Websocket 处理逻辑进行处理，可传入自定义的 WebsocketProxy 类
             - route_patterns: 自定义路由校验规则
             - SchedulerProxy_Class: 自定义任务调度器代理类
+            - sync_server_timeout: 同步服务器操作超时时间
         '''
 
         self._host: str = host if host is not None else ('::' if ipv6 else '0.0.0.0')
@@ -513,6 +544,7 @@ class CheeseAPI:
         self._RouteProxy_Class: Type[RouteProxy] = RouteProxy_Class
         self._WebsocketProxy_Class: Type[WebsocketProxy] = WebsocketProxy_Class
         self._SchedulerProxy_Class: Type[SchedulerProxy] = SchedulerProxy_Class
+        self._sync_server_timeout: float = sync_server_timeout
 
         self._logger: CheeseLogger = CheeseLogger(self.logger_path, messages = {
             'START': Message('START', 20, message_template_styled = '(<green>%k</green>) <black>%t</black> > %c'),
@@ -533,16 +565,10 @@ class CheeseAPI:
         self.route.patterns.extend(route_patterns)
         self.route.patterns.sort(key = lambda x: x['weight'], reverse = True)
 
-    def __setstate__(self, state: tuple[None, dict[str, any]]):
-        for key, value in state[1].items():
+    def __setstate__(self, data: tuple[None, dict[str, any]]):
+        for key, value in data[1].items():
             setattr(self, key, value)
-
-        if self.sync_server_url and WebsocketProxy.sync_servers is None:
-            WebsocketProxy.sync_servers = (redis.Redis.from_url(self.sync_server_url), redis.asyncio.Redis.from_url(self.sync_server_url))
-        if WebsocketProxy.data_encode is None:
-            WebsocketProxy.data_encode = self.sync_server_data_encode
-        if WebsocketProxy.data_decode is None:
-            WebsocketProxy.data_decode = self.sync_server_data_decode
+        self._proxy._process_init(self)
 
     def start(self):
         self._proxy.start()
@@ -829,3 +855,11 @@ class CheeseAPI:
         '''
 
         return self._SchedulerProxy_Class
+
+    @property
+    def sync_server_timeout(self) -> float:
+        '''
+        同步服务器操作超时时间
+        '''
+
+        return self._sync_server_timeout

{cheeseapi-2.0.4b1 → cheeseapi-2.0.5b3}/CheeseAPI/cors.py

@@ -5,7 +5,7 @@ from CheeseAPI.response import Response
 if TYPE_CHECKING:
     from CheeseAPI.request import Request
 
-HTTP_METHOD_TYPE = Literal['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH']
+HTTP_METHOD_TYPE = Literal['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH', 'CONNECT']
 
 class CORS:
     __slots__ = ('allow_origins', 'allow_methods', 'allow_headers', 'allow_credentials', 'expose_headers', 'max_age')

{cheeseapi-2.0.4b1 → cheeseapi-2.0.5b3}/CheeseAPI/request.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 HTTP_METHOD_TYPE = Literal['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE', 'WEBSOCKET']
 
 class Request:
-    __slots__ = ('_proxy', '_ip', '_method', '_path', '_params', '_headers', '_query', '_body', '_json', '_form', '_files', '_cookies', '_full_path', '_ranges', '_fn')
+    __slots__ = ('_proxy', '_ip', '_method', '_path', '_params', '_headers', '_query', '_body', '_json', '_form', '_files', '_cookies', '_full_path', '_ranges', '_fn', '_file')
 
     def __init__(self, app: 'CheeseAPI', client_socket: socket.socket, addr: tuple[str, int]):
         self._proxy: RequestProxy = app.RequestProxy_Class(app, self, client_socket)
@@ -26,6 +26,7 @@ class Request:
         self._json: dict | list | None = None
         self._form: dict[str, str] | None = None
         self._files: dict[str, File] | None = None
+        self._file: File | None = None
         self._cookies: dict[str, str] | None = None
         self._full_path: str | None = None
         self._ranges: list[tuple[int, int | None]] | None = None
@@ -93,6 +94,10 @@ class Request:
     def files(self) -> dict[str, bytes] | None:
         return self._files
 
+    @property
+    def file(self) -> File | None:
+        return self._file
+
     @property
     def cookies(self) -> dict[str, str] | None:
         return self._cookies
@@ -183,6 +188,7 @@ class RequestProxy:
                 data = None
                 try:
                     data = await asyncio.wait_for(loop.sock_recv(self.client_socket, self.app.socket_receive_buffer_size), self.app.request_timeout)
+                    self.request._body += data
                 except asyncio.TimeoutError:
                     raise
                 if not data:

{cheeseapi-2.0.4b1 → cheeseapi-2.0.5b3}/CheeseAPI/response.py

@@ -75,6 +75,10 @@ HTTP_STATUS = {
 }
 NO_BODY_STATUS = (100, 101, 102, 204, 304)
 PREVIEWABLE_TYPES = ('text/plain', 'text/html', 'text/css', 'text/javascript', 'application/json', 'application/xml', 'text/xml', 'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/svg+xml', 'image/webp', 'image/bmp', 'video/mp4', 'video/webm', 'video/ogg', 'audio/mpeg', 'audio/ogg', 'audio/wav', 'audio/webm', 'application/pdf')
+MERGE_TYPES = {
+    'audio/x-wav': 'audio/wav',
+    'audio/vnd.wave': 'audio/wav'
+}
 
 class Cookie(TypedDict):
     value: str
@@ -87,7 +91,7 @@ class Cookie(TypedDict):
 class Response:
     __slots__ = ('status', '_proxy', 'body', 'headers', 'cookies', 'high_precision_date', 'compress', 'compress_level')
 
-    def __init__(self, body: dict | list | str | bytes | AsyncIterable | None = None, status: int = 200, headers: dict[str, str] = {}, *, high_precision_date: bool = False, compress: Literal['gzip', 'deflate', 'br', 'zstd'] | None = None, compress_level: int | None = None):
+    def __init__(self, body: dict | list | str | bytes | AsyncIterable | None = None, status: int = 200, headers: dict[str, str] | None = None, *, high_precision_date: bool = False, compress: Literal['gzip', 'deflate', 'br', 'zstd'] | None = None, compress_level: int | None = None):
         '''
         - Args
             - body: 当为 `AsyncIterable` 时，自动使用 chunked 传输编码
@@ -99,7 +103,7 @@ class Response:
 
         self.status: int = status
         self.body: dict | list | str | bytes | AsyncIterable | None = body
-        self.headers: dict[str, str] = headers
+        self.headers: dict[str, str] = headers if headers is not None else {}
         self.cookies: dict[str, Cookie] = {}
         self.high_precision_date: bool = high_precision_date
         self.compress: Literal['gzip', 'deflate', 'br', 'zstd'] | None = compress
@@ -118,7 +122,9 @@ class Response:
         }
 
 class RedirectResponse(Response):
-    def __init__(self, location: str, status: Literal[301, 302, 303, 307, 308] = 302, headers: dict[str, str] = {}, body: bytes | str | list | dict | None = None):
+    def __init__(self, location: str, status: Literal[301, 302, 303, 307, 308] = 302, headers: dict[str, str] | None = None, body: bytes | str | list | dict | None = None):
+        if headers is None:
+            headers = {}
         headers['Location'] = location
 
         super().__init__(status, body, headers)
@@ -126,7 +132,7 @@ class RedirectResponse(Response):
 class FileResponse(Response):
     __slots__ = ('file', 'preview', 'transmission_type', 'chunked_size')
 
-    def __init__(self, file_path_or_file: str | File, *, status: int = 200, headers: dict[str, str] = {}, preview: bool = True, transmission_type: Literal['CONTENT_LENGTH', 'CHUNKED'] = 'CONTENT_LENGTH', chunked_size: int | None = None, compress: Literal['gzip', 'deflate', 'br', 'zstd'] | None = None, compress_level: int | None = None):
+    def __init__(self, file_path_or_file: str | File, *, status: int = 200, headers: dict[str, str] | None = None , preview: bool = True, transmission_type: Literal['CONTENT_LENGTH', 'CHUNKED'] = 'CONTENT_LENGTH', chunked_size: int | None = None, compress: Literal['gzip', 'deflate', 'br', 'zstd'] | None = None, compress_level: int | None = None):
         '''
         - Args
             - preview: 优先预览文件
@@ -225,6 +231,8 @@ class ResponseProxy:
 
             if 'Content-Type' not in headers and 'Content-Disposition' not in headers:
                 mime_type = mimetypes.guess_type(self.response.file.name)[0] or 'application/octet-stream'
+                if mime_type in MERGE_TYPES:
+                    mime_type = MERGE_TYPES[mime_type]
                 headers['Content-Type'] = f'{mime_type}; charset=utf-8'
                 headers['Content-Disposition'] = f'{"inline" if self.response.preview and mime_type in PREVIEWABLE_TYPES else "attachment"}; filename="{self.response.file.name}"'
 
@@ -398,4 +406,4 @@ class ResponseProxy:
             if 'Content-Encoding' in headers:
                 del headers['Content-Encoding']
 
-        return status, headers, body
+        return status, headers, body

{cheeseapi-2.0.4b1 → cheeseapi-2.0.5b3}/CheeseAPI/route.py

@@ -1,6 +1,8 @@
 import re, uuid
 from typing import Literal, TypedDict, Callable, TYPE_CHECKING, AsyncIterable, Union
 
+from urllib.parse import unquote
+
 from CheeseAPI.cors import CORS
 
 if TYPE_CHECKING:
@@ -252,7 +254,7 @@ class RouteProxy:
                     i = 1
                     for key, type in self.app.route._proxy.dynamic_routes[_path][method]['params'].items():
                         value = match.group(i)
-                        _params[key] = type(value)
+                        _params[key] = type(unquote(value))
                         i += 1
                     return self.app.route._proxy.dynamic_routes[_path][method], _params
                 else: